diff --git a/LICENSE.TXT b/LICENSE.TXT
index 8d5fff6..562a772 100644
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -4,11 +4,13 @@
 University of Illinois/NCSA
 Open Source License
 
-Copyright (c) 2011-2011 MediaTek Inc.
+Copyright (c) 2011-2013 MediaTek Inc.
 All rights reserved.
 
 Developed by:
 
+    MCLinker Team.
+
     MediaTek Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
diff --git a/include/mcld/ADT/BinTree.h b/include/mcld/ADT/BinTree.h
index 76de607..4093b72 100644
--- a/include/mcld/ADT/BinTree.h
+++ b/include/mcld/ADT/BinTree.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_BINARY_TREE_H
-#define MCLD_BINARY_TREE_H
+#ifndef MCLD_ADT_BITREE_H
+#define MCLD_ADT_BITREE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -438,16 +438,16 @@
   //  @param DIRECT the direction of the connecting edge of the parent node.
   //  @param position the parent node
   //  @param value the value being pushed.
-  template<size_t DIRECT, class Pos>
-  BinaryTree& join(Pos position, const DataType& value) {
+  template<size_t DIRECT>
+  BinaryTree& join(TreeIteratorBase& pPosition, const DataType& pValue) {
     node_type *node = BinaryTreeBase<DataType>::createNode();
-    node->data = const_cast<DataType*>(&value);
-    if (position.isRoot())
-      proxy::hook<TreeIteratorBase::Leftward>(position.m_pNode,
-                          const_cast<const node_type*>(node));
+    node->data = const_cast<DataType*>(&pValue);
+
+    if (pPosition.isRoot())
+      pPosition.hook<TreeIteratorBase::Leftward>(node);
     else
-      proxy::hook<DIRECT>(position.m_pNode,
-                          const_cast<const node_type*>(node));
+      pPosition.hook<DIRECT>(node);
+
     return *this;
   }
 
@@ -456,14 +456,13 @@
   //  @param position the parent node
   //  @param the tree being joined.
   //  @return the joined tree
-  template<size_t DIRECT, class Pos>
-  BinaryTree& merge(Pos position, BinaryTree& pTree) {
+  template<size_t DIRECT>
+  BinaryTree& merge(TreeIteratorBase& pPosition, BinaryTree& pTree) {
     if (this == &pTree)
       return *this;
 
     if (!pTree.empty()) {
-      proxy::hook<DIRECT>(position.m_pNode,
-                        const_cast<const NodeBase*>(pTree.m_Root.node.left));
+      pPosition.hook<DIRECT>(pTree.m_Root.node.left);
       BinaryTreeBase<DataType>::m_Root.summon(
                                    pTree.BinaryTreeBase<DataType>::m_Root);
       BinaryTreeBase<DataType>::m_Root.delegate(pTree.m_Root);
diff --git a/include/mcld/ADT/Flags.h b/include/mcld/ADT/Flags.h
index d38d941..c6a41e8 100644
--- a/include/mcld/ADT/Flags.h
+++ b/include/mcld/ADT/Flags.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_FLAGS_H
-#define MCLD_FLAGS_H
+#ifndef MCLD_ADT_FLAGS_H
+#define MCLD_ADT_FLAGS_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/ADT/GraphLite/Digraph.h b/include/mcld/ADT/GraphLite/Digraph.h
new file mode 100644
index 0000000..9e1b604
--- /dev/null
+++ b/include/mcld/ADT/GraphLite/Digraph.h
@@ -0,0 +1,85 @@
+//===- Digraph.h ----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_ADT_GRAPHLITE_DIGRAPH_H
+#define MCLD_ADT_GRAPHLITE_DIGRAPH_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+#include <mcld/ADT/Uncopyable.h>
+#include <mcld/ADT/GraphLite/GraphBasicTypes.h>
+#include <stdint.h>
+
+namespace mcld {
+namespace graph {
+
+/** \class Digraph
+ *  \brief Digraph provides the common interface of all directed graphs.
+ */
+class Digraph : private Uncopyable
+{
+public:
+  typedef DirectedTag direction_tag;
+
+  class Node
+  {
+    friend class Digraph;
+  public:
+    Node() {}
+
+    bool operator==(const Node& pOther) const { return m_ID == pOther.m_ID; }
+    bool operator!=(const Node& pOther) const { return m_ID != pOther.m_ID; }
+
+  protected:
+    intptr_t m_ID;
+  };
+
+  class Arc
+  {
+    friend class Digraph;
+  public:
+    Arc();
+
+    bool operator==(const Node& pOther) const;
+    bool operator!=(const Node& pOther) const;
+
+    Node source() const;
+    Node target() const;
+
+  protected:
+    Arc(Digraph& pParent);
+
+  protected:
+    intptr_t m_ID;
+    Digraph* m_Parent;
+  };
+
+public:
+  Digraph();
+
+  Node addNode();
+
+  Arc addArc(const Node& pSource, const Node& pTarget);
+
+  void erase(const Node& pNode);
+
+  void erase(const Arc& pArc);
+
+  void clear();
+
+  unsigned int numOfNodes() const;
+
+  unsigned int numOfArcs() const;
+
+};
+
+} // namespace of graph
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/ADT/GraphLite/GraphBasicTypes.h b/include/mcld/ADT/GraphLite/GraphBasicTypes.h
new file mode 100644
index 0000000..5862bcb
--- /dev/null
+++ b/include/mcld/ADT/GraphLite/GraphBasicTypes.h
@@ -0,0 +1,29 @@
+//===- GraphBasicTypes.h --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_ADT_GRAPHLITE_GRAPHBASICTYPES_H
+#define MCLD_ADT_GRAPHLITE_GRAPHBASICTYPES_H
+
+namespace mcld {
+namespace graph {
+
+/** \class UndirectedTag
+ *  \brief Undirected graph category.
+ */
+struct UndirectedTag {};
+
+/** \class DirectedTag
+ *  \brief Directed graph category.
+ */
+struct DirectedTag {};
+
+} // namespace of graph
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/ADT/GraphLite/ListDigraph.h b/include/mcld/ADT/GraphLite/ListDigraph.h
new file mode 100644
index 0000000..4ae2c50
--- /dev/null
+++ b/include/mcld/ADT/GraphLite/ListDigraph.h
@@ -0,0 +1,92 @@
+//===- ListDigraph.h ------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_ADT_GRAPHLITE_LISTDIGRAPH_H
+#define MCLD_ADT_GRAPHLITE_LISTDIGRAPH_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+#include <mcld/Support/GCFactory.h>
+
+namespace mcld {
+namespace graph {
+
+/** \class ListDigraph
+ *  \brief ListDigraph provides an linked-list inplementation of a graph.
+ *
+ *  ListDigraph is designed to get well performance for most algorithms of
+ *  graph theory.
+ *
+ *  Function        | Complexity | Best Complexity
+ *  ----------------|------------|--------------------------
+ *  Storage         | V + E      |
+ *  Add node        | O(1)       |
+ *  Add arc         | O(1)       |
+ *  Remove node     | O(E)       | O(#(fan-in) + #(fan-out))
+ *  Remove edge     | O(1)       |
+ *  Query adjacency | O(E)       | O(#(fan-in) + #(fan-out))
+ *
+ */
+class ListDigraph
+{
+public:
+  struct Node;
+  struct Arc;
+
+  struct Node {
+  public:
+    Node();
+
+  public:
+    Node *prev, *next;
+    Arc *first_in, *first_out;
+  };
+
+  struct Arc {
+  public:
+    Arc();
+
+  public:
+    Node *target, *source;
+    Arc *prev_in, *next_in;
+    Arc *prev_out, *next_out;
+  };
+
+public:
+  ListDigraph();
+
+  Node* addNode();
+
+  Arc* addArc(Node& pU, Node& pV);
+
+  void erase(Node& pNode);
+
+  void erase(Arc& pArc);
+
+  void clear();
+
+  void getHead(Node*& pNode) const { pNode = m_pNodeHead; }
+
+private:
+  typedef GCFactory<Node, 0> NodeList;
+  typedef GCFactory<Arc, 0> ArcList;
+
+private:
+  Node* m_pNodeHead;
+  Node* m_pFreeNodeHead;
+  Arc*  m_pFreeArcHead;
+
+  NodeList m_NodeList;
+  ArcList m_ArcList;
+};
+
+} // namespace of graph
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/ADT/HashBase.h b/include/mcld/ADT/HashBase.h
index 896f5b8..f3332a0 100644
--- a/include/mcld/ADT/HashBase.h
+++ b/include/mcld/ADT/HashBase.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_HASH_BASE_H
-#define MCLD_HASH_BASE_H
+#ifndef MCLD_ADT_HASHBASE_H
+#define MCLD_ADT_HASHBASE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/ADT/HashBase.tcc b/include/mcld/ADT/HashBase.tcc
index 165f4ae..50f6ac4 100644
--- a/include/mcld/ADT/HashBase.tcc
+++ b/include/mcld/ADT/HashBase.tcc
@@ -7,8 +7,9 @@
 //
 //===----------------------------------------------------------------------===//
 
-//===--------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 // internal non-member functions
+//===----------------------------------------------------------------------===//
 inline static unsigned int compute_bucket_count(unsigned int pNumOfBuckets)
 {
   static const unsigned int bucket_size[] =
@@ -30,8 +31,9 @@
   return (pNumOfBuckets+131101); // rare case. increase constantly
 }
 
-//===--------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 // template implementation of HashBucket
+//===----------------------------------------------------------------------===//
 template<typename DataType>
 typename HashBucket<DataType>::entry_type*
 HashBucket<DataType>::getEmptyBucket()
@@ -48,8 +50,9 @@
   return tombstone;
 }
 
-//===--------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
 // template implementation of HashTableImpl
+//===----------------------------------------------------------------------===//
 template<typename HashEntryTy,
          typename HashFunctionTy>
 HashTableImpl<HashEntryTy, HashFunctionTy>::HashTableImpl()
diff --git a/include/mcld/ADT/HashEntry.h b/include/mcld/ADT/HashEntry.h
index c034783..5c3557f 100644
--- a/include/mcld/ADT/HashEntry.h
+++ b/include/mcld/ADT/HashEntry.h
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MCLD_HASH_ENTRY_H
-#define MCLD_HASH_ENTRY_H
+#ifndef MCLD_ADT_HASHENTRY_H
+#define MCLD_ADT_HASHENTRY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/ADT/HashEntryFactory.h b/include/mcld/ADT/HashEntryFactory.h
index 42aa5e7..91deab4 100644
--- a/include/mcld/ADT/HashEntryFactory.h
+++ b/include/mcld/ADT/HashEntryFactory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_HASH_ENTRY_FACTORY_H
-#define MCLD_HASH_ENTRY_FACTORY_H
+#ifndef MCLD_ADT_HASHENTRYFACTORY_H
+#define MCLD_ADT_HASHENTRYFACTORY_H
 
 namespace mcld {
 
diff --git a/include/mcld/ADT/HashIterator.h b/include/mcld/ADT/HashIterator.h
index 078b20a..c25870f 100644
--- a/include/mcld/ADT/HashIterator.h
+++ b/include/mcld/ADT/HashIterator.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_HASH_ITERATOR_H
-#define MCLD_HASH_ITERATOR_H
+#ifndef MCLD_ADT_HASHITERATOR_H
+#define MCLD_ADT_HASHITERATOR_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/ADT/HashTable.h b/include/mcld/ADT/HashTable.h
index 0b6757e..522ab48 100644
--- a/include/mcld/ADT/HashTable.h
+++ b/include/mcld/ADT/HashTable.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_HASH_TABLE_H
-#define MCLD_HASH_TABLE_H
+#ifndef MCLD_ADT_HASHTABLE_H
+#define MCLD_ADT_HASHTABLE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/ADT/SizeTraits.h b/include/mcld/ADT/SizeTraits.h
index dbd5d7b..3baf129 100644
--- a/include/mcld/ADT/SizeTraits.h
+++ b/include/mcld/ADT/SizeTraits.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SIZE_TRAITS_H
-#define MCLD_SIZE_TRAITS_H
+#ifndef MCLD_ADT_SIZETRAITS_H
+#define MCLD_ADT_SIZETRAITS_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -153,6 +153,36 @@
            ((pData & 0x00000000000000FFULL) << 56));
 }
 
+template<size_t SIZE>
+typename SizeTraits<SIZE>::Word bswap(typename SizeTraits<SIZE>::Word pData);
+
+template<>
+inline SizeTraits<32>::Word bswap<32>(SizeTraits<32>::Word pData)
+{
+  return bswap32(pData);
+}
+
+template<>
+inline SizeTraits<64>::Word bswap<64>(SizeTraits<64>::Word pData)
+{
+  return bswap64(pData);
+}
+
+template <size_t WIDTH>
+inline uint64_t signExtend(uint64_t pVal)
+{
+  uint64_t mask = (~((uint64_t)0)) >> (64 - WIDTH);
+  uint64_t sign_bit = 1 << (WIDTH - 1);
+
+  return ((pVal & mask) ^ sign_bit) - sign_bit;
+}
+
+template <>
+inline uint64_t signExtend<64>(uint64_t pVal)
+{
+  return pVal;
+}
+
 template <size_t SizeOfStr, typename FieldType>
 class StringSizerHelper
 {
diff --git a/include/mcld/ADT/StringEntry.h b/include/mcld/ADT/StringEntry.h
index e6d1c20..3588c05 100644
--- a/include/mcld/ADT/StringEntry.h
+++ b/include/mcld/ADT/StringEntry.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_STRING_ENTRY_H
-#define MCLD_STRING_ENTRY_H
+#ifndef MCLD_ADT_STRINGENTRY_H
+#define MCLD_ADT_STRINGENTRY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/ADT/StringHash.h b/include/mcld/ADT/StringHash.h
index a9c0025..048f35f 100644
--- a/include/mcld/ADT/StringHash.h
+++ b/include/mcld/ADT/StringHash.h
@@ -6,15 +6,15 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_STRING_HASH_FUNCTION_H
-#define MCLD_STRING_HASH_FUNCTION_H
+#ifndef MCLD_ADT_STRINGHASH_H
+#define MCLD_ADT_STRINGHASH_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/DataTypes.h>
-#include <llvm/Support/ErrorHandling.h>
 #include <cctype>
+#include <cassert>
 #include <functional>
 
 namespace mcld {
@@ -43,7 +43,8 @@
 {
   uint32_t operator()(const llvm::StringRef& pKey) const
   {
-    llvm::report_fatal_error("Undefined StringHash function.\n");
+    assert(false && "Undefined StringHash function.\n");
+    return 0;
   }
 };
 
diff --git a/include/mcld/ADT/TreeAllocator.h b/include/mcld/ADT/TreeAllocator.h
index 10de761..b2bb39b 100644
--- a/include/mcld/ADT/TreeAllocator.h
+++ b/include/mcld/ADT/TreeAllocator.h
@@ -6,13 +6,13 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TREE_ALLOCATOR_H
-#define MCLD_TREE_ALLOCATOR_H
+#ifndef MCLD_ADT_TREEALLOCATOR_H
+#define MCLD_ADT_TREEALLOCATOR_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 #include <set>
-#include "mcld/Support/GCFactory.h"
+#include <mcld/Support/GCFactory.h>
 
 namespace mcld {
 
diff --git a/include/mcld/ADT/TreeBase.h b/include/mcld/ADT/TreeBase.h
index 13eb474..bca375f 100644
--- a/include/mcld/ADT/TreeBase.h
+++ b/include/mcld/ADT/TreeBase.h
@@ -6,9 +6,9 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TREE_BASE_H
-#define MCLD_TREE_BASE_H
-#include "mcld/ADT/TypeTraits.h"
+#ifndef MCLD_ADT_TREEBASE_H
+#define MCLD_ADT_TREEBASE_H
+#include <mcld/ADT/TypeTraits.h>
 
 #include <cstddef>
 #include <cassert>
@@ -28,18 +28,6 @@
   { }
 };
 
-namespace proxy
-{
-  template<size_t DIRECT>
-  inline void move(NodeBase *&X)
-  { assert(0 && "not allowed"); }
-
-  template<size_t DIRECT>
-  inline void hook(NodeBase *X, const NodeBase *Y)
-  { assert(0 && "not allowed"); }
-
-} // namespace of template proxy
-
 class TreeIteratorBase
 {
 public:
@@ -67,9 +55,10 @@
   virtual ~TreeIteratorBase(){};
 
   template<size_t DIRECT>
-  inline void move() {
-    proxy::move<DIRECT>(m_pNode);
-  }
+  void move() { assert(0 && "not allowed"); }
+
+  template<size_t DIRECT>
+  void hook(NodeBase* pNode) { assert(0 && "not allowed"); }
 
   bool isRoot() const
   { return (m_pNode->right == m_pNode); }
@@ -87,25 +76,29 @@
   { return this->m_pNode != y.m_pNode; }
 };
 
-namespace proxy
+template<> inline
+void TreeIteratorBase::move<TreeIteratorBase::Leftward>()
 {
-  template<>
-  inline void move<TreeIteratorBase::Leftward>(NodeBase *&X)
-  { X = X->left; }
+  this->m_pNode = this->m_pNode->left;
+}
 
-  template<>
-  inline void move<TreeIteratorBase::Rightward>(NodeBase *&X)
-  { X = X->right; }
+template<> inline
+void TreeIteratorBase::move<TreeIteratorBase::Rightward>()
+{
+  this->m_pNode = this->m_pNode->right;
+}
 
-  template<>
-  inline void hook<TreeIteratorBase::Leftward>(NodeBase *X, const NodeBase *Y)
-  { X->left = const_cast<NodeBase*>(Y); }
+template<> inline
+void TreeIteratorBase::hook<TreeIteratorBase::Leftward>(NodeBase* pOther)
+{
+  this->m_pNode->left = pOther;
+}
 
-  template<>
-  inline void hook<TreeIteratorBase::Rightward>(NodeBase* X, const NodeBase* Y)
-  { X->right = const_cast<NodeBase*>(Y); }
-
-} //namespace of template proxy
+template<> inline
+void TreeIteratorBase::hook<TreeIteratorBase::Rightward>(NodeBase* pOther)
+{
+  this->m_pNode->right = pOther;
+}
 
 template<typename DataType>
 class Node : public NodeBase
diff --git a/include/mcld/ADT/TypeTraits.h b/include/mcld/ADT/TypeTraits.h
index 90b2224..7f872da 100644
--- a/include/mcld/ADT/TypeTraits.h
+++ b/include/mcld/ADT/TypeTraits.h
@@ -6,16 +6,16 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TYPE_TRAITS_H
-#define MCLD_TYPE_TRAITS_H
+#ifndef MCLD_ADT_TYPETRAITS_H
+#define MCLD_ADT_TYPETRAITS_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 
 #include <cstdlib>
 
-namespace mcld
-{
+namespace mcld {
+
 template<typename DataType>
 struct NonConstTraits;
 
diff --git a/include/mcld/ADT/Uncopyable.h b/include/mcld/ADT/Uncopyable.h
index 7ddfbe3..d899a0a 100644
--- a/include/mcld/ADT/Uncopyable.h
+++ b/include/mcld/ADT/Uncopyable.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_UNCOPYABLE_H
-#define MCLD_UNCOPYABLE_H
+#ifndef MCLD_ADT_UNCOPYABLE_H
+#define MCLD_ADT_UNCOPYABLE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/AttributeOption.h b/include/mcld/AttributeOption.h
index 18d7278..a0130d2 100644
--- a/include/mcld/AttributeOption.h
+++ b/include/mcld/AttributeOption.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ATTRIBUTE_OPTIONS_H
-#define MCLD_ATTRIBUTE_OPTIONS_H
+#ifndef MCLD_ATTRIBUTEOPTION_H
+#define MCLD_ATTRIBUTEOPTION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/BitcodeOption.h b/include/mcld/BitcodeOption.h
index 4e9a5e1..6d2b9b7 100644
--- a/include/mcld/BitcodeOption.h
+++ b/include/mcld/BitcodeOption.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_BITCODE_OPTIONS_H
-#define MCLD_BITCODE_OPTIONS_H
+#ifndef MCLD_BITCODEOPTION_H
+#define MCLD_BITCODEOPTION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/CodeGen/MCLinker.h b/include/mcld/CodeGen/MCLinker.h
index 34ddcb7..10423bb 100644
--- a/include/mcld/CodeGen/MCLinker.h
+++ b/include/mcld/CodeGen/MCLinker.h
@@ -28,10 +28,10 @@
 namespace mcld {
 
 class Module;
-class MemoryArea;
 class IRBuilder;
 class LinkerConfig;
 class Linker;
+class FileHandle;
 
 /** \class MCLinker
 *  \brief MCLinker provides a linking pass for standard compilation flow
@@ -54,7 +54,7 @@
   // - the standard symbols
   MCLinker(LinkerConfig& pConfig,
            mcld::Module& pModule,
-           MemoryArea& pOutput);
+           FileHandle& pFileHandle);
 
 public:
   virtual ~MCLinker();
@@ -71,7 +71,7 @@
 protected:
   LinkerConfig& m_Config;
   mcld::Module& m_Module;
-  MemoryArea& m_Output;
+  FileHandle& m_FileHandle;
   IRBuilder* m_pBuilder;
   Linker* m_pLinker;
 
diff --git a/include/mcld/Target/TargetMachine.h b/include/mcld/CodeGen/TargetMachine.h
similarity index 66%
rename from include/mcld/Target/TargetMachine.h
rename to include/mcld/CodeGen/TargetMachine.h
index 669e860..6454d87 100644
--- a/include/mcld/Target/TargetMachine.h
+++ b/include/mcld/CodeGen/TargetMachine.h
@@ -6,12 +6,9 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TARGET_TARGET_MACHINE_H
-#define MCLD_TARGET_TARGET_MACHINE_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-#include <llvm/Target/TargetMachine.h>
+#ifndef MCLD_CODEGEN_TARGETMACHINE_H
+#define MCLD_CODEGEN_TARGETMACHINE_H
+#include <llvm/Support/CodeGen.h>
 #include <string>
 
 namespace llvm {
@@ -19,20 +16,22 @@
 class Target;
 class TargetData;
 class TargetMachine;
+class MCContext;
+class raw_ostream;
+class formatted_raw_ostream;
+namespace legacy {
 class PassManagerBase;
-
-} // namespace of llvm
+} // namepsace legacy
+} // namespace llvm
 
 namespace mcld {
 
 class Module;
 class Target;
-class MemoryArea;
+class FileHandle;
 class LinkerConfig;
 class ToolOutputFile;
 
-using namespace llvm;
-
 enum CodeGenFileType {
   CGFT_ASMFile,
   CGFT_OBJFile,
@@ -52,9 +51,10 @@
 public:
   /// Adapter of llvm::TargetMachine
   ///
-  MCLDTargetMachine(llvm::TargetMachine &pTM,
-                    const mcld::Target &pTarget,
-                    const std::string &pTriple);
+  MCLDTargetMachine(llvm::TargetMachine& pTM,
+                    const llvm::Target& pLLMVTarget,
+                    const mcld::Target& pMCLDTarget,
+                    const std::string& pTriple);
 
   virtual ~MCLDTargetMachine();
 
@@ -67,48 +67,41 @@
 
   /// appPassesToEmitFile - The target function which we has to modify as
   /// upstreaming.
-  bool addPassesToEmitFile(PassManagerBase &,
+  bool addPassesToEmitFile(llvm::legacy::PassManagerBase &,
                            mcld::ToolOutputFile& pOutput,
                            mcld::CodeGenFileType,
-                           CodeGenOpt::Level,
+                           llvm::CodeGenOpt::Level,
                            mcld::Module& pModule,
                            mcld::LinkerConfig& pConfig,
                            bool DisableVerify = true);
 
-  /// getDataLayout
-  const DataLayout *getDataLayout() const { return m_TM.getDataLayout(); }
-
-  /// setAsmVerbosityDefault
-  static void setAsmVerbosityDefault(bool pAsmVerbose) {
-    llvm::TargetMachine::setAsmVerbosityDefault(pAsmVerbose);
-  }
-
 private:
   /// addCommonCodeGenPasses - Add standard LLVM codegen passes used for
   /// both emitting to assembly files or machine code output.
-  bool addCommonCodeGenPasses(PassManagerBase &,
+  bool addCommonCodeGenPasses(llvm::legacy::PassManagerBase &,
                               mcld::CodeGenFileType,
-                              CodeGenOpt::Level,
+                              llvm::CodeGenOpt::Level,
                               bool DisableVerify,
                               llvm::MCContext *&OutCtx);
 
-  bool addCompilerPasses(PassManagerBase &pPM,
+  bool addCompilerPasses(llvm::legacy::PassManagerBase &pPM,
                          llvm::formatted_raw_ostream &pOutput,
                          llvm::MCContext *&OutCtx);
 
-  bool addAssemblerPasses(PassManagerBase &pPM,
+  bool addAssemblerPasses(llvm::legacy::PassManagerBase &pPM,
                           llvm::raw_ostream &pOutput,
                           llvm::MCContext *&OutCtx);
 
-  bool addLinkerPasses(PassManagerBase &pPM,
-                       LinkerConfig& pConfig,
-                       Module& pModule,
-                       mcld::MemoryArea& pOutput,
+  bool addLinkerPasses(llvm::legacy::PassManagerBase &pPM,
+                       mcld::LinkerConfig& pConfig,
+                       mcld::Module& pModule,
+                       mcld::FileHandle& pFileHandle,
                        llvm::MCContext *&OutCtx);
 
 private:
   llvm::TargetMachine &m_TM;
-  const mcld::Target *m_pTarget;
+  const llvm::Target *m_pLLVMTarget;
+  const mcld::Target *m_pMCLDTarget;
   const std::string& m_Triple;
 };
 
diff --git a/include/mcld/Config/Config.h b/include/mcld/Config/Config.h
index 94946df..9e52d54 100644
--- a/include/mcld/Config/Config.h
+++ b/include/mcld/Config/Config.h
@@ -40,5 +40,7 @@
 #define MCLD_SYMBOLS_PER_INPUT 128
 #define MCLD_RELOCATIONS_PER_INPUT 1024
 
+#define MCLD_SEGMENTS_PER_OUTPUT 8
+
 #endif
 
diff --git a/include/mcld/Fragment/AlignFragment.h b/include/mcld/Fragment/AlignFragment.h
index 14d0051..1175c07 100644
--- a/include/mcld/Fragment/AlignFragment.h
+++ b/include/mcld/Fragment/AlignFragment.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_ALIGNFRAGMENT_H
-#define MCLD_LD_ALIGNFRAGMENT_H
+#ifndef MCLD_FRAGMENT_ALIGNFRAGMENT_H
+#define MCLD_FRAGMENT_ALIGNFRAGMENT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Fragment/FGNode.h b/include/mcld/Fragment/FGNode.h
deleted file mode 100644
index 0afee0e..0000000
--- a/include/mcld/Fragment/FGNode.h
+++ /dev/null
@@ -1,91 +0,0 @@
-//===- FGNode.h -----------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_FGNODE_H
-#define MCLD_FGNODE_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-
-#include <llvm/Support/DataTypes.h>
-
-#include <vector>
-
-namespace mcld
-{
-
-class Relocation;
-class ResolveInfo;
-class Fragment;
-
-/** \class FGNode
- *  \brief FGNode is a node for FragmentGraph
- */
-class FGNode
-{
-public:
-  typedef ResolveInfo* Slot;
-  typedef Relocation*  Signal;
-
-  typedef std::vector<Fragment*> FragmentListType;
-  typedef FragmentListType::iterator frag_iterator;
-  typedef FragmentListType::const_iterator const_frag_iterator;
-
-  typedef std::vector<Slot> SlotListType;
-  typedef SlotListType::iterator slot_iterator;
-  typedef SlotListType::const_iterator const_slot_iterator;
-
-  typedef std::vector<Signal> SignalListType;
-  typedef SignalListType::iterator signal_iterator;
-  typedef SignalListType::const_iterator const_signal_iterator;
-
-public:
-  FGNode();
-  explicit FGNode(uint32_t pIndex);
-
-  void addFragment(Fragment* pFrag);
-  void addSignal(Signal pSignal);
-  void addSlot(Slot pSlot);
-
-  /// ----- observers ----- ///
-  uint32_t getIndex() const
-  {  return m_Index; }
-
-  slot_iterator         slot_begin   ()       { return m_Slots.begin();     }
-  const_slot_iterator   slot_begin   () const { return m_Slots.begin();     }
-  slot_iterator         slot_end     ()       { return m_Slots.end();       }
-  const_slot_iterator   slot_end     () const { return m_Slots.end();       }
-
-  signal_iterator       signal_begin ()       { return m_Signals.begin();   }
-  const_signal_iterator signal_begin () const { return m_Signals.begin();   }
-  signal_iterator       signal_end   ()       { return m_Signals.end();     }
-  const_signal_iterator signal_end   () const { return m_Signals.end();     }
-
-  frag_iterator         frag_begin   ()       { return m_Fragments.begin(); }
-  const_frag_iterator   frag_begin   () const { return m_Fragments.begin(); }
-  frag_iterator         frag_end     ()       { return m_Fragments.end();   }
-  const_frag_iterator   frag_end     () const { return m_Fragments.end();   }
-
-private:
-  FragmentListType m_Fragments;
-
-  /// m_Signals - a list of relocations describes the possible fan-out of this
-  /// node
-  SignalListType m_Signals;
-
-  /// m_Slots - a list of symbols describes the possible fan-in of this node
-  SlotListType m_Slots;
-
-  /// m_Index - the index in the reachability matrix
-  uint32_t m_Index;
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Fragment/FillFragment.h b/include/mcld/Fragment/FillFragment.h
index af78237..aa32ec8 100644
--- a/include/mcld/Fragment/FillFragment.h
+++ b/include/mcld/Fragment/FillFragment.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_FILLFRAGMENT_H
-#define MCLD_LD_FILLFRAGMENT_H
+#ifndef MCLD_FRAGMENT_FILLFRAGMENT_H
+#define MCLD_FRAGMENT_FILLFRAGMENT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Fragment/FragmentGraph.h b/include/mcld/Fragment/FragmentGraph.h
deleted file mode 100644
index 96d438f..0000000
--- a/include/mcld/Fragment/FragmentGraph.h
+++ /dev/null
@@ -1,177 +0,0 @@
-//===- FragmentGraph.h ----------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_FRAGMENTGRAPH_H
-#define MCLD_FRAGMENTGRAPH_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-
-#include <vector>
-
-#include <mcld/ADT/HashTable.h>
-#include <mcld/ADT/HashEntry.h>
-#include <mcld/Config/Config.h>
-#include <mcld/Fragment/FGNode.h>
-#include <mcld/Fragment/FGEdge.h>
-#include <mcld/Support/GCFactory.h>
-
-#include <llvm/Support/DataTypes.h>
-
-namespace mcld
-{
-class Module;
-class ResolveInfo;
-class Relocation;
-class LinkerConfig;
-
-/** \class FragmentGraph
- *  \brief FragmentGraph describes the references between fragments.
- */
-class FragmentGraph
-{
-public:
-  typedef FGNode::Slot   Slot;
-  typedef FGNode::Signal Signal;
-
-  typedef GCFactory<FGNode, MCLD_SECTIONS_PER_INPUT> NodeFactoryType;
-  typedef NodeFactoryType::iterator node_iterator;
-  typedef NodeFactoryType::const_iterator const_node_iterator;
-
-  typedef std::vector<FGEdge> EdgeListType;
-  typedef EdgeListType::iterator edge_iterator;
-  typedef EdgeListType::const_iterator const_edge_iterator;
-
-
-public:
-  FragmentGraph();
-  ~FragmentGraph();
-
-  /// construct - construct the whole graph from input Fragments, relocations
-  /// and symbols
-  bool construct(const LinkerConfig& pConfig, Module& pModule);
-
-  /// connect - connect two nodes
-  bool connect(Signal pSignal, Slot pSlot);
-  bool connect(FGNode& pFrom, Slot pSlot);
-
-  /// getEdges - given a node, get the list of edges which are the fan-out of
-  /// this node
-  /// @param pEdges - the edge list which contains the found edges
-  /// @return false - the given node
-  bool getEdges(FGNode& pNode, EdgeListType& pEdges);
-
-  /// ----- observers -----///
-  /// getNode - given a fragment, finde the node which the fragment is belong to
-  FGNode* getNode(const Fragment& pFrag);
-  const FGNode* getNode(const Fragment& pFrag) const;
-
-  FGNode* getNode(const ResolveInfo& pSym);
-  const FGNode* getNode(const ResolveInfo& pSym) const;
-
-private:
-  typedef std::vector<Relocation*> RelocationListType;
-  typedef RelocationListType::iterator reloc_iterator;
-  typedef RelocationListType::const_iterator const_reloc_iterator;
-
-  struct PtrCompare
-  {
-    bool operator()(const void* X, const void* Y) const
-    { return (X==Y); }
-  };
-
-  struct PtrHash
-  {
-    size_t operator()(const void* pKey) const
-    {
-      return (unsigned((uintptr_t)pKey) >> 4) ^
-             (unsigned((uintptr_t)pKey) >> 9);
-    }
-  };
-
-  /// HashTable for Fragment* to Node*
-  typedef HashEntry<const Fragment*, FGNode*, PtrCompare> FragHashEntryType;
-  typedef HashTable<FragHashEntryType,
-                    PtrHash,
-                    EntryFactory<FragHashEntryType> > FragHashTableType;
-
-  /// HashTable for ResolveInfo* to Node*
-  typedef HashEntry<const ResolveInfo*, FGNode*, PtrCompare> SymHashEntryType;
-  typedef HashTable<SymHashEntryType,
-                    PtrHash,
-                    EntryFactory<SymHashEntryType> > SymHashTableType;
-
-  /** \class ReachMatrix
-   *  \brief ReachMatrix is the reachability matrix which describes the relation
-   *   of Nodes in FragmentGraph
-   */
-  class ReachMatrix
-  {
-  public:
-    typedef std::vector<uint32_t> MatrixDataType;
-
-  public:
-    ReachMatrix(size_t pSize);
-    ~ReachMatrix();
-    uint32_t& at(uint32_t pX, uint32_t pY);
-    uint32_t at(uint32_t pX, uint32_t pY) const;
-
-    uint32_t getN() const
-    { return m_N; }
-
-    void print();
-
-  private:
-    // m_Data - the contents of the matrix. Here we use a one dimensional array
-    // to represent the two dimensional matrix
-    MatrixDataType m_Data;
-
-    // m_N - this is an m_N x m_N matrix
-    size_t m_N;
-  };
-
-private:
-  FGNode* producePseudoNode();
-  FGNode* produceRegularNode();
-  void destroyPseudoNode();
-  void destroyRegularNode();
-
-  void initMatrix();
-
-  bool createRegularNodes(Module& pModule);
-  bool setNodeSlots(Module& pModule);
-  bool createPseudoNodes(Module& pModule);
-
-  bool createRegularEdges(Module& pModule);
-  bool createPseudoEdges(Module& pModule);
-
-private:
-  NodeFactoryType* m_pPseudoNodeFactory;
-  NodeFactoryType* m_pRegularNodeFactory;
-
-  /// m_pFragNodeMap - HashTable to map the fragment to the node it belongs to
-  FragHashTableType* m_pFragNodeMap;
-
-  /// m_pSymNodeMap - HashTable to map the ResolveInfo to the node. The node is
-  /// the pseudo node which the contains it's fan-out is to the ResolveInfo
-  SymHashTableType* m_pSymNodeMap;
-
-  ReachMatrix* m_pMatrix;
-
-  /// m_NumOfPNodes - number of pseudo nodes
-  size_t m_NumOfPNodes;
-  /// m_NumOfRNodes - number of regular nodes
-  size_t m_NumOfRNodes;
-  /// m_NumOfEdges - number of edges
-  size_t m_NumOfEdges;
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Fragment/FragmentLinker.h b/include/mcld/Fragment/FragmentLinker.h
deleted file mode 100644
index 45ef85d..0000000
--- a/include/mcld/Fragment/FragmentLinker.h
+++ /dev/null
@@ -1,78 +0,0 @@
-//===- FragmentLinker.h ---------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file provides a number of APIs used by SectLinker.
-// These APIs do the things which a linker should do.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_FRAGMENT_FRAGMENT_LINKER_H
-#define MCLD_FRAGMENT_FRAGMENT_LINKER_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-
-#include <string>
-
-#include <mcld/LinkerConfig.h>
-#include <mcld/LD/LDFileFormat.h>
-#include <mcld/LD/LDSymbol.h>
-#include <mcld/Fragment/Relocation.h>
-#include <mcld/MC/MCLDInput.h>
-
-namespace mcld {
-
-class Module;
-class TargetLDBackend;
-class LinkerConfig;
-class MemoryArea;
-
-/** \class FragmentLinker
- *  \brief FragmentLinker provides a pass to link object files.
- */
-class FragmentLinker
-{
-public:
-  FragmentLinker(const LinkerConfig& pConfig,
-                 Module& pModule,
-                 TargetLDBackend& pBackend);
-
-  ~FragmentLinker();
-
-  bool finalizeSymbols();
-
-  /// applyRelocations - apply all relocation enties.
-  bool applyRelocations();
-
-  /// syncRelocationResult - After applying relocation, write back relocation target
-  /// data to output file.
-  void syncRelocationResult(MemoryArea& pOutput);
-
-private:
-  /// normalSyncRelocationResult - sync relocation result when producing shared
-  /// objects or executables
-  void normalSyncRelocationResult(MemoryArea& pOutput);
-
-  /// partialSyncRelocationResult - sync relocation result when doing partial
-  /// link
-  void partialSyncRelocationResult(MemoryArea& pOutput);
-
-  /// writeRelocationResult - helper function of syncRelocationResult, write
-  /// relocation target data to output
-  void writeRelocationResult(Relocation& pReloc, uint8_t* pOutput);
-
-private:
-  const LinkerConfig& m_Config;
-  Module& m_Module;
-  TargetLDBackend& m_Backend;
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Fragment/FragmentRef.h b/include/mcld/Fragment/FragmentRef.h
index 3fce7c9..3bfd804 100644
--- a/include/mcld/Fragment/FragmentRef.h
+++ b/include/mcld/Fragment/FragmentRef.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_FRAGMENT_FRAGMENT_REFERENCE_H
-#define MCLD_FRAGMENT_FRAGMENT_REFERENCE_H
+#ifndef MCLD_FRAGMENT_FRAGMENTREF_H
+#define MCLD_FRAGMENT_FRAGMENTREF_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -78,17 +78,6 @@
 
   Offset getOutputOffset() const;
 
-  // -----  dereference  ----- //
-  Address deref();
-
-  ConstAddress deref() const;
-
-  Address operator*()
-  { return deref(); }
-
-  ConstAddress operator*() const
-  { return deref(); }
-
 private:
   friend FragmentRef& NullFragmentRef();
   friend class Chunk<FragmentRef, MCLD_SECTIONS_PER_INPUT>;
diff --git a/include/mcld/Fragment/NullFragment.h b/include/mcld/Fragment/NullFragment.h
index 1c84fae..3440453 100644
--- a/include/mcld/Fragment/NullFragment.h
+++ b/include/mcld/Fragment/NullFragment.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_NULL_FRAGMENT_H
-#define MCLD_LD_NULL_FRAGMENT_H
+#ifndef MCLD_FRAGMENT_NULLFRAGMENT_H
+#define MCLD_FRAGMENT_NULLFRAGMENT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Fragment/RegionFragment.h b/include/mcld/Fragment/RegionFragment.h
index e077264..4f1908a 100644
--- a/include/mcld/Fragment/RegionFragment.h
+++ b/include/mcld/Fragment/RegionFragment.h
@@ -6,30 +6,29 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_REGION_FRAGMENT_H
-#define MCLD_LD_REGION_FRAGMENT_H
+#ifndef MCLD_FRAGMENT_REGIONFRAGMENT_H
+#define MCLD_FRAGMENT_REGIONFRAGMENT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 
 #include <mcld/Fragment/Fragment.h>
+#include <llvm/ADT/StringRef.h>
 
 namespace mcld {
 
-class MemoryRegion;
-
 /** \class RegionFragment
- *  \brief RegionFragment is a kind of Fragment containing mcld::MemoryRegion
+ *  \brief RegionFragment is a kind of Fragment containing input memory region
  */
 class RegionFragment : public Fragment
 {
 public:
-  RegionFragment(MemoryRegion& pRegion, SectionData* pSD = NULL);
+  RegionFragment(llvm::StringRef pRegion, SectionData* pSD = NULL);
 
   ~RegionFragment();
 
-  const MemoryRegion& getRegion() const { return m_Region; }
-  MemoryRegion&       getRegion()       { return m_Region; }
+  const llvm::StringRef getRegion() const { return m_Region; }
+  llvm::StringRef       getRegion()       { return m_Region; }
 
   static bool classof(const Fragment *F)
   { return F->getKind() == Fragment::Region; }
@@ -40,7 +39,7 @@
   size_t size() const;
 
 private:
-  MemoryRegion& m_Region;
+  llvm::StringRef m_Region;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/Fragment/Relocation.h b/include/mcld/Fragment/Relocation.h
index e8c57e4..3824dd5 100644
--- a/include/mcld/Fragment/Relocation.h
+++ b/include/mcld/Fragment/Relocation.h
@@ -34,7 +34,7 @@
   typedef uint64_t Address; // FIXME: use SizeTrait<T>::Address instead
   typedef uint64_t DWord;   // FIXME: use SizeTrait<T>::Word instead
   typedef int64_t  SWord;   // FIXME: use SizeTrait<T>::SWord instead
-  typedef uint8_t  Type;
+  typedef uint32_t Type;
   typedef uint32_t Size;
 
 private:
diff --git a/include/mcld/Fragment/TargetFragment.h b/include/mcld/Fragment/TargetFragment.h
index 665fcea..76148ea 100644
--- a/include/mcld/Fragment/TargetFragment.h
+++ b/include/mcld/Fragment/TargetFragment.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_TARGET_FRAGMENT_H
-#define MCLD_LD_TARGET_FRAGMENT_H
+#ifndef MCLD_FRAGMENT_TARGETFRAGMENT_H
+#define MCLD_FRAGMENT_TARGETFRAGMENT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/GeneralOptions.h b/include/mcld/GeneralOptions.h
index 77232ac..8348b6f 100644
--- a/include/mcld/GeneralOptions.h
+++ b/include/mcld/GeneralOptions.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_GENERAL_OPTIONS_H
-#define MCLD_GENERAL_OPTIONS_H
+#ifndef MCLD_GENERALOPTIONS_H
+#define MCLD_GENERALOPTIONS_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -15,11 +15,11 @@
 #include <vector>
 #include <mcld/Support/RealPath.h>
 #include <mcld/Support/FileSystem.h>
-#include <mcld/MC/ZOption.h>
 
 namespace mcld {
 
 class Input;
+class ZOption;
 
 /** \class GeneralOptions
  *  \brief GeneralOptions collects the options that not be one of the
@@ -46,6 +46,10 @@
   typedef RpathList::iterator rpath_iterator;
   typedef RpathList::const_iterator const_rpath_iterator;
 
+  typedef std::vector<std::string> ScriptList;
+  typedef ScriptList::iterator script_iterator;
+  typedef ScriptList::const_iterator const_script_iterator;
+
   typedef std::vector<std::string> AuxiliaryList;
   typedef AuxiliaryList::iterator aux_iterator;
   typedef AuxiliaryList::const_iterator const_aux_iterator;
@@ -54,11 +58,6 @@
   GeneralOptions();
   ~GeneralOptions();
 
-  /// default link script
-  bool hasDefaultLDScript() const;
-  const char* defaultLDScript() const;
-  void setDefaultLDScript(const std::string& pFilename);
-
   /// trace
   void setTrace(bool pEnableTrace = true)
   { m_bTrace = pEnableTrace; }
@@ -84,15 +83,6 @@
   bool Bgroup() const
   { return m_Bgroup; }
 
-  bool hasEntry() const
-  { return !m_Entry.empty(); }
-
-  void setEntry(const std::string& pEntry)
-  { m_Entry = pEntry; }
-
-  const std::string& entry() const
-  { return m_Entry; }
-
   void setDyld(const std::string& pDyld)
   { m_Dyld = pDyld; }
 
@@ -132,10 +122,10 @@
   { return m_bColor; }
 
   void setNoUndefined(bool pEnable = true)
-  { m_bNoUndefined = pEnable; }
+  { m_NoUndefined = (pEnable?YES:NO); }
 
   void setMulDefs(bool pEnable = true)
-  { m_bMulDefs = pEnable; }
+  { m_MulDefs = (pEnable?YES:NO); }
 
   void setEhFrameHdr(bool pEnable = true)
   { m_bCreateEhFrameHdr = pEnable; }
@@ -146,8 +136,11 @@
   bool hasCombReloc() const
   { return m_bCombReloc; }
 
+  bool hasNoUndefined() const
+  { return (Unknown != m_NoUndefined); }
+
   bool isNoUndefined() const
-  { return m_bNoUndefined; }
+  { return (YES == m_NoUndefined); }
 
   bool hasStackSet() const
   { return (Unknown != m_ExecStack); }
@@ -165,7 +158,10 @@
   { return m_bLoadFltr; }
 
   bool hasMulDefs() const
-  { return m_bMulDefs; }
+  { return (Unknown != m_MulDefs); }
+
+  bool isMulDefs() const
+  { return (YES == m_MulDefs); }
 
   bool hasNoCopyReloc() const
   { return m_bNoCopyReloc; }
@@ -278,6 +274,26 @@
   bool printMap() const
   { return m_bPrintMap; }
 
+  void setWarnMismatch(bool pEnable = true)
+  { m_bWarnMismatch = pEnable; }
+
+  bool warnMismatch() const
+  { return m_bWarnMismatch; }
+
+  // --gc-sections
+  void setGCSections(bool pEnable = true)
+  { m_bGCSections = pEnable; }
+
+  bool GCSections() const
+  { return m_bGCSections; }
+
+  // --ld-generated-unwind-info
+  void setGenUnwindInfo(bool pEnable = true)
+  { m_bGenUnwindInfo = pEnable; }
+
+  bool genUnwindInfo() const
+  { return m_bGenUnwindInfo; }
+
   // -G, max GP size option
   void setGPSize(int gpsize)
   { m_GPSize = gpsize; }
@@ -299,6 +315,15 @@
   const_rpath_iterator rpath_end  () const { return m_RpathList.end();   }
   rpath_iterator       rpath_end  ()       { return m_RpathList.end();   }
 
+  // -----  link-in script  ----- //
+  const ScriptList& getScriptList() const { return m_ScriptList; }
+  ScriptList&       getScriptList()       { return m_ScriptList; }
+
+  const_script_iterator script_begin() const { return m_ScriptList.begin(); }
+  script_iterator       script_begin()       { return m_ScriptList.begin(); }
+  const_script_iterator script_end  () const { return m_ScriptList.end();   }
+  script_iterator       script_end  ()       { return m_ScriptList.end();   }
+
   // -----  filter and auxiliary filter  ----- //
   void setFilter(const std::string& pFilter)
   { m_Filter = pFilter; }
@@ -327,21 +352,20 @@
 private:
   Input* m_pDefaultBitcode;
   std::string m_DefaultLDScript;
-  std::string m_Entry;
   std::string m_Dyld;
   std::string m_SOName;
   int8_t m_Verbose;            // --verbose[=0,1,2]
   uint16_t m_MaxErrorNum;      // --error-limit=N
   uint16_t m_MaxWarnNum;       // --warning-limit=N
   status m_ExecStack;          // execstack, noexecstack
+  status m_NoUndefined;        // defs, --no-undefined
+  status m_MulDefs;            // muldefs, --allow-multiple-definition
   uint64_t m_CommPageSize;     // common-page-size=value
   uint64_t m_MaxPageSize;      // max-page-size=value
   bool m_bCombReloc     : 1;   // combreloc, nocombreloc
-  bool m_bNoUndefined   : 1;   // defs, --no-undefined
   bool m_bInitFirst     : 1;   // initfirst
   bool m_bInterPose     : 1;   // interpose
   bool m_bLoadFltr      : 1;   // loadfltr
-  bool m_bMulDefs       : 1;   // muldefs
   bool m_bNoCopyReloc   : 1;   // nocopyreloc
   bool m_bNoDefaultLib  : 1;   // nodefaultlib
   bool m_bNoDelete      : 1;   // nodelete
@@ -367,9 +391,13 @@
   bool m_bNewDTags: 1; // --enable-new-dtags
   bool m_bNoStdlib: 1; // -nostdlib
   bool m_bPrintMap: 1; // --print-map
+  bool m_bWarnMismatch: 1; // --no-warn-mismatch
+  bool m_bGCSections: 1; // --gc-sections
+  bool m_bGenUnwindInfo: 1; // --ld-generated-unwind-info
   uint32_t m_GPSize; // -G, --gpsize
   StripSymbolMode m_StripSymbols;
   RpathList m_RpathList;
+  ScriptList m_ScriptList;
   unsigned int m_HashStyle;
   std::string m_Filter;
   AuxiliaryList m_AuxiliaryList;
diff --git a/include/mcld/IRBuilder.h b/include/mcld/IRBuilder.h
index e9f1d13..7cacb36 100644
--- a/include/mcld/IRBuilder.h
+++ b/include/mcld/IRBuilder.h
@@ -14,7 +14,7 @@
 #ifndef MCLD_IRBUILDER_H
 #define MCLD_IRBUILDER_H
 
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/MC/InputBuilder.h>
 
 #include <mcld/LD/LDSection.h>
@@ -29,7 +29,6 @@
 
 #include <mcld/Support/Path.h>
 #include <mcld/Support/FileHandle.h>
-#include <mcld/Support/raw_mem_ostream.h>
 
 namespace mcld {
 
@@ -129,19 +128,6 @@
   Input* ReadInput(const std::string& pNameSpec);
 
   /// ReadInput - To read an input file and append it to the input tree.
-  ///
-  /// This function is like to add an input in the command line.
-  ///
-  /// LLVM compiler usually emits outputs by llvm::raw_ostream.
-  /// mcld::raw_mem_ostream inherits llvm::raw_ostream and is suitable to be
-  /// the output of LLVM compier. Users can connect LLVM compiler and MCLinker
-  /// by passing mcld::raw_mem_ostream from LLVM compiler to MCLinker.
-  ///
-  /// @param pMemOStream [in] The input raw_mem_stream
-  /// @param the create mcld::Input.
-  Input* ReadInput(raw_mem_ostream& pMemOStream);
-
-  /// ReadInput - To read an input file and append it to the input tree.
   /// Another way to open file manually. Use MCLinker's mcld::FileHandle.
   Input* ReadInput(FileHandle& pFileHandle);
 
@@ -470,6 +456,10 @@
                                    uint32_t pOffset,
                                    Relocation::Address pAddend = 0);
 
+  /// shouldForceLocal - The helper function for AddSymbol to check if the
+  /// symbols should be force to local symbols
+  bool shouldForceLocal(const ResolveInfo& pInfo, const LinkerConfig& pConfig);
+
 private:
   LDSymbol* addSymbolFromObject(const std::string& pName,
                                 ResolveInfo::Type pType,
diff --git a/include/mcld/InputTree.h b/include/mcld/InputTree.h
index 0c7e060..0213527 100644
--- a/include/mcld/InputTree.h
+++ b/include/mcld/InputTree.h
@@ -6,15 +6,15 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_MC_INPUT_TREE_H
-#define MCLD_MC_INPUT_TREE_H
+#ifndef MCLD_INPUTTREE_H
+#define MCLD_INPUTTREE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 
 #include <mcld/ADT/BinTree.h>
 #include <mcld/ADT/TypeTraits.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/Support/Path.h>
 
 #include <string>
@@ -182,16 +182,16 @@
   //  @param DIRECT the direction of the connecting edge of the parent node.
   //  @param position the parent node
   //  @param value the value being pushed.
-  template<size_t DIRECT, class Pos>
-  BinaryTree& join(Pos position, const Input& value) {
+  template<size_t DIRECT>
+  BinaryTree& join(TreeIteratorBase& pPosition, const Input& value) {
     node_type *node = BinaryTreeBase<Input>::createNode();
     node->data = const_cast<Input*>(&value);
-    if (position.isRoot())
-      proxy::hook<TreeIteratorBase::Leftward>(position.m_pNode,
-                          const_cast<const node_type*>(node));
+
+    if (pPosition.isRoot())
+      pPosition.hook<TreeIteratorBase::Leftward>(node);
     else
-      proxy::hook<DIRECT>(position.m_pNode,
-                          const_cast<const node_type*>(node));
+      pPosition.hook<DIRECT>(node);
+
     return *this;
   }
 
@@ -200,14 +200,13 @@
   //  @param position the parent node
   //  @param the tree being joined.
   //  @return the joined tree
-  template<size_t DIRECT, class Pos>
-  BinaryTree& merge(Pos position, BinaryTree& pTree) {
+  template<size_t DIRECT>
+  BinaryTree& merge(TreeIteratorBase& pPosition, BinaryTree& pTree) {
     if (this == &pTree)
       return *this;
 
     if (!pTree.empty()) {
-      proxy::hook<DIRECT>(position.m_pNode,
-                        const_cast<const NodeBase*>(pTree.m_Root.node.left));
+      pPosition.hook<DIRECT>(pTree.m_Root.node.left);
       BinaryTreeBase<Input>::m_Root.summon(
                                    pTree.BinaryTreeBase<Input>::m_Root);
       BinaryTreeBase<Input>::m_Root.delegate(pTree.m_Root);
@@ -248,20 +247,20 @@
    *  connects two nodes of the given iterators togather.
    */
   struct Mover {
-    virtual ~Mover() {}
-    virtual void connect(TreeIteratorBase& pFrom, const TreeIteratorBase& pTo) const = 0;
+    virtual void connect(TreeIteratorBase& pFrom, NodeBase* pTo) const = 0;
     virtual void move(TreeIteratorBase& pNode) const = 0;
+    virtual ~Mover() { }
   };
 
   /** \class Succeeder
    *  \brief class Succeeder moves the iterator afterward.
    */
   struct Succeeder : public Mover {
-    virtual void connect(TreeIteratorBase& pFrom, const TreeIteratorBase& pTo) const {
-      proxy::hook<Positional>(pFrom.m_pNode, pTo.m_pNode);
+    void connect(TreeIteratorBase& pFrom, NodeBase* pTo) const {
+      pFrom.hook<Positional>(pTo);
     }
 
-    virtual void move(TreeIteratorBase& pNode) const {
+    void move(TreeIteratorBase& pNode) const {
       pNode.move<Positional>();
     }
   };
@@ -270,11 +269,11 @@
    *  \brief class Includer moves the iterator downward.
    */
   struct Includer : public Mover {
-    virtual void connect(TreeIteratorBase& pFrom, const TreeIteratorBase& pTo) const {
-      proxy::hook<Inclusive>(pFrom.m_pNode, pTo.m_pNode);
+    void connect(TreeIteratorBase& pFrom, NodeBase* pTo) const {
+      pFrom.hook<Inclusive>(pTo);
     }
 
-    virtual void move(TreeIteratorBase& pNode) const {
+    void move(TreeIteratorBase& pNode) const {
       pNode.move<Inclusive>();
     }
   };
@@ -325,12 +324,12 @@
 mcld::InputTree::enterGroup(mcld::TreeIteratorBase pRoot)
 {
   BinTreeTy::node_type* node = createNode();
+
   if (pRoot.isRoot())
-    proxy::hook<TreeIteratorBase::Leftward>(pRoot.m_pNode,
-        const_cast<const node_type*>(node));
+    pRoot.hook<TreeIteratorBase::Leftward>(node);
   else
-    proxy::hook<DIRECT>(pRoot.m_pNode,
-        const_cast<const node_type*>(node));
+    pRoot.hook<DIRECT>(node);
+
   return *this;
 }
 
@@ -340,12 +339,12 @@
 {
   BinTreeTy::node_type* node = createNode();
   node->data = &pInput;
+
   if (pRoot.isRoot())
-    proxy::hook<TreeIteratorBase::Leftward>(pRoot.m_pNode,
-                                         const_cast<const node_type*>(node));
+    pRoot.hook<TreeIteratorBase::Leftward>(node);
   else
-    proxy::hook<DIRECT>(pRoot.m_pNode,
-                        const_cast<const node_type*>(node));
+    pRoot.hook<DIRECT>(node);
+
   return *this;
 }
 
diff --git a/include/mcld/LD/Archive.h b/include/mcld/LD/Archive.h
index 7dc2205..26de7c3 100644
--- a/include/mcld/LD/Archive.h
+++ b/include/mcld/LD/Archive.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ARCHIVE_H
-#define MCLD_ARCHIVE_H
+#ifndef MCLD_LD_ARCHIVE_H
+#define MCLD_LD_ARCHIVE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -26,9 +26,6 @@
 class Input;
 class InputFactory;
 class InputBuilder;
-class AttributeFactory;
-class ContextFactory;
-class MemoryAreaFactory;
 
 /** \class Archive
  *  \brief This class define the interfacee to Archive files
@@ -40,6 +37,7 @@
   static const char   THIN_MAGIC[];        ///< magic of thin archive
   static const size_t MAGIC_LEN;           ///< length of magic string
   static const char   SVR4_SYMTAB_NAME[];  ///< SVR4 symtab entry name
+  static const char   IRIX6_SYMTAB_NAME[]; ///< Irix6 symtab entry name
   static const char   STRTAB_NAME[];       ///< Name of string table
   static const char   PAD[];               ///< inter-file align padding
   static const char   MEMBER_MAGIC[];      ///< fmag field magic #
@@ -98,7 +96,7 @@
 
 public:
   typedef HashTable<ArchiveMemberEntryType,
-                    hash::StringHash<hash::ELF>,
+                    hash::StringHash<hash::DJB>,
                     EntryFactory<ArchiveMemberEntryType> > ArchiveMemberMapType;
 
   struct Symbol
diff --git a/include/mcld/LD/ArchiveReader.h b/include/mcld/LD/ArchiveReader.h
index 5f24f49..eb6bec5 100644
--- a/include/mcld/LD/ArchiveReader.h
+++ b/include/mcld/LD/ArchiveReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ARCHIVE_READER_INTERFACE_H
-#define MCLD_ARCHIVE_READER_INTERFACE_H
+#ifndef MCLD_LD_ARCHIVEREADER_H
+#define MCLD_LD_ARCHIVEREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -16,6 +16,7 @@
 namespace mcld
 {
 
+class LinkerConfig;
 class Archive;
 
 /** \class ArchiveReader
@@ -34,7 +35,7 @@
   ArchiveReader();
   virtual ~ArchiveReader();
 
-  virtual bool readArchive(Archive& pArchive) = 0;
+  virtual bool readArchive(const LinkerConfig& pConfig, Archive& pArchive) = 0;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/BSDArchiveReader.h b/include/mcld/LD/BSDArchiveReader.h
index 7abeecc..fd49966 100644
--- a/include/mcld/LD/BSDArchiveReader.h
+++ b/include/mcld/LD/BSDArchiveReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_BSD_ARCHIVE_READER_H
-#define MCLD_BSD_ARCHIVE_READER_H
+#ifndef MCLD_LD_BSDARCHIVEREADER_H
+#define MCLD_LD_BSDARCHIVEREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -18,6 +18,7 @@
 
 class Input;
 class Archive;
+class LinkerConfig;
 
 /** \class BSDArchiveReader
  *  \brief BSDArchiveReader reads BSD-variant archive files.
@@ -29,8 +30,8 @@
   BSDArchiveReader();
   ~BSDArchiveReader();
 
-  bool readArchive(Archive& pArchive);
-  bool isMyFormat(Input& pInput) const;
+  bool readArchive(const LinkerConfig& pConfig, Archive& pArchive);
+  bool isMyFormat(Input& pInput, bool &pContinue) const;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/BinaryReader.h b/include/mcld/LD/BinaryReader.h
index e9c47db..6b61dba 100644
--- a/include/mcld/LD/BinaryReader.h
+++ b/include/mcld/LD/BinaryReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_Binary_READER_H
-#define MCLD_Binary_READER_H
+#ifndef MCLD_LD_BINARYREADER_H
+#define MCLD_LD_BINARYREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -25,16 +25,11 @@
  */
 class BinaryReader : public LDReader
 {
-protected:
-  BinaryReader()
-  { }
-
 public:
-  virtual ~BinaryReader()
-  { }
+  virtual ~BinaryReader() = 0;
 
-  virtual bool isMyFormat(Input& pInput) const
-  { return true; }
+  virtual bool isMyFormat(Input& pInput, bool &pContinue) const
+  { pContinue = true; return false; }
 
   virtual bool readBinary(Input& pFile) = 0;
 };
diff --git a/include/mcld/LD/BranchIsland.h b/include/mcld/LD/BranchIsland.h
index f340f0a..ca1543f 100644
--- a/include/mcld/LD/BranchIsland.h
+++ b/include/mcld/LD/BranchIsland.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_BRANCH_ISLAND_H
-#define MCLD_LD_BRANCH_ISLAND_H
+#ifndef MCLD_LD_BRANCHISLAND_H
+#define MCLD_LD_BRANCHISLAND_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -125,7 +125,7 @@
       size_t operator() (const Key& KEY) const
       {
         llvm::StringRef sym_name(KEY.symbol()->name());
-        hash::StringHash<hash::ELF> str_hasher;
+        hash::StringHash<hash::DJB> str_hasher;
         return (size_t((uintptr_t)KEY.prototype())) ^
                str_hasher(sym_name) ^
                KEY.addend();
diff --git a/include/mcld/LD/BranchIslandFactory.h b/include/mcld/LD/BranchIslandFactory.h
index 755cc31..9431fb3 100644
--- a/include/mcld/LD/BranchIslandFactory.h
+++ b/include/mcld/LD/BranchIslandFactory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_BRANCH_ISLAND_FACTORY_H
-#define MCLD_LD_BRANCH_ISLAND_FACTORY_H
+#ifndef MCLD_LD_BRANCHISLANDFACTORY_H
+#define MCLD_LD_BRANCHISLANDFACTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -20,6 +20,7 @@
 {
 
 class Fragment;
+class Module;
 
 /** \class BranchIslandFactory
  *  \brief
@@ -37,6 +38,10 @@
 
   ~BranchIslandFactory();
 
+  /// group - group fragments and create islands when needed
+  /// @param pSectionData - the SectionData holds fragments need to be grouped
+  void group(Module& pModule);
+
   /// produce - produce a island for the given fragment
   /// @param pFragment - the fragment needs a branch island
   BranchIsland* produce(Fragment& pFragment);
diff --git a/include/mcld/LD/DWARFLineInfo.h b/include/mcld/LD/DWARFLineInfo.h
index 004d597..4f19312 100644
--- a/include/mcld/LD/DWARFLineInfo.h
+++ b/include/mcld/LD/DWARFLineInfo.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_DWARF_LINE_INFO_H
-#define MCLD_DWARF_LINE_INFO_H
+#ifndef MCLD_LD_DWARFLINEINFO_H
+#define MCLD_LD_DWARFLINEINFO_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/DiagAttribute.inc b/include/mcld/LD/DiagAttribute.inc
new file mode 100644
index 0000000..453ae65
--- /dev/null
+++ b/include/mcld/LD/DiagAttribute.inc
@@ -0,0 +1,19 @@
+// General
+DIAG(warn_unsupported_attribute_section_format, DiagnosticEngine::Warning, "unsupported format of attribute section in input %0 (version=%1).", "unsupported format of attribute section in input %0 (version=%1).")
+DIAG(warn_unrecognized_vendor_subsection, DiagnosticEngine::Warning, "skip unrecognized private vendor subsection with name '%0' in %1.", "skip unrecognized private vendor subsection with name '%0' in %1.")
+
+// ARM attributes
+DIAG(error_unknown_cpu_arch, DiagnosticEngine::Error, "input %0 has unknown CPU architecture profile.", "input %0 has unknown CPU architecture profile.")
+DIAG(warn_mismatch_cpu_arch_profile, DiagnosticEngine::Warning, "conflicting architecture profiles %0 in %1.", "conflicting architecture profiles %0 in %1.")
+DIAG(error_mismatch_mpextension_use, DiagnosticEngine::Error, "conflicting values from Tag_MPextension_use and Tag_MPextension_use_legacy in %0", "conflicting values from Tag_MPextension_use and Tag_MPextension_use_legacy in %0")
+DIAG(warn_mismatch_enum_size, DiagnosticEngine::Warning, "the size of enumerated data item in input %0 (value=%1) is not compatible with the output (value=%2).", "the size of enumerated data item in input %0 (value=%1) is not compatible with the output (value=%2).")
+DIAG(warn_mismatch_fp16_format, DiagnosticEngine::Warning, "conflicting 16-bit FP number format in %0", "conflicting 16-bit FP number format in %0")
+DIAG(warn_unrecognized_virtualization_use, DiagnosticEngine::Warning, "value of Tag_Virtualization_use cannot be recognized in %0 (value=%1).", "value of Tag_Virtualization_use cannot be recognized in %0 (value=%1).")
+DIAG(warn_mismatch_abi_wmmx_args, DiagnosticEngine::Warning, "%0 uses different way to pass WMMX parameters and results.", "%0 uses different way to pass WMMX parameters and results.")
+DIAG(warn_mismatch_pcs_config, DiagnosticEngine::Warning, "conflicting procedure call standard config in input %0.", "conflicting procedure call standard config in input %0.")
+DIAG(warn_mismatch_r9_use, DiagnosticEngine::Warning, "conflicting way to use R9 in input %0.", "conflicting way to use R9 in input %0.")
+DIAG(warn_conflict_rw_data_and_r9, DiagnosticEngine::Warning, "RW static data addressing (SB-relative) conflicts the use of R9 (Tag_ABI_PCS_R9_use) in input %0.", "RW static data addressing (SB-relative) conflicts the use of R9 (Tag_ABI_PCS_R9_use) in input %0.")
+DIAG(warn_mismatch_wchar_size, DiagnosticEngine::Warning, "incompatible size of wchar_t in input %0 (value=%1) with the output (value=%2).", "incompatible size of wchar_t in input %0 (value=%1) with the output (value=%2).")
+DIAG(warn_unknown_mandatory_attribute, DiagnosticEngine::Warning, "unknown mandatory attribute with tag %0 was ignored in %1.", "unknown mandatory attribute with tag %0 was ignored in %1.")
+DIAG(warn_unknown_attribute, DiagnosticEngine::Warning, "unknown attribute with tag %0 was ignored in %1.", "unknown attribute with tag %0 was ignored in %1.")
+DIAG(warn_mismatch_vfp_args, DiagnosticEngine::Warning, "%0 uses different way to pass the floating point parameter and results.", "%0 uses different way to pass the floating point parameter and results.")
diff --git a/include/mcld/LD/DiagCommonKinds.inc b/include/mcld/LD/DiagCommonKinds.inc
index e7d6328..539eafb 100644
--- a/include/mcld/LD/DiagCommonKinds.inc
+++ b/include/mcld/LD/DiagCommonKinds.inc
@@ -3,7 +3,7 @@
 DIAG(warn_cannot_open_search_dir, DiagnosticEngine::Warning, "can not open search directory `-L%0'", "can not open search directory `-L%0'")
 DIAG(err_no_inputs, DiagnosticEngine::Error, "no inputs", "no inputs")
 DIAG(err_empty_input, DiagnosticEngine::Error, "Empty input file `%0' : %1", "Empty input file `%0' : %1")
-DIAG(err_unrecognized_input_file, DiagnosticEngine::Fatal, "cannot recognize the format of file `%0'.\n  object format or given target machine (%1) is wrong.","cannot recognize the format of file `%0'.\n  object format or given target machine (%1) is wrong.")
+DIAG(warn_unrecognized_input_file, DiagnosticEngine::Warning, "cannot recognize the format of file `%0'.\n  object format or given target machine (%1) is incompatible.","cannot recognize the format of file `%0'.\n  object format or given target machine (%1) is incompatible.")
 DIAG(err_cannot_find_namespec, DiagnosticEngine::Fatal, "cannot recognize namespec -l%0", "cannot recognize namespec -l%0")
 DIAG(err_cannot_identify_option, DiagnosticEngine::Fatal, "unknown command line argument `%0' at %1", "unknown command line argument `%0' at %1")
 DIAG(err_mixed_shared_static_objects, DiagnosticEngine::Error, "cannot link shared objects with -static option.\nShared object `%0': %1", "cannot link shared objects with -static option.\nShared object `%0': %1")
@@ -40,7 +40,7 @@
 DIAG(fatal_cannot_init_target, DiagnosticEngine::Fatal, "Cannot initialize mcld::Target for given triple '%0'.\n(Detail: %1)", "Cannot initialize mcld::Target for given triple '%0'.\n(Detail: %1)")
 DIAG(fatal_cannot_init_lineinfo, DiagnosticEngine::Fatal, "Cannot initialize mcld::DiagnosticLineInfo for given triple '%0'", "Cannot initialize mcld::DiagnosticLineInfo for given triple '%0'")
 DIAG(fatal_cannot_init_backend, DiagnosticEngine::Fatal, "Cannot initialize mcld::TargetLDBackend for given triple '%0'.", "Cannot initialize mcld::TargetLDBackend for given triple '%0'.")
-DIAG(fatal_forbid_nest_group, DiagnosticEngine::Fatal, "May not nest groups", "May not nest groups")
+DIAG(fatal_forbid_nest_group, DiagnosticEngine::Fatal, "not matched --start-group and --end-group", "not matched --start-group and --end-group")
 DIAG(fatal_unwritable_output, DiagnosticEngine::Fatal, "unable to write output file %0", "unable to write output file %0")
 DIAG(warn_unsupported_option, DiagnosticEngine::Warning, "Option `%0' is not implemented yet!", "Option `%0' is not implemented yet!")
 DIAG(warn_shared_textrel, DiagnosticEngine::Warning, "Add DT_TEXTREL in a shared object!", "Add DT_TEXTREL in a shared object.")
@@ -48,3 +48,6 @@
 DIAG(err_nmagic_not_static, DiagnosticEngine::Error, "cannot mix -nmagic option with -shared", "cannot mix -nmagic option with -shared")
 DIAG(err_omagic_not_static, DiagnosticEngine::Error, "cannot mix -omagic option with -shared", "cannot mix -omagic option with -shared")
 DIAG(err_invalid_emulation, DiagnosticEngine::Error, "Invalid target emulation: `%0'.", "Invalid target emulation: `%0'.")
+DIAG(err_cannot_find_scriptfile, DiagnosticEngine::Fatal, "cannot open %0 file %1", "cannot open %0 file %1")
+DIAG(err_unsupported_archive, DiagnosticEngine::Error, "Unsupported archive type.", "Unsupported archive type.")
+DIAG(unexpected_frag_type, DiagnosticEngine::Unreachable, "Unexpected fragment type `%0' when constructing FG", "Unexpected fragment type `%0' when constructing FG")
diff --git a/include/mcld/LD/DiagLDScript.inc b/include/mcld/LD/DiagLDScript.inc
new file mode 100644
index 0000000..c752773
--- /dev/null
+++ b/include/mcld/LD/DiagLDScript.inc
@@ -0,0 +1,3 @@
+DIAG(err_unterminated_comment, DiagnosticEngine::Error, "%0:%1:%2: error: unterminated comment\n", "%0:%1:%2: error: unterminated comment\n")
+DIAG(err_syntax_error, DiagnosticEngine::Error, "%0:%1:%2: error: %3\n", "%0:%1:%2: error: %3\n")
+DIAG(err_assert_failed, DiagnosticEngine::Error,"Assertion failed: %0\n", "Assertion failed: %0\n")
diff --git a/include/mcld/LD/DiagRelocations.inc b/include/mcld/LD/DiagRelocations.inc
index 7ada05f..bacae6e 100644
--- a/include/mcld/LD/DiagRelocations.inc
+++ b/include/mcld/LD/DiagRelocations.inc
@@ -1,6 +1,7 @@
 DIAG(reloc_factory_has_not_config, DiagnosticEngine::Fatal, "Please call mcld::Linker::config before creating relocations", "Please call mcld::Linker::config before creating relocations")
 DIAG(unsupported_bitclass, DiagnosticEngine::Fatal, "Only supports 32 and 64 bits targets. (Target: %0, bitclass:%1)", "Only supports 32 and 64 bits targets. (Target: %0, bitclass:%1)")
-DIAG(undefined_reference, DiagnosticEngine::Fatal, "undefined reference to `%0'", "In %1:%2, variable %0 must be defined")
+DIAG(undefined_reference, DiagnosticEngine::Fatal, "%1(%2+%3): undefined reference to `%0'", "%1(%2+%3): undefined reference to `%0'")
+DIAG(undefined_reference_text, DiagnosticEngine::Fatal, "%1:%2:function %3: undefined reference to `%0'", "%1:%2: undefined reference to `%0'")
 DIAG(non_pic_relocation, DiagnosticEngine::Error, "attempt to generate unsupported relocation type `%0' for symbol `%1', recompile with -fPIC", "attempt to generate unsupported relocation type `%0' for symbol `%1, recompile with -fPIC")
 DIAG(base_relocation, DiagnosticEngine::Fatal, "relocation type `%0' is not supported for symbol `%1'\nPlease report to %2", "relocation type `%0' is not supported for symbol `%1'\nPlease report to %2")
 DIAG(dynamic_relocation, DiagnosticEngine::Fatal, "unexpected relocation type `%0' in object file", "unexpected relocation type `%0' in object file")
@@ -11,3 +12,4 @@
 DIAG(result_badreloc, DiagnosticEngine::Error, "applying relocation `%0' encounters unexpected opcode on symbol `%1'","applying relocation `%0' encounters unexpected opcode on symbol `%1'")
 DIAG(invalid_tls, DiagnosticEngine::Error, "TLS relocation against invalid symbol `%0' in section `%1'", "TLS relocation against invalid symbol `%0' in section `%1'")
 DIAG(unknown_reloc_section_type, DiagnosticEngine::Unreachable, "unknown relocation section type: `%0' in section `%1'", "unknown relocation section type: `%0' in section `%1'")
+DIAG(unsupport_cond_branch_reloc, DiagnosticEngine::Error, "applying relocation `%0', conditional branch to PLT in THUMB-2 not supported yet", "applying relocation `%0', conditional branch to PLT in THUMB-2 not supported yet")
diff --git a/include/mcld/LD/DiagSymbolResolutions.inc b/include/mcld/LD/DiagSymbolResolutions.inc
index 786eb4b..04113dc 100644
--- a/include/mcld/LD/DiagSymbolResolutions.inc
+++ b/include/mcld/LD/DiagSymbolResolutions.inc
@@ -8,3 +8,4 @@
 DIAG(indirect_refer_to_inexist, DiagnosticEngine::Fatal, "indirect symbol %0 points to a undefined symbol", "variable %0 is undefined")
 DIAG(multiple_definitions, DiagnosticEngine::Error, "multiple definition of symbol `%0'", "you define variable %0 twice")
 DIAG(undefined_situation, DiagnosticEngine::Unreachable, "reach undefined situation, action: %0, old(%1) -> new(%2)", "reach undefined situation, action: %0, old(%1) -> new(%2)")
+DIAG(multiple_absolute_definitions, DiagnosticEngine::Error, "inconsistent definitions of absolute symbol `%0': old(%1) -> new(%2)", "you defined an absolute symbol with different values")
diff --git a/include/mcld/LD/Diagnostic.h b/include/mcld/LD/Diagnostic.h
index 2e4db11..1982ef0 100644
--- a/include/mcld/LD/Diagnostic.h
+++ b/include/mcld/LD/Diagnostic.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_DIAGNOSTIC_H
-#define MCLD_DIAGNOSTIC_H
+#ifndef MCLD_LD_DIAGNOSTIC_H
+#define MCLD_LD_DIAGNOSTIC_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/DiagnosticEngine.h b/include/mcld/LD/DiagnosticEngine.h
index 1c825a2..b003955 100644
--- a/include/mcld/LD/DiagnosticEngine.h
+++ b/include/mcld/LD/DiagnosticEngine.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_DIAGNOSTIC_ENGINE_H
-#define MCLD_DIAGNOSTIC_ENGINE_H
+#ifndef MCLD_LD_DIAGNOSTICENGINE_H
+#define MCLD_LD_DIAGNOSTICENGINE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/DiagnosticInfos.h b/include/mcld/LD/DiagnosticInfos.h
index cb9bdbd..16ebbab 100644
--- a/include/mcld/LD/DiagnosticInfos.h
+++ b/include/mcld/LD/DiagnosticInfos.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_DIAGNOSTIC_INFORMATION_H
-#define MCLD_DIAGNOSTIC_INFORMATION_H
+#ifndef MCLD_LD_DIAGNOSTICINFORMATION_H
+#define MCLD_LD_DIAGNOSTICINFORMATION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -18,12 +18,14 @@
 namespace diag {
   enum ID {
 #define DIAG(ENUM, CLASS, ADDRMSG, LINEMSG) ENUM,
+#include "mcld/LD/DiagAttribute.inc"
 #include "mcld/LD/DiagCommonKinds.inc"
 #include "mcld/LD/DiagReaders.inc"
 #include "mcld/LD/DiagSymbolResolutions.inc"
 #include "mcld/LD/DiagRelocations.inc"
 #include "mcld/LD/DiagLayouts.inc"
 #include "mcld/LD/DiagGOTPLT.inc"
+#include "mcld/LD/DiagLDScript.inc"
 #undef DIAG
     NUM_OF_BUILDIN_DIAGNOSTIC_INFO
   };
diff --git a/include/mcld/LD/DiagnosticLineInfo.h b/include/mcld/LD/DiagnosticLineInfo.h
index 30f0546..db35287 100644
--- a/include/mcld/LD/DiagnosticLineInfo.h
+++ b/include/mcld/LD/DiagnosticLineInfo.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_DIAGNOSTICLINEINFO_H
-#define MCLD_DIAGNOSTICLINEINFO_H
+#ifndef MCLD_LD_DIAGNOSTICLINEINFO_H
+#define MCLD_LD_DIAGNOSTICLINEINFO_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/DiagnosticPrinter.h b/include/mcld/LD/DiagnosticPrinter.h
index b3617a7..7cf5c8e 100644
--- a/include/mcld/LD/DiagnosticPrinter.h
+++ b/include/mcld/LD/DiagnosticPrinter.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_DIAGNOSTIC_PRINTER_H
-#define MCLD_DIAGNOSTIC_PRINTER_H
+#ifndef MCLD_LD_DIAGNOSTICPRINTER_H
+#define MCLD_LD_DIAGNOSTICPRINTER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/DynObjFileFormat.h b/include/mcld/LD/DynObjFileFormat.h
index 7b1626d..e0972c3 100644
--- a/include/mcld/LD/DynObjFileFormat.h
+++ b/include/mcld/LD/DynObjFileFormat.h
@@ -1,4 +1,4 @@
-//===- header.h -----------------------------------------------------------===//
+//===- DynObjFileFormat.h -------------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef DYNOBJFORMAT_H
-#define DYNOBJFORMAT_H
+#ifndef MCLD_LD_DYNOBJFILEFORMAT_H
+#define MCLD_LD_DYNOBJFILEFORMAT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/DynObjReader.h b/include/mcld/LD/DynObjReader.h
index ddc9500..8a7a6be 100644
--- a/include/mcld/LD/DynObjReader.h
+++ b/include/mcld/LD/DynObjReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_DYNAMIC_SHARED_OBJECT_READER_H
-#define MCLD_DYNAMIC_SHARED_OBJECT_READER_H
+#ifndef MCLD_LD_DYNOBJREADER_H
+#define MCLD_LD_DYNOBJREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/ELFBinaryReader.h b/include/mcld/LD/ELFBinaryReader.h
index fc3a067..9da4535 100644
--- a/include/mcld/LD/ELFBinaryReader.h
+++ b/include/mcld/LD/ELFBinaryReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_Binary_READER_H
-#define MCLD_ELF_Binary_READER_H
+#ifndef MCLD_LD_ELFBINARYREADER_H
+#define MCLD_LD_ELFBINARYREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -19,7 +19,6 @@
 class Module;
 class Input;
 class IRBuilder;
-class GNULDBackend;
 class LinkerConfig;
 
 /** \lclass ELFBinaryReader
@@ -28,16 +27,15 @@
 class ELFBinaryReader : public BinaryReader
 {
 public:
-  ELFBinaryReader(GNULDBackend& pBackend,
-                  IRBuilder& pBuilder,
-                  const LinkerConfig& pConfig);
+  ELFBinaryReader(IRBuilder& pBuilder, const LinkerConfig& pConfig);
 
   ~ELFBinaryReader();
 
-  virtual bool readBinary(Input& pInput);
+  bool isMyFormat(Input& pInput, bool &pContinue) const;
+
+  bool readBinary(Input& pInput);
 
 private:
-  GNULDBackend& m_Backend;
   IRBuilder& m_Builder;
   const LinkerConfig& m_Config;
 };
diff --git a/include/mcld/LD/ELFDynObjFileFormat.h b/include/mcld/LD/ELFDynObjFileFormat.h
index 2ee97a6..dd9cbb9 100644
--- a/include/mcld/LD/ELFDynObjFileFormat.h
+++ b/include/mcld/LD/ELFDynObjFileFormat.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_DYNAMIC_OBJECT_FILE_FROMAT_H
-#define MCLD_ELF_DYNAMIC_OBJECT_FILE_FROMAT_H
+#ifndef MCLD_LD_ELFDYNOBJFILEFROMAT_H
+#define MCLD_LD_ELFDYNOBJFILEFROMAT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/ELFDynObjReader.h b/include/mcld/LD/ELFDynObjReader.h
index f6d2067..23b96ad 100644
--- a/include/mcld/LD/ELFDynObjReader.h
+++ b/include/mcld/LD/ELFDynObjReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_DYNAMIC_SHARED_OBJECT_READER_H
-#define MCLD_ELF_DYNAMIC_SHARED_OBJECT_READER_H
+#ifndef MCLD_LD_ELFDYNOBJREADER_H
+#define MCLD_LD_ELFDYNOBJREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -35,7 +35,7 @@
   ~ELFDynObjReader();
 
   // -----  observers  ----- //
-  bool isMyFormat(Input &pFile) const;
+  bool isMyFormat(Input &pFile, bool &pContinue) const;
 
   // -----  readers  ----- //
   bool readHeader(Input& pFile);
diff --git a/include/mcld/LD/ELFObjectReader.h b/include/mcld/LD/ELFObjectReader.h
index 27e4489..a124676 100644
--- a/include/mcld/LD/ELFObjectReader.h
+++ b/include/mcld/LD/ELFObjectReader.h
@@ -46,7 +46,7 @@
   ~ELFObjectReader();
 
   // -----  observers  ----- //
-  bool isMyFormat(Input &pFile) const;
+  bool isMyFormat(Input &pFile, bool &pContinue) const;
 
   // -----  readers  ----- //
   bool readHeader(Input& pFile);
diff --git a/include/mcld/LD/ELFObjectWriter.h b/include/mcld/LD/ELFObjectWriter.h
index 12a5842..9caa76a 100644
--- a/include/mcld/LD/ELFObjectWriter.h
+++ b/include/mcld/LD/ELFObjectWriter.h
@@ -6,18 +6,20 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_OBJECT_WRITER_H
-#define MCLD_ELF_OBJECT_WRITER_H
+#ifndef MCLD_LD_ELFOBJWRITER_H
+#define MCLD_LD_ELFOBJWRITER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 #include <mcld/LD/ObjectWriter.h>
 #include <cassert>
 
+#include <mcld/Support/FileOutputBuffer.h>
 #include <llvm/Support/system_error.h>
 
 namespace mcld {
 
+class EhFrame;
 class Module;
 class LinkerConfig;
 class GNULDBackend;
@@ -27,8 +29,6 @@
 class SectionData;
 class RelocData;
 class Output;
-class MemoryRegion;
-class MemoryArea;
 
 /** \class ELFObjectWriter
  *  \brief ELFObjectWriter writes the target-independent parts of object files.
@@ -42,10 +42,13 @@
 
   ~ELFObjectWriter();
 
-  llvm::error_code writeObject(Module& pModule, MemoryArea& pOutput);
+  llvm::error_code writeObject(Module& pModule, FileOutputBuffer& pOutput);
+
+  size_t getOutputSize(const Module& pModule) const;
 
 private:
-  void writeSection(MemoryArea& pOutput, LDSection *section);
+  void writeSection(Module& pModule,
+                    FileOutputBuffer& pOutput, LDSection *section);
 
   GNULDBackend&       target()        { return m_Backend; }
 
@@ -55,7 +58,7 @@
   template<size_t SIZE>
   void writeELFHeader(const LinkerConfig& pConfig,
                       const Module& pModule,
-                      MemoryArea& pOutput) const;
+                      FileOutputBuffer& pOutput) const;
 
   uint64_t getEntryPoint(const LinkerConfig& pConfig,
                          const Module& pModule) const;
@@ -64,19 +67,21 @@
   template<size_t SIZE>
   void emitSectionHeader(const Module& pModule,
                          const LinkerConfig& pConfig,
-                         MemoryArea& pOutput) const;
+                         FileOutputBuffer& pOutput) const;
 
   // emitProgramHeader - emit ElfXX_Phdr
   template<size_t SIZE>
-  void emitProgramHeader(MemoryArea& pOutput) const;
+  void emitProgramHeader(FileOutputBuffer& pOutput) const;
 
   // emitShStrTab - emit .shstrtab
   void emitShStrTab(const LDSection& pShStrTab,
                     const Module& pModule,
-                    MemoryArea& pOutput);
+                    FileOutputBuffer& pOutput);
 
-  void emitSectionData(const LDSection& pSection,
-                       MemoryRegion& pRegion) const;
+  void emitSectionData(const LDSection& pSection, MemoryRegion& pRegion) const;
+
+  void emitEhFrame(Module& pModule,
+                   EhFrame& pFrame, MemoryRegion& pRegion) const;
 
   void emitRelocation(const LinkerConfig& pConfig,
                       const LDSection& pSection,
diff --git a/include/mcld/LD/ELFReader.h b/include/mcld/LD/ELFReader.h
index 9df21d3..6750ebd 100644
--- a/include/mcld/LD/ELFReader.h
+++ b/include/mcld/LD/ELFReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_READER_H
-#define MCLD_ELF_READER_H
+#ifndef MCLD_LD_ELFREADER_H
+#define MCLD_LD_ELFREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -20,8 +20,6 @@
 #include <mcld/LD/ResolveInfo.h>
 #include <mcld/LD/LDSymbol.h>
 #include <mcld/Target/GNULDBackend.h>
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/MemoryArea.h>
 
 namespace mcld {
 
@@ -60,19 +58,19 @@
   { return sizeof(ELFHeader); }
 
   /// isELF - is this a ELF file
-  bool isELF(void* pELFHeader) const;
+  bool isELF(const void* pELFHeader) const;
 
   /// isMyEndian - is this ELF file in the same endian to me?
-  bool isMyEndian(void* pELFHeader) const;
+  bool isMyEndian(const void* pELFHeader) const;
 
   /// isMyMachine - is this ELF file generated for the same machine.
-  bool isMyMachine(void* pELFHeader) const;
+  bool isMyMachine(const void* pELFHeader) const;
 
   /// fileType - the file type of this file
-  Input::Type fileType(void* pELFHeader) const;
+  Input::Type fileType(const void* pELFHeader) const;
 
   /// readSectionHeaders - read ELF section header table and create LDSections
-  bool readSectionHeaders(Input& pInput, void* pELFHeader) const;
+  bool readSectionHeaders(Input& pInput, const void* pELFHeader) const;
 
   /// readRegularSection - read a regular section and create fragments.
   bool readRegularSection(Input& pInput, SectionData& pSD) const;
@@ -80,24 +78,24 @@
   /// readSymbols - read ELF symbols and create LDSymbol
   bool readSymbols(Input& pInput,
                    IRBuilder& pBuilder,
-                   const MemoryRegion& pRegion,
+                   llvm::StringRef pRegion,
                    const char* StrTab) const;
 
   /// readSignature - read a symbol from the given Input and index in symtab
   /// This is used to get the signature of a group section.
   ResolveInfo* readSignature(Input& pInput,
-                                    LDSection& pSymTab,
-                                    uint32_t pSymIdx) const;
+                             LDSection& pSymTab,
+                             uint32_t pSymIdx) const;
 
   /// readRela - read ELF rela and create Relocation
   bool readRela(Input& pInput,
                 LDSection& pSection,
-                const MemoryRegion& pRegion) const;
+                llvm::StringRef pRegion) const;
 
   /// readRel - read ELF rel and create Relocation
   bool readRel(Input& pInput,
                LDSection& pSection,
-               const MemoryRegion& pRegion) const;
+               llvm::StringRef pRegion) const;
 
   /// readDynamic - read ELF .dynamic in input dynobj
   bool readDynamic(Input& pInput) const;
@@ -150,19 +148,19 @@
   { return sizeof(ELFHeader); }
 
   /// isELF - is this a ELF file
-  bool isELF(void* pELFHeader) const;
+  bool isELF(const void* pELFHeader) const;
 
   /// isMyEndian - is this ELF file in the same endian to me?
-  bool isMyEndian(void* pELFHeader) const;
+  bool isMyEndian(const void* pELFHeader) const;
 
   /// isMyMachine - is this ELF file generated for the same machine.
-  bool isMyMachine(void* pELFHeader) const;
+  bool isMyMachine(const void* pELFHeader) const;
 
   /// fileType - the file type of this file
-  Input::Type fileType(void* pELFHeader) const;
+  Input::Type fileType(const void* pELFHeader) const;
 
   /// readSectionHeaders - read ELF section header table and create LDSections
-  bool readSectionHeaders(Input& pInput, void* pELFHeader) const;
+  bool readSectionHeaders(Input& pInput, const void* pELFHeader) const;
 
   /// readRegularSection - read a regular section and create fragments.
   bool readRegularSection(Input& pInput, SectionData& pSD) const;
@@ -170,24 +168,24 @@
   /// readSymbols - read ELF symbols and create LDSymbol
   bool readSymbols(Input& pInput,
                    IRBuilder& pBuilder,
-                   const MemoryRegion& pRegion,
+                   llvm::StringRef pRegion,
                    const char* StrTab) const;
 
   /// readSignature - read a symbol from the given Input and index in symtab
   /// This is used to get the signature of a group section.
   ResolveInfo* readSignature(Input& pInput,
-                                    LDSection& pSymTab,
-                                    uint32_t pSymIdx) const;
+                             LDSection& pSymTab,
+                             uint32_t pSymIdx) const;
 
   /// readRela - read ELF rela and create Relocation
   bool readRela(Input& pInput,
                 LDSection& pSection,
-                const MemoryRegion& pRegion) const;
+                llvm::StringRef pRegion) const;
 
   /// readRel - read ELF rel and create Relocation
   bool readRel(Input& pInput,
                LDSection& pSection,
-               const MemoryRegion& pRegion) const;
+               llvm::StringRef pRegion) const;
 
   /// readDynamic - read ELF .dynamic in input dynobj
   bool readDynamic(Input& pInput) const;
diff --git a/include/mcld/LD/ELFReaderIf.h b/include/mcld/LD/ELFReaderIf.h
index 245b542..0ce5992 100644
--- a/include/mcld/LD/ELFReaderIf.h
+++ b/include/mcld/LD/ELFReaderIf.h
@@ -1,4 +1,4 @@
-//===- ELFReader.h --------------------------------------------------------===//
+//===- ELFReaderIf.h ------------------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_READER_INTERFACE_H
-#define MCLD_ELF_READER_INTERFACE_H
+#ifndef MCLD_LD_ELFREADERIF_H
+#define MCLD_LD_ELFREADERIF_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -46,16 +46,16 @@
   virtual size_t getELFHeaderSize() const = 0;
 
   /// isELF - is this a ELF file
-  virtual bool isELF(void* pELFHeader) const = 0;
+  virtual bool isELF(const void* pELFHeader) const = 0;
 
   /// isMyEndian - is this ELF file in the same endian to me?
-  virtual bool isMyEndian(void* pELFHeader) const = 0;
+  virtual bool isMyEndian(const void* pELFHeader) const = 0;
 
   /// isMyMachine - is this ELF file generated for the same machine.
-  virtual bool isMyMachine(void* pELFHeader) const = 0;
+  virtual bool isMyMachine(const void* pELFHeader) const = 0;
 
   /// fileType - the file type of this file
-  virtual Input::Type fileType(void* pELFHeader) const = 0;
+  virtual Input::Type fileType(const void* pELFHeader) const = 0;
 
   /// target - the target backend
   const GNULDBackend& target() const { return m_Backend; }
@@ -63,7 +63,8 @@
 
 
   /// readSectionHeaders - read ELF section header table and create LDSections
-  virtual bool readSectionHeaders(Input& pInput, void* pELFHeader) const = 0;
+  virtual bool readSectionHeaders(Input& pInput,
+                                  const void* pELFHeader) const = 0;
 
   /// readRegularSection - read a regular section and create fragments.
   virtual bool readRegularSection(Input& pInput, SectionData& pSD) const = 0;
@@ -71,7 +72,7 @@
   /// readSymbols - read ELF symbols and create LDSymbol
   virtual bool readSymbols(Input& pInput,
                            IRBuilder& pBuilder,
-                           const MemoryRegion& pRegion,
+                           llvm::StringRef pRegion,
                            const char* StrTab) const = 0;
 
   /// readSignature - read a symbol from the given Input and index in symtab
@@ -83,12 +84,12 @@
   /// readRela - read ELF rela and create Relocation
   virtual bool readRela(Input& pInput,
                         LDSection& pSection,
-                        const MemoryRegion& pRegion) const = 0;
+                        llvm::StringRef pRegion) const = 0;
 
   /// readRel - read ELF rel and create Relocation
   virtual bool readRel(Input& pInput,
                        LDSection& pSection,
-                       const MemoryRegion& pRegion) const = 0;
+                       llvm::StringRef pRegion) const = 0;
 
   /// readDynamic - read ELF .dynamic in input dynobj
   virtual bool readDynamic(Input& pInput) const = 0;
diff --git a/include/mcld/LD/ELFSegment.h b/include/mcld/LD/ELFSegment.h
index d7f769e..5079b54 100644
--- a/include/mcld/LD/ELFSegment.h
+++ b/include/mcld/LD/ELFSegment.h
@@ -6,45 +6,52 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_SEGMENT_H
-#define MCLD_ELF_SEGMENT_H
+#ifndef MCLD_LD_ELFSEGMENT_H
+#define MCLD_LD_ELFSEGMENT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
+#include <mcld/Support/Allocators.h>
+#include <mcld/Config/Config.h>
 #include <llvm/Support/ELF.h>
 #include <llvm/Support/DataTypes.h>
-#include <mcld/LD/LDSection.h>
-#include <cassert>
 #include <vector>
 
 namespace mcld
 {
 
+class LDSection;
+
 /** \class ELFSegment
  *  \brief decribe the program header for ELF executable or shared object
  */
 class ELFSegment
 {
 public:
-  typedef std::vector<LDSection*>::iterator sect_iterator;
-  typedef std::vector<LDSection*>::const_iterator const_sect_iterator;
+  typedef std::vector<LDSection*> SectionList;
+  typedef SectionList::iterator iterator;
+  typedef SectionList::const_iterator const_iterator;
+  typedef SectionList::reverse_iterator reverse_iterator;
+  typedef SectionList::const_reverse_iterator const_reverse_iterator;
+
+private:
+  friend class Chunk<ELFSegment, MCLD_SEGMENTS_PER_OUTPUT>;
+  ELFSegment();
+  ELFSegment(uint32_t pType, uint32_t pFlag = llvm::ELF::PF_R);
+
 public:
-  ELFSegment(uint32_t pType,
-             uint32_t pFlag = llvm::ELF::PF_R,
-             uint64_t pOffset = 0,
-             uint64_t pVaddr = 0,
-             uint64_t pPaddr = 0,
-             uint64_t pFilesz = 0,
-             uint64_t pMemsz = 0,
-             uint64_t pAlign = 0,
-             uint64_t pMaxSectAlign = 0);
   ~ELFSegment();
 
   ///  -----  iterators  -----  ///
-  sect_iterator       begin()       { return m_SectionList.begin(); }
-  const_sect_iterator begin() const { return m_SectionList.begin(); }
-  sect_iterator       end()         { return m_SectionList.end(); }
-  const_sect_iterator end()   const { return m_SectionList.end(); }
+  iterator       begin()       { return m_SectionList.begin(); }
+  const_iterator begin() const { return m_SectionList.begin(); }
+  iterator       end()         { return m_SectionList.end(); }
+  const_iterator end()   const { return m_SectionList.end(); }
+
+  reverse_iterator       rbegin()       { return m_SectionList.rbegin(); }
+  const_reverse_iterator rbegin() const { return m_SectionList.rbegin(); }
+  reverse_iterator       rend()         { return m_SectionList.rend(); }
+  const_reverse_iterator rend()   const { return m_SectionList.rend(); }
 
   LDSection*       front()       { return m_SectionList.front(); }
   const LDSection* front() const { return m_SectionList.front(); }
@@ -52,35 +59,20 @@
   const LDSection* back()  const { return m_SectionList.back(); }
 
   ///  -----  observers  -----  ///
-  uint32_t type() const
-  { return m_Type; }
+  uint32_t type()   const { return m_Type; }
+  uint64_t offset() const { return m_Offset; }
+  uint64_t vaddr()  const { return m_Vaddr; }
+  uint64_t paddr()  const { return m_Paddr; }
+  uint64_t filesz() const { return m_Filesz; }
+  uint64_t memsz()  const { return m_Memsz; }
+  uint32_t flag()   const { return m_Flag; }
+  uint64_t align()  const { return std::max(m_Align, m_MaxSectionAlign); }
 
-  uint64_t offset() const
-  { return m_Offset; }
+  size_t size() const { return m_SectionList.size(); }
+  bool  empty() const { return m_SectionList.empty(); }
 
-  uint64_t vaddr() const
-  { return m_Vaddr; }
-
-  uint64_t paddr() const
-  { return m_Paddr; }
-
-  uint64_t filesz() const
-  { return m_Filesz; }
-
-  uint64_t memsz() const
-  { return m_Memsz; }
-
-  uint32_t flag() const
-  { return m_Flag; }
-
-  uint64_t align() const
-  { return std::max(m_Align, m_MaxSectionAlign); }
-
-  size_t numOfSections() const
-  { return m_SectionList.size(); }
-
+  bool isLoadSegment() const;
   bool isDataSegment() const;
-
   bool isBssSegment() const;
 
   ///  -----  modifiers  -----  ///
@@ -112,13 +104,14 @@
   void setAlign(uint64_t pAlign)
   { m_Align = pAlign; }
 
-  void addSection(LDSection* pSection)
-  {
-    assert(NULL != pSection);
-    if (pSection->align() > m_MaxSectionAlign)
-      m_MaxSectionAlign = pSection->align();
-    m_SectionList.push_back(pSection);
-  }
+  iterator insert(iterator pPos, LDSection* pSection);
+
+  void append(LDSection* pSection);
+
+  /* factory methods */
+  static ELFSegment* Create(uint32_t pType, uint32_t pFlag = llvm::ELF::PF_R);
+  static void Destroy(ELFSegment*& pSegment);
+  static void Clear();
 
 private:
   uint32_t m_Type;            // Type of segment
@@ -130,7 +123,7 @@
   uint64_t m_Memsz;           // # of bytes in mem image of segment (may be 0)
   uint64_t m_Align;           // alignment constraint
   uint64_t m_MaxSectionAlign; // max alignment of the sections in this segment
-  std::vector<LDSection*> m_SectionList;
+  SectionList m_SectionList;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/ELFSegmentFactory.h b/include/mcld/LD/ELFSegmentFactory.h
index 5085a18..6df0389 100644
--- a/include/mcld/LD/ELFSegmentFactory.h
+++ b/include/mcld/LD/ELFSegmentFactory.h
@@ -6,38 +6,64 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELFSEGMENT_FACTORY_H
-#define MCLD_ELFSEGMENT_FACTORY_H
+#ifndef MCLD_LD_ELFSEGMENTFACTORY_H
+#define MCLD_LD_ELFSEGMENTFACTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
-#include <mcld/Support/GCFactory.h>
-#include <mcld/LD/ELFSegment.h>
+
+#include <llvm/Support/DataTypes.h>
+#include <llvm/Support/ELF.h>
+#include <vector>
 
 namespace mcld
 {
 
+class ELFSegment;
+class LDSection;
+
 /** \class ELFSegmentFactory
  *  \brief provide the interface to create and delete an ELFSegment
  */
-class ELFSegmentFactory : public GCFactory<ELFSegment, 0>
+class ELFSegmentFactory
 {
 public:
-  /// ELFSegmentFactory - the factory of ELFSegment
-  /// pNum is the magic number of the ELF segments in the output
-  ELFSegmentFactory(size_t pNum);
-  ~ELFSegmentFactory();
+  typedef std::vector<ELFSegment*> Segments;
+  typedef Segments::const_iterator const_iterator;
+  typedef Segments::iterator iterator;
+
+  const_iterator begin() const { return m_Segments.begin(); }
+  iterator       begin()       { return m_Segments.begin(); }
+  const_iterator end()   const { return m_Segments.end(); }
+  iterator       end()         { return m_Segments.end(); }
+
+  const ELFSegment* front() const { return m_Segments.front(); }
+  ELFSegment*       front()       { return m_Segments.front(); }
+  const ELFSegment* back()  const { return m_Segments.back(); }
+  ELFSegment*       back()        { return m_Segments.back(); }
+
+  size_t size() const { return m_Segments.size(); }
+
+  bool empty() const { return m_Segments.empty(); }
+
+  iterator find(uint32_t pType, uint32_t pFlagSet, uint32_t pFlagClear);
+
+  const_iterator
+  find(uint32_t pType, uint32_t pFlagSet, uint32_t pFlagClear) const;
+
+  iterator       find(uint32_t pType, const LDSection* pSection);
+
+  const_iterator find(uint32_t pType, const LDSection* pSection) const;
 
   /// produce - produce an empty ELF segment information.
   /// this function will create an ELF segment
   /// @param pType - p_type in ELF program header
   ELFSegment* produce(uint32_t pType, uint32_t pFlag = llvm::ELF::PF_R);
 
-  ELFSegment*
-  find(uint32_t pType, uint32_t pFlagSet, uint32_t pFlagClear);
+  void erase(iterator pSegment);
 
-  const ELFSegment*
-  find(uint32_t pType, uint32_t pFlagSet, uint32_t pFlagClear) const;
+private:
+  Segments m_Segments;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/EhFrame.h b/include/mcld/LD/EhFrame.h
index c067746..6663d0f 100644
--- a/include/mcld/LD/EhFrame.h
+++ b/include/mcld/LD/EhFrame.h
@@ -6,23 +6,30 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_EH_FRAME_H
-#define MCLD_LD_EH_FRAME_H
+#ifndef MCLD_LD_EHFRAME_H
+#define MCLD_LD_EHFRAME_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 
 #include <mcld/Config/Config.h>
 #include <mcld/Fragment/RegionFragment.h>
-#include <mcld/Fragment/NullFragment.h>
+#include <mcld/LD/SectionData.h>
 #include <mcld/Support/Allocators.h>
 
+#include <llvm/ADT/StringRef.h>
+#include <list>
+#include <map>
+#include <set>
 #include <vector>
 
 namespace mcld {
 
+class Input;
+class Module;
 class LDSection;
-class SectionData;
+class ObjectLinker;
+class Relocation;
 
 /** \class EhFrame
  *  \brief EhFrame represents .eh_frame section
@@ -41,53 +48,128 @@
   EhFrame& operator=(const EhFrame&); // DO NOT IMPLEMENT
 
 public:
+  enum RecordType {
+    RECORD_UNKNOWN,
+    RECORD_INPUT,
+    RECORD_GENERATED
+  };
+
+  class CIE;
+  class FDE;
+
+  typedef std::vector<CIE*> CIEList;
+  typedef CIEList::iterator cie_iterator;
+  typedef CIEList::const_iterator const_cie_iterator;
+
+  typedef std::list<FDE*> FDEList;
+  typedef FDEList::iterator fde_iterator;
+  typedef FDEList::const_iterator const_fde_iterator;
+
+  typedef std::map</*offset*/size_t, CIE*> CIEMap;
+
+  // A super class of CIE and FDE, containing the same part
+  class Record : public RegionFragment
+  {
+  public:
+    Record(llvm::StringRef pRegion);
+    virtual ~Record();
+
+    const llvm::StringRef getRegion() const { return RegionFragment::getRegion(); }
+          llvm::StringRef getRegion()       { return RegionFragment::getRegion(); }
+    virtual RecordType getRecordType() const { return RECORD_UNKNOWN; }
+
+  private:
+    Record(const Record&);            // DO NOT IMPLEMENT
+    Record& operator=(const Record&); // DO NOT IMPLEMENT
+  };
+
   /** \class CIE
    *  \brief Common Information Entry.
    *  The CIE structure refers to LSB Core Spec 4.1, chap.10.6. Exception Frames.
    */
-  class CIE : public RegionFragment
+  class CIE : public Record
   {
   public:
-    CIE(MemoryRegion& pRegion);
+    CIE(llvm::StringRef pRegion);
+    ~CIE();
+
+    virtual RecordType getRecordType() const { return RECORD_INPUT; }
 
     void setFDEEncode(uint8_t pEncode) { m_FDEEncode = pEncode; }
     uint8_t getFDEEncode() const { return m_FDEEncode; }
 
+    void setMergeable(bool pVal = true) { m_Mergeable = pVal; }
+    virtual bool getMergeable() const { return m_Mergeable; }
+
+    void setRelocation(const Relocation& pReloc) { m_pReloc = &pReloc; }
+    const Relocation* getRelocation() const { return m_pReloc; }
+
+    void setPersonalityOffset(uint64_t pOffset) { m_PersonalityOffset = pOffset; }
+    uint64_t getPersonalityOffset() const { return m_PersonalityOffset; }
+
+    void setPersonalityName(const std::string& pStr) { m_PersonalityName = pStr; }
+    const std::string& getPersonalityName() const { return m_PersonalityName; }
+
+    void setAugmentationData(const std::string& pStr) { m_AugmentationData = pStr; }
+    const std::string& getAugmentationData() const { return m_AugmentationData; }
+
+    void add(FDE& pFDE) { m_FDEs.push_back(&pFDE); }
+    void remove(FDE& pFDE) { m_FDEs.remove(&pFDE); }
+    void clearFDEs() { m_FDEs.clear(); }
+    size_t numOfFDEs() const { return m_FDEs.size(); }
+
+    const_fde_iterator begin() const { return m_FDEs.begin(); }
+    fde_iterator       begin()       { return m_FDEs.begin(); }
+    const_fde_iterator end() const { return m_FDEs.end(); }
+    fde_iterator       end()       { return m_FDEs.end(); }
+
   private:
     uint8_t m_FDEEncode;
+    bool m_Mergeable;
+    const Relocation* m_pReloc;
+    uint64_t m_PersonalityOffset;
+    std::string m_PersonalityName;
+    std::string m_AugmentationData;
+    FDEList m_FDEs;
   };
 
   /** \class FDE
    *  \brief Frame Description Entry
    *  The FDE structure refers to LSB Core Spec 4.1, chap.10.6. Exception Frames.
    */
-  class FDE : public RegionFragment
+  class FDE : public Record
   {
   public:
-    FDE(MemoryRegion& pRegion,
-        const CIE& pCIE,
-        uint32_t pDataStart);
+    FDE(llvm::StringRef pRegion, CIE& pCIE);
+    ~FDE();
 
-    const CIE& getCIE() const { return m_CIE; }
-
-    uint32_t getDataStart() const { return m_DataStart; }
+    void setCIE(CIE& pCIE);
+    const CIE& getCIE() const { return *m_pCIE; }
+    CIE&       getCIE()       { return *m_pCIE; }
 
   private:
-    const CIE& m_CIE;
-    uint32_t m_DataStart;
+    CIE* m_pCIE;  // Referenced CIE may change when merging.
   };
 
-  typedef std::vector<CIE*> CIEList;
+  // These are created for PLT
+  class GeneratedCIE : public CIE
+  {
+  public:
+    GeneratedCIE(llvm::StringRef pRegion);
+    ~GeneratedCIE();
 
-  // cie_iterator and const_cie_iterator must be a kind of random access iterator
-  typedef CIEList::iterator cie_iterator;
-  typedef CIEList::const_iterator const_cie_iterator;
+    virtual RecordType getRecordType() const { return RECORD_GENERATED; }
+    virtual bool getMergeable() const { return true; }
+  };
 
-  typedef std::vector<FDE*> FDEList;
+  class GeneratedFDE : public FDE
+  {
+  public:
+    GeneratedFDE(llvm::StringRef pRegion, CIE& pCIE);
+    ~GeneratedFDE();
 
-  // fde_iterator and const_fde_iterator must be a kind of random access iterator
-  typedef FDEList::iterator fde_iterator;
-  typedef FDEList::const_iterator const_fde_iterator;
+    virtual RecordType getRecordType() const { return RECORD_GENERATED; }
+  };
 
 public:
   static EhFrame* Create(LDSection& pSection);
@@ -97,7 +179,7 @@
   static void Clear();
 
   /// merge - move all data from pOther to this object.
-  EhFrame& merge(EhFrame& pOther);
+  EhFrame& merge(const Input& pInput, EhFrame& pInFrame);
 
   const LDSection& getSection() const;
   LDSection&       getSection();
@@ -106,17 +188,13 @@
   SectionData*       getSectionData()       { return m_pSectionData; }
 
   // -----  fragment  ----- //
-  /// addFragment - when we start treating CIEs and FDEs as regular fragments,
-  /// we call this function instead of addCIE() and addFDE().
-  void addFragment(RegionFragment& pFrag);
-
-  void addFragment(NullFragment& pFrag);
+  void addFragment(Fragment& pFrag);
 
   /// addCIE - add a CIE entry in EhFrame
-  void addCIE(CIE& pCIE);
+  void addCIE(CIE& pCIE, bool pAlsoAddFragment = true);
 
   /// addFDE - add a FDE entry in EhFrame
-  void addFDE(FDE& pFDE);
+  void addFDE(FDE& pFDE, bool pAlsoAddFragment = true);
 
   // -----  CIE  ----- //
   const_cie_iterator cie_begin() const { return m_CIEs.begin(); }
@@ -129,29 +207,54 @@
   const CIE& cie_back () const { return *m_CIEs.back(); }
   CIE&       cie_back ()       { return *m_CIEs.back(); }
 
+  bool emptyCIEs() const { return m_CIEs.empty(); }
   size_t numOfCIEs() const { return m_CIEs.size(); }
+  size_t numOfFDEs() const;
 
-  // -----  FDE  ----- //
-  const_fde_iterator fde_begin() const { return m_FDEs.begin(); }
-  fde_iterator       fde_begin()       { return m_FDEs.begin(); }
-  const_fde_iterator fde_end  () const { return m_FDEs.end(); }
-  fde_iterator       fde_end  ()       { return m_FDEs.end(); }
+  const CIEMap& getCIEMap() const { return m_FoundCIEs; }
+  CIEMap&       getCIEMap()       { return m_FoundCIEs; }
 
-  const FDE& fde_front() const { return *m_FDEs.front(); }
-  FDE&       fde_front()       { return *m_FDEs.front(); }
-  const FDE& fde_back () const { return *m_FDEs.back(); }
-  FDE&       fde_back ()       { return *m_FDEs.back(); }
+public:
+  size_t computeOffsetSize();
 
-  size_t numOfFDEs() const { return m_FDEs.size(); }
+  /// getDataStartOffset - Get the offset after length and ID field.
+  /// The offset is 8byte for 32b, and 16byte for 64b.
+  /// We can just use "BITCLASS/4" to represent offset.
+  template <size_t BITCLASS>
+  static size_t getDataStartOffset() { return BITCLASS / 4; }
+
+private:
+  // We needs to check if it is mergeable and check personality name
+  // before merging them. The important note is we must do this after
+  // ALL readSections done, that is the reason why we don't check this
+  // immediately when reading.
+  void setupAttributes(const LDSection* reloc_sect);
+  void removeDiscardedFDE(CIE& pCIE, const LDSection* pRelocEhFrameSect);
+
+private:
+  void removeAndUpdateCIEForFDE(EhFrame& pInFrame, CIE& pInCIE, CIE& pOutCIE,
+                                const LDSection* reloc_sect);
+  void moveInputFragments(EhFrame& pInFrame);
+  void moveInputFragments(EhFrame& pInFrame, CIE& pInCIE, CIE* pOutCIE = 0);
 
 private:
   LDSection* m_pSection;
   SectionData* m_pSectionData;
 
+  // Each eh_frame has a list of CIE, and each CIE has a list of FDE
+  // pointing to the CIE itself. This is used by management when we are
+  // processing eh_frame merge.
+  // However, don't forget we need to handle the Fragments inside SectionData
+  // correctly since they are truly used when output emission.
   CIEList m_CIEs;
-  FDEList m_FDEs;
+
+  // We need this map to find the corresponding CIE for FDE. Not all FDE point
+  // to the nearest CIE.
+  CIEMap m_FoundCIEs;
 };
 
+bool operator==(const EhFrame::CIE&, const EhFrame::CIE&);
+
 } // namespace of mcld
 
 #endif
diff --git a/include/mcld/LD/EhFrameHdr.h b/include/mcld/LD/EhFrameHdr.h
index 3a5971d..2d7b0e9 100644
--- a/include/mcld/LD/EhFrameHdr.h
+++ b/include/mcld/LD/EhFrameHdr.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_EHFRAMEHDR_H
-#define MCLD_EHFRAMEHDR_H
+#ifndef MCLD_LD_EHFRAMEHDR_H
+#define MCLD_LD_EHFRAMEHDR_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -15,11 +15,11 @@
 #include <cassert>
 
 #include <mcld/LD/EhFrame.h>
+#include <mcld/Support/FileOutputBuffer.h>
 namespace mcld {
 
 class LDSection;
-class MemoryArea;
-class MemoryRegion;
+class FileOutputBuffer;
 
 /** \class EhFrameHdr
  *  \brief EhFrameHdr represents .eh_frame_hdr section.
@@ -47,13 +47,14 @@
 
   /// emitOutput - write out eh_frame_hdr
   template<size_t size>
-  void emitOutput(MemoryArea& pOutput)
+  void emitOutput(FileOutputBuffer& pOutput)
   { assert(false && "Call invalid EhFrameHdr::emitOutput"); }
 
 private:
   /// computePCBegin - return the address of FDE's pc
   /// @ref binutils gold: ehframe.cc:222
-  uint32_t computePCBegin(const EhFrame::FDE& pFDE, const MemoryRegion& pEhFrameRegion);
+  uint32_t computePCBegin(const EhFrame::FDE& pFDE,
+                          const MemoryRegion& pEhFrameRegion);
 
 private:
   /// .eh_frame_hdr section
@@ -68,7 +69,7 @@
 //===----------------------------------------------------------------------===//
 /// emitOutput - write out eh_frame_hdr
 template<>
-void EhFrameHdr::emitOutput<32>(MemoryArea& pOutput);
+void EhFrameHdr::emitOutput<32>(FileOutputBuffer& pOutput);
 
 } // namespace of mcld
 
diff --git a/include/mcld/LD/EhFrameReader.h b/include/mcld/LD/EhFrameReader.h
index 1ac0351..509debf 100644
--- a/include/mcld/LD/EhFrameReader.h
+++ b/include/mcld/LD/EhFrameReader.h
@@ -6,17 +6,18 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_EH_FRAME_READER_H
-#define MCLD_EH_FRAME_READER_H
+#ifndef MCLD_LD_EHFRAMEREADER_H
+#define MCLD_LD_EHFRAMEREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
-#include <mcld/Support/MemoryRegion.h>
+#include <mcld/LD/EhFrame.h>
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/DataTypes.h>
 
 namespace mcld {
 
 class Input;
-class EhFrame;
 class LDSection;
 
 /** \class EhFrameReader
@@ -28,8 +29,8 @@
 class EhFrameReader
 {
 public:
-  typedef const uint8_t* ConstAddress;
-  typedef       uint8_t* Address;
+  typedef const char* ConstAddress;
+  typedef       char* Address;
 
 public:
   /// read - read an .eh_frame section and create the corresponding
@@ -70,29 +71,29 @@
   /// @param pSection - the input .eh_frame section
   /// @param pRegion - the memory region that needs to handle with.
   typedef bool (*Action)(EhFrame& pEhFrame,
-                         MemoryRegion& pRegion,
+                         llvm::StringRef pRegion,
                          const Token& pToken);
 private:
   /// scan - scan pData from pHandler for a token.
-  template<bool SAME_ENDIAN> Token
-  scan(ConstAddress pHandler, uint64_t pOffset, const MemoryRegion& pData) const;
+  template<bool SAME_ENDIAN> Token scan(ConstAddress pHandler,
+                                        uint64_t pOffset,
+                                        llvm::StringRef pData) const;
 
   static bool addCIE(EhFrame& pEhFrame,
-                     MemoryRegion& pRegion,
+                     llvm::StringRef pRegion,
                      const Token& pToken);
 
   static bool addFDE(EhFrame& pEhFrame,
-                     MemoryRegion& pRegion,
+                     llvm::StringRef pRegion,
                      const Token& pToken);
 
   static bool addTerm(EhFrame& pEhFrame,
-                      MemoryRegion& pRegion,
+                      llvm::StringRef pRegion,
                       const Token& pToken);
 
   static bool reject(EhFrame& pEhFrame,
-                     MemoryRegion& pRegion,
+                     llvm::StringRef pRegion,
                      const Token& pToken);
-
 };
 
 template<> bool
@@ -101,7 +102,7 @@
 template<> EhFrameReader::Token
 EhFrameReader::scan<true>(ConstAddress pHandler,
                           uint64_t pOffset,
-                          const MemoryRegion& pData) const;
+                          llvm::StringRef pData) const;
 
 } // namespace of mcld
 
diff --git a/include/mcld/LD/GNUArchiveReader.h b/include/mcld/LD/GNUArchiveReader.h
index 7a33ff4..1c2e10a 100644
--- a/include/mcld/LD/GNUArchiveReader.h
+++ b/include/mcld/LD/GNUArchiveReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_GNU_ARCHIVE_READER_H
-#define MCLD_GNU_ARCHIVE_READER_H
+#ifndef MCLD_LD_GNUARCHIVEREADER_H
+#define MCLD_LD_GNUARCHIVEREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -20,8 +20,8 @@
 class Module;
 class Input;
 class ELFObjectReader;
-class MemoryAreaFactory;
 class Archive;
+class LinkerConfig;
 
 /** \class GNUArchiveReader
  *  \brief GNUArchiveReader reads GNU archive files.
@@ -35,10 +35,10 @@
 
   /// readArchive - read an archive, include the needed members, and build up
   /// the subtree
-  bool readArchive(Archive& pArchive);
+  bool readArchive(const LinkerConfig& pConfig, Archive& pArchive);
 
   /// isMyFormat
-  bool isMyFormat(Input& input) const;
+  bool isMyFormat(Input& input, bool &pContinue) const;
 
 private:
   /// isArchive
@@ -78,13 +78,16 @@
 
   /// includeMember - include the object member in the given file offset, and
   /// return the size of the object
+  /// @param pConfig - LinkerConfig
   /// @param pArchiveRoot - the archive root
   /// @param pFileOffset  - file offset of the member header in the archive
-  size_t includeMember(Archive& pArchiveRoot, uint32_t pFileOffset);
+  size_t includeMember(const LinkerConfig& pConfig,
+                       Archive& pArchiveRoot,
+                       uint32_t pFileOffset);
 
   /// includeAllMembers - include all object members. This is called if
   /// --whole-archive is the attribute for this archive file.
-  bool includeAllMembers(Archive& pArchive);
+  bool includeAllMembers(const LinkerConfig& pConfig, Archive& pArchive);
 
 private:
   Module& m_Module;
diff --git a/include/mcld/LD/GarbageCollection.h b/include/mcld/LD/GarbageCollection.h
new file mode 100644
index 0000000..3476cd1
--- /dev/null
+++ b/include/mcld/LD/GarbageCollection.h
@@ -0,0 +1,94 @@
+//===- GarbageCollection.h ------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_LD_GARBAGECOLLECTION_H
+#define MCLD_LD_GARBAGECOLLECTION_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <map>
+#include <set>
+#include <vector>
+
+namespace mcld {
+
+class LDSection;
+class LinkerConfig;
+class Module;
+class TargetLDBackend;
+
+/** \class GarbageCollection
+ *  \brief Implementation of garbage collection for --gc-section.
+ *  @ref GNU gold, gc.
+ */
+class GarbageCollection
+{
+public:
+  typedef std::set<const LDSection*> SectionListTy;
+  typedef std::vector<const LDSection*> SectionVecTy;
+
+  /** \class SectionReachedListMap
+   *  \brief Map the section to the list of sections which it can reach directly
+   */
+  class SectionReachedListMap
+  {
+  public:
+    SectionReachedListMap() {}
+
+    /// addReference - add a reference from pFrom to pTo
+    void addReference(const LDSection& pFrom, const LDSection& pTo);
+
+    /// getReachedList - get the list of sections which can be reached by
+    /// pSection, create one if the list has not existed
+    SectionListTy& getReachedList(const LDSection& pSection);
+
+    /// findReachedList - find the list of sections which can be reached by
+    /// pSection, return NULL if the list not exists
+    SectionListTy* findReachedList(const LDSection& pSection);
+
+  private:
+    typedef std::map<const LDSection*, SectionListTy> ReachedSectionsTy;
+
+  private:
+    /// m_ReachedSections - map a section to the reachable sections list
+    ReachedSectionsTy m_ReachedSections;
+  };
+
+public:
+  GarbageCollection(const LinkerConfig& pConfig,
+                    const TargetLDBackend& pBackend,
+                    Module& pModule);
+  ~GarbageCollection();
+
+  /// run - do garbage collection
+  bool run();
+
+private:
+  void setUpReachedSections();
+  void findReferencedSections(SectionVecTy& pEntry);
+  void getEntrySections(SectionVecTy& pEntry);
+  void stripSections();
+
+private:
+  /// m_SectionReachedListMap - map the section to the list of sections which it
+  /// can reach directly
+  SectionReachedListMap m_SectionReachedListMap;
+
+  /// m_ReferencedSections - a list of sections which can be reached from entry
+  SectionListTy m_ReferencedSections;
+
+  const LinkerConfig& m_Config;
+  const TargetLDBackend& m_Backend;
+  Module& m_Module;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/Group.h b/include/mcld/LD/Group.h
index 31c4a68..30e8f63 100644
--- a/include/mcld/LD/Group.h
+++ b/include/mcld/LD/Group.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef LD_GROUP_H
-#define LD_GROUP_H
+#ifndef MCLD_LD_GROUP_H
+#define MCLD_LD_GROUP_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/GroupReader.h b/include/mcld/LD/GroupReader.h
index 01178a0..fa1e182 100644
--- a/include/mcld/LD/GroupReader.h
+++ b/include/mcld/LD/GroupReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_GROUPREADER_H
-#define MCLD_GROUPREADER_H
+#ifndef MCLD_LD_GROUPREADER_H
+#define MCLD_LD_GROUPREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -43,6 +43,7 @@
   /// readGroup - handle the input sub-tree wich its root is pRoot
   /// @param pRoot - the root Group node of the sub-tree
   bool readGroup(Module::input_iterator pRoot,
+                 Module::input_iterator pEnd,
                  InputBuilder& pBuilder,
                  const LinkerConfig& pConfig);
 
diff --git a/include/mcld/LD/LDContext.h b/include/mcld/LD/LDContext.h
index 3ab6ce1..c9f30ae 100644
--- a/include/mcld/LD/LDContext.h
+++ b/include/mcld/LD/LDContext.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LDCONTEXT_H
-#define MCLD_LDCONTEXT_H
+#ifndef MCLD_LD_LDCONTEXT_H
+#define MCLD_LD_LDCONTEXT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -72,6 +72,12 @@
   void addSymbol(LDSymbol* pSym)
   { m_SymTab.push_back(pSym); }
 
+  const_sym_iterator symTabBegin() const { return m_SymTab.begin(); }
+  sym_iterator       symTabBegin()       { return m_SymTab.begin(); }
+
+  const_sym_iterator symTabEnd() const { return m_SymTab.end(); }
+  sym_iterator       symTabEnd()       { return m_SymTab.end(); }
+
   // -----  relocations  ----- //
   const_sect_iterator relocSectBegin() const { return m_RelocSections.begin(); }
   sect_iterator       relocSectBegin()       { return m_RelocSections.begin(); }
diff --git a/include/mcld/LD/LDFileFormat.h b/include/mcld/LD/LDFileFormat.h
index 4fa58ce..fb5ab63 100644
--- a/include/mcld/LD/LDFileFormat.h
+++ b/include/mcld/LD/LDFileFormat.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LDFILE_FORMAT_H
-#define MCLD_LDFILE_FORMAT_H
+#ifndef MCLD_LD_LDFILEFORMAT_H
+#define MCLD_LD_LDFILEFORMAT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/LDReader.h b/include/mcld/LD/LDReader.h
index 4fde9f0..38bf24d 100644
--- a/include/mcld/LD/LDReader.h
+++ b/include/mcld/LD/LDReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_READER_INTERFACE_H
-#define MCLD_READER_INTERFACE_H
+#ifndef MCLD_LD_LDREADER_H
+#define MCLD_LD_LDREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -37,7 +37,7 @@
 public:
   virtual ~LDReader() { }
 
-  virtual bool isMyFormat(Input& pInput) const = 0;
+  virtual bool isMyFormat(Input& pInput, bool &pContinue) const = 0;
 
 };
 
diff --git a/include/mcld/LD/LDSymbol.h b/include/mcld/LD/LDSymbol.h
index b40213c..bebdd18 100644
--- a/include/mcld/LD/LDSymbol.h
+++ b/include/mcld/LD/LDSymbol.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_SYMBOL_H
-#define MCLD_LD_SYMBOL_H
+#ifndef MCLD_LD_LDSYMBOL_H
+#define MCLD_LD_LDSYMBOL_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -19,7 +19,12 @@
 #include <mcld/LD/ResolveInfo.h>
 #include <mcld/Support/Allocators.h>
 
-#include <llvm/Support/ManagedStatic.h>
+namespace llvm {
+
+// forware declaration
+template<class T> void* object_creator();
+
+} // namespace of llvm
 
 namespace mcld {
 
diff --git a/include/mcld/LD/MsgHandler.h b/include/mcld/LD/MsgHandler.h
index 9b1ed80..62def8e 100644
--- a/include/mcld/LD/MsgHandler.h
+++ b/include/mcld/LD/MsgHandler.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_MESSAGE_HANDLER_H
-#define MCLD_MESSAGE_HANDLER_H
+#ifndef MCLD_LD_MSGHANDLER_H
+#define MCLD_LD_MSGHANDLER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/NamePool.h b/include/mcld/LD/NamePool.h
index 32354ea..7a8f816 100644
--- a/include/mcld/LD/NamePool.h
+++ b/include/mcld/LD/NamePool.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_NAME_POOL_H
-#define MCLD_NAME_POOL_H
+#ifndef MCLD_LD_NAMEPOOL_H
+#define MCLD_LD_NAMEPOOL_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -38,7 +38,14 @@
 class NamePool : private Uncopyable
 {
 public:
-  typedef HashTable<ResolveInfo, hash::StringHash<hash::ELF> > Table;
+  typedef HashTable<ResolveInfo, hash::StringHash<hash::DJB> > Table;
+  typedef Table::iterator syminfo_iterator;
+  typedef Table::const_iterator const_syminfo_iterator;
+
+  typedef GCFactory<ResolveInfo*, 128> FreeInfoSet;
+  typedef FreeInfoSet::iterator freeinfo_iterator;
+  typedef FreeInfoSet::const_iterator const_freeinfo_iterator;
+
   typedef size_t size_type;
 
 public:
@@ -56,7 +63,7 @@
                             ResolveInfo::Binding pBinding,
                             ResolveInfo::SizeType pSize,
                             ResolveInfo::Visibility pVisibility = ResolveInfo::Default);
-  
+
   /// insertSymbol - insert a symbol and resolve the symbol immediately
   /// @param pOldInfo - if pOldInfo is not NULL, the old ResolveInfo being
   ///                   overriden is kept in pOldInfo.
@@ -69,6 +76,7 @@
                     ResolveInfo::Desc pDesc,
                     ResolveInfo::Binding pBinding,
                     ResolveInfo::SizeType pSize,
+                    LDSymbol::ValueType pValue,
                     ResolveInfo::Visibility pVisibility,
                     ResolveInfo* pOldInfo,
                     Resolver::Result& pResult);
@@ -93,15 +101,39 @@
   bool empty() const
   { return m_Table.empty(); }
 
+  // syminfo_iterator - traverse the ResolveInfo in the resolved HashTable
+  syminfo_iterator syminfo_begin()
+  { return m_Table.begin(); }
+
+  syminfo_iterator syminfo_end()
+  { return m_Table.end(); }
+
+  const_syminfo_iterator syminfo_begin() const
+  { return m_Table.begin(); }
+
+  const_syminfo_iterator syminfo_end() const
+  { return m_Table.end(); }
+
+  // freeinfo_iterator - traverse the ResolveInfo those do not need to be
+  // resolved, for example, local symbols
+  freeinfo_iterator freeinfo_begin()
+  { return m_FreeInfoSet.begin(); }
+
+  freeinfo_iterator freeinfo_end()
+  { return m_FreeInfoSet.end(); }
+
+  const_freeinfo_iterator freeinfo_begin() const
+  { return m_FreeInfoSet.begin(); }
+
+  const_freeinfo_iterator freeinfo_end() const
+  { return m_FreeInfoSet.end(); }
+
   // -----  capacity  ----- //
   void reserve(size_type pN);
 
   size_type capacity() const;
 
 private:
-  typedef GCFactory<ResolveInfo*, 128> FreeInfoSet;
-
-private:
   Resolver* m_pResolver;
   Table m_Table;
   FreeInfoSet m_FreeInfoSet;
diff --git a/include/mcld/LD/ObjectReader.h b/include/mcld/LD/ObjectReader.h
index 2ca3173..34427f8 100644
--- a/include/mcld/LD/ObjectReader.h
+++ b/include/mcld/LD/ObjectReader.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_OBJECT_READER_H
-#define MCLD_OBJECT_READER_H
+#ifndef MCLD_LD_OBJECTREADER_H
+#define MCLD_LD_OBJECTREADER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -29,7 +29,7 @@
 class ObjectReader : public LDReader
 {
 protected:
-  typedef HashTable<ResolveInfo, hash::StringHash<hash::ELF> > GroupSignatureMap;
+  typedef HashTable<ResolveInfo, hash::StringHash<hash::DJB> > GroupSignatureMap;
 
 protected:
   ObjectReader()
diff --git a/include/mcld/LD/ObjectWriter.h b/include/mcld/LD/ObjectWriter.h
index c1dcac6..2a42aed 100644
--- a/include/mcld/LD/ObjectWriter.h
+++ b/include/mcld/LD/ObjectWriter.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_OBJECT_WRITER_INTERFACE_H
-#define MCLD_OBJECT_WRITER_INTERFACE_H
+#ifndef MCLD_LD_OBJECTWRITER_H
+#define MCLD_LD_OBJECTWRITER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -16,7 +16,7 @@
 namespace mcld {
 
 class Module;
-class MemoryArea;
+class FileOutputBuffer;
 
 /** \class ObjectWriter
  *  \brief ObjectWriter provides a common interface for object file writers.
@@ -29,7 +29,10 @@
 public:
   virtual ~ObjectWriter();
 
-  virtual llvm::error_code writeObject(Module& pModule, MemoryArea& pOutput) = 0;
+  virtual llvm::error_code writeObject(Module& pModule,
+                                       FileOutputBuffer& pOutput) = 0;
+
+  virtual size_t getOutputSize(const Module& pModule) const = 0;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/RelocData.h b/include/mcld/LD/RelocData.h
index b53151a..68bc7e1 100644
--- a/include/mcld/LD/RelocData.h
+++ b/include/mcld/LD/RelocData.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_RELOCATION_DATA_H
-#define MCLD_RELOCATION_DATA_H
+#ifndef MCLD_LD_RELOCDATA_H
+#define MCLD_LD_RELOCDATA_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -21,6 +21,8 @@
 #include <llvm/ADT/ilist_node.h>
 #include <llvm/Support/DataTypes.h>
 
+#include <list>
+
 namespace mcld {
 
 class LDSection;
@@ -73,6 +75,7 @@
   bool empty() const { return m_Relocations.empty(); }
 
   RelocData& append(Relocation& pRelocation);
+  Relocation& remove(Relocation& pRelocation);
 
   reference              front ()       { return m_Relocations.front();  }
   const_reference        front () const { return m_Relocations.front();  }
@@ -88,6 +91,18 @@
   const_reverse_iterator rend  () const { return m_Relocations.rend();   }
   reverse_iterator       rend  ()       { return m_Relocations.rend();   }
 
+  template<class Comparator> void sort(Comparator pComparator) {
+    /* FIXME: use llvm::iplist::sort */
+    std::list<Relocation*> relocs;
+    for (iterator it = begin(), ie = end(); it != ie; ++it)
+      relocs.push_back(it);
+    relocs.sort(pComparator);
+    m_Relocations.clear();
+    for (std::list<Relocation*>::iterator it = relocs.begin(),
+      ie = relocs.end(); it != ie; ++it)
+      m_Relocations.push_back(*it);
+  }
+
 private:
   RelocationListType m_Relocations;
   LDSection* m_pSection;
diff --git a/include/mcld/LD/Relocator.h b/include/mcld/LD/Relocator.h
index 54ea7e8..2828a5b 100644
--- a/include/mcld/LD/Relocator.h
+++ b/include/mcld/LD/Relocator.h
@@ -61,10 +61,21 @@
   /// @param pReloc - a read in relocation entry
   /// @param pInputSym - the input LDSymbol of relocation target symbol
   /// @param pSection - the section of relocation applying target
+  /// @param pInput - the input file of relocation
   virtual void scanRelocation(Relocation& pReloc,
                               IRBuilder& pBuilder,
                               Module& pModule,
-                              LDSection& pSection) = 0;
+                              LDSection& pSection,
+                              Input& pInput) = 0;
+
+  /// issueUndefRefError - Provides a basic version for undefined reference dump.
+  /// It will handle the filename and function name automatically.
+  /// @param pReloc - a read in relocation entry
+  /// @param pSection - the section of relocation applying target
+  /// @ param pInput - the input file of relocation
+  virtual void issueUndefRef(Relocation& pReloc,
+                             LDSection& pSection,
+                             Input& pInput);
 
   /// initializeScan - do initialization before scan relocations in pInput
   /// @return - return true for initialization success
diff --git a/include/mcld/LD/ResolveInfo.h b/include/mcld/LD/ResolveInfo.h
index 6f28169..9616719 100644
--- a/include/mcld/LD/ResolveInfo.h
+++ b/include/mcld/LD/ResolveInfo.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_RESOLVE_INFO_H
-#define MCLD_RESOLVE_INFO_H
+#ifndef MCLD_LD_RESOLVEINFO_H
+#define MCLD_LD_RESOLVEINFO_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -18,6 +18,7 @@
 namespace mcld {
 
 class LDSymbol;
+class LinkerConfig;
 
 /** \class ResolveInfo
  *  \brief ResolveInfo records the information about how to resolve a symbol.
@@ -142,6 +143,10 @@
     m_BitField |= indirect_flag;
   }
 
+  /// setInDyn - set if the symbol has been seen in the dynamic objects. Once
+  /// InDyn set, then it won't be set back to false
+  void setInDyn();
+
   // -----  observers  ----- //
   bool isNull() const;
 
@@ -167,6 +172,8 @@
 
   bool isIndirect() const;
 
+  bool isInDyn() const;
+
   uint32_t type() const;
 
   uint32_t desc() const;
@@ -207,6 +214,9 @@
   uint32_t bitfield() const
   { return m_BitField; }
 
+  // shouldForceLocal - check if this symbol should be forced to local
+  bool shouldForceLocal(const LinkerConfig& pConfig);
+
   // -----  For HashTable  ----- //
   bool compare(const key_type& pKey);
 
@@ -236,7 +246,11 @@
 
   static const uint32_t RESERVED_OFFSET    = 12;
   static const uint32_t RESERVED_MASK      = 0xF << RESERVED_OFFSET;
-  static const uint32_t NAME_LENGTH_OFFSET = 16;
+
+  static const uint32_t IN_DYN_OFFSET      = 16;
+  static const uint32_t IN_DYN_MASK        = 1   << IN_DYN_OFFSET;
+
+  static const uint32_t NAME_LENGTH_OFFSET = 17;
   static const uint32_t INFO_MASK          = 0xF;
   static const uint32_t RESOLVE_MASK       = 0xFFFF;
 
@@ -262,6 +276,7 @@
   static const uint32_t file_flag      = File     << TYPE_OFFSET;
   static const uint32_t string_flag    = 0        << SYMBOL_OFFSET;
   static const uint32_t symbol_flag    = 1        << SYMBOL_OFFSET;
+  static const uint32_t indyn_flag     = 1        << IN_DYN_OFFSET;
 
 private:
   ResolveInfo();
@@ -274,8 +289,8 @@
   SymOrInfo m_Ptr;
 
   /** m_BitField
-   *  31     ...    16 15    12 11     10..7 6      ..    5 4     3   2   1   0
-   * |length of m_Name|reserved|Symbol|Type |ELF visibility|Local|Com|Def|Dyn|Weak|
+   *  31     ...    17 16    15    12 11     10..7 6      ..    5 4     3   2   1   0
+   * |length of m_Name|InDyn|reserved|Symbol|Type |ELF visibility|Local|Com|Def|Dyn|Weak|
    */
   uint32_t m_BitField;
   char m_Name[];
diff --git a/include/mcld/LD/Resolver.h b/include/mcld/LD/Resolver.h
index d506a2d..069a167 100644
--- a/include/mcld/LD/Resolver.h
+++ b/include/mcld/LD/Resolver.h
@@ -6,13 +6,14 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SYMBOL_RESOLVER_H
-#define MCLD_SYMBOL_RESOLVER_H
+#ifndef MCLD_LD_RESOLVER_H
+#define MCLD_LD_RESOLVER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 #include <string>
 #include <utility>
+#include <mcld/LD/LDSymbol.h>
 
 namespace mcld
 {
@@ -59,7 +60,7 @@
   /// @param pNew the symbol which is used to replace pOld
   virtual bool resolve(ResolveInfo & __restrict__ pOld,
                        const ResolveInfo & __restrict__ pNew,
-                       bool &pOverride) const = 0;
+                       bool &pOverride, LDSymbol::ValueType pValue) const = 0;
 
   /// resolveAgain - Can override by derived classes.
   /// @return the pointer to resolved ResolveInfo
diff --git a/include/mcld/LD/SectionData.h b/include/mcld/LD/SectionData.h
index 4f58afa..0a74961 100644
--- a/include/mcld/LD/SectionData.h
+++ b/include/mcld/LD/SectionData.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_SECTION_DATA_H
-#define MCLD_LD_SECTION_DATA_H
+#ifndef MCLD_LD_SECTIONDATA_H
+#define MCLD_LD_SECTIONDATA_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/SectionSymbolSet.h b/include/mcld/LD/SectionSymbolSet.h
index 801fe37..fe814a7 100644
--- a/include/mcld/LD/SectionSymbolSet.h
+++ b/include/mcld/LD/SectionSymbolSet.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SECTIONSYMBOLSET_H
-#define MCLD_SECTIONSYMBOLSET_H
+#ifndef MCLD_LD_SECTIONSYMBOLSET_H
+#define MCLD_LD_SECTIONSYMBOLSET_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/StaticResolver.h b/include/mcld/LD/StaticResolver.h
index 9fc6104..586e44d 100644
--- a/include/mcld/LD/StaticResolver.h
+++ b/include/mcld/LD/StaticResolver.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_STATIC_SYMBOL_RESOLVER_H
-#define MCLD_STATIC_SYMBOL_RESOLVER_H
+#ifndef MCLD_LD_STATICRESOLVER_H
+#define MCLD_LD_STATICRESOLVER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -111,7 +111,7 @@
   /// @param pNew the symbol which is used to replace pOld
   virtual bool resolve(ResolveInfo & __restrict__ pOld,
                        const ResolveInfo & __restrict__ pNew,
-                       bool &pOverride) const;
+                       bool &pOverride, LDSymbol::ValueType pValue) const;
 
 private:
   inline unsigned int getOrdinate(const ResolveInfo& pInfo) const {
diff --git a/include/mcld/LD/StubFactory.h b/include/mcld/LD/StubFactory.h
index 8548e5a..4298c16 100644
--- a/include/mcld/LD/StubFactory.h
+++ b/include/mcld/LD/StubFactory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_STUB_FACTORY_H
-#define MCLD_LD_STUB_FACTORY_H
+#ifndef MCLD_LD_STUBFACTORY_H
+#define MCLD_LD_STUBFACTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LD/TextDiagnosticPrinter.h b/include/mcld/LD/TextDiagnosticPrinter.h
index 3e7d4c4..6400fa2 100644
--- a/include/mcld/LD/TextDiagnosticPrinter.h
+++ b/include/mcld/LD/TextDiagnosticPrinter.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TEXT_DIAGNOSTIC_PRINTER_H
-#define MCLD_TEXT_DIAGNOSTIC_PRINTER_H
+#ifndef MCLD_LD_TEXTDIAGNOSTICPRINTER_H
+#define MCLD_LD_TEXTDIAGNOSTICPRINTER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Linker.h b/include/mcld/Linker.h
index 83eb295..80f6586 100644
--- a/include/mcld/Linker.h
+++ b/include/mcld/Linker.h
@@ -27,7 +27,7 @@
 class ObjectLinker;
 
 class FileHandle;
-class MemoryArea;
+class FileOutputBuffer;
 
 /** \class Linker
 *  \brief Linker is a modular linker.
@@ -46,7 +46,7 @@
   bool normalize(Module& pModule, IRBuilder& pBuilder);
 
   /// resolve - To build up the topology of mcld::Module.
-  bool resolve();
+  bool resolve(Module& pModule);
 
   /// layout - To serialize the final result of the output mcld::Module.
   bool layout();
@@ -54,15 +54,15 @@
   /// link - A convenient way to resolve and to layout the output mcld::Module.
   bool link(Module& pModule, IRBuilder& pBuilder);
 
-  /// emit - To emit output mcld::Module to a output MemoryArea
-  bool emit(MemoryArea& pOutput);
+  /// emit - To emit output mcld::Module to a FileOutputBuffer.
+  bool emit(FileOutputBuffer& pOutput);
 
   /// emit - To open a file for output in pPath and to emit output mcld::Module
   /// to the file.
-  bool emit(const std::string& pPath);
+  bool emit(const Module& pModule, const std::string& pPath);
 
   /// emit - To emit output mcld::Module in the pFileDescriptor.
-  bool emit(int pFileDescriptor);
+  bool emit(const Module& pModule, int pFileDescriptor);
 
   bool reset();
 
diff --git a/include/mcld/LinkerConfig.h b/include/mcld/LinkerConfig.h
index 96dd5dc..a41be39 100644
--- a/include/mcld/LinkerConfig.h
+++ b/include/mcld/LinkerConfig.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LINKER_CONFIG_H
-#define MCLD_LINKER_CONFIG_H
+#ifndef MCLD_LINKERCONFIG_H
+#define MCLD_LINKERCONFIG_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/LinkerScript.h b/include/mcld/LinkerScript.h
index 91e4bdb..bdd0917 100644
--- a/include/mcld/LinkerScript.h
+++ b/include/mcld/LinkerScript.h
@@ -6,21 +6,26 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_LINKER_SCRIPT_H
-#define MCLD_LINKER_SCRIPT_H
+#ifndef MCLD_LINKERSCRIPT_H
+#define MCLD_LINKERSCRIPT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 #include <string>
+#include <vector>
 #include <llvm/ADT/StringRef.h>
 #include <mcld/ADT/StringEntry.h>
 #include <mcld/ADT/StringHash.h>
 #include <mcld/ADT/HashTable.h>
 #include <mcld/Object/SectionMap.h>
 #include <mcld/MC/SearchDirs.h>
+#include <mcld/Script/Assignment.h>
+#include <mcld/Script/AssertCmd.h>
 
 namespace mcld {
 
+class LDSymbol;
+
 /** \class LinkerScript
  *
  */
@@ -28,16 +33,16 @@
 {
 public:
   typedef HashTable<StringEntry<llvm::StringRef>,
-                    hash::StringHash<hash::ELF>,
+                    hash::StringHash<hash::DJB>,
                     StringEntryFactory<llvm::StringRef> > SymbolRenameMap;
 
   typedef HashTable<StringEntry<uint64_t>,
-                    hash::StringHash<hash::ELF>,
+                    hash::StringHash<hash::DJB>,
                     StringEntryFactory<uint64_t> > AddressMap;
 
-  typedef HashTable<StringEntry<llvm::StringRef>,
-                    hash::StringHash<hash::ELF>,
-                    StringEntryFactory<llvm::StringRef> > DefSymMap;
+  typedef std::vector<std::pair<LDSymbol*, Assignment> > Assignments;
+
+  typedef std::vector<AssertCmd> Assertions;
 
 public:
   LinkerScript();
@@ -53,8 +58,11 @@
   const SectionMap& sectionMap() const { return m_SectionMap; }
   SectionMap&       sectionMap()       { return m_SectionMap; }
 
-  const DefSymMap& defSymMap() const { return m_DefSymMap; }
-  DefSymMap&       defSymMap()       { return m_DefSymMap; }
+  const Assignments& assignments() const { return m_Assignments; }
+  Assignments&       assignments()       { return m_Assignments; }
+
+  const Assertions& assertions() const { return m_Assertions; }
+  Assertions&       assertions()       { return m_Assertions; }
 
   /// search directory
   const SearchDirs& directories() const { return m_SearchDirs; }
@@ -67,12 +75,29 @@
 
   bool hasSysroot() const;
 
+  /// entry point
+  const std::string& entry() const;
+
+  void setEntry(const std::string& pEntry);
+
+  bool hasEntry() const;
+
+  /// output filename
+  const std::string& outputFile() const;
+
+  void setOutputFile(const std::string& pOutputFile);
+
+  bool hasOutputFile() const;
+
 private:
   SymbolRenameMap m_SymbolRenames;
   AddressMap m_AddressMap;
   SectionMap m_SectionMap;
-  DefSymMap m_DefSymMap;
+  Assignments m_Assignments;
+  Assertions m_Assertions;
   SearchDirs m_SearchDirs;
+  std::string m_Entry;
+  std::string m_OutputFile;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/MC/Attribute.h b/include/mcld/MC/Attribute.h
index 11f6d26..a7c7176 100644
--- a/include/mcld/MC/Attribute.h
+++ b/include/mcld/MC/Attribute.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ATTRIBUTE_H
-#define MCLD_ATTRIBUTE_H
+#ifndef MCLD_MC_ATTRIBUTE_H
+#define MCLD_MC_ATTRIBUTE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/MC/AttributeSet.h b/include/mcld/MC/AttributeSet.h
index e50384d..97b20a9 100644
--- a/include/mcld/MC/AttributeSet.h
+++ b/include/mcld/MC/AttributeSet.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ATTRIBUTE_SET_H
-#define MCLD_ATTRIBUTE_SET_H
+#ifndef MCLD_MC_ATTRIBUTESET_H
+#define MCLD_MC_ATTRIBUTESET_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/MC/CommandAction.h b/include/mcld/MC/CommandAction.h
index a0ff909..19f74fd 100644
--- a/include/mcld/MC/CommandAction.h
+++ b/include/mcld/MC/CommandAction.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_MC_COMMAND_ACTION_H
-#define MCLD_MC_COMMAND_ACTION_H
+#ifndef MCLD_MC_COMMANDACTION_H
+#define MCLD_MC_COMMANDACTION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -15,11 +15,13 @@
 #include <string>
 #include <mcld/Support/Path.h>
 #include <mcld/MC/InputAction.h>
+#include <mcld/Script/ScriptFile.h>
 
 namespace mcld {
 
 class SearchDirs;
 class InputBuilder;
+class LinkerConfig;
 
 //===----------------------------------------------------------------------===//
 // Derived InputAction
@@ -44,7 +46,7 @@
 public:
   NamespecAction(unsigned int pPosition,
                  const std::string &pNamespec,
-                 SearchDirs& pSearchDirs);
+                 const SearchDirs& pSearchDirs);
 
   const std::string &namespec() const { return m_Namespec; }
 
@@ -52,7 +54,7 @@
 
 private:
   std::string m_Namespec;
-  SearchDirs& m_SearchDirs;
+  const SearchDirs& m_SearchDirs;
 };
 
 /// BitcodeAction
@@ -159,6 +161,41 @@
   bool activate(InputBuilder&) const;
 };
 
+/// DefSymAction
+class DefSymAction : public InputAction
+{
+public:
+  explicit DefSymAction(unsigned int pPosition, std::string& pAssignment);
+
+  bool activate(InputBuilder&) const;
+
+  const std::string& assignment() const { return m_Assignment; }
+
+private:
+  std::string& m_Assignment;
+};
+
+/// ScriptAction
+class ScriptAction : public InputAction
+{
+public:
+  ScriptAction(unsigned int pPosition,
+               const std::string& pFileName,
+               ScriptFile::Kind pKind,
+               const SearchDirs& pSearchDirs);
+
+  bool activate(InputBuilder&) const;
+
+  const std::string& filename() const { return m_FileName; }
+
+  ScriptFile::Kind kind() const { return m_Kind; }
+
+private:
+  std::string m_FileName;
+  ScriptFile::Kind m_Kind;
+  const SearchDirs& m_SearchDirs;
+};
+
 } // end of namespace mcld
 
 #endif
diff --git a/include/mcld/MC/ContextFactory.h b/include/mcld/MC/ContextFactory.h
index dde2627..169dbfa 100644
--- a/include/mcld/MC/ContextFactory.h
+++ b/include/mcld/MC/ContextFactory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_CONTEXT_FACTORY_H
-#define MCLD_CONTEXT_FACTORY_H
+#ifndef MCLD_MC_CONTEXTFACTORY_H
+#define MCLD_MC_CONTEXTFACTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/MC/FileAction.h b/include/mcld/MC/FileAction.h
index 4644405..269c700 100644
--- a/include/mcld/MC/FileAction.h
+++ b/include/mcld/MC/FileAction.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_MC_FILE_ACTION_H
-#define MCLD_MC_FILE_ACTION_H
+#ifndef MCLD_MC_FILEACTION_H
+#define MCLD_MC_FILEACTION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -17,7 +17,6 @@
 namespace mcld {
 
 class ContextFactory;
-class MemoryAreaFactory;
 
 /** \class ContextAction
  *  \brief ContextAction is a command object to create input's LDContext.
diff --git a/include/mcld/MC/MCLDInput.h b/include/mcld/MC/Input.h
similarity index 95%
rename from include/mcld/MC/MCLDInput.h
rename to include/mcld/MC/Input.h
index 94b9479..a8e9c35 100644
--- a/include/mcld/MC/MCLDInput.h
+++ b/include/mcld/MC/Input.h
@@ -1,4 +1,4 @@
-//===- MCLDInput.h --------------------------------------------------------===//
+//===- Input.h ------------------------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -10,8 +10,8 @@
 //  Input class inherits MCLDFile, which is used to represent a input file
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_INPUT_H
-#define MCLD_INPUT_H
+#ifndef MCLD_MC_INPUT_H
+#define MCLD_MC_INPUT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -35,6 +35,7 @@
 public:
   enum Type {
     Unknown,
+    Binary,
     Object,
     Exec,
     DynObj,
diff --git a/include/mcld/MC/InputAction.h b/include/mcld/MC/InputAction.h
index fb7d660..4b94378 100644
--- a/include/mcld/MC/InputAction.h
+++ b/include/mcld/MC/InputAction.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_MC_INPUT_ACTION_H
-#define MCLD_MC_INPUT_ACTION_H
+#ifndef MCLD_MC_INPUTACTION_H
+#define MCLD_MC_INPUTACTION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/MC/InputBuilder.h b/include/mcld/MC/InputBuilder.h
index 0301c15..1b2e8b9 100644
--- a/include/mcld/MC/InputBuilder.h
+++ b/include/mcld/MC/InputBuilder.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_MC_INPUT_BUILDER_H
-#define MCLD_MC_INPUT_BUILDER_H
+#ifndef MCLD_MC_INPUTBUILDER_H
+#define MCLD_MC_INPUTBUILDER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -16,7 +16,7 @@
 #include <stack>
 
 #include <mcld/InputTree.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/Support/FileHandle.h>
 
 namespace mcld {
@@ -26,7 +26,6 @@
 class ContextFactory;
 class MemoryAreaFactory;
 class AttrConstraint;
-class raw_mem_ostream;
 
 /** \class InputBuilder
  *  \brief InputBuilder recieves InputActions and build the InputTree.
diff --git a/include/mcld/MC/InputFactory.h b/include/mcld/MC/InputFactory.h
index d644222..8c73d0b 100644
--- a/include/mcld/MC/InputFactory.h
+++ b/include/mcld/MC/InputFactory.h
@@ -6,13 +6,13 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_INPUT_FACTORY_H
-#define MCLD_INPUT_FACTORY_H
+#ifndef MCLD_MC_INPUTFACTORY_H
+#define MCLD_MC_INPUTFACTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 #include <mcld/Support/GCFactory.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 
 namespace mcld {
 
diff --git a/include/mcld/MC/MCLDDirectory.h b/include/mcld/MC/MCLDDirectory.h
index 988f9d3..77692c0 100644
--- a/include/mcld/MC/MCLDDirectory.h
+++ b/include/mcld/MC/MCLDDirectory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_MCLDDIRECTORY_H
-#define MCLD_MCLDDIRECTORY_H
+#ifndef MCLD_MC_MCLDDIRECTORY_H
+#define MCLD_MC_MCLDDIRECTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/MC/SearchDirs.h b/include/mcld/MC/SearchDirs.h
index 0c0c657..a3bcf39 100644
--- a/include/mcld/MC/SearchDirs.h
+++ b/include/mcld/MC/SearchDirs.h
@@ -12,7 +12,7 @@
 #include <gtest.h>
 #endif
 #include <mcld/ADT/Uncopyable.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/Support/Path.h>
 
 #include <llvm/ADT/StringRef.h>
diff --git a/include/mcld/MC/SymbolCategory.h b/include/mcld/MC/SymbolCategory.h
index 61c015e..9ecc5b9 100644
--- a/include/mcld/MC/SymbolCategory.h
+++ b/include/mcld/MC/SymbolCategory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SYMBOL_CATEGORY_H
-#define MCLD_SYMBOL_CATEGORY_H
+#ifndef MCLD_MC_SYMBOLCATEGORY_H
+#define MCLD_MC_SYMBOLCATEGORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/MC/ZOption.h b/include/mcld/MC/ZOption.h
index e451734..d9cd635 100644
--- a/include/mcld/MC/ZOption.h
+++ b/include/mcld/MC/ZOption.h
@@ -6,15 +6,15 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ZOPTION_H
-#define MCLD_ZOPTION_H
+#ifndef MCLD_MC_ZOPTION_H
+#define MCLD_MC_ZOPTION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
+
 #include <llvm/Support/DataTypes.h>
 
-namespace mcld
-{
+namespace mcld {
 
 /** \class ZOption
  *  \brief The -z options for GNU ld compatibility.
@@ -50,19 +50,13 @@
 public:
   ZOption();
 
-  ~ZOption();
+  Kind kind() const { return m_Kind; }
 
-  Kind kind() const
-  { return m_Kind; }
+  void setKind(Kind pKind) { m_Kind = pKind; }
 
-  uint64_t pageSize() const
-  { return m_PageSize; }
+  uint64_t pageSize() const { return m_PageSize; }
 
-  void setKind(Kind pKind)
-  { m_Kind = pKind; }
-
-  void setPageSize(uint64_t pPageSize)
-  { m_PageSize = pPageSize; }
+  void setPageSize(uint64_t pPageSize) { m_PageSize = pPageSize; }
 
 private:
   Kind m_Kind;
diff --git a/include/mcld/Module.h b/include/mcld/Module.h
index 9ea9812..9dfb59e 100644
--- a/include/mcld/Module.h
+++ b/include/mcld/Module.h
@@ -16,25 +16,18 @@
 #include <gtest.h>
 #endif
 
-#include <vector>
-#include <string>
-#include <map>
-
-#include <mcld/LinkerScript.h>
 #include <mcld/InputTree.h>
-#include <mcld/ADT/HashTable.h>
-#include <mcld/ADT/HashEntry.h>
-#include <mcld/Support/GCFactoryListTraits.h>
-#include <mcld/Fragment/Fragment.h>
 #include <mcld/LD/NamePool.h>
 #include <mcld/LD/SectionSymbolSet.h>
 #include <mcld/MC/SymbolCategory.h>
-#include <mcld/MC/MCLDInput.h>
 
-#include <llvm/ADT/ilist.h>
+#include <vector>
+#include <string>
 
 namespace mcld {
 
+class Input;
+class LinkerScript;
 class LDSection;
 class LDSymbol;
 
diff --git a/include/mcld/Object/ObjectBuilder.h b/include/mcld/Object/ObjectBuilder.h
index 79f81a5..ec80528 100644
--- a/include/mcld/Object/ObjectBuilder.h
+++ b/include/mcld/Object/ObjectBuilder.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_OBJECT_OBJECT_BUILDER_H
-#define MCLD_OBJECT_OBJECT_BUILDER_H
+#ifndef MCLD_OBJECT_OBJECTBUILDER_H
+#define MCLD_OBJECT_OBJECTBUILDER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -27,6 +27,7 @@
 class RelocData;
 class Fragment;
 class Relocation;
+class Input;
 
 /** \class ObjectBuilder
  *  \brief ObjectBuilder recieve ObjectAction and build the mcld::Module.
@@ -67,7 +68,7 @@
   /// @param [in] pInputSection The merged input section.
   /// @return The merged output section. If the corresponding output sections
   /// is not defined, return NULL.
-  LDSection* MergeSection(LDSection& pInputSection);
+  LDSection* MergeSection(const Input& pInputFile, LDSection& pInputSection);
 
   /// MoveSectionData - move the fragment of pFrom to pTo section data.
   static bool MoveSectionData(SectionData& pFrom, SectionData& pTo);
diff --git a/include/mcld/Object/ObjectLinker.h b/include/mcld/Object/ObjectLinker.h
index 128cf64..5c8c5cc 100644
--- a/include/mcld/Object/ObjectLinker.h
+++ b/include/mcld/Object/ObjectLinker.h
@@ -6,39 +6,34 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-//
-// ObjectLinker plays the same role as GNU collect2 to prepare all implicit
-// parameters for FragmentLinker.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_OBJECT_OBJECT_LINKER_H
-#define MCLD_OBJECT_OBJECT_LINKER_H
+#ifndef MCLD_OBJECT_OBJECTLINKER_H
+#define MCLD_OBJECT_OBJECTLINKER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
-#include <stddef.h>
+#include <llvm/Support/DataTypes.h>
 
 namespace mcld {
 
 class Module;
 class LinkerConfig;
 class IRBuilder;
-class FragmentLinker;
 class TargetLDBackend;
-class MemoryArea;
-class MemoryAreaFactory;
+class FileOutputBuffer;
 class ObjectReader;
 class DynObjReader;
 class ArchiveReader;
 class GroupReader;
 class BinaryReader;
+class ScriptReader;
 class ObjectWriter;
 class DynObjWriter;
 class ExecWriter;
 class BinaryWriter;
+class Relocation;
+class ResolveInfo;
 
 /** \class ObjectLinker
- *  \brief ObjectLinker prepares parameters for FragmentLinker.
  */
 class ObjectLinker
 {
@@ -48,11 +43,7 @@
 
   ~ObjectLinker();
 
-  void setup(Module& pModule, IRBuilder& pBuilder);
-
-  /// initFragmentLinker - initialize FragmentLinker
-  ///  Connect all components in FragmentLinker
-  bool initFragmentLinker();
+  bool initialize(Module& pModule, IRBuilder& pBuilder);
 
   /// initStdSections - initialize standard sections of the output file.
   bool initStdSections();
@@ -69,9 +60,16 @@
   /// readRelocations - read all relocation entries
   bool readRelocations();
 
+  /// dataStrippingOpt - optimizations for reducing code size
+  void dataStrippingOpt();
+
   /// mergeSections - put allinput sections into output sections
   bool mergeSections();
 
+  /// addSymbolsToOutput - after all symbols has been resolved, add the symbol
+  /// to output
+  void addSymbolsToOutput(Module& pModule);
+
   /// allocateCommonSymobols - allocate fragments for common symbols to the
   /// corresponding sections
   bool allocateCommonSymbols();
@@ -122,18 +120,10 @@
   bool finalizeSymbolValue();
 
   /// emitOutput - emit the output file.
-  bool emitOutput(MemoryArea& pOutput);
+  bool emitOutput(FileOutputBuffer& pOutput);
 
   /// postProcessing - do modificatiion after all processes
-  bool postProcessing(MemoryArea& pOutput);
-
-  /// getLinker - get internal FragmentLinker object
-  const FragmentLinker* getLinker() const { return m_pLinker; }
-  FragmentLinker*       getLinker()       { return m_pLinker; }
-
-  /// hasInitLinker - has Linker been initialized?
-  bool hasInitLinker() const
-  { return (NULL != m_pLinker); }
+  bool postProcessing(FileOutputBuffer& pOutput);
 
   // -----  readers and writers  ----- //
   const ObjectReader*  getObjectReader () const { return m_pObjectReader;  }
@@ -151,12 +141,31 @@
   const BinaryReader*  getBinaryReader () const { return m_pBinaryReader;  }
   BinaryReader*        getBinaryReader ()       { return m_pBinaryReader;  }
 
+  const ScriptReader*  getScriptReader () const { return m_pScriptReader;  }
+  ScriptReader*        getScriptReader ()       { return m_pScriptReader;  }
+
   const ObjectWriter*  getWriter () const { return m_pWriter;  }
   ObjectWriter*        getWriter ()       { return m_pWriter;  }
 
 private:
+  /// normalSyncRelocationResult - sync relocation result when producing shared
+  /// objects or executables
+  void normalSyncRelocationResult(FileOutputBuffer& pOutput);
+
+  /// partialSyncRelocationResult - sync relocation result when doing partial
+  /// link
+  void partialSyncRelocationResult(FileOutputBuffer& pOutput);
+
+  /// writeRelocationResult - helper function of syncRelocationResult, write
+  /// relocation target data to output
+  void writeRelocationResult(Relocation& pReloc, uint8_t* pOutput);
+
+  /// addSymbolToOutput - add a symbol to output symbol table if it's not a
+  /// section symbol and not defined in the discarded section
+  void addSymbolToOutput(ResolveInfo& pInfo, Module& pModule);
+
+private:
   const LinkerConfig& m_Config;
-  FragmentLinker* m_pLinker;
   Module* m_pModule;
   IRBuilder* m_pBuilder;
 
@@ -168,6 +177,7 @@
   ArchiveReader* m_pArchiveReader;
   GroupReader*   m_pGroupReader;
   BinaryReader*  m_pBinaryReader;
+  ScriptReader*  m_pScriptReader;
   ObjectWriter*  m_pWriter;
 };
 
diff --git a/include/mcld/Object/SectionMap.h b/include/mcld/Object/SectionMap.h
index 37df4a3..e6e779d 100644
--- a/include/mcld/Object/SectionMap.h
+++ b/include/mcld/Object/SectionMap.h
@@ -6,82 +6,206 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SECTION_MAP_H
-#define MCLD_SECTION_MAP_H
+#ifndef MCLD_OBJECT_SECTIONMAP_H
+#define MCLD_OBJECT_SECTIONMAP_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 
+#include <mcld/Script/OutputSectDesc.h>
+#include <mcld/Script/InputSectDesc.h>
+#include <mcld/Script/Assignment.h>
+#include <llvm/Support/DataTypes.h>
 #include <vector>
 #include <string>
 
-#include <llvm/Support/DataTypes.h>
-
 namespace mcld {
 
+class Fragment;
+class LDSection;
+
 /** \class SectionMap
- *  \brief descirbe the mappings of input section's name (or prefix) to
- *         its associated output section's name and offset
+ *  \brief descirbe how to map input sections into output sections
  */
 class SectionMap
 {
 public:
-  // a mapping in SectionMap is the triple of
-  // {input substr, output section's name, output section's offset}
-  struct NamePair
-  {
+  class Input {
   public:
-    NamePair();
-    NamePair(const std::string& pFrom, const std::string& pTo);
+    typedef std::vector<std::pair<Fragment*, Assignment> > DotAssignments;
+    typedef DotAssignments::const_iterator const_dot_iterator;
+    typedef DotAssignments::iterator dot_iterator;
 
-    bool isNull() const;
+    Input(const std::string& pName, InputSectDesc::KeepPolicy pPolicy);
+    Input(const InputSectDesc& pInputDesc);
 
-  public:
-    unsigned int hash;
-    std::string from;
-    std::string to;
+    InputSectDesc::KeepPolicy policy() const { return m_Policy; }
+
+    const InputSectDesc::Spec& spec() const { return m_Spec; }
+
+    const LDSection* getSection() const { return m_pSection; }
+    LDSection*       getSection()       { return m_pSection; }
+
+    const_dot_iterator dot_begin() const { return m_DotAssignments.begin(); }
+    dot_iterator       dot_begin()       { return m_DotAssignments.begin(); }
+    const_dot_iterator dot_end  () const { return m_DotAssignments.end(); }
+    dot_iterator       dot_end  ()       { return m_DotAssignments.end(); }
+
+    const DotAssignments& dotAssignments() const { return m_DotAssignments; }
+    DotAssignments&       dotAssignments()       { return m_DotAssignments; }
+
+  private:
+    InputSectDesc::KeepPolicy m_Policy;
+    InputSectDesc::Spec m_Spec;
+    LDSection* m_pSection;
+    DotAssignments m_DotAssignments;
   };
 
-  typedef std::vector<NamePair> NamePairList;
-  typedef NamePairList::iterator iterator;
-  typedef NamePairList::const_iterator const_iterator;
+  class Output {
+  public:
+    typedef std::vector<Input*> InputList;
+    typedef InputList::const_iterator const_iterator;
+    typedef InputList::iterator iterator;
+    typedef InputList::const_reference const_reference;
+    typedef InputList::reference reference;
 
-  /// NullName - the null object of NamePair
-  static NamePair NullName;
+    typedef std::vector<Assignment> DotAssignments;
+    typedef DotAssignments::const_iterator const_dot_iterator;
+    typedef DotAssignments::iterator dot_iterator;
+
+    Output(const std::string& pName);
+    Output(const OutputSectDesc& pOutputDesc);
+
+    const std::string& name() const { return m_Name; }
+
+    const OutputSectDesc::Prolog& prolog() const { return m_Prolog; }
+    OutputSectDesc::Prolog&       prolog()       { return m_Prolog; }
+
+    const OutputSectDesc::Epilog& epilog() const { return m_Epilog; }
+    OutputSectDesc::Epilog&       epilog()       { return m_Epilog; }
+
+    size_t order() const { return m_Order; }
+
+    void setOrder(size_t pOrder) { m_Order = pOrder; }
+
+    bool hasContent() const;
+
+    const LDSection* getSection() const { return m_pSection; }
+    LDSection*       getSection()       { return m_pSection; }
+
+    void setSection(LDSection* pSection) { m_pSection = pSection; }
+
+    const_iterator begin() const { return m_InputList.begin(); }
+    iterator       begin()       { return m_InputList.begin(); }
+    const_iterator end  () const { return m_InputList.end(); }
+    iterator       end  ()       { return m_InputList.end(); }
+
+    const_reference front() const { return m_InputList.front(); }
+    reference       front()       { return m_InputList.front(); }
+    const_reference back () const { return m_InputList.back(); }
+    reference       back ()       { return m_InputList.back(); }
+
+    size_t size() const { return m_InputList.size(); }
+
+    bool empty() const { return m_InputList.empty(); }
+
+    bool isDiscard() const { return m_bIsDiscard; }
+
+    void append(Input* pInput) { m_InputList.push_back(pInput); }
+
+    const_dot_iterator dot_begin() const { return m_DotAssignments.begin(); }
+    dot_iterator       dot_begin()       { return m_DotAssignments.begin(); }
+    const_dot_iterator dot_end  () const { return m_DotAssignments.end(); }
+    dot_iterator       dot_end  ()       { return m_DotAssignments.end(); }
+
+    const_dot_iterator find_first_explicit_dot() const;
+    dot_iterator       find_first_explicit_dot();
+
+    const_dot_iterator find_last_explicit_dot() const;
+    dot_iterator       find_last_explicit_dot();
+
+    const DotAssignments& dotAssignments() const { return m_DotAssignments; }
+    DotAssignments&       dotAssignments()       { return m_DotAssignments; }
+
+  private:
+    std::string m_Name;
+    OutputSectDesc::Prolog m_Prolog;
+    OutputSectDesc::Epilog m_Epilog;
+    LDSection* m_pSection;
+    size_t m_Order;
+    bool m_bIsDiscard;
+    InputList m_InputList;
+    DotAssignments m_DotAssignments;
+  };
+
+  struct SHOCompare
+  {
+    bool operator()(const Output* LHS, const Output* RHS) const
+    { return LHS->order() < RHS->order(); }
+  };
+
+  typedef std::pair<const Output*, const Input*> const_mapping;
+  typedef std::pair<Output*, Input*> mapping;
+
+  typedef std::vector<Output*> OutputDescList;
+  typedef OutputDescList::const_iterator const_iterator;
+  typedef OutputDescList::iterator iterator;
+  typedef OutputDescList::const_reference const_reference;
+  typedef OutputDescList::reference reference;
+
+  typedef OutputDescList::const_reverse_iterator const_reverse_iterator;
+  typedef OutputDescList::reverse_iterator reverse_iterator;
 
 public:
-  // get the possible output section name based on the mapping table
-  // return NullPair if not found
-  const NamePair& find(const std::string& pFrom) const;
-  NamePair&       find(const std::string& pFrom);
+  ~SectionMap();
 
-  const NamePair& find(const std::string& pFrom, unsigned int pHash) const;
-  NamePair&       find(const std::string& pFrom, unsigned int pHash);
+  const_mapping find(const std::string& pInputFile,
+                     const std::string& pInputSection) const;
+  mapping       find(const std::string& pInputFile,
+                     const std::string& pInputSection);
 
-  // add a mapping from input sub-string to output name.
-  // @param [in]  pFrom  the given input sub-string
-  // @param [in]  pTo    the mapped output string
-  // @param [out] pExist does pFrom exist?
-  NamePair& append(const std::string& pFrom,
-                   const std::string& pTo,
-                   bool& pExist);
+  const_iterator find(const std::string& pOutputSection) const;
+  iterator       find(const std::string& pOutputSection);
 
-  const_iterator begin() const { return m_NamePairList.begin(); }
-  iterator       begin()       { return m_NamePairList.begin(); }
-  const_iterator end  () const { return m_NamePairList.end(); }
-  iterator       end  ()       { return m_NamePairList.end(); }
+  std::pair<mapping, bool>
+  insert(const std::string& pInputSection,
+         const std::string& pOutputSection,
+         InputSectDesc::KeepPolicy pPolicy = InputSectDesc::NoKeep);
+  std::pair<mapping, bool>
+  insert(const InputSectDesc& pInputDesc, const OutputSectDesc& pOutputDesc);
 
-  bool           empty() const { return m_NamePairList.empty(); }
-  size_t         size () const { return m_NamePairList.size(); }
+  bool   empty() const { return m_OutputDescList.empty(); }
+  size_t size () const { return m_OutputDescList.size(); }
 
-  static unsigned int hash(const std::string& pString);
+  const_iterator begin() const { return m_OutputDescList.begin(); }
+  iterator       begin()       { return m_OutputDescList.begin(); }
+  const_iterator end  () const { return m_OutputDescList.end(); }
+  iterator       end  ()       { return m_OutputDescList.end(); }
+
+  const_reference front() const { return m_OutputDescList.front(); }
+  reference       front()       { return m_OutputDescList.front(); }
+  const_reference back () const { return m_OutputDescList.back(); }
+  reference       back ()       { return m_OutputDescList.back(); }
+
+  const_reverse_iterator rbegin() const { return m_OutputDescList.rbegin(); }
+  reverse_iterator       rbegin()       { return m_OutputDescList.rbegin(); }
+  const_reverse_iterator rend  () const { return m_OutputDescList.rend(); }
+  reverse_iterator       rend  ()       { return m_OutputDescList.rend(); }
+
+  iterator insert(iterator pPosition, LDSection* pSection);
+
+  // fixupDotSymbols - ensure the dot assignments are valid
+  void fixupDotSymbols();
 
 private:
-  bool matched(const NamePair& pNamePair,
-               const std::string& pInput,
-               unsigned int pHash) const;
+  bool matched(const Input& pInput,
+               const std::string& pInputFile,
+               const std::string& pInputSection) const;
+
+  bool matched(const WildcardPattern& pPattern, const std::string& pName) const;
+
 private:
-  NamePairList m_NamePairList;
+  OutputDescList m_OutputDescList;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/Script/AssertCmd.h b/include/mcld/Script/AssertCmd.h
new file mode 100644
index 0000000..1e57375
--- /dev/null
+++ b/include/mcld/Script/AssertCmd.h
@@ -0,0 +1,58 @@
+//===- AssertCmd.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_ASSERTCMD_H
+#define MCLD_SCRIPT_ASSERTCMD_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <string>
+
+namespace mcld
+{
+
+class RpnExpr;
+class Module;
+
+/** \class AssertCmd
+ *  \brief This class defines the interfaces to assert command.
+ */
+
+class AssertCmd : public ScriptCommand
+{
+public:
+  AssertCmd(RpnExpr& pRpnExpr, const std::string& pMessage);
+
+  ~AssertCmd();
+
+  AssertCmd& operator=(const AssertCmd& pAssertCmd);
+
+  const RpnExpr& getRpnExpr() const { return m_RpnExpr; }
+  RpnExpr&       getRpnExpr()       { return m_RpnExpr; }
+
+  const std::string& message() const { return m_Message; }
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::ASSERT;
+  }
+
+  void activate(Module& pModule);
+
+private:
+  RpnExpr& m_RpnExpr;
+  std::string m_Message;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Script/Assignment.h b/include/mcld/Script/Assignment.h
new file mode 100644
index 0000000..068735d
--- /dev/null
+++ b/include/mcld/Script/Assignment.h
@@ -0,0 +1,87 @@
+//===- Assignment.h -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_ASSIGNMENT_H
+#define MCLD_SCRIPT_ASSIGNMENT_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+
+namespace mcld
+{
+
+class Module;
+class RpnExpr;
+class SymOperand;
+class RpnEvaluator;
+
+/** \class Assignment
+ *  \brief This class defines the interfaces to assignment command.
+ */
+
+class Assignment : public ScriptCommand
+{
+public:
+  enum Level {
+    OUTSIDE_SECTIONS, // outside SECTIONS command
+    OUTPUT_SECTION,   // related to an output section
+    INPUT_SECTION     // related to an input section
+  };
+
+  enum Type {
+    DEFAULT,
+    HIDDEN,
+    PROVIDE,
+    PROVIDE_HIDDEN
+  };
+
+public:
+  Assignment(Level pLevel,
+             Type pType,
+             SymOperand& pSymbol,
+             RpnExpr& pRpnExpr);
+
+  ~Assignment();
+
+  Assignment& operator=(const Assignment& pAssignment);
+
+  Level level() const { return m_Level; }
+
+  Type type() const { return m_Type; }
+
+  const SymOperand& symbol() const { return m_Symbol; }
+  SymOperand&       symbol()       { return m_Symbol; }
+
+  const RpnExpr& getRpnExpr() const { return m_RpnExpr; }
+  RpnExpr&       getRpnExpr()       { return m_RpnExpr; }
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::ASSIGNMENT;
+  }
+
+  void activate(Module& pModule);
+
+  /// assign - evaluate the rhs and assign the result to lhs.
+  bool assign(RpnEvaluator& pEvaluator);
+
+private:
+  Level m_Level;
+  Type m_Type;
+  SymOperand& m_Symbol;
+  RpnExpr& m_RpnExpr;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/BinaryOp.h b/include/mcld/Script/BinaryOp.h
new file mode 100644
index 0000000..884c0c1
--- /dev/null
+++ b/include/mcld/Script/BinaryOp.h
@@ -0,0 +1,135 @@
+//===- BinaryOp.h ---------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_BINARYOP_H
+#define MCLD_SCRIPT_BINARYOP_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/Operator.h>
+#include <cstddef>
+
+namespace mcld
+{
+
+class Operand;
+class IntOperand;
+class Module;
+class TargetLDBackend;
+
+/** \class BinaryOP
+ *  \brief This class defines the interfaces to an binary operator token.
+ */
+
+template<Operator::Type TYPE>
+class BinaryOp : public Operator
+{
+private:
+  friend class Operator;
+
+  BinaryOp()
+    : Operator(Operator::BINARY, TYPE), m_Size(0)
+  {
+    m_pOperand[0] = m_pOperand[1] = NULL;
+  }
+
+public:
+  ~BinaryOp()
+  {}
+
+  IntOperand* eval(const Module& pModule, const TargetLDBackend& pBackend);
+
+  void appendOperand(Operand* pOperand)
+  {
+    m_pOperand[m_Size++] = pOperand;
+    if (m_Size == 2)
+      m_Size = 0;
+  }
+
+private:
+  size_t m_Size;
+  Operand* m_pOperand[2];
+};
+
+template<>
+IntOperand* BinaryOp<Operator::MUL>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::DIV>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::MOD>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::ADD>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::SUB>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::LSHIFT>::eval(const Module&,
+                                             const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::RSHIFT>::eval(const Module&,
+                                             const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::LT>::eval(const Module&,
+                                         const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::LE>::eval(const Module&,
+                                         const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::GT>::eval(const Module&,
+                                         const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::GE>::eval(const Module&,
+                                         const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::EQ>::eval(const Module&,
+                                         const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::NE>::eval(const Module&,
+                                         const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::BITWISE_AND>::eval(const Module&,
+                                                  const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::BITWISE_XOR>::eval(const Module&,
+                                                  const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::BITWISE_OR>::eval(const Module&,
+                                                 const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::LOGICAL_AND>::eval(const Module&,
+                                                  const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::LOGICAL_OR>::eval(const Module&,
+                                                 const TargetLDBackend&);
+
+template<>
+IntOperand* BinaryOp<Operator::ALIGN>::eval(const Module&,
+                                            const TargetLDBackend&);
+template<>
+IntOperand*
+BinaryOp<Operator::DATA_SEGMENT_RELRO_END>::eval(const Module&,
+                                                 const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::MAX>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::MIN>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* BinaryOp<Operator::SEGMENT_START>::eval(const Module&,
+                                                    const TargetLDBackend&);
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/EntryCmd.h b/include/mcld/Script/EntryCmd.h
new file mode 100644
index 0000000..acbdd10
--- /dev/null
+++ b/include/mcld/Script/EntryCmd.h
@@ -0,0 +1,49 @@
+//===- EntryCmd.h ---------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_ENTRYCMD_H
+#define MCLD_SCRIPT_ENTRYCMD_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <string>
+
+namespace mcld
+{
+
+class Module;
+
+/** \class EntryCmd
+ *  \brief This class defines the interfaces to Entry command.
+ */
+
+class EntryCmd : public ScriptCommand
+{
+public:
+  EntryCmd(const std::string& pEntry);
+  ~EntryCmd();
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::ENTRY;
+  }
+
+  void activate(Module& pModule);
+
+private:
+  std::string m_Entry;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/ExprToken.h b/include/mcld/Script/ExprToken.h
new file mode 100644
index 0000000..be248d5
--- /dev/null
+++ b/include/mcld/Script/ExprToken.h
@@ -0,0 +1,50 @@
+//===- ExprToken.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_EXPRTOKEN_H
+#define MCLD_SCRIPT_EXPRTOKEN_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+namespace mcld
+{
+
+/** \class ExprToken
+ *  \brief This class defines the interfaces to an expression token.
+ */
+
+class ExprToken
+{
+public:
+  enum Kind {
+    OPERATOR,
+    OPERAND
+  };
+
+protected:
+  ExprToken(Kind pKind)
+    : m_Kind(pKind)
+  {}
+
+public:
+  virtual ~ExprToken()
+  {}
+
+  virtual void dump() const = 0;
+
+  Kind kind() const { return m_Kind; }
+
+private:
+  Kind m_Kind;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/FileToken.h b/include/mcld/Script/FileToken.h
new file mode 100644
index 0000000..92faab4
--- /dev/null
+++ b/include/mcld/Script/FileToken.h
@@ -0,0 +1,50 @@
+//===- FileToken.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_FILETOKEN_H
+#define MCLD_SCRIPT_FILETOKEN_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/InputToken.h>
+#include <mcld/Support/Allocators.h>
+#include <mcld/Config/Config.h>
+
+namespace mcld
+{
+
+/** \class FileToken
+ *  \brief This class defines the interfaces to a filename in INPUT/GROUP
+ *         command.
+ */
+
+class FileToken : public InputToken
+{
+private:
+  friend class Chunk<FileToken, MCLD_SYMBOLS_PER_INPUT>;
+  FileToken();
+  FileToken(const std::string& pName, bool pAsNeeded);
+
+public:
+  ~FileToken();
+
+  static bool classof(const InputToken* pToken)
+  {
+    return pToken->type() == InputToken::File;
+  }
+
+  /* factory method */
+  static FileToken* create(const std::string& pName, bool pAsNeeded);
+  static void destroy(FileToken*& pToken);
+  static void clear();
+};
+
+} // namepsace of mcld
+
+#endif
diff --git a/include/mcld/Script/FlexLexer.h b/include/mcld/Script/FlexLexer.h
new file mode 100644
index 0000000..f09ab20
--- /dev/null
+++ b/include/mcld/Script/FlexLexer.h
@@ -0,0 +1,215 @@
+//===- FlexLexer.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// -*-C++-*-
+// FlexLexer.h -- define interfaces for lexical analyzer classes generated
+// by flex
+
+// Copyright (c) 1993 The Regents of the University of California.
+// All rights reserved.
+//
+// This code is derived from software contributed to Berkeley by
+// Kent Williams and Tom Epperly.
+//
+//  Redistribution and use in source and binary forms, with or without
+//  modification, are permitted provided that the following conditions
+//  are met:
+
+//  1. Redistributions of source code must retain the above copyright
+//  notice, this list of conditions and the following disclaimer.
+//  2. Redistributions in binary form must reproduce the above copyright
+//  notice, this list of conditions and the following disclaimer in the
+//  documentation and/or other materials provided with the distribution.
+
+//  Neither the name of the University nor the names of its contributors
+//  may be used to endorse or promote products derived from this software
+//  without specific prior written permission.
+
+//  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+//  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+//  PURPOSE.
+
+// This file defines FlexLexer, an abstract class which specifies the
+// external interface provided to flex C++ lexer objects, and yyFlexLexer,
+// which defines a particular lexer class.
+//
+// If you want to create multiple lexer classes, you use the -P flag
+// to rename each yyFlexLexer to some other xxFlexLexer.  You then
+// include <FlexLexer.h> in your other sources once per lexer class:
+//
+//	#undef yyFlexLexer
+//	#define yyFlexLexer xxFlexLexer
+//	#include <FlexLexer.h>
+//
+//	#undef yyFlexLexer
+//	#define yyFlexLexer zzFlexLexer
+//	#include <FlexLexer.h>
+//	...
+
+#ifndef __FLEX_LEXER_H
+// Never included before - need to define base class.
+#define __FLEX_LEXER_H
+
+#include <iostream>
+#  ifndef FLEX_STD
+#    define FLEX_STD std::
+#  endif
+
+extern "C++" {
+
+struct yy_buffer_state;
+typedef int yy_state_type;
+
+class FlexLexer {
+public:
+	virtual ~FlexLexer()	{ }
+
+	const char* YYText() const	{ return yytext; }
+	int YYLeng()	const	{ return yyleng; }
+
+	virtual void
+		yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
+	virtual struct yy_buffer_state*
+		yy_create_buffer( FLEX_STD istream* s, int size ) = 0;
+	virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
+	virtual void yyrestart( FLEX_STD istream* s ) = 0;
+
+	virtual int yylex() = 0;
+
+	// Call yylex with new input/output sources.
+	int yylex( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 )
+		{
+		switch_streams( new_in, new_out );
+		return yylex();
+		}
+
+	// Switch to new input/output streams.  A nil stream pointer
+	// indicates "keep the current one".
+	virtual void switch_streams( FLEX_STD istream* new_in = 0,
+					FLEX_STD ostream* new_out = 0 ) = 0;
+
+	int lineno() const		{ return yylineno; }
+
+	int debug() const		{ return yy_flex_debug; }
+	void set_debug( int flag )	{ yy_flex_debug = flag; }
+
+protected:
+	char* yytext;
+	int yyleng;
+	int yylineno;		// only maintained if you use %option yylineno
+	int yy_flex_debug;	// only has effect with -d or "%option debug"
+};
+
+}
+#endif // FLEXLEXER_H
+
+#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)
+// Either this is the first time through (yyFlexLexerOnce not defined),
+// or this is a repeated include to define a different flavor of
+// yyFlexLexer, as discussed in the flex manual.
+#define yyFlexLexerOnce
+
+extern "C++" {
+
+class yyFlexLexer : public FlexLexer {
+public:
+	// arg_yyin and arg_yyout default to the cin and cout, but we
+	// only make that assignment when initializing in yylex().
+	yyFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout = 0 );
+
+	virtual ~yyFlexLexer();
+
+	void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );
+	struct yy_buffer_state* yy_create_buffer( FLEX_STD istream* s, int size );
+	void yy_delete_buffer( struct yy_buffer_state* b );
+	void yyrestart( FLEX_STD istream* s );
+
+	void yypush_buffer_state( struct yy_buffer_state* new_buffer );
+	void yypop_buffer_state();
+
+	virtual int yylex();
+	virtual void switch_streams( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 );
+	virtual int yywrap();
+
+protected:
+	virtual int LexerInput( char* buf, int max_size );
+	virtual void LexerOutput( const char* buf, int size );
+	virtual void LexerError( const char* msg );
+
+	void yyunput( int c, char* buf_ptr );
+	int yyinput();
+
+	void yy_load_buffer_state();
+	void yy_init_buffer( struct yy_buffer_state* b, FLEX_STD istream* s );
+	void yy_flush_buffer( struct yy_buffer_state* b );
+
+	int yy_start_stack_ptr;
+	int yy_start_stack_depth;
+	int* yy_start_stack;
+
+	void yy_push_state( int new_state );
+	void yy_pop_state();
+	int yy_top_state();
+
+	yy_state_type yy_get_previous_state();
+	yy_state_type yy_try_NUL_trans( yy_state_type current_state );
+	int yy_get_next_buffer();
+
+	FLEX_STD istream* yyin;	// input source for default LexerInput
+	FLEX_STD ostream* yyout;	// output sink for default LexerOutput
+
+	// yy_hold_char holds the character lost when yytext is formed.
+	char yy_hold_char;
+
+	// Number of characters read into yy_ch_buf.
+	int yy_n_chars;
+
+	// Points to current character in buffer.
+	char* yy_c_buf_p;
+
+	int yy_init;		// whether we need to initialize
+	int yy_start;		// start state number
+
+	// Flag which is used to allow yywrap()'s to do buffer switches
+	// instead of setting up a fresh yyin.  A bit of a hack ...
+	int yy_did_buffer_switch_on_eof;
+
+
+	size_t yy_buffer_stack_top; /**< index of top of stack. */
+	size_t yy_buffer_stack_max; /**< capacity of stack. */
+	struct yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
+	void yyensure_buffer_stack(void);
+
+	// The following are not always needed, but may be depending
+	// on use of certain flex features (like REJECT or yymore()).
+
+	yy_state_type yy_last_accepting_state;
+	char* yy_last_accepting_cpos;
+
+	yy_state_type* yy_state_buf;
+	yy_state_type* yy_state_ptr;
+
+	char* yy_full_match;
+	int* yy_full_state;
+	int yy_full_lp;
+
+	int yy_lp;
+	int yy_looking_for_trail_begin;
+
+	int yy_more_flag;
+	int yy_more_len;
+	int yy_more_offset;
+	int yy_prev_more_offset;
+};
+
+}
+
+#endif // yyFlexLexer || ! yyFlexLexerOnce
+
diff --git a/include/mcld/Script/GroupCmd.h b/include/mcld/Script/GroupCmd.h
new file mode 100644
index 0000000..3006c79
--- /dev/null
+++ b/include/mcld/Script/GroupCmd.h
@@ -0,0 +1,60 @@
+//===- GroupCmd.h ---------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_GROUPCMD_H
+#define MCLD_SCRIPT_GROUPCMD_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+
+namespace mcld
+{
+
+class StringList;
+class InputTree;
+class InputBuilder;
+class GroupReader;
+class LinkerConfig;
+
+/** \class GroupCmd
+ *  \brief This class defines the interfaces to Group command.
+ */
+
+class GroupCmd : public ScriptCommand
+{
+public:
+  GroupCmd(StringList& pStringList,
+           InputTree& pInputTree,
+           InputBuilder& pBuilder,
+           GroupReader& m_GroupReader,
+           const LinkerConfig& pConfig);
+  ~GroupCmd();
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::GROUP;
+  }
+
+  void activate(Module& pModule);
+
+private:
+  StringList& m_StringList;
+  InputTree& m_InputTree;
+  InputBuilder& m_Builder;
+  GroupReader& m_GroupReader;
+  const LinkerConfig& m_Config;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/InputSectDesc.h b/include/mcld/Script/InputSectDesc.h
new file mode 100644
index 0000000..e2bbf8d
--- /dev/null
+++ b/include/mcld/Script/InputSectDesc.h
@@ -0,0 +1,105 @@
+//===- InputSectDesc.h ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_INPUTSECTDESC_H
+#define MCLD_SCRIPT_INPUTSECTDESC_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <mcld/Script/StringList.h>
+#include <cassert>
+
+namespace mcld
+{
+
+class WildcardPattern;
+class OutputSectDesc;
+
+/** \class InputSectDesc
+ *  \brief This class defines the interfaces to input section description.
+ */
+
+class InputSectDesc : public ScriptCommand
+{
+public:
+  enum KeepPolicy {
+    Keep,
+    NoKeep
+  };
+
+  struct Spec {
+    bool hasFile() const { return m_pWildcardFile != NULL; }
+    const WildcardPattern& file() const {
+      assert(hasFile());
+      return *m_pWildcardFile;
+    }
+
+    bool hasExcludeFiles() const {
+      return m_pExcludeFiles != NULL && !m_pExcludeFiles->empty();
+    }
+    const StringList& excludeFiles() const {
+      assert(hasExcludeFiles());
+      return *m_pExcludeFiles;
+    }
+
+    bool hasSections() const {
+      return m_pWildcardSections != NULL && !m_pWildcardSections->empty();
+    }
+    const StringList& sections() const {
+      assert(hasSections());
+      return *m_pWildcardSections;
+    }
+
+    bool operator==(const Spec& pRHS) const {
+      /* FIXME: currently I don't check the real content */
+      if (this == &pRHS)
+        return true;
+      if (m_pWildcardFile != pRHS.m_pWildcardFile)
+        return false;
+      if (m_pExcludeFiles != pRHS.m_pExcludeFiles)
+        return false;
+      if (m_pWildcardSections != pRHS.m_pWildcardSections)
+        return false;
+      return true;
+    }
+
+    WildcardPattern* m_pWildcardFile;
+    StringList* m_pExcludeFiles;
+    StringList* m_pWildcardSections;
+  };
+
+public:
+  InputSectDesc(KeepPolicy pPolicy,
+                const Spec& pSpec,
+                const OutputSectDesc& pOutputDesc);
+  ~InputSectDesc();
+
+  KeepPolicy policy() const { return m_KeepPolicy; }
+
+  const Spec& spec() const { return m_Spec; }
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::INPUT_SECT_DESC;
+  }
+
+  void activate(Module& pModule);
+
+private:
+  KeepPolicy m_KeepPolicy;
+  Spec m_Spec;
+  const OutputSectDesc& m_OutputSectDesc;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Script/InputToken.h b/include/mcld/Script/InputToken.h
new file mode 100644
index 0000000..8d89022
--- /dev/null
+++ b/include/mcld/Script/InputToken.h
@@ -0,0 +1,56 @@
+//===- InputToken.h -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_INPUTTOKEN_H
+#define MCLD_SCRIPT_INPUTTOKEN_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/StrToken.h>
+
+namespace mcld
+{
+
+/** \class InputToken
+ *  \brief This class defines the interfaces to a file/namespec token.
+ */
+
+class InputToken : public StrToken
+{
+public:
+  enum Type {
+    Unknown,
+    File,
+    NameSpec
+  };
+
+protected:
+  InputToken();
+  InputToken(Type pType, const std::string& pName, bool pAsNeeded);
+
+public:
+  virtual ~InputToken();
+
+  Type type() const { return m_Type; }
+
+  bool asNeeded() const { return m_bAsNeeded; }
+
+  static bool classof(const StrToken* pToken)
+  {
+    return pToken->kind() == StrToken::Input;
+  }
+
+private:
+  Type m_Type;
+  bool m_bAsNeeded;
+};
+
+} // namepsace of mcld
+
+#endif
diff --git a/include/mcld/Script/NameSpec.h b/include/mcld/Script/NameSpec.h
new file mode 100644
index 0000000..96cf95c
--- /dev/null
+++ b/include/mcld/Script/NameSpec.h
@@ -0,0 +1,50 @@
+//===- NameSpec.h ---------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_NAMESPEC_H
+#define MCLD_SCRIPT_NAMESPEC_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/InputToken.h>
+#include <mcld/Support/Allocators.h>
+#include <mcld/Config/Config.h>
+
+namespace mcld
+{
+
+/** \class NameSpec
+ *  \brief This class defines the interfaces to a namespec in INPUT/GROUP
+ *         command.
+ */
+
+class NameSpec : public InputToken
+{
+private:
+  friend class Chunk<NameSpec, MCLD_SYMBOLS_PER_INPUT>;
+  NameSpec();
+  NameSpec(const std::string& pName, bool pAsNeeded);
+
+public:
+  ~NameSpec();
+
+  static bool classof(const InputToken* pToken)
+  {
+    return pToken->type() == InputToken::NameSpec;
+  }
+
+  /* factory method */
+  static NameSpec* create(const std::string& pName, bool pAsNeeded);
+  static void destroy(NameSpec*& pToken);
+  static void clear();
+};
+
+} // namepsace of mcld
+
+#endif
diff --git a/include/mcld/Script/NullaryOp.h b/include/mcld/Script/NullaryOp.h
new file mode 100644
index 0000000..95fdc18
--- /dev/null
+++ b/include/mcld/Script/NullaryOp.h
@@ -0,0 +1,65 @@
+//===- NullaryOp.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_NULLOP_H
+#define MCLD_SCRIPT_NULLOP_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/Operator.h>
+#include <cassert>
+
+namespace mcld
+{
+
+class Operand;
+class IntOperand;
+class Module;
+class TargetLDBackend;
+
+/** \class NullaryOp
+ *  \brief This class defines the interfaces to an nullary operator token.
+ */
+
+template<Operator::Type TYPE>
+class NullaryOp : public Operator
+{
+private:
+  friend class Operator;
+
+  NullaryOp()
+    : Operator(Operator::NULLARY, TYPE)
+  {}
+
+public:
+  ~NullaryOp()
+  {}
+
+  IntOperand* eval(const Module& pModule, const TargetLDBackend& pBackend);
+
+  void appendOperand(Operand* pOperand)
+  {
+    assert(0);
+  }
+};
+
+template<>
+IntOperand* NullaryOp<Operator::SIZEOF_HEADERS>::eval(const Module&,
+                                                      const TargetLDBackend&);
+template<>
+IntOperand* NullaryOp<Operator::MAXPAGESIZE>::eval(const Module&,
+                                                   const TargetLDBackend&);
+
+template<>
+IntOperand* NullaryOp<Operator::COMMONPAGESIZE>::eval(const Module&,
+                                                      const TargetLDBackend&);
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Script/Operand.h b/include/mcld/Script/Operand.h
new file mode 100644
index 0000000..403701c
--- /dev/null
+++ b/include/mcld/Script/Operand.h
@@ -0,0 +1,241 @@
+//===- Operand.h ----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_OPERAND_H
+#define MCLD_SCRIPT_OPERAND_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ExprToken.h>
+#include <mcld/Object/SectionMap.h>
+#include <mcld/Support/Allocators.h>
+#include <mcld/Config/Config.h>
+#include <llvm/Support/DataTypes.h>
+#include <string>
+#include <cassert>
+
+namespace mcld
+{
+
+/** \class Operand
+ *  \brief This class defines the interfaces to an operand token.
+ */
+
+class Operand : public ExprToken
+{
+public:
+  enum Type {
+    SYMBOL,
+    INTEGER,
+    SECTION,
+    SECTION_DESC,
+    FRAGMENT
+  };
+
+protected:
+  Operand(Type pType);
+  virtual ~Operand();
+
+public:
+  Type type() const { return m_Type; }
+
+  virtual bool isDot() const { return false; }
+
+  virtual uint64_t value() const = 0;
+
+  static bool classof(const ExprToken* pToken)
+  {
+    return pToken->kind() == ExprToken::OPERAND;
+  }
+
+private:
+  Type m_Type;
+};
+
+/** \class SymOperand
+ *  \brief This class defines the interfaces to a symbol operand.
+ */
+
+class SymOperand : public Operand
+{
+private:
+  friend class Chunk<SymOperand, MCLD_SYMBOLS_PER_INPUT>;
+  SymOperand();
+  SymOperand(const std::string& pName);
+
+public:
+  void dump() const;
+
+  const std::string& name() const { return m_Name; }
+
+  bool isDot() const;
+
+  uint64_t value() const { return m_Value; }
+
+  void setValue(uint64_t pValue) { m_Value = pValue; }
+
+  static bool classof(const Operand* pOperand)
+  {
+    return pOperand->type() == Operand::SYMBOL;
+  }
+
+  /* factory method */
+  static SymOperand* create(const std::string& pName);
+  static void destroy(SymOperand*& pOperand);
+  static void clear();
+
+private:
+  std::string m_Name;
+  uint64_t m_Value;
+};
+
+/** \class IntOperand
+ *  \brief This class defines the interfaces to an integer operand.
+ */
+
+class IntOperand : public Operand
+{
+private:
+  friend class Chunk<IntOperand, MCLD_SYMBOLS_PER_INPUT>;
+  IntOperand();
+  IntOperand(uint64_t pValue);
+
+public:
+  void dump() const;
+
+  uint64_t value() const { return m_Value; }
+
+  void setValue(uint64_t pValue) { m_Value = pValue; }
+
+  static bool classof(const Operand* pOperand)
+  {
+    return pOperand->type() == Operand::INTEGER;
+  }
+
+  /* factory method */
+  static IntOperand* create(uint64_t pValue);
+  static void destroy(IntOperand*& pOperand);
+  static void clear();
+
+private:
+  uint64_t m_Value;
+};
+
+/** \class SectOperand
+ *  \brief This class defines the interfaces to an section name operand.
+ */
+class LDSection;
+
+class SectOperand : public Operand
+{
+private:
+  friend class Chunk<SectOperand, MCLD_SECTIONS_PER_INPUT>;
+  SectOperand();
+  SectOperand(const std::string& pName);
+
+public:
+  void dump() const;
+
+  const std::string& name() const { return m_Name; }
+
+  uint64_t value() const
+  {
+    assert(0);
+    return 0;
+  }
+
+  static bool classof(const Operand* pOperand)
+  {
+    return pOperand->type() == Operand::SECTION;
+  }
+
+  /* factory method */
+  static SectOperand* create(const std::string& pName);
+  static void destroy(SectOperand*& pOperand);
+  static void clear();
+
+private:
+  std::string m_Name;
+};
+
+/** \class SectDescOperand
+ *  \brief This class defines the interfaces to an section name operand.
+ */
+
+class SectDescOperand : public Operand
+{
+private:
+  friend class Chunk<SectDescOperand, MCLD_SECTIONS_PER_INPUT>;
+  SectDescOperand();
+  SectDescOperand(const SectionMap::Output* pOutputDesc);
+
+public:
+  void dump() const;
+
+  const SectionMap::Output* outputDesc() const { return m_pOutputDesc; }
+
+  uint64_t value() const
+  {
+    assert(0);
+    return 0;
+  }
+
+  static bool classof(const Operand* pOperand)
+  {
+    return pOperand->type() == Operand::SECTION_DESC;
+  }
+
+  /* factory method */
+  static SectDescOperand* create(const SectionMap::Output* pOutputDesc);
+  static void destroy(SectDescOperand*& pOperand);
+  static void clear();
+
+private:
+  const SectionMap::Output* m_pOutputDesc;
+};
+
+/** \class FragOperand
+ *  \brief This class defines the interfaces to a fragment operand.
+ */
+
+class Fragment;
+
+class FragOperand : public Operand
+{
+private:
+  friend class Chunk<FragOperand, MCLD_SYMBOLS_PER_INPUT>;
+  FragOperand();
+  FragOperand(Fragment& pFragment);
+
+public:
+  void dump() const;
+
+  const Fragment* frag() const { return m_pFragment; }
+  Fragment*       frag()       { return m_pFragment; }
+
+  uint64_t value() const;
+
+  static bool classof(const Operand* pOperand)
+  {
+    return pOperand->type() == Operand::FRAGMENT;
+  }
+
+  /* factory method */
+  static FragOperand* create(Fragment& pFragment);
+  static void destroy(FragOperand*& pOperand);
+  static void clear();
+
+private:
+  Fragment* m_pFragment;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/Operator.h b/include/mcld/Script/Operator.h
new file mode 100644
index 0000000..1fe8118
--- /dev/null
+++ b/include/mcld/Script/Operator.h
@@ -0,0 +1,231 @@
+//===- Operator.h ---------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_OPERATOR_INTERFACE_H
+#define MCLD_SCRIPT_OPERATOR_INTERFACE_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ExprToken.h>
+#include <llvm/Support/DataTypes.h>
+
+namespace mcld
+{
+
+class Operand;
+class IntOperand;
+class Module;
+class TargetLDBackend;
+
+/** \class Operator
+ *  \brief This class defines the interfaces to an operator token.
+ */
+
+class Operator : public ExprToken
+{
+public:
+  enum Arity {
+    NULLARY,
+    UNARY,
+    BINARY,
+    TERNARY
+  };
+
+  enum Type {
+    /* arithmetic operator */
+    UNARY_PLUS  = 0,
+    UNARY_MINUS = 1,
+    LOGICAL_NOT = 2,
+    BITWISE_NOT = 3,
+    MUL         = 4,
+    DIV         = 5,
+    MOD         = 6,
+    ADD         = 7,
+    SUB         = 8,
+    LSHIFT      = 9,
+    RSHIFT      = 10,
+    LT          = 11,
+    LE          = 12,
+    GT          = 13,
+    GE          = 14,
+    EQ          = 15,
+    NE          = 16,
+    BITWISE_AND = 17,
+    BITWISE_XOR = 18,
+    BITWISE_OR  = 19,
+    LOGICAL_AND = 20,
+    LOGICAL_OR  = 21,
+    TERNARY_IF  = 22,
+    ASSIGN      = 23,
+    ADD_ASSIGN  = 24,
+    SUB_ASSIGN  = 25,
+    MUL_ASSIGN  = 26,
+    DIV_ASSIGN  = 27,
+    AND_ASSIGN  = 28,
+    OR_ASSIGN   = 29,
+    LS_ASSIGN   = 30,
+    RS_ASSIGN   = 31,
+    /* function */
+    ABSOLUTE               = 32,
+    ADDR                   = 33,
+    ALIGN                  = 34,
+    ALIGNOF                = 35,
+    BLOCK                  = 36,
+    DATA_SEGMENT_ALIGN     = 37,
+    DATA_SEGMENT_END       = 38,
+    DATA_SEGMENT_RELRO_END = 39,
+    DEFINED                = 40,
+    LENGTH                 = 41,
+    LOADADDR               = 42,
+    MAX                    = 43,
+    MIN                    = 44,
+    NEXT                   = 45,
+    ORIGIN                 = 46,
+    SEGMENT_START          = 47,
+    SIZEOF                 = 48,
+    SIZEOF_HEADERS         = 49,
+    MAXPAGESIZE            = 50,
+    COMMONPAGESIZE         = 51
+  };
+
+  static const char* OpNames[];
+
+protected:
+  Operator(Arity pArity, Type pType);
+
+  const IntOperand* result() const { return m_pIntOperand; }
+  IntOperand*       result()       { return m_pIntOperand; }
+
+public:
+  virtual ~Operator();
+
+  Arity arity() const { return m_Arity; }
+
+  Type type() const { return m_Type; }
+
+  virtual void dump() const;
+
+  virtual IntOperand* eval(const Module& pModule,
+                           const TargetLDBackend& pBackend) = 0;
+
+  virtual void appendOperand(Operand* pOperand) = 0;
+
+  static bool classof(const ExprToken* pToken)
+  {
+    return pToken->kind() == ExprToken::OPERATOR;
+  }
+
+  template<Operator::Type TYPE>
+  static Operator& create();
+
+private:
+  Arity m_Arity;
+  Type m_Type;
+  IntOperand* m_pIntOperand;
+};
+
+/* Nullary operator */
+template<>
+Operator& Operator::create<Operator::SIZEOF_HEADERS>();
+template<>
+Operator& Operator::create<Operator::MAXPAGESIZE>();
+template<>
+Operator& Operator::create<Operator::COMMONPAGESIZE>();
+
+/* Unary operator */
+template<>
+Operator& Operator::create<Operator::UNARY_PLUS>();
+template<>
+Operator& Operator::create<Operator::UNARY_MINUS>();
+template<>
+Operator& Operator::create<Operator::LOGICAL_NOT>();
+template<>
+Operator& Operator::create<Operator::BITWISE_NOT>();
+
+template<>
+Operator& Operator::create<Operator::ABSOLUTE>();
+template<>
+Operator& Operator::create<Operator::ADDR>();
+template<>
+Operator& Operator::create<Operator::ALIGNOF>();
+template<>
+Operator& Operator::create<Operator::DATA_SEGMENT_END>();
+template<>
+Operator& Operator::create<Operator::DEFINED>();
+template<>
+Operator& Operator::create<Operator::LENGTH>();
+template<>
+Operator& Operator::create<Operator::LOADADDR>();
+template<>
+Operator& Operator::create<Operator::NEXT>();
+template<>
+Operator& Operator::create<Operator::ORIGIN>();
+template<>
+Operator& Operator::create<Operator::SIZEOF>();
+
+/* Binary operator */
+template<>
+Operator& Operator::create<Operator::MUL>();
+template<>
+Operator& Operator::create<Operator::DIV>();
+template<>
+Operator& Operator::create<Operator::MOD>();
+template<>
+Operator& Operator::create<Operator::ADD>();
+template<>
+Operator& Operator::create<Operator::SUB>();
+template<>
+Operator& Operator::create<Operator::LSHIFT>();
+template<>
+Operator& Operator::create<Operator::RSHIFT>();
+template<>
+Operator& Operator::create<Operator::LT>();
+template<>
+Operator& Operator::create<Operator::LE>();
+template<>
+Operator& Operator::create<Operator::GT>();
+template<>
+Operator& Operator::create<Operator::GE>();
+template<>
+Operator& Operator::create<Operator::EQ>();
+template<>
+Operator& Operator::create<Operator::NE>();
+template<>
+Operator& Operator::create<Operator::BITWISE_AND>();
+template<>
+Operator& Operator::create<Operator::BITWISE_XOR>();
+template<>
+Operator& Operator::create<Operator::BITWISE_OR>();
+template<>
+Operator& Operator::create<Operator::LOGICAL_AND>();
+template<>
+Operator& Operator::create<Operator::LOGICAL_OR>();
+
+template<>
+Operator& Operator::create<Operator::ALIGN>();
+template<>
+Operator& Operator::create<Operator::DATA_SEGMENT_RELRO_END>();
+template<>
+Operator& Operator::create<Operator::MAX>();
+template<>
+Operator& Operator::create<Operator::MIN>();
+template<>
+Operator& Operator::create<Operator::SEGMENT_START>();
+
+/* Ternary operator */
+template<>
+Operator& Operator::create<Operator::TERNARY_IF>();
+
+template<>
+Operator&
+Operator::create<Operator::DATA_SEGMENT_ALIGN>();
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/OutputArchCmd.h b/include/mcld/Script/OutputArchCmd.h
new file mode 100644
index 0000000..51b75cc
--- /dev/null
+++ b/include/mcld/Script/OutputArchCmd.h
@@ -0,0 +1,49 @@
+//===- OutputArchCmd.h ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_OUTPUTARCHCMD_H
+#define MCLD_SCRIPT_OUTPUTARCHCMD_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <string>
+
+namespace mcld
+{
+
+class Module;
+
+/** \class OutputArchCmd
+ *  \brief This class defines the interfaces to OutputArch command.
+ */
+
+class OutputArchCmd : public ScriptCommand
+{
+public:
+  OutputArchCmd(const std::string& pArch);
+  ~OutputArchCmd();
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::OUTPUT_ARCH;
+  }
+
+  void activate(Module& pModule);
+
+private:
+  std::string m_Arch;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/OutputCmd.h b/include/mcld/Script/OutputCmd.h
new file mode 100644
index 0000000..0a63891
--- /dev/null
+++ b/include/mcld/Script/OutputCmd.h
@@ -0,0 +1,50 @@
+//===- OutputCmd.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_OUTPUTCMD_H
+#define MCLD_SCRIPT_OUTPUTCMD_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <string>
+
+namespace mcld
+{
+
+class Module;
+
+/** \class OutputCmd
+ *  \brief This class defines the interfaces to Output command.
+ */
+
+class OutputCmd : public ScriptCommand
+{
+public:
+  OutputCmd(const std::string& pOutputFile);
+
+  ~OutputCmd();
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::OUTPUT;
+  }
+
+  void activate(Module& pModule);
+
+private:
+  std::string m_OutputFile;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/OutputFormatCmd.h b/include/mcld/Script/OutputFormatCmd.h
new file mode 100644
index 0000000..b716e81
--- /dev/null
+++ b/include/mcld/Script/OutputFormatCmd.h
@@ -0,0 +1,63 @@
+//===- OutputFormatCmd.h --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_OUTPUTFORMATCMD_H
+#define MCLD_SCRIPT_OUTPUTFORMATCMD_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <string>
+#include <vector>
+
+namespace mcld
+{
+
+class Module;
+
+/** \class OutputFormatCmd
+ *  \brief This class defines the interfaces to OutputFormat command.
+ */
+
+class OutputFormatCmd : public ScriptCommand
+{
+public:
+  typedef std::vector<std::string> FormatList;
+  typedef FormatList::const_iterator const_iterator;
+  typedef FormatList::iterator iterator;
+
+public:
+  OutputFormatCmd(const std::string& pFormat);
+  OutputFormatCmd(const std::string& pDefault,
+                  const std::string& pBig,
+                  const std::string& pLittle);
+  ~OutputFormatCmd();
+
+  const_iterator begin() const { return m_FormatList.begin(); }
+  iterator       begin()       { return m_FormatList.begin(); }
+  const_iterator end()   const { return m_FormatList.end(); }
+  iterator       end()         { return m_FormatList.end(); }
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::OUTPUT_FORMAT;
+  }
+
+  void activate(Module& pModule);
+
+private:
+  FormatList m_FormatList;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/OutputSectDesc.h b/include/mcld/Script/OutputSectDesc.h
new file mode 100644
index 0000000..3c5187b
--- /dev/null
+++ b/include/mcld/Script/OutputSectDesc.h
@@ -0,0 +1,214 @@
+//===- OutputSectDesc.h ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_OUTPUTSECTDESC_H
+#define MCLD_SCRIPT_OUTPUTSECTDESC_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <vector>
+#include <string>
+#include <cassert>
+
+namespace mcld
+{
+
+class RpnExpr;
+class StringList;
+
+/** \class OutputSectDesc
+ *  \brief This class defines the interfaces to output section description.
+ */
+
+class OutputSectDesc : public ScriptCommand
+{
+public:
+  enum Type {
+    LOAD, // ALLOC
+    NOLOAD,
+    DSECT,
+    COPY,
+    INFO,
+    OVERLAY
+  };
+
+  enum Constraint {
+    NO_CONSTRAINT,
+    ONLY_IF_RO,
+    ONLY_IF_RW
+  };
+
+  struct Prolog {
+    bool hasVMA() const { return m_pVMA != NULL; }
+    const RpnExpr& vma() const {
+      assert(hasVMA());
+      return *m_pVMA;
+    }
+    RpnExpr& vma() {
+      assert(hasVMA());
+      return *m_pVMA;
+    }
+
+    void setType(Type pType) {
+      m_Type = pType;
+    }
+
+    Type type() const { return m_Type; }
+
+    bool hasLMA() const { return m_pLMA != NULL; }
+    const RpnExpr& lma() const {
+      assert(hasLMA());
+      return *m_pLMA;
+    }
+    RpnExpr& lma() {
+      assert(hasLMA());
+      return *m_pLMA;
+    }
+
+    bool hasAlign() const { return m_pAlign != NULL; }
+    const RpnExpr& align() const {
+      assert(hasAlign());
+      return *m_pAlign;
+    }
+
+    bool hasSubAlign() const { return m_pSubAlign != NULL; }
+    const RpnExpr& subAlign() const {
+      assert(hasSubAlign());
+      return *m_pSubAlign;
+    }
+
+    Constraint constraint() const { return m_Constraint; }
+
+    bool operator==(const Prolog& pRHS) const {
+      /* FIXME: currently I don't check the real content */
+      if (this == &pRHS)
+        return true;
+      if (m_pVMA != pRHS.m_pVMA)
+        return false;
+      if (m_Type != pRHS.m_Type)
+        return false;
+      if (m_pLMA!= pRHS.m_pLMA)
+        return false;
+      if (m_pAlign != pRHS.m_pAlign)
+        return false;
+      if (m_pSubAlign != pRHS.m_pSubAlign)
+        return false;
+      if (m_Constraint != pRHS.m_Constraint)
+        return false;
+      return true;
+    }
+
+    RpnExpr* m_pVMA;
+    Type m_Type;
+    RpnExpr* m_pLMA;
+    RpnExpr* m_pAlign;
+    RpnExpr* m_pSubAlign;
+    Constraint m_Constraint;
+  };
+
+  struct Epilog {
+    bool hasRegion() const { return m_pRegion != NULL; }
+    const std::string& region() const {
+      assert(hasRegion());
+      return *m_pRegion;
+    }
+
+    bool hasLMARegion() const { return m_pLMARegion != NULL; }
+    const std::string& lmaRegion() const {
+      assert(hasLMARegion());
+      return *m_pLMARegion;
+    }
+
+    bool hasPhdrs() const { return m_pPhdrs != NULL; }
+    const StringList& phdrs() const {
+      assert(hasPhdrs());
+      return *m_pPhdrs;
+    }
+
+    bool hasFillExp() const { return m_pFillExp != NULL; }
+    const RpnExpr& fillExp() const {
+      assert(hasFillExp());
+      return *m_pFillExp;
+    }
+
+    bool operator==(const Epilog& pRHS) const {
+      /* FIXME: currently I don't check the real content */
+      if (this == &pRHS)
+        return true;
+      if (m_pRegion != pRHS.m_pRegion)
+        return false;
+      if (m_pLMARegion != pRHS.m_pLMARegion)
+        return false;
+      if (m_pPhdrs != pRHS.m_pPhdrs)
+        return false;
+      if (m_pFillExp != pRHS.m_pFillExp)
+        return false;
+      return true;
+    }
+
+    const std::string* m_pRegion;
+    const std::string* m_pLMARegion;
+    StringList* m_pPhdrs;
+    RpnExpr* m_pFillExp;
+  };
+
+  typedef std::vector<ScriptCommand*> OutputSectCmds;
+  typedef OutputSectCmds::const_iterator const_iterator;
+  typedef OutputSectCmds::iterator iterator;
+  typedef OutputSectCmds::const_reference const_reference;
+  typedef OutputSectCmds::reference reference;
+
+public:
+  OutputSectDesc(const std::string& pName, const Prolog& pProlog);
+  ~OutputSectDesc();
+
+  const_iterator  begin() const { return m_OutputSectCmds.begin(); }
+  iterator        begin()       { return m_OutputSectCmds.begin(); }
+  const_iterator  end()   const { return m_OutputSectCmds.end(); }
+  iterator        end()         { return m_OutputSectCmds.end(); }
+
+  const_reference front() const { return m_OutputSectCmds.front(); }
+  reference       front()       { return m_OutputSectCmds.front(); }
+  const_reference back()  const { return m_OutputSectCmds.back(); }
+  reference       back()        { return m_OutputSectCmds.back(); }
+
+  const std::string& name() const { return m_Name; }
+
+  size_t size() const { return m_OutputSectCmds.size(); }
+
+  bool empty() const { return m_OutputSectCmds.empty(); }
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::OUTPUT_SECT_DESC;
+  }
+
+  void activate(Module& pModule);
+
+  void push_back(ScriptCommand* pCommand);
+
+  void setEpilog(const Epilog& pEpilog);
+
+  const Prolog& prolog() const { return m_Prolog; }
+
+  const Epilog& epilog() const { return m_Epilog; }
+
+private:
+  OutputSectCmds m_OutputSectCmds;
+  std::string m_Name;
+  Prolog m_Prolog;
+  Epilog m_Epilog;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Script/RpnEvaluator.h b/include/mcld/Script/RpnEvaluator.h
new file mode 100644
index 0000000..7e35e86
--- /dev/null
+++ b/include/mcld/Script/RpnEvaluator.h
@@ -0,0 +1,36 @@
+//===- RpnEvaluator.h -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_RPNEVALUATOR_H
+#define MCLD_SCRIPT_RPNEVALUATOR_H
+
+namespace mcld {
+
+class RpnExpr;
+class Module;
+class TargetLDBackend;
+
+/** \class RpnEvaluator
+ *  \brief RpnEvaluator evaluate a rpn expression
+ */
+class RpnEvaluator
+{
+public:
+  RpnEvaluator(const Module& pModule, const TargetLDBackend& pBackend);
+
+  // evaluate a valid expression and set the value in the second parameter
+  bool eval(const RpnExpr& pExpr, uint64_t& pResult);
+
+private:
+  const Module& m_Module;
+  const TargetLDBackend& m_Backend;
+};
+
+} // mcld
+
+#endif
diff --git a/include/mcld/Script/RpnExpr.h b/include/mcld/Script/RpnExpr.h
new file mode 100644
index 0000000..96b11e9
--- /dev/null
+++ b/include/mcld/Script/RpnExpr.h
@@ -0,0 +1,81 @@
+//===- RPNExpr.h ----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_RPNEXPR_H
+#define MCLD_SCRIPT_RPNEXPR_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Support/Allocators.h>
+#include <mcld/Config/Config.h>
+#include <mcld/Object/SectionMap.h>
+#include <vector>
+
+namespace mcld
+{
+
+class ExprToken;
+class Fragment;
+
+/** \class RpnExpr
+ *  \brief This class defines the interfaces to a rpn expression.
+ */
+
+class RpnExpr
+{
+public:
+  typedef std::vector<ExprToken*> TokenQueue;
+  typedef TokenQueue::const_iterator const_iterator;
+  typedef TokenQueue::iterator iterator;
+
+private:
+  friend class Chunk<RpnExpr, MCLD_SYMBOLS_PER_INPUT>;
+  RpnExpr();
+
+public:
+  ~RpnExpr();
+
+  const_iterator begin() const { return m_TokenQueue.begin(); }
+  iterator       begin()       { return m_TokenQueue.begin(); }
+  const_iterator end()   const { return m_TokenQueue.end(); }
+  iterator       end()         { return m_TokenQueue.end(); }
+
+  size_t size() const { return m_TokenQueue.size(); }
+
+  bool empty() const { return m_TokenQueue.empty(); }
+
+  bool hasDot() const;
+
+  void dump() const;
+
+  void push_back(ExprToken* pToken);
+
+  iterator insert(iterator pPosition, ExprToken* pToken);
+
+  void erase(iterator pPosition);
+
+  /* factory methods */
+  static RpnExpr* create();
+  static void destroy(RpnExpr*& pRpnExpr);
+  static void clear();
+
+  // buildHelperExpr - build the helper expr:
+  //                   ADDR ( `output_sect' ) + SIZEOF ( `output_sect' )
+  static RpnExpr* buildHelperExpr(SectionMap::iterator pIter);
+  // buildHelperExpr - build the helper expr: `fragment'
+  static RpnExpr* buildHelperExpr(Fragment& pFrag);
+
+private:
+  TokenQueue m_TokenQueue;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/ScriptCommand.h b/include/mcld/Script/ScriptCommand.h
new file mode 100644
index 0000000..06e07eb
--- /dev/null
+++ b/include/mcld/Script/ScriptCommand.h
@@ -0,0 +1,60 @@
+//===- ScriptCommand.h ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_COMMAND_H
+#define MCLD_SCRIPT_COMMAND_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+namespace mcld {
+
+class Module;
+
+/** \class ScriptCommand
+ *  \brief This class defines the interfaces to a script command.
+ */
+class ScriptCommand
+{
+public:
+  enum Kind {
+    ENTRY,
+    OUTPUT_FORMAT,
+    GROUP,
+    OUTPUT,
+    SEARCH_DIR,
+    OUTPUT_ARCH,
+    ASSERT,
+    ASSIGNMENT,
+    SECTIONS,
+    OUTPUT_SECT_DESC,
+    INPUT_SECT_DESC
+  };
+
+protected:
+  ScriptCommand(Kind pKind)
+    : m_Kind(pKind)
+  {}
+
+public:
+  virtual ~ScriptCommand() = 0;
+
+  virtual void dump() const = 0;
+
+  virtual void activate(Module&) = 0;
+
+  Kind getKind() const { return m_Kind; }
+
+private:
+  Kind m_Kind;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/ScriptFile.h b/include/mcld/Script/ScriptFile.h
new file mode 100644
index 0000000..03662e3
--- /dev/null
+++ b/include/mcld/Script/ScriptFile.h
@@ -0,0 +1,165 @@
+//===- ScriptFile.h -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_SCRIPTFILE_H
+#define MCLD_SCRIPT_SCRIPTFILE_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/Assignment.h>
+#include <mcld/Script/OutputSectDesc.h>
+#include <mcld/Script/InputSectDesc.h>
+#include <vector>
+#include <string>
+
+namespace mcld
+{
+
+class ScriptCommand;
+class Input;
+class InputTree;
+class InputBuilder;
+class GroupReader;
+class LinkerConfig;
+class RpnExpr;
+class StringList;
+class Module;
+
+/** \class ScriptFile
+ *  \brief This class defines the interfaces to a linker script file.
+ */
+
+class ScriptFile
+{
+public:
+  enum Kind {
+    LDScript,      // -T
+    Expression,    // --defsym
+    VersionScript, // --version-script
+    DynamicList,   // --dynamic-list
+    Unknown
+  };
+
+  typedef std::vector<ScriptCommand*> CommandQueue;
+  typedef CommandQueue::const_iterator const_iterator;
+  typedef CommandQueue::iterator iterator;
+  typedef CommandQueue::const_reference const_reference;
+  typedef CommandQueue::reference reference;
+
+public:
+  ScriptFile(Kind pKind, Input& pInput, InputBuilder& pBuilder);
+  ~ScriptFile();
+
+  const_iterator  begin() const { return m_CommandQueue.begin(); }
+  iterator        begin()       { return m_CommandQueue.begin(); }
+  const_iterator  end()   const { return m_CommandQueue.end(); }
+  iterator        end()         { return m_CommandQueue.end(); }
+
+  const_reference front() const { return m_CommandQueue.front(); }
+  reference       front()       { return m_CommandQueue.front(); }
+  const_reference back()  const { return m_CommandQueue.back(); }
+  reference       back()        { return m_CommandQueue.back(); }
+
+  const Input& input() const { return m_Input; }
+  Input&       input()       { return m_Input; }
+
+  size_t size() const { return m_CommandQueue.size(); }
+
+  Kind getKind() const { return m_Kind; }
+
+  const InputTree& inputs() const { return *m_pInputTree; }
+  InputTree&       inputs()       { return *m_pInputTree; }
+
+  const std::string& name() const { return m_Name; }
+  std::string&       name()       { return m_Name; }
+
+  void dump() const;
+  void activate(Module& pModule);
+
+  /// ENTRY(symbol)
+  void addEntryPoint(const std::string& pSymbol);
+
+  /// OUTPUT_FORMAT(bfdname)
+  /// OUTPUT_FORMAT(default, big, little)
+  void addOutputFormatCmd(const std::string& pFormat);
+  void addOutputFormatCmd(const std::string& pDefault,
+                          const std::string& pBig,
+                          const std::string& pLittle);
+
+  /// GROUP(file, file, ...)
+  /// GROUP(file file ...)
+  void addGroupCmd(StringList& pStringList,
+                   GroupReader& pGroupReader,
+                   const LinkerConfig& pConfig);
+
+  /// OUTPUT(filename)
+  void addOutputCmd(const std::string& pFileName);
+
+  /// SEARCH_DIR(path)
+  void addSearchDirCmd(const std::string& pPath);
+
+  /// OUTPUT_ARCH(bfdarch)
+  void addOutputArchCmd(const std::string& pArch);
+
+  /// ASSERT(exp, message)
+  void addAssertCmd(RpnExpr& pRpnExpr, const std::string& pMessage);
+
+  /// assignment
+  void addAssignment(const std::string& pSymbol,
+                     RpnExpr& pRpnExpr,
+                     Assignment::Type pType = Assignment::DEFAULT);
+
+  bool hasSectionsCmd() const;
+
+  void enterSectionsCmd();
+
+  void leaveSectionsCmd();
+
+  void enterOutputSectDesc(const std::string& pName,
+                           const OutputSectDesc::Prolog& pProlog);
+
+  void leaveOutputSectDesc(const OutputSectDesc::Epilog& pEpilog);
+
+  void addInputSectDesc(InputSectDesc::KeepPolicy pPolicy,
+                        const InputSectDesc::Spec& pSpec);
+
+  RpnExpr* createRpnExpr();
+  const RpnExpr* getCurrentRpnExpr() const { return m_pRpnExpr; }
+  RpnExpr*       getCurrentRpnExpr()       { return m_pRpnExpr; }
+
+  StringList* createStringList();
+  const StringList* getCurrentStringList() const { return m_pStringList; }
+  StringList*       getCurrentStringList()       { return m_pStringList; }
+
+  void setAsNeeded(bool pEnable = true);
+  bool asNeeded() const { return m_bAsNeeded; }
+
+  static const std::string& createParserStr(const char* pText, size_t pLength);
+
+  static void clearParserStrPool();
+
+private:
+  Kind m_Kind;
+  Input& m_Input;
+  std::string m_Name;
+  InputTree* m_pInputTree;
+  InputBuilder& m_Builder;
+  CommandQueue m_CommandQueue;
+  bool m_bHasSectionsCmd;
+  bool m_bInSectionsCmd;
+  bool m_bInOutputSectDesc;
+  RpnExpr* m_pRpnExpr;
+  StringList* m_pStringList;
+  bool m_bAsNeeded;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/ScriptReader.h b/include/mcld/Script/ScriptReader.h
new file mode 100644
index 0000000..14a667f
--- /dev/null
+++ b/include/mcld/Script/ScriptReader.h
@@ -0,0 +1,49 @@
+//===- ScriptReader.h -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_SCRIPTREADER_H
+#define MCLD_SCRIPT_SCRIPTREADER_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/LD/LDReader.h>
+
+namespace mcld {
+
+class Module;
+class ScriptFile;
+class Input;
+class GroupReader;
+class LinkerConfig;
+class LinkerScript;
+class TargetLDBackend;
+
+class ScriptReader : public LDReader
+{
+public:
+  ScriptReader(GroupReader& pGroupReader);
+
+  ~ScriptReader();
+
+  /// readScript
+  bool readScript(const LinkerConfig& pConfig, ScriptFile& pScriptFile);
+
+  /// isMyFormat
+  bool isMyFormat(Input& pInput, bool &pContinue) const;
+
+  GroupReader& getGroupReader() { return m_GroupReader; }
+
+private:
+  GroupReader& m_GroupReader;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/ScriptScanner.h b/include/mcld/Script/ScriptScanner.h
new file mode 100644
index 0000000..43897e5
--- /dev/null
+++ b/include/mcld/Script/ScriptScanner.h
@@ -0,0 +1,62 @@
+//===- ScriptScanner.h ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_SCRIPTSCANNER_H
+#define MCLD_SCRIPT_SCRIPTSCANNER_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#ifndef __FLEX_LEXER_H
+#include "FlexLexer.h"
+#endif
+
+#ifndef YY_DECL
+#define YY_DECL                                                       \
+  mcld::ScriptParser::token_type                                      \
+  mcld::ScriptScanner::lex(mcld::ScriptParser::semantic_type* yylval, \
+                           mcld::ScriptParser::location_type* yylloc, \
+                           const mcld::ScriptFile& pScriptFile)
+#endif
+
+#include <mcld/Script/ScriptFile.h>
+#include "ScriptParser.h"
+#include <stack>
+
+namespace mcld {
+
+/** \class ScriptScanner
+ *
+ */
+class ScriptScanner : public yyFlexLexer
+{
+public:
+  ScriptScanner(std::istream* yyin = NULL, std::ostream* yyout = NULL);
+
+  virtual ~ScriptScanner();
+
+  virtual ScriptParser::token_type lex(ScriptParser::semantic_type* yylval,
+                                       ScriptParser::location_type* yylloc,
+                                       const ScriptFile& pScriptFile);
+
+  void setLexState(ScriptFile::Kind pKind);
+
+  void popLexState();
+
+private:
+  void enterComments(ScriptParser::location_type& pLocation);
+
+private:
+  ScriptFile::Kind m_Kind;
+  std::stack<ScriptFile::Kind> m_StateStack;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/SearchDirCmd.h b/include/mcld/Script/SearchDirCmd.h
new file mode 100644
index 0000000..f695a76
--- /dev/null
+++ b/include/mcld/Script/SearchDirCmd.h
@@ -0,0 +1,49 @@
+//===- SearchDirCmd.h -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_SEARCHDIRCMD_H
+#define MCLD_SCRIPT_SEARCHDIRCMD_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <string>
+
+namespace mcld
+{
+
+class Module;
+
+/** \class SearchDirCmd
+ *  \brief This class defines the interfaces to SEARCH_DIR command.
+ */
+
+class SearchDirCmd : public ScriptCommand
+{
+public:
+  SearchDirCmd(const std::string& pPath);
+  ~SearchDirCmd();
+
+  void dump() const;
+
+  void activate(Module& pModule);
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::SEARCH_DIR;
+  }
+
+private:
+  std::string m_Path;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/SectionsCmd.h b/include/mcld/Script/SectionsCmd.h
new file mode 100644
index 0000000..afff1b1
--- /dev/null
+++ b/include/mcld/Script/SectionsCmd.h
@@ -0,0 +1,72 @@
+//===- SectionsCmd.h ------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_SECTIONSCMD_H
+#define MCLD_SCRIPT_SECTIONSCMD_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/ScriptCommand.h>
+#include <llvm/Support/DataTypes.h>
+#include <vector>
+
+namespace mcld
+{
+
+class Module;
+
+/** \class SectionsCmd
+ *  \brief This class defines the interfaces to SECTIONS command.
+ */
+
+class SectionsCmd : public ScriptCommand
+{
+public:
+  typedef std::vector<ScriptCommand*> SectionCommands;
+  typedef SectionCommands::const_iterator const_iterator;
+  typedef SectionCommands::iterator iterator;
+  typedef SectionCommands::const_reference const_reference;
+  typedef SectionCommands::reference reference;
+
+public:
+  SectionsCmd();
+  ~SectionsCmd();
+
+  const_iterator  begin() const { return m_SectionCommands.begin(); }
+  iterator        begin()       { return m_SectionCommands.begin(); }
+  const_iterator  end()   const { return m_SectionCommands.end(); }
+  iterator        end()         { return m_SectionCommands.end(); }
+
+  const_reference front() const { return m_SectionCommands.front(); }
+  reference       front()       { return m_SectionCommands.front(); }
+  const_reference back()  const { return m_SectionCommands.back(); }
+  reference       back()        { return m_SectionCommands.back(); }
+
+  size_t size() const { return m_SectionCommands.size(); }
+
+  bool empty() const { return m_SectionCommands.empty(); }
+
+  void dump() const;
+
+  static bool classof(const ScriptCommand* pCmd)
+  {
+    return pCmd->getKind() == ScriptCommand::SECTIONS;
+  }
+
+  void activate(Module& pModule);
+
+  void push_back(ScriptCommand* pCommand);
+
+private:
+  SectionCommands m_SectionCommands;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Script/StrToken.h b/include/mcld/Script/StrToken.h
new file mode 100644
index 0000000..359b0be
--- /dev/null
+++ b/include/mcld/Script/StrToken.h
@@ -0,0 +1,67 @@
+//===- StrToken.h ---------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_STRTOKEN_H
+#define MCLD_SCRIPT_STRTOKEN_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Support/Allocators.h>
+#include <mcld/Config/Config.h>
+#include <string>
+
+namespace mcld
+{
+
+/** \class StrToken
+ *  \brief This class defines the interfaces to a element in EXCLUDE_FILE list
+ *         or in Output Section Phdr, or be a base class of other str token.
+ */
+
+class StrToken
+{
+public:
+  enum Kind {
+    Unknown,
+    String,
+    Input,
+    Wildcard
+  };
+
+private:
+  friend class Chunk<StrToken, MCLD_SYMBOLS_PER_INPUT>;
+protected:
+  StrToken();
+  StrToken(Kind pKind, const std::string& pString);
+
+public:
+  virtual ~StrToken();
+
+  Kind kind() const { return m_Kind; }
+
+  const std::string& name() const { return m_Name; }
+
+  static bool classof(const StrToken* pToken)
+  {
+    return pToken->kind() == StrToken::String;
+  }
+
+  /* factory method */
+  static StrToken* create(const std::string& pString);
+  static void destroy(StrToken*& pToken);
+  static void clear();
+
+private:
+  Kind m_Kind;
+  std::string m_Name;
+};
+
+} // namepsace of mcld
+
+#endif
diff --git a/include/mcld/Script/StringList.h b/include/mcld/Script/StringList.h
new file mode 100644
index 0000000..da27e41
--- /dev/null
+++ b/include/mcld/Script/StringList.h
@@ -0,0 +1,72 @@
+//===- StringList.h -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_STRINGLIST_H
+#define MCLD_SCRIPT_STRINGLIST_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Config/Config.h>
+#include <mcld/Support/Allocators.h>
+#include <vector>
+
+namespace mcld
+{
+
+class StrToken;
+
+/** \class StringList
+ *  \brief This class defines the interfaces to StringList.
+ */
+
+class StringList
+{
+public:
+  typedef std::vector<StrToken*> Tokens;
+  typedef Tokens::const_iterator const_iterator;
+  typedef Tokens::iterator iterator;
+  typedef Tokens::const_reference const_reference;
+  typedef Tokens::reference reference;
+
+private:
+  friend class Chunk<StringList, MCLD_SYMBOLS_PER_INPUT>;
+  StringList();
+
+public:
+  ~StringList();
+
+  const_iterator  begin() const { return m_Tokens.begin(); }
+  iterator        begin()       { return m_Tokens.begin(); }
+  const_iterator  end()   const { return m_Tokens.end(); }
+  iterator        end()         { return m_Tokens.end(); }
+
+  const_reference front() const { return m_Tokens.front(); }
+  reference       front()       { return m_Tokens.front(); }
+  const_reference back()  const { return m_Tokens.back(); }
+  reference       back()        { return m_Tokens.back(); }
+
+  bool empty() const { return m_Tokens.empty(); }
+
+  void push_back(StrToken* pToken);
+
+  void dump() const;
+
+  /* factory methods */
+  static StringList* create();
+  static void destroy(StringList*& pStringList);
+  static void clear();
+
+private:
+  Tokens m_Tokens;
+};
+
+} // namepsace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/TernaryOp.h b/include/mcld/Script/TernaryOp.h
new file mode 100644
index 0000000..0517b4a
--- /dev/null
+++ b/include/mcld/Script/TernaryOp.h
@@ -0,0 +1,71 @@
+//===- TernaryOp.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_TERNARYOP_H
+#define MCLD_SCRIPT_TERNARYOP_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/Operator.h>
+#include <cstddef>
+
+namespace mcld
+{
+
+class Operand;
+class IntOperand;
+class Module;
+class TargetLDBackend;
+
+/** \class TernaryOP
+ *  \brief This class defines the interfaces to an binary operator token.
+ */
+
+template<Operator::Type TYPE>
+class TernaryOp : public Operator
+{
+private:
+  friend class Operator;
+
+  TernaryOp()
+    : Operator(Operator::TERNARY, TYPE)
+  {
+    m_pOperand[0] = m_pOperand[1] = m_pOperand[2] = NULL;
+  }
+
+public:
+  ~TernaryOp()
+  {}
+
+  IntOperand* eval(const Module& pModule, const TargetLDBackend& pBackend);
+
+  void appendOperand(Operand* pOperand)
+  {
+    m_pOperand[m_Size++] = pOperand;
+    if (m_Size == 3)
+      m_Size = 0;
+  }
+
+private:
+  size_t m_Size;
+  Operand* m_pOperand[3];
+};
+
+template<>
+IntOperand* TernaryOp<Operator::TERNARY_IF>::eval(const Module&,
+                                                  const TargetLDBackend&);
+
+template<>
+IntOperand*
+TernaryOp<Operator::DATA_SEGMENT_ALIGN>::eval(const Module&,
+                                              const TargetLDBackend&);
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Script/UnaryOp.h b/include/mcld/Script/UnaryOp.h
new file mode 100644
index 0000000..6b79b3c
--- /dev/null
+++ b/include/mcld/Script/UnaryOp.h
@@ -0,0 +1,102 @@
+//===- UnaryOp.h ----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_UNARYOP_H
+#define MCLD_SCRIPT_UNARYOP_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/Operator.h>
+#include <cstddef>
+
+namespace mcld
+{
+
+class Operand;
+class IntOperand;
+class Module;
+class TargetLDBackend;
+
+/** \class UnaryOp
+ *  \brief This class defines the interfaces to an unary operator token.
+ */
+
+template<Operator::Type TYPE>
+class UnaryOp : public Operator
+{
+private:
+  friend class Operator;
+
+  UnaryOp()
+    : Operator(Operator::UNARY, TYPE), m_pOperand(NULL)
+  {}
+
+public:
+  ~UnaryOp()
+  {}
+
+  IntOperand* eval(const Module& pModule, const TargetLDBackend& pBackend);
+
+  void appendOperand(Operand* pOperand)
+  {
+    m_pOperand = pOperand;
+  }
+
+private:
+  Operand* m_pOperand;
+};
+
+template<>
+IntOperand* UnaryOp<Operator::UNARY_PLUS>::eval(const Module&,
+                                                const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::UNARY_MINUS>::eval(const Module&,
+                                                 const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::LOGICAL_NOT>::eval(const Module&,
+                                                 const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::BITWISE_NOT>::eval(const Module&,
+                                                 const TargetLDBackend&);
+
+template<>
+IntOperand* UnaryOp<Operator::ABSOLUTE>::eval(const Module&,
+                                              const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::ADDR>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::ALIGNOF>::eval(const Module&,
+                                             const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::DATA_SEGMENT_END>::eval(const Module&,
+                                                      const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::DEFINED>::eval(const Module&,
+                                             const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::LENGTH>::eval(const Module&,
+                                            const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::LOADADDR>::eval(const Module&,
+                                              const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::NEXT>::eval(const Module&,
+                                          const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::ORIGIN>::eval(const Module&,
+                                            const TargetLDBackend&);
+template<>
+IntOperand* UnaryOp<Operator::SIZEOF>::eval(const Module&,
+                                            const TargetLDBackend&);
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Script/WildcardPattern.h b/include/mcld/Script/WildcardPattern.h
new file mode 100644
index 0000000..0c91435
--- /dev/null
+++ b/include/mcld/Script/WildcardPattern.h
@@ -0,0 +1,71 @@
+//===- WildcardPattern.h --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SCRIPT_WILDCARDPATTERN_H
+#define MCLD_SCRIPT_WILDCARDPATTERN_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Script/StrToken.h>
+#include <mcld/Support/Allocators.h>
+#include <mcld/Config/Config.h>
+#include <llvm/ADT/StringRef.h>
+
+namespace mcld
+{
+
+/** \class WildcardPattern
+ *  \brief This class defines the interfaces to Input Section Wildcard Patterns
+ */
+
+class WildcardPattern : public StrToken
+{
+public:
+  enum SortPolicy {
+    SORT_NONE,
+    SORT_BY_NAME,
+    SORT_BY_ALIGNMENT,
+    SORT_BY_NAME_ALIGNMENT,
+    SORT_BY_ALIGNMENT_NAME,
+    SORT_BY_INIT_PRIORITY
+  };
+
+private:
+  friend class Chunk<WildcardPattern, MCLD_SYMBOLS_PER_INPUT>;
+  WildcardPattern();
+  WildcardPattern(const std::string& pPattern, SortPolicy pPolicy);
+
+public:
+  ~WildcardPattern();
+
+  SortPolicy sortPolicy() const { return m_SortPolicy; }
+
+  bool isPrefix() const { return m_bIsPrefix; }
+
+  llvm::StringRef prefix() const;
+
+  static bool classof(const StrToken* pToken)
+  {
+    return pToken->kind() == StrToken::Wildcard;
+  }
+
+  /* factory method */
+  static WildcardPattern* create(const std::string& pPattern,
+                                 SortPolicy pPolicy);
+  static void destroy(WildcardPattern*& pToken);
+  static void clear();
+
+private:
+  SortPolicy m_SortPolicy;
+  bool m_bIsPrefix;
+};
+
+} // namepsace of mcld
+
+#endif
diff --git a/include/mcld/Support/CommandLine.h b/include/mcld/Support/CommandLine.h
index 00907fe..6cb0fae 100644
--- a/include/mcld/Support/CommandLine.h
+++ b/include/mcld/Support/CommandLine.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_COMMANDLINE_H
-#define MCLD_COMMANDLINE_H
+#ifndef MCLD_SUPPORT_COMMANDLINE_H
+#define MCLD_SUPPORT_COMMANDLINE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/DefSymParser.h b/include/mcld/Support/DefSymParser.h
deleted file mode 100644
index a721b48..0000000
--- a/include/mcld/Support/DefSymParser.h
+++ /dev/null
@@ -1,34 +0,0 @@
-//===- DefSymParser.h -----------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_DEFSYM_PARSER_H
-#define MCLD_DEFSYM_PARSER_H
-
-#include <mcld/Module.h>
-#include <llvm/ADT/StringRef.h>
-
-namespace mcld {
-
-/** \class DefSymParser
- *  \brief DefSymParser parses --defsym option.
- */
-class DefSymParser
-{
-public:
-  DefSymParser(const Module& pModule);
-
-  // parse a valid expression and set the value in the second parameter
-  bool parse(llvm::StringRef, uint64_t&);
-
-private:
-  const Module& m_Module;
-};
-
-} // mcld
-
-#endif
diff --git a/include/mcld/Support/Directory.h b/include/mcld/Support/Directory.h
index 66ba118..2bf8f06 100644
--- a/include/mcld/Support/Directory.h
+++ b/include/mcld/Support/Directory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_DIRECTORY_H
-#define MCLD_DIRECTORY_H
+#ifndef MCLD_SUPPORT_DIRECTORY_H
+#define MCLD_SUPPORT_DIRECTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/FileHandle.h b/include/mcld/Support/FileHandle.h
index f9fe73a..9f551b9 100644
--- a/include/mcld/Support/FileHandle.h
+++ b/include/mcld/Support/FileHandle.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_FILE_HANDLE_H
-#define MCLD_FILE_HANDLE_H
+#ifndef MCLD_SUPPORT_FILEHANDLE_H
+#define MCLD_SUPPORT_FILEHANDLE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/FileOutputBuffer.h b/include/mcld/Support/FileOutputBuffer.h
new file mode 100644
index 0000000..a49ffb7
--- /dev/null
+++ b/include/mcld/Support/FileOutputBuffer.h
@@ -0,0 +1,72 @@
+//===- FileOutputBuffer.h -------------------------------------------------===//
+//
+//                     the mclinker project
+//
+// this file is distributed under the university of illinois open source
+// license. see license.txt for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SUPPORT_FILEOUTPUTBUFFER_H
+#define MCLD_SUPPORT_FILEOUTPUTBUFFER_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Support/MemoryRegion.h>
+#include <llvm/ADT/OwningPtr.h>
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/DataTypes.h>
+#include <llvm/Support/FileSystem.h>
+#include <llvm/Support/system_error.h>
+
+namespace mcld {
+
+class FileHandle;
+
+/// FileOutputBuffer - This interface is borrowed from llvm bassically, and we
+/// may use ostream to emit output later.
+class FileOutputBuffer {
+public:
+  /// Factory method to create an OutputBuffer object which manages a read/write
+  /// buffer of the specified size. When committed, the buffer will be written
+  /// to the file at the specified path.
+  static llvm::error_code create(FileHandle& pFileHandle,
+                                 size_t pSize,
+                                 llvm::OwningPtr<FileOutputBuffer>& pResult);
+
+  /// Returns a pointer to the start of the buffer.
+  uint8_t* getBufferStart() {
+    return (uint8_t*)m_pRegion->data();
+  }
+
+  /// Returns a pointer to the end of the buffer.
+  uint8_t* getBufferEnd() {
+    return (uint8_t*)m_pRegion->data() + m_pRegion->size();
+  }
+
+  /// Returns size of the buffer.
+  size_t getBufferSize() const {
+    return m_pRegion->size();
+  }
+
+  MemoryRegion request(size_t pOffset, size_t pLength);
+
+  /// Returns path where file will show up if buffer is committed.
+  llvm::StringRef getPath() const;
+
+  ~FileOutputBuffer();
+
+private:
+  FileOutputBuffer(const FileOutputBuffer &);
+  FileOutputBuffer &operator=(const FileOutputBuffer &);
+
+  FileOutputBuffer(llvm::sys::fs::mapped_file_region* pRegion,
+                   FileHandle& pFileHandle);
+
+  llvm::OwningPtr<llvm::sys::fs::mapped_file_region> m_pRegion;
+  FileHandle& m_FileHandle;
+};
+
+} // namespace mcld
+
+#endif
diff --git a/include/mcld/Support/FileSystem.h b/include/mcld/Support/FileSystem.h
index 927346e..e0dddd7 100644
--- a/include/mcld/Support/FileSystem.h
+++ b/include/mcld/Support/FileSystem.h
@@ -11,8 +11,8 @@
 // path class.
 //===----------------------------------------------------------------------===//
 
-#ifndef MCLD_FILE_SYSTEM_H
-#define MCLD_FILE_SYSTEM_H
+#ifndef MCLD_SUPPORT_FILESYSTEM_H
+#define MCLD_SUPPORT_FILESYSTEM_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/GCFactory.h b/include/mcld/Support/GCFactory.h
index 6679f41..9ae8650 100644
--- a/include/mcld/Support/GCFactory.h
+++ b/include/mcld/Support/GCFactory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_GC_FACTORY_H
-#define MCLD_GC_FACTORY_H
+#ifndef MCLD_SUPPORT_GCFACTORY_H
+#define MCLD_SUPPORT_GCFACTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/GCFactoryListTraits.h b/include/mcld/Support/GCFactoryListTraits.h
index 986f6f6..b7d44d3 100644
--- a/include/mcld/Support/GCFactoryListTraits.h
+++ b/include/mcld/Support/GCFactoryListTraits.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_GC_FACTORY_LIST_TRAITS_H
-#define MCLD_GC_FACTORY_LIST_TRAITS_H
+#ifndef MCLD_SUPPORT_GCFACTORYLISTTRAITS_H
+#define MCLD_SUPPORT_GCFACTORYLISTTRAITS_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/HandleToArea.h b/include/mcld/Support/HandleToArea.h
deleted file mode 100644
index 8c24db7..0000000
--- a/include/mcld/Support/HandleToArea.h
+++ /dev/null
@@ -1,118 +0,0 @@
-//===- HandleToArea.h -----------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_FILE_HANDLE_TO_MEMORY_AREA_H
-#define MCLD_FILE_HANDLE_TO_MEMORY_AREA_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-#include <mcld/ADT/Uncopyable.h>
-#include <mcld/ADT/TypeTraits.h>
-#include <mcld/ADT/StringHash.h>
-#include <mcld/Support/Path.h>
-#include <mcld/Support/FileHandle.h>
-#include <vector>
-
-namespace mcld {
-
-class MemoryArea;
-
-/** \class HandleToArea
- *
- *  Special double-key associative container. Keys are Path and file handler,
- *  associative value is MemoryArea.
- *
- *  For high performance, HandleToArea is not designed to contain unique
- *  <key, value> pair. The key and value may be duplicated.
- *
- *  Like FileHandle, HandleToArea should neither throw exception nor call
- *  expressive diagnostic.
- */
-class HandleToArea : private Uncopyable
-{
-private:
-  struct Bucket {
-    unsigned int hash_value;
-    FileHandle* handle;
-    MemoryArea* area;
-  };
-
-  // the best data structure is a binary search tree.
-  // However, by the shrinking time-to-market constraint, I used
-  // vector and sequential search here.
-  typedef std::vector<Bucket> HandleToAreaMap;
-
-  typedef hash::StringHash<hash::BKDR> HashFunction;
-
-public:
-  typedef HandleToAreaMap::iterator iterator;
-  typedef HandleToAreaMap::const_iterator const_iterator;
-
-public:
-  struct Result {
-  public:
-    Result(FileHandle* pHandle, MemoryArea* pArea)
-      : handle(pHandle), area(pArea) { }
-
-  public:
-    FileHandle* handle;
-    MemoryArea* area;
-  };
-
-  struct ConstResult {
-  public:
-    ConstResult(const FileHandle* pHandle, const MemoryArea* pArea)
-      : handle(pHandle), area(pArea) { }
-
-  public:
-    const FileHandle* handle;
-    const MemoryArea* area;
-  };
-
-public:
-  bool push_back(FileHandle* pHandle, MemoryArea* pArea);
-
-  bool erase(MemoryArea* pArea);
-
-  bool erase(const sys::fs::Path& pPath);
-
-  Result findFirst(const sys::fs::Path& pPath);
-
-  ConstResult findFirst(const sys::fs::Path& pPath) const;
-
-  iterator begin()
-  { return m_AreaMap.begin(); }
-
-  iterator end()
-  { return m_AreaMap.end(); }
-
-  const_iterator begin() const
-  { return m_AreaMap.begin(); }
-
-  const_iterator end() const
-  { return m_AreaMap.end(); }
-
-  // -----  capacity  ----- //
-  bool empty() const
-  { return m_AreaMap.empty(); }
-
-  size_t size() const
-  { return m_AreaMap.size(); }
-
-  HandleToArea() : m_AreaMap() { }
-
-  ~HandleToArea() { }
-
-private:
-  HandleToAreaMap m_AreaMap;
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Support/LEB128.h b/include/mcld/Support/LEB128.h
index 816ed72..e44966a 100644
--- a/include/mcld/Support/LEB128.h
+++ b/include/mcld/Support/LEB128.h
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef MCLD_LEB128_H
-#define MCLD_LEB128_H
+#ifndef MCLD_SUPPORT_LEB128_H
+#define MCLD_SUPPORT_LEB128_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/MemoryArea.h b/include/mcld/Support/MemoryArea.h
index d3ae9b7..18ea985 100644
--- a/include/mcld/Support/MemoryArea.h
+++ b/include/mcld/Support/MemoryArea.h
@@ -6,43 +6,22 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SUPPORT_MEMORY_AREA_H
-#define MCLD_SUPPORT_MEMORY_AREA_H
+#ifndef MCLD_SUPPORT_MEMORYAREA_H
+#define MCLD_SUPPORT_MEMORYAREA_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 
 #include <mcld/ADT/Uncopyable.h>
-#include <cstddef>
-#include <map>
 
-#if defined(ENABLE_UNITTEST)
-namespace mcldtest {
-  class MemoryAreaTest;
-} // namespace of mcldtest
-#endif
+#include <llvm/ADT/OwningPtr.h>
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/MemoryBuffer.h>
 
 namespace mcld {
 
-class Space;
-class FileHandle;
-class MemoryRegion;
-
 /** \class MemoryArea
- *  \brief MemoryArea is used to manage distinct MemoryRegions of address space.
- *
- *  Good linkers must well manipulate memory mapped I/O and dynamic memory.
- *  In MCLinker, MemoryArea is the decision-maker to use memory mapped I/O or
- *  dynamic memory. When a client requests MemoryArea for a piece of memory
- *  to hold a part of a file, MemoryArea is going to see whether the requested
- *  part of the file is already in any existing memory which is requested
- *  before. If it is, MemoryArea creates a new MemoryRegion within the memory
- *  requested before. Otherwise, MemoryArea uses memory mapped I/O or dynamic
- *  memory to load the file.
- *
- *  If the part a file being loaded is larger than 3/4 pages, MemoryArea uses
- *  memory mapped I/O to load the file. Otherwise, MemoryArea uses dynamic
- *  memory to read the content of file into the memory space.
+ *  \brief MemoryArea is used to manage input read-only memory space.
  */
 class MemoryArea : private Uncopyable
 {
@@ -52,72 +31,22 @@
   // If the given file handler is read-only, client can not request a region
   // that out of the file size.
   // @param pFileHandle - file handler
-  explicit MemoryArea(FileHandle& pFileHandle);
+  explicit MemoryArea(llvm::StringRef pFilename);
 
-  // constructor by set universal space.
-  // Client can not request a region that out of the universal space.
-  // @param pUniverse - file handler
-  explicit MemoryArea(Space& pUniverse);
-
-  // destructor
-  ~MemoryArea();
+  explicit MemoryArea(const char* pMemBuffer, size_t pSize);
 
   // request - create a MemoryRegion within a sufficient space
   // find an existing space to hold the MemoryRegion.
   // if MemoryArea does not find such space, then it creates a new space and
   // assign a MemoryRegion into the space.
-  MemoryRegion* request(size_t pOffset, size_t pLength);
+  llvm::StringRef request(size_t pOffset, size_t pLength);
 
-  // release - release a MemoryRegion.
-  // release a MemoryRegion does not cause
-  void release(MemoryRegion* pRegion);
-
-  // clear - release all memory regions.
-  void clear();
-
-  const FileHandle* handler() const { return m_pFileHandle; }
-  FileHandle*       handler()       { return m_pFileHandle; }
-
-  bool hasHandler() const { return (NULL != m_pFileHandle); }
-
-  // -----  space list methods  ----- //
-  Space* find(size_t pOffset, size_t pLength);
-
-  const Space* find(size_t pOffset, size_t pLength) const;
+  size_t size() const;
 
 private:
-  class Key {
-  public:
-    Key(size_t pOffset, size_t pLength)
-    : m_Offset(pOffset), m_Length(pLength)
-    { }
-
-    size_t offset() const { return m_Offset; }
-
-    size_t length() const { return m_Length; }
-
-    struct Compare {
-      bool operator()(const Key& KEY1, const Key& KEY2) const
-      {
-        return KEY1.offset() + KEY1.length() < KEY2.offset() ||
-               (KEY1.offset() < KEY2.offset() &&
-                (KEY1.offset() + KEY1.length() < KEY2.offset() + KEY2.length()));
-      }
-    };
-
-  private:
-    size_t m_Offset;
-    size_t m_Length;
-  };
-
-  typedef std::multimap<Key, Space*, Key::Compare> SpaceMapType;
-
-private:
-  SpaceMapType m_SpaceMap;
-  FileHandle* m_pFileHandle;
+  llvm::OwningPtr<llvm::MemoryBuffer> m_pMemoryBuffer;
 };
 
 } // namespace of mcld
 
 #endif
-
diff --git a/include/mcld/Support/MemoryAreaFactory.h b/include/mcld/Support/MemoryAreaFactory.h
index b28f096..302fbd1 100644
--- a/include/mcld/Support/MemoryAreaFactory.h
+++ b/include/mcld/Support/MemoryAreaFactory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SUPPORT_MEMORY_AREA_FACTORY_H
-#define MCLD_SUPPORT_MEMORY_AREA_FACTORY_H
+#ifndef MCLD_SUPPORT_MEMORYAREAFACTORY_H
+#define MCLD_SUPPORT_MEMORYAREAFACTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -15,7 +15,7 @@
 #include <mcld/Support/MemoryArea.h>
 #include <mcld/Support/Path.h>
 #include <mcld/Support/FileHandle.h>
-#include <mcld/Support/HandleToArea.h>
+#include <llvm/ADT/StringMap.h>
 
 namespace mcld
 {
@@ -63,12 +63,10 @@
   MemoryArea* produce(int pFD, FileHandle::OpenMode pMode);
 
   void destruct(MemoryArea* pArea);
-
 private:
-  HandleToArea m_HandleToArea;
+  llvm::StringMap<MemoryArea*> m_AreaMap;
 };
 
 } // namespace of mcld
 
 #endif
-
diff --git a/include/mcld/Support/MemoryRegion.h b/include/mcld/Support/MemoryRegion.h
index 0984873..0d18f59 100644
--- a/include/mcld/Support/MemoryRegion.h
+++ b/include/mcld/Support/MemoryRegion.h
@@ -6,112 +6,24 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef LD_MEMORY_REGION_H
-#define LD_MEMORY_REGION_H
+#ifndef MCLD_SUPPORT_MEMORYREGION_H
+#define MCLD_SUPPORT_MEMORYREGION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 
-#include <mcld/Config/Config.h>
-#include <mcld/ADT/Uncopyable.h>
-#include <mcld/Support/Allocators.h>
-#include <mcld/Support/Space.h>
+#include <mcld/ADT/TypeTraits.h>
+#include <llvm/ADT/ArrayRef.h>
+#include <llvm/Support/DataTypes.h>
 
 namespace mcld {
 
-class MemoryArea;
+typedef NonConstTraits<uint8_t>::pointer Address;
+typedef ConstTraits<uint8_t>::pointer ConstAddress;
 
-/** \class MemoryRegion
- *  \brief MemoryRegion is a range of virtual memory which is mapped onto a
- *  range of files which is opened by MemoryArea.
- *
- *  MemoryArea maps a file onto virtual memory. Clients can get a range of
- *  mapped memory space by requesting a MemoryRegion from MemoryArea, and
- *  read/write the mapped file through the MemoryRegion.
- *
- *  When two different MemoryRegion may overlap memory space, race condition
- *  may occurs. Clients must call MemoryRegion::sync() explicit to tell the
- *  MemoryArea when to synchronize the virtual memory space with the mapped
- *  file.
- */
-class MemoryRegion : private Uncopyable
-{
-friend class Chunk<MemoryRegion, MCLD_REGION_CHUNK_SIZE>;
-friend class RegionFactory;
-friend class MemoryArea;
+typedef llvm::ArrayRef<uint8_t> ConstMemoryRegion;
+typedef llvm::MutableArrayRef<uint8_t> MemoryRegion;
 
-public:
-  typedef Space::Address Address;
-  typedef Space::ConstAddress ConstAddress;
-
-private:
-  MemoryRegion();
-
-  MemoryRegion(const Address pVMAStart, size_t pSize);
-
-  ~MemoryRegion();
-
-  void setParent(Space& pSpace) { m_pParent = &pSpace; }
-
-public:
-  /// Create - To wrap a piece of memory and to create a new region.
-  /// This function wraps a piece of memory and to create a new region. Region
-  /// is just a wraper, it is not responsible for deallocate the given memory.
-  ///
-  /// @param pStart [in] The start address of a piece of memory
-  /// @param pSize  [in] The size of the given memory
-  static MemoryRegion* Create(void* pStart, size_t pSize);
-
-  /// Create - To wrap a piece of memory and to create a new region.
-  /// This function wraps a piece of memory and to create a new region. Region
-  /// is just a wraper, it is not responsible for deallocate the given memory.
-  ///
-  /// If a wrapped memory comes from a Space, then we say the space is the
-  /// parent of the region. pSpace is a memory counting container. It remembers
-  /// the number of regions in it. A space which has no region will be removed
-  /// quickly.
-  ///
-  /// The wrapped memory will be deallocated by Space when the space has no
-  /// region used it.
-  ///
-  /// @param pStart [in] The start address of a piece of memory
-  /// @param pSize  [in] The size of the given memory
-  /// @param pSpace [in] The parent space.
-  static MemoryRegion* Create(void* pStart, size_t pSize, Space& pSpace);
-
-  /// Destroy - To destroy the region
-  /// If the region has a parent space, it will be also remove from the space.
-  ///
-  /// @param pRegion [in, out] pRegion is set to NULL if the destruction is
-  /// success.
-  static void Destroy(MemoryRegion*& pRegion);
-
-  const Space* parent() const { return m_pParent; }
-  Space*       parent()       { return m_pParent; }
-
-  bool hasParent() const { return (NULL != m_pParent); }
-
-  ConstAddress start() const { return m_VMAStart; }
-  Address      start()       { return m_VMAStart; }
-
-  ConstAddress end() const { return m_VMAStart+m_Length; }
-  Address      end()       { return m_VMAStart+m_Length; }
-
-  size_t size() const { return m_Length; }
-
-  ConstAddress getBuffer(size_t pOffset = 0) const
-  { return m_VMAStart+pOffset; }
- 
-  Address getBuffer(size_t pOffset = 0)
-  { return m_VMAStart+pOffset; }
-
-private:
-  Space* m_pParent;
-  Address m_VMAStart;
-  size_t m_Length;
-};
-
-} // namespace of mcld
+} // namespace mcld
 
 #endif
-
diff --git a/include/mcld/Support/MsgHandling.h b/include/mcld/Support/MsgHandling.h
index d00132c..778ec68 100644
--- a/include/mcld/Support/MsgHandling.h
+++ b/include/mcld/Support/MsgHandling.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_MESSAGE_HANDLING_H
-#define MCLD_MESSAGE_HANDLING_H
+#ifndef MCLD_SUPPORT_MSGHANDLING_H
+#define MCLD_SUPPORT_MSGHANDLING_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/Path.h b/include/mcld/Support/Path.h
index 13e8ddb..fe7914e 100644
--- a/include/mcld/Support/Path.h
+++ b/include/mcld/Support/Path.h
@@ -10,8 +10,8 @@
 // filesystem (v3), but modified to remove exception handling and the
 // path class.
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_PATH_H
-#define MCLD_PATH_H
+#ifndef MCLD_SUPPORT_PATH_H
+#define MCLD_SUPPORT_PATH_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/PathCache.h b/include/mcld/Support/PathCache.h
index 50c6984..37857dc 100644
--- a/include/mcld/Support/PathCache.h
+++ b/include/mcld/Support/PathCache.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_PATHCACHE_H
-#define MCLD_PATHCACHE_H
+#ifndef MCLD_SUPPORT_PATHCACHE_H
+#define MCLD_SUPPORT_PATHCACHE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/RealPath.h b/include/mcld/Support/RealPath.h
index 6c0cd40..0369f25 100644
--- a/include/mcld/Support/RealPath.h
+++ b/include/mcld/Support/RealPath.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_REAL_PATH_H
-#define MCLD_REAL_PATH_H
+#ifndef MCLD_SUPPORT_REALPATH_H
+#define MCLD_SUPPORT_REALPATH_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/RegionFactory.h b/include/mcld/Support/RegionFactory.h
deleted file mode 100644
index fd90186..0000000
--- a/include/mcld/Support/RegionFactory.h
+++ /dev/null
@@ -1,42 +0,0 @@
-//===- RegionFactory.h ----------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_SUPPORT_REGION_FACTORY_H
-#define MCLD_SUPPORT_REGION_FACTORY_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-#include <mcld/Config/Config.h>
-#include <mcld/Support/GCFactory.h>
-#include <mcld/Support/MemoryRegion.h>
-
-namespace mcld {
-
-class MemoryArea;
-
-/** \class RegionFactory
- *  \brief RegionFactory produces and destroys MemoryRegions
- *
- */
-class RegionFactory : public GCFactory<MemoryRegion, MCLD_REGION_CHUNK_SIZE>
-{
-public:
-  typedef GCFactory<MemoryRegion, MCLD_REGION_CHUNK_SIZE> Alloc;
-  typedef MemoryRegion::Address Address;
-  typedef MemoryRegion::ConstAddress ConstAddress;
-
-public:
-  MemoryRegion* produce(Address pVMAStart, size_t pSize);
-
-  void destruct(MemoryRegion* pRegion);
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Support/Space.h b/include/mcld/Support/Space.h
deleted file mode 100644
index cdf69b0..0000000
--- a/include/mcld/Support/Space.h
+++ /dev/null
@@ -1,99 +0,0 @@
-//===- Space.h ------------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_MEMORY_SPACE_H
-#define MCLD_MEMORY_SPACE_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-#include <llvm/Support/DataTypes.h>
-#include <mcld/ADT/TypeTraits.h>
-
-namespace mcld {
-
-class FileHandle;
-class MemoryRegion;
-
-/** \class Space
- *  \brief Space contains a chunk of memory space that does not overlap with
- *  the other Space.
- *
- */
-class Space
-{
-public:
-  enum Type
-  {
-    ALLOCATED_ARRAY,
-    MMAPED,
-    EXTERNAL,
-    UNALLOCATED
-  };
-
-  typedef NonConstTraits<uint8_t>::pointer Address;
-  typedef ConstTraits<uint8_t>::pointer ConstAddress;
-
-private:
-  Space();
-
-  ~Space();
-
-  Space(Type pType, void* pMemBuffer, size_t pSize);
-
-public:
-  void setStart(size_t pOffset)
-  { m_StartOffset = pOffset; }
-
-  Address memory()
-  { return m_Data; }
-
-  ConstAddress memory() const
-  { return m_Data; }
-
-  size_t start() const
-  { return m_StartOffset; }
-
-  size_t size() const
-  { return m_Size; }
-
-  Type type() const
-  { return m_Type; }
-
-  void addRegion(MemoryRegion& pRegion)
-  { ++m_RegionCount; }
-
-  void removeRegion(MemoryRegion& pRegion)
-  { --m_RegionCount; }
-
-  size_t numOfRegions() const
-  { return m_RegionCount; }
-
-  /// Create - Create a Space from external memory
-  static Space* Create(void* pMemBuffer, size_t pSize);
-
-  /// Create - Create a Space from FileHandler
-  static Space* Create(FileHandle& pHandler, size_t pOffset, size_t pSize);
-
-  static void Destroy(Space*& pSpace);
-  
-  static void Release(Space* pSpace, FileHandle& pHandler);
-
-  static void Sync(Space* pSpace, FileHandle& pHandler);
-
-private:
-  Address m_Data;
-  uint32_t m_StartOffset;
-  uint32_t m_Size;
-  uint16_t m_RegionCount;
-  Type m_Type : 2;
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Support/SystemUtils.h b/include/mcld/Support/SystemUtils.h
index 8f8507a..f15fccf 100644
--- a/include/mcld/Support/SystemUtils.h
+++ b/include/mcld/Support/SystemUtils.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SYSTEM_UTILS_H
-#define MCLD_SYSTEM_UTILS_H
+#ifndef MCLD_SUPPORT_SYSTEMUTILS_H
+#define MCLD_SUPPORT_SYSTEMUTILS_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/Target.h b/include/mcld/Support/Target.h
new file mode 100644
index 0000000..021fc2e
--- /dev/null
+++ b/include/mcld/Support/Target.h
@@ -0,0 +1,105 @@
+//===- Target.h -----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_SUPPORT_TARGET_H
+#define MCLD_SUPPORT_TARGET_H
+#include <string>
+#include <list>
+
+namespace llvm {
+class Target;
+class Triple;
+class TargetMachine;
+} // namespace of llvm
+
+namespace mcld {
+
+class MCLDTargetMachine;
+class TargetRegistry;
+class MCLinker;
+class LinkerScript;
+class LinkerConfig;
+class Module;
+class FileHandle;
+class DiagnosticLineInfo;
+class TargetLDBackend;
+
+/** \class Target
+ *  \brief Target collects target specific information
+ */
+class Target
+{
+  friend class mcld::MCLDTargetMachine;
+  friend class mcld::TargetRegistry;
+
+public:
+  typedef unsigned int (*TripleMatchQualityFnTy)(const llvm::Triple& pTriple);
+
+  typedef MCLDTargetMachine *(*TargetMachineCtorTy)(const llvm::Target &,
+                                                    const mcld::Target &,
+                                                    llvm::TargetMachine &,
+                                                    const std::string&);
+
+  typedef MCLinker *(*MCLinkerCtorTy)(const std::string& pTriple,
+                                      LinkerConfig&,
+                                      Module&,
+                                      FileHandle& pFileHandle);
+
+  typedef bool (*EmulationFnTy)(LinkerScript&, LinkerConfig&);
+
+  typedef TargetLDBackend  *(*TargetLDBackendCtorTy)(const LinkerConfig&);
+
+  typedef DiagnosticLineInfo *(*DiagnosticLineInfoCtorTy)(const mcld::Target&,
+                                                          const std::string&);
+
+public:
+  Target();
+
+  /// getName - get the target name
+  const char* name() const { return Name; }
+
+  unsigned int getTripleQuality(const llvm::Triple& pTriple) const;
+
+  /// createTargetMachine - create target-specific TargetMachine
+  MCLDTargetMachine* createTargetMachine(const std::string& pTriple,
+                                         const llvm::Target& pTarget,
+                                         llvm::TargetMachine& pTM) const;
+
+  /// createMCLinker - create target-specific MCLinker
+  MCLinker *createMCLinker(const std::string &pTriple,
+                           LinkerConfig& pConfig,
+                           Module& pModule,
+                           FileHandle& pFileHandle) const;
+
+  /// emulate - given MCLinker default values for the other aspects of the
+  /// target system.
+  bool emulate(LinkerScript& pScript, LinkerConfig& pConfig) const;
+
+  /// createLDBackend - create target-specific LDBackend
+  TargetLDBackend* createLDBackend(const LinkerConfig& pConfig) const;
+
+  /// createDiagnosticLineInfo - create target-specific DiagnosticLineInfo
+  DiagnosticLineInfo* createDiagnosticLineInfo(const mcld::Target& pTarget,
+                                               const std::string& pTriple) const;
+
+private:
+  /// Name - The target name
+  const char* Name;
+
+  TripleMatchQualityFnTy TripleMatchQualityFn;
+  TargetMachineCtorTy TargetMachineCtorFn;
+  MCLinkerCtorTy MCLinkerCtorFn;
+  EmulationFnTy EmulationFn;
+  TargetLDBackendCtorTy TargetLDBackendCtorFn;
+  DiagnosticLineInfoCtorTy DiagnosticLineInfoCtorFn;
+};
+
+} //end namespace mcld
+
+#endif
+
diff --git a/include/mcld/Support/TargetRegistry.h b/include/mcld/Support/TargetRegistry.h
index aabb06d..1ae6245 100644
--- a/include/mcld/Support/TargetRegistry.h
+++ b/include/mcld/Support/TargetRegistry.h
@@ -6,9 +6,11 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TARGET_REGISTRY_H
-#define MCLD_TARGET_REGISTRY_H
-#include <llvm/Support/TargetRegistry.h>
+#ifndef MCLD_SUPPORT_TARGETREGISTRY_H
+#define MCLD_SUPPORT_TARGETREGISTRY_H
+#include <mcld/Support/Target.h>
+#include <llvm/ADT/Triple.h>
+
 #include <string>
 #include <list>
 
@@ -21,122 +23,9 @@
 
 namespace mcld {
 
-class Module;
-class LinkerConfig;
-class LinkerScript;
-class MemoryArea;
-class MCLDTargetMachine;
-class TargetRegistry;
-class MCLinker;
-class TargetLDBackend;
-class AttributeFactory;
-class InputFactory;
-class ContextFactory;
-class DiagnosticLineInfo;
-
-//===----------------------------------------------------------------------===//
-/// Target - mcld::Target is an object adapter of llvm::Target
-//===----------------------------------------------------------------------===//
-class Target
-{
-  friend class mcld::MCLDTargetMachine;
-  friend class mcld::TargetRegistry;
-public:
-  typedef mcld::MCLDTargetMachine *(*TargetMachineCtorTy)(const mcld::Target &,
-                                                          llvm::TargetMachine &,
-                                                          const std::string&);
-
-  typedef MCLinker *(*MCLinkerCtorTy)(const std::string& pTriple,
-                                      LinkerConfig&,
-                                      Module&,
-                                      MemoryArea& pOutput);
-
-  typedef bool (*EmulationFnTy)(LinkerScript&, LinkerConfig&);
-
-  typedef TargetLDBackend  *(*TargetLDBackendCtorTy)(const llvm::Target&,
-                                                     const LinkerConfig&);
-
-  typedef DiagnosticLineInfo *(*DiagnosticLineInfoCtorTy)(const mcld::Target&,
-                                                          const std::string&);
-
-public:
-  Target();
-
-  void setTarget(const llvm::Target& pTarget)
-  { m_pT = &pTarget; }
-
-  mcld::MCLDTargetMachine *createTargetMachine(const std::string &pTriple,
-                          const std::string &pCPU, const std::string &pFeatures,
-                          const llvm::TargetOptions &Options,
-                          llvm::Reloc::Model RM = llvm::Reloc::Default,
-                          llvm::CodeModel::Model CM = llvm::CodeModel::Default,
-                          llvm::CodeGenOpt::Level OL = llvm::CodeGenOpt::Default) const
-  {
-    if (TargetMachineCtorFn && m_pT) {
-      llvm::TargetMachine *tm = m_pT->createTargetMachine(pTriple, pCPU, pFeatures, Options, RM, CM, OL);
-      if (tm)
-        return TargetMachineCtorFn(*this, *tm, pTriple);
-    }
-    return NULL;
-  }
-
-  /// createMCLinker - create target-specific MCLinker
-  ///
-  /// @return created MCLinker
-  MCLinker *createMCLinker(const std::string &pTriple,
-                           LinkerConfig& pConfig,
-                           Module& pModule,
-                           MemoryArea& pOutput) const {
-    if (!MCLinkerCtorFn)
-      return NULL;
-    return MCLinkerCtorFn(pTriple, pConfig, pModule, pOutput);
-  }
-
-  /// emulate - given MCLinker default values for the other aspects of the
-  /// target system.
-  bool emulate(LinkerScript& pScript, LinkerConfig& pConfig) const {
-    if (!EmulationFn)
-      return false;
-    return EmulationFn(pScript, pConfig);
-  }
-
-  /// createLDBackend - create target-specific LDBackend
-  ///
-  /// @return created TargetLDBackend
-  TargetLDBackend* createLDBackend(const LinkerConfig& pConfig) const
-  {
-    if (!TargetLDBackendCtorFn)
-      return NULL;
-    return TargetLDBackendCtorFn(*get(), pConfig);
-  }
-
-  /// createDiagnosticLineInfo - create target-specific DiagnosticLineInfo
-  DiagnosticLineInfo* createDiagnosticLineInfo(const mcld::Target& pTarget,
-                                               const std::string& pTriple) const
-  {
-    if (!DiagnosticLineInfoCtorFn)
-      return NULL;
-    return DiagnosticLineInfoCtorFn(pTarget, pTriple);
-  }
-
-  const llvm::Target* get() const { return m_pT; }
-
-private:
-  // -----  function pointers  ----- //
-  TargetMachineCtorTy TargetMachineCtorFn;
-  MCLinkerCtorTy MCLinkerCtorFn;
-  EmulationFnTy EmulationFn;
-  TargetLDBackendCtorTy TargetLDBackendCtorFn;
-  DiagnosticLineInfoCtorTy DiagnosticLineInfoCtorFn;
-
-  // -----  adapted llvm::Target  ----- //
-  const llvm::Target* m_pT;
-};
-
-//===----------------------------------------------------------------------===//
-/// TargetRegistry - mcld::TargetRegistry is an object adapter of
-/// llvm::TargetRegistry
-///
+/** \class TargetRegistry
+ *  \brief TargetRegistry is an object adapter of llvm::TargetRegistry
+ */
 class TargetRegistry
 {
 public:
@@ -161,7 +50,9 @@
   /// this is done by initializing all targets at program startup.
   ///
   /// @param T - The target being registered.
-  static void RegisterTarget(mcld::Target &T);
+  static void RegisterTarget(Target& pTarget,
+                             const char* pName,
+                             Target::TripleMatchQualityFnTy pQualityFn);
 
   /// RegisterTargetMachine - Register a TargetMachine implementation for the
   /// given target.
@@ -221,16 +112,23 @@
       T.DiagnosticLineInfoCtorFn = Fn;
   }
 
-  /// lookupTarget - Lookup a target based on a llvm::Target.
-  ///
-  /// @param T - The llvm::Target to find
-  static const mcld::Target *lookupTarget(const llvm::Target& T);
-
-  /// lookupTarget - function wrapper of llvm::TargetRegistry::lookupTarget
+  /// lookupTarget - Look up MCLinker target
   ///
   /// @param Triple - The Triple string
   /// @param Error  - The returned error message
-  static const mcld::Target *lookupTarget(const std::string &Triple,
+  static const mcld::Target *lookupTarget(const std::string& pTriple,
+                                          std::string& pError);
+
+  /// lookupTarget - Look up MCLinker target by an architecture name
+  /// and a triple. If the architecture name is not empty, then the
+  /// the lookup is done mainly by architecture. Otherwise, the target
+  /// triple is used.
+  ///
+  /// @param pArch   - The architecture name
+  /// @param pTriple - The target triple
+  /// @param pError  - The returned error message
+  static const mcld::Target *lookupTarget(const std::string& pArchName,
+                                          llvm::Triple& pTriple,
                                           std::string &Error);
 };
 
@@ -240,22 +138,27 @@
 /// Target TheFooTarget; // The global target instance.
 ///
 /// extern "C" void MCLDInitializeFooTargetInfo() {
-///   RegisterTarget X(TheFooTarget, "foo", "Foo description");
+///   RegisterTarget<llvm::Foo> X(TheFooTarget, "foo", "Foo description");
 /// }
+template<llvm::Triple::ArchType TargetArchType = llvm::Triple::UnknownArch>
 struct RegisterTarget
 {
-  RegisterTarget(mcld::Target &T, const char *Name) {
-    llvm::TargetRegistry::iterator TIter, TEnd = llvm::TargetRegistry::end();
-    // lookup llvm::Target
-    for( TIter=llvm::TargetRegistry::begin(); TIter!=TEnd; ++TIter ) {
-      if( 0==strcmp(TIter->getName(), Name) )
-        break;
+public:
+  RegisterTarget(mcld::Target &pTarget, const char* pName) {
+    // if we've registered one, then return immediately.
+    TargetRegistry::iterator target, ie = TargetRegistry::end();
+    for (target = TargetRegistry::begin(); target != ie; ++target) {
+      if (0 == strcmp((*target)->name(), pName))
+        return;
     }
 
-    if (TIter != TEnd)
-      T.setTarget(*TIter);
+    TargetRegistry::RegisterTarget(pTarget, pName, &getTripleMatchQuality);
+  }
 
-    TargetRegistry::RegisterTarget(T);
+  static unsigned int getTripleMatchQuality(const llvm::Triple& pTriple) {
+    if (pTriple.getArch() == TargetArchType)
+      return 20;
+    return 0;
   }
 };
 
@@ -275,10 +178,11 @@
   }
 
 private:
-  static mcld::MCLDTargetMachine *Allocator(const mcld::Target &T,
-                                            llvm::TargetMachine& TM,
-                                            const std::string &Triple) {
-    return new TargetMachineImpl(TM, T, Triple);
+  static MCLDTargetMachine *Allocator(const llvm::Target& pLLVMTarget,
+                                      const mcld::Target& pMCLDTarget,
+                                      llvm::TargetMachine& pTM,
+                                      const std::string& pTriple) {
+    return new TargetMachineImpl(pTM, pLLVMTarget, pMCLDTarget, pTriple);
   }
 };
 
diff --git a/include/mcld/Support/TargetSelect.h b/include/mcld/Support/TargetSelect.h
index 7fcb74a..0b2be2a 100644
--- a/include/mcld/Support/TargetSelect.h
+++ b/include/mcld/Support/TargetSelect.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TARGET_SELECT_H
-#define MCLD_TARGET_SELECT_H
+#ifndef MCLD_SUPPORT_TARGETSELECT_H
+#define MCLD_SUPPORT_TARGETSELECT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/ToolOutputFile.h b/include/mcld/Support/ToolOutputFile.h
index 4dfc4e6..f1186c3 100644
--- a/include/mcld/Support/ToolOutputFile.h
+++ b/include/mcld/Support/ToolOutputFile.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_SUPPORT_TOOL_OUTPUT_FILE_H
-#define MCLD_SUPPORT_TOOL_OUTPUT_FILE_H
+#ifndef MCLD_SUPPORT_TOOLOUTPUTFILE_H
+#define MCLD_SUPPORT_TOOLOUTPUTFILE_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -23,12 +23,9 @@
 
 class Path;
 class FileHandle;
-class MemoryArea;
-class raw_mem_ostream;
 
 /** \class ToolOutputFile
- *  \brief ToolOutputFile contains a raw_mem_ostream and adds extra new
- *  features:
+ *  \brief ToolOutputFile has the following features:
  *   - The file is automatically deleted if the process is killed.
  *   - The file is automatically deleted when the TooOutputFile object is
  *     destoryed unless the client calls keep().
@@ -36,21 +33,21 @@
 class ToolOutputFile
 {
 public:
-  ToolOutputFile(const std::string& pPath,
+  ToolOutputFile(const sys::fs::Path& pPath,
                  FileHandle::OpenMode pMode,
                  FileHandle::Permission pPermission);
 
   ~ToolOutputFile();
 
-  /// mem_os - Return the contained raw_mem_ostream.
-  raw_mem_ostream &mem_os();
+  /// fd - Retutn the output file handle
+  FileHandle& fd() { return m_FileHandle; }
 
-  /// os - Return the contained formatted_raw_ostream
+  /// os - Return the contained raw_fd_ostream
+  llvm::raw_fd_ostream& os();
+
+  /// formatted_os - Return the contained formatted_raw_ostream
   llvm::formatted_raw_ostream& formatted_os();
 
-  /// memory - Return the contained MemoryArea.
-  MemoryArea& memory();
-
   /// keep - Indicate that the tool's job wrt this output file has been
   /// successful and the file should not be deleted.
   void keep();
@@ -59,7 +56,7 @@
   class CleanupInstaller
   {
   public:
-    explicit CleanupInstaller(const std::string& pPath);
+    explicit CleanupInstaller(const sys::fs::Path& pPath);
 
     ~CleanupInstaller();
 
@@ -67,19 +64,16 @@
     bool Keep;
 
   private:
-    std::string m_Path;
+    sys::fs::Path m_Path;
   }; 
 
 private:
   FileHandle m_FileHandle;
   CleanupInstaller m_Installer;
-  MemoryArea* m_pMemoryArea;
-  raw_mem_ostream* m_pOStream;
-  llvm::formatted_raw_ostream* m_pFOStream;
-
+  llvm::raw_fd_ostream* m_pFdOstream;
+  llvm::formatted_raw_ostream* m_pFormattedOstream;
 };
 
 } // namespace of mcld
 
 #endif
-
diff --git a/include/mcld/Support/UniqueGCFactory.h b/include/mcld/Support/UniqueGCFactory.h
index 3147bab..73c1110 100644
--- a/include/mcld/Support/UniqueGCFactory.h
+++ b/include/mcld/Support/UniqueGCFactory.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_UNIQUE_GCFACTORY_H
-#define MCLD_UNIQUE_GCFACTORY_H
+#ifndef MCLD_SUPPORT_UNIQUEGCFACTORY_H
+#define MCLD_SUPPORT_UNIQUEGCFACTORY_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Support/raw_mem_ostream.h b/include/mcld/Support/raw_mem_ostream.h
deleted file mode 100644
index b2db64a..0000000
--- a/include/mcld/Support/raw_mem_ostream.h
+++ /dev/null
@@ -1,51 +0,0 @@
-//===- raw_mem_ostream.h --------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_RAW_MEMORY_AREA_OSTREAM_H
-#define MCLD_RAW_MEMORY_AREA_OSTREAM_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-#include <string>
-
-#include <llvm/Support/raw_ostream.h>
-
-namespace mcld {
-
-class MemoryArea;
-
-class raw_mem_ostream : public llvm::raw_ostream
-{
-public:
-  /// constructor - pMemoryArea must be writable.
-  explicit raw_mem_ostream(MemoryArea &pMemoryArea);
-
-  ~raw_mem_ostream();
-
-  MemoryArea& getMemoryArea() {
-    flush();
-    return m_MemoryArea;
-  }
-
-private:
-  /// write_impl - See raw_ostream::write_impl.
-  virtual void write_impl(const char *pPtr, size_t pSize);
-
-  /// current_pos - Return the current position within the stream, not
-  /// counting the bytes currently in the buffer.
-  virtual uint64_t current_pos() const;
-
-private:
-  MemoryArea& m_MemoryArea;
-  uint64_t m_Position;
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Support/raw_ostream.h b/include/mcld/Support/raw_ostream.h
index 0e2cc40..6274e49 100644
--- a/include/mcld/Support/raw_ostream.h
+++ b/include/mcld/Support/raw_ostream.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_RAW_OSTREAM_H
-#define MCLD_RAW_OSTREAM_H
+#ifndef MCLD_SUPPORT_RAWOSTREAM_H
+#define MCLD_SUPPORT_RAWOSTREAM_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Target/DarwinLDBackend.h b/include/mcld/Target/DarwinLDBackend.h
index d55055a..9003812 100644
--- a/include/mcld/Target/DarwinLDBackend.h
+++ b/include/mcld/Target/DarwinLDBackend.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef DARWINLDBACKEND_H
-#define DARWINLDBACKEND_H
+#ifndef MCLD_TARGET_DARWINLDBACKEND_H
+#define MCLD_TARGET_DARWINLDBACKEND_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Target/ELFAttribute.h b/include/mcld/Target/ELFAttribute.h
new file mode 100644
index 0000000..7d9d30d
--- /dev/null
+++ b/include/mcld/Target/ELFAttribute.h
@@ -0,0 +1,125 @@
+//===- ELFAttribute.h -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_ELFATTRIBUTE_H
+#define MCLD_TARGET_ELFATTRIBUTE_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Support/MemoryRegion.h>
+#include <mcld/Target/ELFAttributeData.h>
+
+#include <llvm/ADT/SmallVector.h>
+#include <llvm/ADT/StringRef.h>
+
+namespace mcld {
+
+class ELFAttributeData;
+class GNULDBackend;
+class Input;
+class LDSection;
+class LinkerConfig;
+
+/** \class ELFAttribute
+ *  \brief ELFAttribute is the attribute section in an ELF file.
+ */
+class ELFAttribute
+{
+public:
+  // ARM [ABI-addenda], 2.2.3.
+  static const char   FormatVersion = 'A';
+  static const size_t FormatVersionFieldSize = sizeof(FormatVersion); // a byte
+  static const size_t SubsectionLengthFieldSize = 4; // a 4-byte integer
+
+  // MinimalELFAttributeSubsectionSize is the minimal number of bytes a valid
+  // subsection in ELF attribute section should have.
+  static const size_t MinimalELFAttributeSubsectionSize
+      = 1 /* Tag_File, see ARM [ABI-addenda], 2.2.4 */ +
+        4 /* byte-size, see ARM [ABI-addenda], 2.2.4 */;
+
+  // MinimalELFAttributeSectionSize is the minimal number of bytes a valid ELF
+  // attribute section should have.
+  static const size_t MinimalELFAttributeSectionSize
+      = FormatVersionFieldSize + SubsectionLengthFieldSize +
+        2 /* vendor-name, a char plus '\0', see ARM [ABI-addenda], 2.2.3 */ +
+        1 * MinimalELFAttributeSubsectionSize;
+
+public:
+  ELFAttribute(const GNULDBackend &pBackend, const LinkerConfig& pConfig)
+    : m_Backend(pBackend), m_Config(pConfig) { }
+
+  ~ELFAttribute();
+
+public:
+  /// merge - merge attributes from input (attribute) section
+  bool merge(const Input &pInput, LDSection &pInputAttrSectHdr);
+
+  /// sizeOutput - calculate the number of bytes required to encode this
+  /// attribute data section
+  size_t sizeOutput() const;
+
+  /// emit - encode and write out this attribute section
+  size_t emit(MemoryRegion &pRegion) const;
+
+  inline const GNULDBackend &backend() const { return m_Backend; }
+
+  inline const LinkerConfig &config() const { return m_Config; }
+
+  // Place vendor's attribute data under the management.
+  void registerAttributeData(ELFAttributeData& pAttrData);
+
+private:
+  /** \class Subsection
+   *  \brief A helper class to wrap ELFAttributeData and to provide general
+   *  interfaces for ELFAttribute to operate on
+   */
+  class Subsection {
+  public:
+    Subsection(ELFAttribute &pParent, ELFAttributeData &pAttrData)
+      : m_Parent(pParent), m_AttrData(pAttrData) { }
+
+  public:
+    bool isMyAttribute(llvm::StringRef pVendorName) const
+    {
+      return (m_AttrData.getVendorName() == pVendorName);
+    }
+
+    /// merge -  Merge the attributes from the section in the input data.
+    bool merge(const Input &pInput, ConstAddress pData, size_t pSize);
+
+    /// sizeOutput - calculate the number of bytes required to encode this
+    /// subsection
+    size_t sizeOutput() const;
+
+    /// emit - write out this attribute subsection to the buffer.
+    size_t emit(char *pBuf) const;
+
+  private:
+    // The attribute section this subsection belongs to
+    ELFAttribute &m_Parent;
+
+    // The attribute data containing in this subsection
+    ELFAttributeData &m_AttrData;
+  };
+
+  // Obtain the corresponding subsection of the specified vendor
+  Subsection *getSubsection(llvm::StringRef pVendorName) const;
+
+private:
+  const GNULDBackend &m_Backend;
+
+  const LinkerConfig &m_Config;
+
+  // There is at most two subsections ("aeabi" and "gnu") in most cases.
+  llvm::SmallVector<Subsection*, 2> m_Subsections;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Target/ELFAttributeData.h b/include/mcld/Target/ELFAttributeData.h
new file mode 100644
index 0000000..1cb9ad7
--- /dev/null
+++ b/include/mcld/Target/ELFAttributeData.h
@@ -0,0 +1,114 @@
+//===- ELFAttributeData.h -------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_ELFATTRIBUTEDATA_H
+#define MCLD_TARGET_ELFATTRIBUTEDATA_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <stdint.h>
+#include <string>
+#include <utility>
+
+namespace mcld {
+
+class ELFAttributeValue;
+class Input;
+class LinkerConfig;
+
+/** \class ELFAttributeData
+ *  \brief ELFAttributeData handles data in vendor attribute subsection.
+ */
+class ELFAttributeData
+{
+public:
+  typedef uint32_t TagType;
+
+  // Generic attribute tags shared between all vendors
+  enum {
+    Tag_NULL          = 0,
+    Tag_File          = 1,
+    Tag_Section       = 2,
+    Tag_Symbol        = 3,
+  };
+
+public:
+  ELFAttributeData(const char* pVendor) : m_Vendor(pVendor) { }
+
+  virtual ~ELFAttributeData() { }
+
+public:
+  inline const std::string &getVendorName() const { return m_Vendor; }
+
+  /// getAttributeValue - query the data store for the attribute value of the
+  /// given tag.
+  virtual const ELFAttributeValue *getAttributeValue(TagType pTag) const = 0;
+
+  /// getOrCreateAttributeValue - obtain attribute value for the given tag and
+  /// create if it does not exist.
+  ///
+  /// It returns a pair containing the attribute value instance (guaranteed to
+  /// be non-NULL) and a boolean value indicating whether the instance is newly
+  /// created (true) or not (false.)
+  virtual std::pair<ELFAttributeValue*, bool>
+      getOrCreateAttributeValue(TagType pTag) = 0;
+
+  /// preMerge - hooks to call before starting merge the attribute data in an
+  /// input.
+  virtual bool preMerge(const Input &pInput) { return true; }
+
+  /// merge - implement logics to merge input attribute to the output.
+  virtual bool merge(const LinkerConfig& pConfig, const Input &pInput,
+                     TagType pTag, const ELFAttributeValue& pInAttr) = 0;
+
+  /// postMerge - hooks to call after finishing merge the attribute data from an
+  /// input.
+  virtual bool postMerge(const LinkerConfig& pConfig, const Input &pInput)
+  { return true; }
+
+  /// sizeOutput - obtain number of bytes required to encode the attribute data.
+  virtual size_t sizeOutput() const = 0;
+
+  /// emit - write out attribute data to the buffer and return the number of
+  /// bytes written
+  virtual size_t emit(char *pBuf) const = 0;
+
+public:
+  /// ReadTag - read an attribute tag from input buffer.
+  ///
+  /// If the read succeeds, pBuf moves to the new position just pass the end of
+  /// the tag in the buffer and pBufSize decreases the size of tag in the
+  /// buffer. Otherwise, this function will return false and change nothing
+  /// except leaving undefined value in pTag.
+  static bool ReadTag(TagType& pTag, const char* &pBuf, size_t &pBufSize);
+
+  /// ReadValue - read an attribute value from input buffer
+  ///
+  /// Similar with ReadTag() while this reads attribute value from the input
+  /// buffer. Note that the value type of the attribute must be properly set in
+  /// pValue prior the call.
+  static bool ReadValue(ELFAttributeValue& pValue, const char* &pBuf,
+                        size_t &pBufSize);
+
+  /// WriteAttribute - write an attribute tag plus value to buffer.
+  ///
+  /// On success, the pBuf moves to the new position just pass the end of the
+  /// attribute data just written. Otherwise, it returns false and leaves pBuf
+  /// in an undefined position. Note that buffer is guaranteed to be able to
+  /// contain the attribute data.
+  static bool WriteAttribute(TagType pTag, const ELFAttributeValue& pValue,
+                             char* &pBuf);
+
+private:
+  const std::string m_Vendor;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Target/ELFAttributeValue.h b/include/mcld/Target/ELFAttributeValue.h
new file mode 100644
index 0000000..0af3c97
--- /dev/null
+++ b/include/mcld/Target/ELFAttributeValue.h
@@ -0,0 +1,125 @@
+//===- ELFAttributeValue.h ------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_ELFATTRIBUTEVALUE_H
+#define MCLD_TARGET_ELFATTRIBUTEVALUE_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <string>
+
+namespace mcld
+{
+
+/** \class ELFAttributeValue
+ *  \brief ELFAttributeValue stroes the value of an attribute tag. The attribtue
+ *  tag itself is not stored in this object.
+ */
+class ELFAttributeValue
+{
+public:
+  // Type of value that an attribute tag holds.
+  enum Type {
+    // The value contains no data and has unknown type.
+    Uninitialized = 0,
+
+    // The value contains integer data.
+    Int           = 1L << 0,
+
+    // The value contains string data.
+    String        = 1L << 1,
+
+    // This is for attribute in which "default value" (0 for int type and empty
+    // string for string type) has special meaning for them. That is, the
+    // default value is "disabled" and meaningful for those attribute.
+    NoDefault     = 1L << 2,
+  };
+
+public:
+  ELFAttributeValue()
+    : m_Type(Uninitialized), m_IntValue(0), m_StringValue() { }
+
+  ~ELFAttributeValue() { }
+
+public:
+  unsigned int type() const
+  { return m_Type; }
+
+  void setType(unsigned int pType)
+  { m_Type = pType; }
+
+  unsigned int getIntValue() const
+  { return m_IntValue; }
+
+  void setIntValue(unsigned int pIntValue)
+  { m_IntValue = pIntValue; }
+
+  const std::string &getStringValue() const
+  { return m_StringValue; }
+
+  void setStringValue(const std::string &pStringValue)
+  { m_StringValue = pStringValue; }
+
+  void setStringValue(const char *pStringValue, size_t pSize)
+  { m_StringValue.assign(pStringValue, pSize); }
+
+  void setStringValue(const char *pStringValue)
+  { m_StringValue.assign(pStringValue); }
+
+  size_t getSize() const;
+
+  inline bool isUninitialized() const
+  { return (m_Type == Uninitialized); }
+
+  inline bool isInitialized() const
+  { return !isUninitialized(); }
+
+  inline bool isIntValue() const
+  { return (m_Type & Int); }
+
+  inline bool isStringValue() const
+  { return (m_Type & String); }
+
+  inline bool hasNoDefault() const
+  { return (m_Type & NoDefault); }
+
+  bool isDefaultValue() const;
+
+  // Returns true if this attribute value should be emitted to the output.
+  inline bool shouldEmit() const {
+    // Attribute with non-default value should be emitted.
+    return !isDefaultValue();
+  }
+
+  bool equals(const ELFAttributeValue& pValue) const;
+
+  bool operator==(const ELFAttributeValue& pValue) const
+  { return equals(pValue); }
+  bool operator!=(const ELFAttributeValue& pValue) const
+  { return !equals(pValue); }
+
+  /// reset - reset this value to the uninitialized state
+  void reset()
+  {
+    m_Type = Uninitialized;
+    m_IntValue = 0;
+    m_StringValue.clear();
+    return;
+  }
+
+private:
+  unsigned int m_Type;
+
+  unsigned int m_IntValue;
+  std::string m_StringValue;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/include/mcld/Target/ELFDynamic.h b/include/mcld/Target/ELFDynamic.h
index 62f534d..c9b257f 100644
--- a/include/mcld/Target/ELFDynamic.h
+++ b/include/mcld/Target/ELFDynamic.h
@@ -6,14 +6,15 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_DYNAMIC_SECTION_H
-#define MCLD_ELF_DYNAMIC_SECTION_H
+#ifndef MCLD_TARGET_ELFDYNAMIC_H
+#define MCLD_TARGET_ELFDYNAMIC_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 
-#include <llvm/Support/ELF.h>
 #include <mcld/LD/LDSection.h>
+#include <mcld/Support/FileOutputBuffer.h>
+#include <llvm/Support/ELF.h>
 #include <vector>
 #include <cstring>
 
@@ -22,7 +23,6 @@
 class ELFFileFormat;
 class GNULDBackend;
 class LinkerConfig;
-class MemoryRegion;
 
 namespace elf_dynamic {
 
diff --git a/include/mcld/Target/ELFEmulation.h b/include/mcld/Target/ELFEmulation.h
index 9d35792..2a79f11 100644
--- a/include/mcld/Target/ELFEmulation.h
+++ b/include/mcld/Target/ELFEmulation.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_EMULATION_H
-#define MCLD_ELF_EMULATION_H
+#ifndef MCLD_TARGET_ELFEMULATION_H
+#define MCLD_TARGET_ELFEMULATION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
diff --git a/include/mcld/Target/ELFMCLinker.h b/include/mcld/Target/ELFMCLinker.h
index 76f46e8..2cead3b 100644
--- a/include/mcld/Target/ELFMCLinker.h
+++ b/include/mcld/Target/ELFMCLinker.h
@@ -11,8 +11,8 @@
 // This pass set up default parameters for ELF.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ELF_SECTION_LINKER_H
-#define MCLD_ELF_SECTION_LINKER_H
+#ifndef MCLD_TARGET_ELFMCLINKER_H
+#define MCLD_TARGET_ELFMCLINKER_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -22,13 +22,14 @@
 
 class Module;
 class Output;
+class FileHandle;
 
 class ELFMCLinker : public MCLinker
 {
 public:
   ELFMCLinker(LinkerConfig& pConfig,
               mcld::Module& pModule,
-              MemoryArea& pOutput);
+              FileHandle& pFileHandle);
 
   virtual ~ELFMCLinker();
 };
diff --git a/include/mcld/Target/GNUInfo.h b/include/mcld/Target/GNUInfo.h
index 86a29ba..247d817 100644
--- a/include/mcld/Target/GNUInfo.h
+++ b/include/mcld/Target/GNUInfo.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TARGET_GNU_INFO_H
-#define MCLD_TARGET_GNU_INFO_H
+#ifndef MCLD_TARGET_GNUINFO_H
+#define MCLD_TARGET_GNUINFO_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -36,7 +36,7 @@
   uint8_t OSABI() const;
 
   /// ABIVersion - the value of e_ident[EI_ABIVRESION]
-  uint8_t ABIVersion() const { return 0x0; }
+  virtual uint8_t ABIVersion() const { return 0x0; }
 
   /// defaultTextSegmentAddr - target should specify its own default start address
   /// of the text segment. esp. for exec.
@@ -65,7 +65,7 @@
   /// here. If target favors the different size, please override this function
   virtual uint64_t abiPageSize() const { return 0x1000; }
 
-private:
+protected:
   const llvm::Triple& m_Triple;
 };
 
diff --git a/include/mcld/Target/GNULDBackend.h b/include/mcld/Target/GNULDBackend.h
index 3384eae..0d23964 100644
--- a/include/mcld/Target/GNULDBackend.h
+++ b/include/mcld/Target/GNULDBackend.h
@@ -6,31 +6,21 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TARGET_GNU_LDBACKEND_H
-#define MCLD_TARGET_GNU_LDBACKEND_H
+#ifndef MCLD_TARGET_GNULDBACKEND_H
+#define MCLD_TARGET_GNULDBACKEND_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
 #include <mcld/Target/TargetLDBackend.h>
 
-#include <llvm/Support/ELF.h>
-#include <mcld/ADT/HashTable.h>
-#include <mcld/ADT/HashEntry.h>
-#include <mcld/LD/ELFDynObjFileFormat.h>
-#include <mcld/LD/ELFExecFileFormat.h>
-#include <mcld/LD/ELFObjectFileFormat.h>
+#include <mcld/Module.h>
 #include <mcld/LD/GNUArchiveReader.h>
-#include <mcld/LD/ELFObjectReader.h>
 #include <mcld/LD/ELFDynObjReader.h>
 #include <mcld/LD/ELFBinaryReader.h>
+#include <mcld/LD/ELFObjectReader.h>
 #include <mcld/LD/ELFObjectWriter.h>
-#include <mcld/LD/ELFSegment.h>
-#include <mcld/LD/ELFSegmentFactory.h>
-#include <mcld/Target/ELFDynamic.h>
-#include <mcld/Target/GNUInfo.h>
 
-#include <mcld/Support/GCFactory.h>
-#include <mcld/Module.h>
+#include <llvm/Support/ELF.h>
 
 namespace mcld {
 
@@ -42,6 +32,15 @@
 class BranchIslandFactory;
 class StubFactory;
 class GNUInfo;
+class ELFFileFormat;
+class ELFSegmentFactory;
+class ELFAttribute;
+class ELFDynamic;
+class ELFDynObjFileFormat;
+class ELFExecFileFormat;
+class ELFObjectFileFormat;
+class LinkerScript;
+class Relocation;
 
 /** \class GNULDBackend
  *  \brief GNULDBackend provides a common interface for all GNU Unix-OS
@@ -110,6 +109,9 @@
   /// getSegmentStartAddr - this function returns the start address of the segment
   uint64_t getSegmentStartAddr(const LinkerScript& pScript) const;
 
+  /// sizeShstrtab - compute the size of .shstrtab
+  void sizeShstrtab(Module& pModule);
+
   /// sizeNamePools - compute the size of regular name pools
   /// In ELF executable files, regular name pools are .symtab, .strtab.,
   /// .dynsym, .dynstr, and .hash
@@ -120,25 +122,25 @@
                                    MemoryRegion& pRegion) const = 0;
 
   /// emitRegNamePools - emit regular name pools - .symtab, .strtab
-  virtual void emitRegNamePools(const Module& pModule, MemoryArea& pOutput);
+  virtual void emitRegNamePools(const Module& pModule, FileOutputBuffer& pOutput);
 
   /// emitNamePools - emit dynamic name pools - .dyntab, .dynstr, .hash
-  virtual void emitDynNamePools(Module& pModule, MemoryArea& pOutput);
+  virtual void emitDynNamePools(Module& pModule, FileOutputBuffer& pOutput);
 
   /// emitELFHashTab - emit .hash
   virtual void emitELFHashTab(const Module::SymbolTable& pSymtab,
-                              MemoryArea& pOutput);
+                              FileOutputBuffer& pOutput);
 
   /// emitGNUHashTab - emit .gnu.hash
   virtual void emitGNUHashTab(Module::SymbolTable& pSymtab,
-                              MemoryArea& pOutput);
+                              FileOutputBuffer& pOutput);
 
   /// sizeInterp - compute the size of program interpreter's name
   /// In ELF executables, this is the length of dynamic linker's path name
   virtual void sizeInterp();
 
   /// emitInterp - emit the .interp
-  virtual void emitInterp(MemoryArea& pOutput);
+  virtual void emitInterp(FileOutputBuffer& pOutput);
 
   /// hasEntryInStrTab - symbol has an entry in a .strtab
   virtual bool hasEntryInStrTab(const LDSymbol& pSym) const;
@@ -169,16 +171,11 @@
   virtual unsigned int getTargetSectionOrder(const LDSection& pSectHdr) const
   { return (unsigned int)-1; }
 
-  /// numOfSegments - return the number of segments
-  /// if the target favors other ways to emit program header, please override
-  /// this function
-  size_t numOfSegments() const { return m_ELFSegmentTable.size(); }
+  /// elfSegmentTable - return the reference of the elf segment table
+  ELFSegmentFactory&       elfSegmentTable();
 
   /// elfSegmentTable - return the reference of the elf segment table
-  ELFSegmentFactory&       elfSegmentTable()       { return m_ELFSegmentTable; }
-
-  /// elfSegmentTable - return the reference of the elf segment table
-  const ELFSegmentFactory& elfSegmentTable() const { return m_ELFSegmentTable; }
+  const ELFSegmentFactory& elfSegmentTable() const;
 
   /// commonPageSize - the common page size of the target machine
   uint64_t commonPageSize() const;
@@ -198,6 +195,58 @@
   /// update the output section flags based on input section flags.
   virtual bool updateSectionFlags(LDSection& pTo, const LDSection& pFrom);
 
+  /// readRelocation - read ELF32_Rel entry
+  virtual bool readRelocation(const llvm::ELF::Elf32_Rel& pRel,
+                              uint32_t& pType,
+                              uint32_t& pSymIdx,
+                              uint32_t& pOffset) const;
+
+  /// readRelocation - read ELF32_Rela entry
+  virtual bool readRelocation(const llvm::ELF::Elf32_Rela& pRel,
+                              uint32_t& pType,
+                              uint32_t& pSymIdx,
+                              uint32_t& pOffset,
+                              int32_t& pAddend) const;
+
+  /// readRelocation - read ELF64_Rel entry
+  virtual bool readRelocation(const llvm::ELF::Elf64_Rel& pRel,
+                              uint32_t& pType,
+                              uint32_t& pSymIdx,
+                              uint64_t& pOffset) const;
+
+  /// readRel - read ELF64_Rela entry
+  virtual bool readRelocation(const llvm::ELF::Elf64_Rela& pRel,
+                              uint32_t& pType,
+                              uint32_t& pSymIdx,
+                              uint64_t& pOffset,
+                              int64_t& pAddend) const;
+
+  /// emitRelocation - write data to the ELF32_Rel entry
+  virtual void emitRelocation(llvm::ELF::Elf32_Rel& pRel,
+                              uint32_t pType,
+                              uint32_t pSymIdx,
+                              uint32_t pOffset) const;
+
+  /// emitRelocation - write data to the ELF32_Rela entry
+  virtual void emitRelocation(llvm::ELF::Elf32_Rela& pRel,
+                              uint32_t pType,
+                              uint32_t pSymIdx,
+                              uint32_t pOffset,
+                              int32_t pAddend) const;
+
+  /// emitRelocation - write data to the ELF64_Rel entry
+  virtual void emitRelocation(llvm::ELF::Elf64_Rel& pRel,
+                              uint32_t pType,
+                              uint32_t pSymIdx,
+                              uint64_t pOffset) const;
+
+  /// emitRelocation - write data to the ELF64_Rela entry
+  virtual void emitRelocation(llvm::ELF::Elf64_Rela& pRel,
+                              uint32_t pType,
+                              uint32_t pSymIdx,
+                              uint64_t pOffset,
+                              int64_t pAddend) const;
+
   /// symbolNeedsPLT - return whether the symbol needs a PLT entry
   /// @ref Google gold linker, symtab.h:596
   bool symbolNeedsPLT(const ResolveInfo& pSym) const;
@@ -223,11 +272,11 @@
 
   /// isDynamicSymbol
   /// @ref Google gold linker: symtab.cc:311
-  bool isDynamicSymbol(const LDSymbol& pSymbol);
+  bool isDynamicSymbol(const LDSymbol& pSymbol) const;
 
   /// isDynamicSymbol
   /// @ref Google gold linker: symtab.cc:311
-  bool isDynamicSymbol(const ResolveInfo& pResolveInfo);
+  bool isDynamicSymbol(const ResolveInfo& pResolveInfo) const;
 
   virtual ResolveInfo::Desc getSymDesc(uint16_t pShndx) const {
     return ResolveInfo::Define;
@@ -247,6 +296,9 @@
   LDSymbol& getTBSSSymbol();
   const LDSymbol& getTBSSSymbol() const;
 
+  /// getEntry - get the entry point name
+  llvm::StringRef getEntry(const Module& pModule) const;
+
   //  -----  relaxation  -----  //
   /// initBRIslandFactory - initialize the branch island factory for relaxation
   bool initBRIslandFactory();
@@ -267,7 +319,27 @@
   /// checkAndSetHasTextRel - check pSection flag to set HasTextRel
   void checkAndSetHasTextRel(const LDSection& pSection);
 
+  /// sortRelocation - sort the dynamic relocations to let dynamic linker
+  /// process relocations more efficiently
+  void sortRelocation(LDSection& pSection);
+
+  /// createAndSizeEhFrameHdr - This is seperated since we may add eh_frame
+  /// entry in the middle
+  void createAndSizeEhFrameHdr(Module& pModule);
+
+  /// attribute - the attribute section data.
+  ELFAttribute& attribute() { return *m_pAttribute; }
+
+  /// attribute - the attribute section data.
+  const ELFAttribute& attribute() const { return *m_pAttribute; }
+
 protected:
+  /// getRelEntrySize - the size in BYTE of rel type relocation
+  virtual size_t getRelEntrySize() = 0;
+
+  /// getRelEntrySize - the size in BYTE of rela type relocation
+  virtual size_t getRelaEntrySize() = 0;
+
   uint64_t getSymbolSize(const LDSymbol& pSymbol) const;
 
   uint64_t getSymbolInfo(const LDSymbol& pSymbol) const;
@@ -315,33 +387,19 @@
 
   /// getSegmentFlag - give a section flag and return the corresponding segment
   /// flag
-  inline uint32_t getSegmentFlag(const uint32_t pSectionFlag)
-  {
-    uint32_t flag = llvm::ELF::PF_R;
-    if (0 != (pSectionFlag & llvm::ELF::SHF_WRITE))
-      flag |= llvm::ELF::PF_W;
-    if (0 != (pSectionFlag & llvm::ELF::SHF_EXECINSTR))
-      flag |= llvm::ELF::PF_X;
-    return flag;
-  }
+  inline uint32_t getSegmentFlag(const uint32_t pSectionFlag);
 
   /// setupGNUStackInfo - setup the section flag of .note.GNU-stack in output
   void setupGNUStackInfo(Module& pModule);
 
-  /// setupRelro - setup the offset constraint of PT_RELRO
-  void setupRelro(Module& pModule);
+  /// setOutputSectionOffset - helper function to set output sections' offset.
+  void setOutputSectionOffset(Module& pModule);
 
-  /// setOutputSectionOffset - helper function to set a group of output sections'
-  /// offset, and set pSectBegin to pStartOffset if pStartOffset is not -1U.
-  void setOutputSectionOffset(Module& pModule,
-                              Module::iterator pSectBegin,
-                              Module::iterator pSectEnd,
-                              uint64_t pStartOffset = -1U);
+  /// setOutputSectionAddress - helper function to set output sections' address.
+  void setOutputSectionAddress(Module& pModule);
 
-  /// setOutputSectionOffset - helper function to set output sections' address.
-  void setOutputSectionAddress(Module& pModule,
-                               Module::iterator pSectBegin,
-                               Module::iterator pSectEnd);
+  /// placeOutputSections - place output sections based on SectionMap
+  void placeOutputSections(Module& pModule);
 
   /// layout - layout method
   void layout(Module& pModule);
@@ -359,7 +417,7 @@
   virtual void doPostLayout(Module& pModule, IRBuilder& pLinker) = 0;
 
   /// postProcessing - Backend can do any needed modification in the final stage
-  void postProcessing(MemoryArea& pOutput);
+  void postProcessing(FileOutputBuffer& pOutput);
 
   /// dynamic - the dynamic section of the target machine.
   virtual ELFDynamic& dynamic() = 0;
@@ -380,56 +438,48 @@
   virtual bool doRelax(Module& pModule, IRBuilder& pBuilder, bool& pFinished)
   { return false; }
 
-  /// getRelEntrySize - the size in BYTE of rel type relocation
-  virtual size_t getRelEntrySize() = 0;
-
-  /// getRelEntrySize - the size in BYTE of rela type relocation
-  virtual size_t getRelaEntrySize() = 0;
-
 protected:
   // Based on Kind in LDFileFormat to define basic section orders for ELF, and
   // refer gold linker to add more enumerations to handle Regular and BSS kind
   enum SectionOrder {
-    SHO_INTERP = 1,          // .interp
-    SHO_RO_NOTE,             // .note.ABI-tag, .note.gnu.build-id
-    SHO_NAMEPOOL,            // *.hash, .dynsym, .dynstr
-    SHO_RELOCATION,          // .rel.*, .rela.*
-    SHO_REL_PLT,             // .rel.plt should come after other .rel.*
-    SHO_INIT,                // .init
-    SHO_PLT,                 // .plt
-    SHO_TEXT,                // .text
-    SHO_FINI,                // .fini
-    SHO_RO,                  // .rodata
-    SHO_EXCEPTION,           // .eh_frame_hdr, .eh_frame, .gcc_except_table
-    SHO_TLS_DATA,            // .tdata
-    SHO_TLS_BSS,             // .tbss
-    SHO_RELRO_LOCAL,         // .data.rel.ro.local
-    SHO_RELRO,               // .data.rel.ro,
-    SHO_RELRO_LAST,          // for x86 to adjust .got if needed
-    SHO_NON_RELRO_FIRST,     // for x86 to adjust .got.plt if needed
-    SHO_DATA,                // .data
-    SHO_LARGE_DATA,          // .ldata
-    SHO_RW_NOTE,             //
-    SHO_SMALL_DATA,          // .sdata
-    SHO_SMALL_BSS,           // .sbss
-    SHO_BSS,                 // .bss
-    SHO_LARGE_BSS,           // .lbss
-    SHO_UNDEFINED,           // default order
-    SHO_STRTAB               // .strtab
+    SHO_NULL = 0,        // NULL
+    SHO_INTERP,          // .interp
+    SHO_RO_NOTE,         // .note.ABI-tag, .note.gnu.build-id
+    SHO_NAMEPOOL,        // *.hash, .dynsym, .dynstr
+    SHO_RELOCATION,      // .rel.*, .rela.*
+    SHO_REL_PLT,         // .rel.plt should come after other .rel.*
+    SHO_INIT,            // .init
+    SHO_PLT,             // .plt
+    SHO_TEXT,            // .text
+    SHO_FINI,            // .fini
+    SHO_RO,              // .rodata
+    SHO_EXCEPTION,       // .eh_frame_hdr, .eh_frame, .gcc_except_table
+    SHO_TLS_DATA,        // .tdata
+    SHO_TLS_BSS,         // .tbss
+    SHO_RELRO_LOCAL,     // .data.rel.ro.local
+    SHO_RELRO,           // .data.rel.ro,
+    SHO_RELRO_LAST,      // for x86 to adjust .got if needed
+    SHO_NON_RELRO_FIRST, // for x86 to adjust .got.plt if needed
+    SHO_DATA,            // .data
+    SHO_LARGE_DATA,      // .ldata
+    SHO_RW_NOTE,         //
+    SHO_SMALL_DATA,      // .sdata
+    SHO_SMALL_BSS,       // .sbss
+    SHO_BSS,             // .bss
+    SHO_LARGE_BSS,       // .lbss
+    SHO_UNDEFINED,       // default order
+    SHO_STRTAB           // .strtab
   };
 
-  typedef std::pair<LDSection*, unsigned int> SHOEntry;
-
-  struct SHOCompare
+  // for -z combreloc
+  struct RelocCompare
   {
-    bool operator()(const SHOEntry& X, const SHOEntry& Y) const
-    { return X.second < Y.second; }
-  };
-
-  struct SymCompare
-  {
-    bool operator()(const LDSymbol* X, const LDSymbol* Y) const
-    { return (X==Y); }
+    RelocCompare(const GNULDBackend& pBackend)
+      : m_Backend(pBackend) {
+    }
+    bool operator()(const Relocation* X, const Relocation* Y) const;
+  private:
+    const GNULDBackend& m_Backend;
   };
 
   // for gnu style hash table
@@ -440,6 +490,12 @@
     bool operator()(const LDSymbol* X, const LDSymbol* Y) const;
   };
 
+  struct SymCompare
+  {
+    bool operator()(const LDSymbol* X, const LDSymbol* Y) const
+    { return (X==Y); }
+  };
+
   struct SymPtrHash
   {
     size_t operator()(const LDSymbol* pKey) const
@@ -467,7 +523,7 @@
   GNUInfo* m_pInfo;
 
   // ELF segment factory
-  ELFSegmentFactory m_ELFSegmentTable;
+  ELFSegmentFactory* m_pELFSegmentTable;
 
   // branch island factory
   BranchIslandFactory* m_pBRIslandFactory;
@@ -481,6 +537,9 @@
   // section .eh_frame_hdr
   EhFrameHdr* m_pEhFrameHdr;
 
+  // attribute section
+  ELFAttribute* m_pAttribute;
+
   // ----- dynamic flags ----- //
   // DF_TEXTREL of DT_FLAGS
   bool m_bHasTextRel;
diff --git a/include/mcld/Target/GOT.h b/include/mcld/Target/GOT.h
index 9b61bcd..eb73741 100644
--- a/include/mcld/Target/GOT.h
+++ b/include/mcld/Target/GOT.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_GLOBAL_OFFSET_TABLE_H
-#define MCLD_GLOBAL_OFFSET_TABLE_H
+#ifndef MCLD_TARGET_GOT_H
+#define MCLD_TARGET_GOT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -80,13 +80,6 @@
   // finalizeSectionSize - set LDSection size
   virtual void finalizeSectionSize();
 
-  /// reserve - reseve number of pNum of empty entries
-  /// Before layout, we scan all relocations to determine if GOT entries are
-  /// needed. If an entry is needed, the empty entry is reserved for layout
-  /// to adjust the fragment offset. After that, we fill up the entries when
-  /// applying relocations.
-  virtual void reserve(size_t pNum = 1) = 0;
-
 protected:
   LDSection& m_Section;
   SectionData* m_SectionData;
diff --git a/include/mcld/Target/KeyEntryMap.h b/include/mcld/Target/KeyEntryMap.h
new file mode 100644
index 0000000..8136687
--- /dev/null
+++ b/include/mcld/Target/KeyEntryMap.h
@@ -0,0 +1,204 @@
+//===- KeyEntryMap.h ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_KEYENTRYMAP_H
+#define MCLD_TARGET_KEYENTRYMAP_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <vector>
+#include <list>
+
+namespace mcld {
+
+/** \class KeyEntryMap
+ *  \brief KeyEntryMap is a <const KeyType*, ENTRY*> map.
+ */
+template<typename KEY, typename ENTRY>
+class KeyEntryMap
+{
+public:
+  typedef KEY   KeyType;
+  typedef ENTRY EntryType;
+
+private:
+  struct EntryPair {
+    EntryPair(EntryType* pEntry1, EntryType* pEntry2)
+     : entry1(pEntry1), entry2(pEntry2)
+    {}
+
+    EntryType* entry1;
+    EntryType* entry2;
+  };
+
+  /// EntryOrPair - A key may mapping to a signal entry or a pair of entries,
+  /// user is responsible for the type of Mapping.entry
+  union EntryOrPair {
+    EntryType* entry_ptr;
+    EntryPair* pair_ptr;
+  };
+
+  struct Mapping {
+    const KeyType* key;
+    EntryOrPair entry;
+  };
+
+  typedef std::vector<Mapping> KeyEntryPool;
+  typedef std::list<EntryPair> PairListType;
+
+public:
+  typedef typename KeyEntryPool::iterator iterator;
+  typedef typename KeyEntryPool::const_iterator const_iterator;
+
+public:
+  /// lookUp - look up the entry mapping to pKey
+  const EntryType* lookUp(const KeyType& pKey) const;
+  EntryType*       lookUp(const KeyType& pKey);
+
+  /// lookUpFirstEntry - look up the first entry mapping to pKey
+  const EntryType* lookUpFirstEntry(const KeyType& pKey) const;
+  EntryType*       lookUpFirstEntry(const KeyType& pKey);
+
+  /// lookUpSecondEntry - look up the second entry mapping to pKey
+  const EntryType* lookUpSecondEntry(const KeyType& pKey) const;
+  EntryType*       lookUpSecondEntry(const KeyType& pKey);
+
+  void record(const KeyType& pKey, EntryType& pEntry);
+  void record(const KeyType& pKey,
+              EntryType& pEntry1,
+              EntryType& pEntry2);
+
+  bool   empty() const { return m_Pool.empty(); }
+  size_t size () const { return m_Pool.size(); }
+
+  const_iterator begin() const { return m_Pool.begin(); }
+  iterator       begin()       { return m_Pool.begin(); }
+  const_iterator end  () const { return m_Pool.end();   }
+  iterator       end  ()       { return m_Pool.end();   }
+
+  void reserve(size_t pSize) { m_Pool.reserve(pSize); }
+
+private:
+  KeyEntryPool m_Pool;
+
+  /// m_Pairs - the EntryPairs
+  PairListType m_Pairs;
+};
+
+template<typename KeyType, typename EntryType>
+const EntryType*
+KeyEntryMap<KeyType, EntryType>::lookUp(const KeyType& pKey) const
+{
+  const_iterator mapping, mEnd = m_Pool.end();
+  for (mapping = m_Pool.begin(); mapping != mEnd; ++mapping) {
+    if (mapping->key == &pKey) {
+      return mapping->entry.entry_ptr;
+    }
+  }
+
+  return NULL;
+}
+
+template<typename KeyType, typename EntryType>
+EntryType*
+KeyEntryMap<KeyType, EntryType>::lookUp(const KeyType& pKey)
+{
+  iterator mapping, mEnd = m_Pool.end();
+  for (mapping = m_Pool.begin(); mapping != mEnd; ++mapping) {
+    if (mapping->key == &pKey) {
+      return mapping->entry.entry_ptr;
+    }
+  }
+
+  return NULL;
+}
+
+template<typename KeyType, typename EntryType>
+const EntryType*
+KeyEntryMap<KeyType, EntryType>::lookUpFirstEntry(const KeyType& pKey) const
+{
+  const_iterator mapping, mEnd = m_Pool.end();
+  for (mapping = m_Pool.begin(); mapping != mEnd; ++mapping) {
+    if (mapping->key == &pKey) {
+      return mapping->entry.pair_ptr->entry1;
+    }
+  }
+
+  return NULL;
+}
+
+template<typename KeyType, typename EntryType>
+EntryType*
+KeyEntryMap<KeyType, EntryType>::lookUpFirstEntry(const KeyType& pKey)
+{
+  const_iterator mapping, mEnd = m_Pool.end();
+  for (mapping = m_Pool.begin(); mapping != mEnd; ++mapping) {
+    if (mapping->key == &pKey) {
+      return mapping->entry.pair_ptr->entry1;
+    }
+  }
+
+  return NULL;
+}
+
+template<typename KeyType, typename EntryType>
+const EntryType*
+KeyEntryMap<KeyType, EntryType>::lookUpSecondEntry(const KeyType& pKey) const
+{
+  const_iterator mapping, mEnd = m_Pool.end();
+  for (mapping = m_Pool.begin(); mapping != mEnd; ++mapping) {
+    if (mapping->key == &pKey) {
+      return mapping->entry.pair_ptr->entry2;
+    }
+  }
+
+  return NULL;
+}
+
+template<typename KeyType, typename EntryType>
+EntryType*
+KeyEntryMap<KeyType, EntryType>::lookUpSecondEntry(const KeyType& pKey)
+{
+  const_iterator mapping, mEnd = m_Pool.end();
+  for (mapping = m_Pool.begin(); mapping != mEnd; ++mapping) {
+    if (mapping->key == &pKey) {
+      return mapping->entry.pair_ptr->entry2;
+    }
+  }
+
+  return NULL;
+}
+
+template<typename KeyType, typename EntryType>
+void
+KeyEntryMap<KeyType, EntryType>::record(const KeyType& pKey, EntryType& pEntry)
+{
+  Mapping mapping;
+  mapping.key = &pKey;
+  mapping.entry.entry_ptr = &pEntry;
+  m_Pool.push_back(mapping);
+}
+
+template<typename KeyType, typename EntryType>
+void
+KeyEntryMap<KeyType, EntryType>::record(const KeyType& pKey,
+                                  EntryType& pEntry1,
+                                  EntryType& pEntry2)
+{
+  Mapping mapping;
+  mapping.key = &pKey;
+  m_Pairs.push_back(EntryPair(&pEntry1, &pEntry2));
+  mapping.entry.pair_ptr = &m_Pairs.back();
+  m_Pool.push_back(mapping);
+}
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Target/OutputRelocSection.h b/include/mcld/Target/OutputRelocSection.h
index b0f8f2d..a109843 100644
--- a/include/mcld/Target/OutputRelocSection.h
+++ b/include/mcld/Target/OutputRelocSection.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_OUTPUT_RELOCATION_SECTION_H
-#define MCLD_OUTPUT_RELOCATION_SECTION_H
+#ifndef MCLD_TARGET_OUTPUTRELOCSECTION_H
+#define MCLD_TARGET_OUTPUTRELOCSECTION_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -32,6 +32,9 @@
 
   ~OutputRelocSection();
 
+  /// create - create an dynamic relocation entry
+  Relocation* create();
+
   void reserveEntry(size_t pNum=1);
 
   Relocation* consumeEntry();
diff --git a/include/mcld/Target/PLT.h b/include/mcld/Target/PLT.h
index 5d91446..7305a74 100644
--- a/include/mcld/Target/PLT.h
+++ b/include/mcld/Target/PLT.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_PROCEDURE_LINKAGE_TABLE_H
-#define MCLD_PROCEDURE_LINKAGE_TABLE_H
+#ifndef MCLD_TARGET_PLT_H
+#define MCLD_TARGET_PLT_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -22,7 +22,7 @@
 class ResolveInfo;
 
 /** \class PLTEntryDefaultBase
- *  \brief PLTEntryDefaultBase provides the default interface for PLE Entry
+ *  \brief PLTEntryDefaultBase provides the default interface for PLT Entry
  */
 class PLTEntryBase : public TargetFragment
 {
@@ -33,7 +33,7 @@
 
   virtual ~PLTEntryBase()
   {
-    delete m_pValue;
+    free(m_pValue);
   }
 
   void setValue(unsigned char* pValue)
@@ -81,10 +81,6 @@
 
   virtual ~PLT();
 
-  /// reserveEntry - reseve the number of pNum of empty entries
-  /// The empty entris are reserved for layout to adjust the fragment offset.
-  virtual void reserveEntry(size_t pNum = 1) = 0;
-
   // finalizeSectionSize - set LDSection size
   virtual void finalizeSectionSize() = 0;
 
diff --git a/include/mcld/Target/SymbolEntryMap.h b/include/mcld/Target/SymbolEntryMap.h
deleted file mode 100644
index fc5ea93..0000000
--- a/include/mcld/Target/SymbolEntryMap.h
+++ /dev/null
@@ -1,104 +0,0 @@
-//===- SymbolEntryMap.h ---------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_TARGET_SYMBOL_ENTRY_MAP_H
-#define MCLD_TARGET_SYMBOL_ENTRY_MAP_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-
-#include <vector>
-
-namespace mcld {
-
-class ResolveInfo;
-
-/** \class SymbolEntryMap
- *  \brief SymbolEntryMap is a <const ResolveInfo*, ENTRY*> map.
- */
-template<typename ENTRY>
-class SymbolEntryMap
-{
-public:
-  typedef ENTRY EntryType;
-
-private:
-  struct Mapping {
-    const ResolveInfo* symbol;
-    EntryType*   entry;
-  };
-
-  typedef std::vector<Mapping> SymbolEntryPool;
-
-public:
-  typedef typename SymbolEntryPool::iterator iterator;
-  typedef typename SymbolEntryPool::const_iterator const_iterator;
-
-public:
-  const EntryType* lookUp(const ResolveInfo& pSymbol) const;
-  EntryType*       lookUp(const ResolveInfo& pSymbol);
-
-  void record(const ResolveInfo& pSymbol, EntryType& pEntry);
-
-  bool   empty() const { return m_Pool.empty(); }
-  size_t size () const { return m_Pool.size(); }
-
-  const_iterator begin() const { return m_Pool.begin(); }
-  iterator       begin()       { return m_Pool.begin(); }
-  const_iterator end  () const { return m_Pool.end();   }
-  iterator       end  ()       { return m_Pool.end();   }
-
-  void reserve(size_t pSize) { m_Pool.reserve(pSize); }
-
-private:
-  SymbolEntryPool m_Pool;
-
-};
-
-template<typename EntryType>
-const EntryType*
-SymbolEntryMap<EntryType>::lookUp(const ResolveInfo& pSymbol) const
-{
-  const_iterator mapping, mEnd = m_Pool.end();
-  for (mapping = m_Pool.begin(); mapping != mEnd; ++mapping) {
-    if (mapping->symbol == &pSymbol) {
-      return mapping->entry;
-    }
-  }
-
-  return NULL;
-}
-
-template<typename EntryType>
-EntryType*
-SymbolEntryMap<EntryType>::lookUp(const ResolveInfo& pSymbol)
-{
-  iterator mapping, mEnd = m_Pool.end();
-  for (mapping = m_Pool.begin(); mapping != mEnd; ++mapping) {
-    if (mapping->symbol == &pSymbol) {
-      return mapping->entry;
-    }
-  }
-
-  return NULL;
-}
-
-template<typename EntryType>
-void
-SymbolEntryMap<EntryType>::record(const ResolveInfo& pSymbol, EntryType& pEntry)
-{
-  Mapping mapping;
-  mapping.symbol = &pSymbol;
-  mapping.entry = &pEntry;
-  m_Pool.push_back(mapping);
-}
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Target/TargetLDBackend.h b/include/mcld/Target/TargetLDBackend.h
index d3f14b2..29fb395 100644
--- a/include/mcld/Target/TargetLDBackend.h
+++ b/include/mcld/Target/TargetLDBackend.h
@@ -1,4 +1,4 @@
-//===-- llvm/Target/TargetLDBackend.h - Target LD Backend -----*- C++ -*-===//
+//===-- TargetLDBackend.h - Target LD Backend -------------------*- C++ -*-===//
 //
 //                     The MCLinker Project
 //
@@ -9,36 +9,34 @@
 #ifndef MCLD_TARGET_TARGETLDBACKEND_H
 #define MCLD_TARGET_TARGETLDBACKEND_H
 
+#include <llvm/ADT/StringRef.h>
 #include <llvm/Support/DataTypes.h>
+#include <mcld/LD/GarbageCollection.h>
 
 namespace mcld {
 
-class Module;
-class LinkerConfig;
-class IRBuilder;
-class Relocation;
-class RelocationFactory;
-class Relocator;
-class Layout;
 class ArchiveReader;
-class ObjectReader;
-class DynObjReader;
 class BinaryReader;
-class ObjectWriter;
+class BinaryWriter;
+class BranchIslandFactory;
+class DynObjReader;
 class DynObjWriter;
 class ExecWriter;
-class BinaryWriter;
-class LDFileFormat;
-class LDSymbol;
-class LDSection;
-class SectionData;
+class FileOutputBuffer;
+class SectionReachedListMap;
+class IRBuilder;
 class Input;
-class GOT;
-class MemoryArea;
-class MemoryAreaFactory;
-class BranchIslandFactory;
-class StubFactory;
+class LDSection;
+class LDSymbol;
+class Layout;
+class LinkerConfig;
+class Module;
 class ObjectBuilder;
+class ObjectReader;
+class ObjectWriter;
+class Relocator;
+class SectionData;
+class StubFactory;
 
 //===----------------------------------------------------------------------===//
 /// TargetLDBackend - Generic interface to target specific assembler backends.
@@ -84,7 +82,7 @@
   virtual void postLayout(Module& pModule, IRBuilder& pBuilder) = 0;
 
   /// postProcessing - Backend can do any needed modification in the final stage
-  virtual void postProcessing(MemoryArea& pOutput) = 0;
+  virtual void postProcessing(FileOutputBuffer& pOutput) = 0;
 
   /// section start offset in the output file
   virtual size_t sectionStartOffset() const = 0;
@@ -112,9 +110,17 @@
   virtual bool allocateCommonSymbols(Module& pModule) = 0;
 
   /// mergeSection - merge target dependent sections.
-  virtual bool mergeSection(Module& pModule, LDSection& pInputSection)
+  virtual bool mergeSection(Module& pModule,
+                            const Input& pInputFile,
+                            LDSection& pInputSection)
   { return true; }
 
+  /// setUpReachedSectionsForGC - set the reference between two sections for
+  /// some special target sections. GC will set up the reference for the Regular
+  /// and BSS sections. Backends can also set up the reference if need.
+  virtual void setUpReachedSectionsForGC(const Module& pModule,
+        GarbageCollection::SectionReachedListMap& pSectReachedListMap) const { }
+
   /// updateSectionFlags - update pTo's flags when merging pFrom
   /// update the output section flags based on input section flags.
   /// FIXME: (Luba) I know ELF need to merge flags, but I'm not sure if
@@ -130,6 +136,9 @@
   /// In ELF executables, this is the length of dynamic linker's path name
   virtual void sizeInterp() = 0;
 
+  /// getEntry - get the entry point name
+  virtual llvm::StringRef getEntry(const Module& pModule) const = 0;
+
   // -----  relaxation  ----- //
   virtual bool initBRIslandFactory() = 0;
   virtual bool initStubFactory() = 0;
@@ -144,6 +153,20 @@
   /// mayRelax - return true if the backend needs to do relaxation
   virtual bool mayRelax() = 0;
 
+  /// commonPageSize - the common page size of the target machine
+  virtual uint64_t commonPageSize() const = 0;
+
+  /// abiPageSize - the abi page size of the target machine
+  virtual uint64_t abiPageSize() const = 0;
+
+  /// sortRelocation - sort the dynamic relocations to let dynamic linker
+  /// process relocations more efficiently
+  virtual void sortRelocation(LDSection& pSection) = 0;
+
+  /// createAndSizeEhFrameHdr - This is seperated since we may add eh_frame
+  /// entry in the middle
+  virtual void createAndSizeEhFrameHdr(Module& pModule) = 0;
+
 protected:
   const LinkerConfig& config() const { return m_Config; }
 
diff --git a/include/mcld/TargetOptions.h b/include/mcld/TargetOptions.h
index dfdd773..5f7e339 100644
--- a/include/mcld/TargetOptions.h
+++ b/include/mcld/TargetOptions.h
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_TARGET_OPTIONS_H
-#define MCLD_TARGET_OPTIONS_H
+#ifndef MCLD_TARGETOPTIONS_H
+#define MCLD_TARGETOPTIONS_H
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
@@ -44,6 +44,10 @@
 
   void setTriple(const llvm::Triple& pTriple);
 
+  const std::string& getArch() const { return m_ArchName; }
+
+  void setArch(const std::string& pArchName);
+
   const std::string& getTargetCPU() const { return m_TargetCPU; }
 
   void setTargetCPU(const std::string& pCPU);
@@ -68,6 +72,7 @@
 
 private:
   llvm::Triple m_Triple;
+  std::string m_ArchName;
   std::string m_TargetCPU;
   std::string m_TargetFS;
   Endian m_Endian;
diff --git a/lib/ADT/GraphLite/Digraph.cpp b/lib/ADT/GraphLite/Digraph.cpp
new file mode 100644
index 0000000..301f9fa
--- /dev/null
+++ b/lib/ADT/GraphLite/Digraph.cpp
@@ -0,0 +1,88 @@
+//===- Digraph.cpp --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/ADT/GraphLite/Digraph.h>
+
+using namespace mcld::graph;
+
+//===----------------------------------------------------------------------===//
+// Digraph::Arc
+//===----------------------------------------------------------------------===//
+Digraph::Arc::Arc()
+{
+}
+
+bool Digraph::Arc::operator==(const Digraph::Node& pOther) const
+{
+  return true;
+}
+
+bool Digraph::Arc::operator!=(const Digraph::Node& pOther) const
+{
+  return true;
+}
+
+Digraph::Node Digraph::Arc::source() const
+{
+  return Node();
+}
+
+Digraph::Node Digraph::Arc::target() const
+{
+  return Node();
+}
+
+Digraph::Arc::Arc(Digraph& pParent)
+{
+}
+
+
+//===----------------------------------------------------------------------===//
+// Digraph
+//===----------------------------------------------------------------------===//
+Digraph::Digraph()
+{
+}
+
+
+Digraph::Node Digraph::addNode()
+{
+  return Node();
+}
+
+
+Digraph::Arc
+Digraph::addArc(const Digraph::Node& pSource, const Digraph::Node& pTarget)
+{
+  return Arc();
+}
+
+
+void Digraph::erase(const Digraph::Node& pNode)
+{
+}
+
+
+void Digraph::erase(const Digraph::Arc& pArc)
+{
+}
+
+
+void Digraph::clear()
+{
+}
+
+unsigned int Digraph::numOfNodes() const
+{
+  return 0;
+}
+
+unsigned int Digraph::numOfArcs() const
+{
+  return 0;
+}
diff --git a/lib/ADT/GraphLite/ListDigraph.cpp b/lib/ADT/GraphLite/ListDigraph.cpp
new file mode 100644
index 0000000..fcf957b
--- /dev/null
+++ b/lib/ADT/GraphLite/ListDigraph.cpp
@@ -0,0 +1,178 @@
+//===- ListDigraph.cpp ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/ADT/GraphLite/ListDigraph.h>
+
+using namespace mcld::graph;
+
+//===----------------------------------------------------------------------===//
+// ListDigraph::Node
+//===----------------------------------------------------------------------===//
+ListDigraph::Node::Node()
+  : prev(NULL), next(NULL), first_in(NULL), first_out(NULL) {
+}
+
+//===----------------------------------------------------------------------===//
+// ListDigraph::Arc
+//===----------------------------------------------------------------------===//
+ListDigraph::Arc::Arc()
+  : target(NULL), source(NULL),
+    prev_in(NULL), next_in(NULL), prev_out(NULL), next_out(NULL) {
+}
+
+//===----------------------------------------------------------------------===//
+// ListDigraph
+//===----------------------------------------------------------------------===//
+ListDigraph::ListDigraph()
+  : m_pNodeHead(NULL), m_pFreeNodeHead(NULL), m_pFreeArcHead(NULL),
+    m_NodeList(32), m_ArcList(32) {
+}
+
+
+ListDigraph::Node* ListDigraph::addNode()
+{
+  // 1. find an available free node
+  Node* result = NULL;
+  if (NULL == m_pFreeNodeHead) {
+    result = m_NodeList.allocate();
+    new (result) Node();
+  }
+  else {
+    result = m_pFreeNodeHead;
+    m_pFreeNodeHead = m_pFreeNodeHead->next;
+  }
+
+  // 2. set up linkages
+  result->prev = NULL;
+  result->next = m_pNodeHead;
+
+  // 3. reset head node
+  if (NULL != m_pNodeHead) {
+    m_pNodeHead->prev = result;
+  }
+  m_pNodeHead = result;
+
+  return result;
+}
+
+
+ListDigraph::Arc* ListDigraph::addArc(Node& pU, Node& pV)
+{
+  // 1. find an available free arc
+  Arc* result = NULL;
+  if (NULL == m_pFreeArcHead) {
+    result = m_ArcList.allocate();
+    new (result) Arc();
+  }
+  else {
+    result = m_pFreeArcHead;
+    m_pFreeArcHead = m_pFreeArcHead->next_in;
+  }
+
+  // 2. set up arc
+  result->source = &pU;
+  result->target = &pV;
+
+  // 3. set up fan-out linked list
+  result->next_out = pU.first_out;
+  if (NULL != pU.first_out) {
+    pU.first_out->prev_out = result;
+  }
+  pU.first_out = result;
+
+  // 4. set up fan-in linked list
+  result->next_in = pV.first_in;
+  if (NULL != pV.first_in) {
+    pV.first_in->prev_in = result;
+  }
+  pV.first_in = result;
+
+  return result;
+}
+
+void ListDigraph::erase(ListDigraph::Node& pNode)
+{
+  // 1. connect previous node and next node.
+  if (NULL != pNode.next) {
+    pNode.next->prev = pNode.prev;
+  }
+
+  if (NULL != pNode.prev) {
+    pNode.prev->next = pNode.next;
+  }
+  else { // pNode.prev is NULL => pNode is the head
+    m_pNodeHead = pNode.next;
+  }
+
+  // 2. remove all fan-in arcs
+  Arc* fan_in = pNode.first_in;
+  while(NULL != fan_in) {
+    Arc* next_in = fan_in->next_in;
+    erase(*fan_in);
+    fan_in = next_in;
+  }
+
+  // 3. remove all fan-out arcs
+  Arc* fan_out = pNode.first_out;
+  while(NULL != fan_out) {
+    Arc* next_out = fan_out->next_out;
+    erase(*fan_out);
+    fan_out = next_out;
+  }
+
+  // 4. put pNode in the free node list
+  pNode.next = m_pFreeNodeHead;
+  pNode.prev = NULL;
+  if (NULL != m_pFreeNodeHead)
+    m_pFreeNodeHead->prev = &pNode;
+  m_pFreeNodeHead = &pNode;
+}
+
+
+void ListDigraph::erase(ListDigraph::Arc& pArc)
+{
+  // 1. remove from the fan-out list
+  if (NULL != pArc.prev_out) {
+    pArc.prev_out->next_out = pArc.next_out;
+  }
+  else { // pArc.prev_out is NULL => pArc is the first_out of the source
+    pArc.source->first_out = pArc.next_out;
+  }
+
+  if (NULL != pArc.next_out) {
+    pArc.next_out->prev_out = pArc.prev_out;
+  }
+
+  // 2. remove from the fan-in list
+  if (NULL != pArc.prev_in) {
+    pArc.prev_in->next_in = pArc.next_in;
+  }
+  else {
+    pArc.target->first_in = pArc.next_in;
+  }
+
+  if (NULL != pArc.next_in) {
+    pArc.next_in->prev_in = pArc.prev_in;
+  }
+
+  // 3. put pArc in the free arc list
+  // Use fan-in links to chain the free list
+  pArc.next_in = m_pFreeArcHead;
+  m_pFreeArcHead = &pArc;
+}
+
+
+void ListDigraph::clear()
+{
+  m_pNodeHead = NULL;
+  m_pFreeNodeHead = NULL;
+  m_pFreeArcHead = NULL;
+  m_NodeList.clear();
+  m_ArcList.clear();
+}
+
diff --git a/lib/CodeGen/MCLDTargetMachine.cpp b/lib/CodeGen/MCLDTargetMachine.cpp
index a695f29..272e775 100644
--- a/lib/CodeGen/MCLDTargetMachine.cpp
+++ b/lib/CodeGen/MCLDTargetMachine.cpp
@@ -6,15 +6,13 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <mcld/Target/TargetMachine.h>
+#include <mcld/CodeGen/TargetMachine.h>
 
 #include <mcld/Module.h>
 #include <mcld/LinkerConfig.h>
 #include <mcld/CodeGen/MCLinker.h>
-#include <mcld/Support/raw_mem_ostream.h>
 #include <mcld/Support/TargetRegistry.h>
 #include <mcld/Support/ToolOutputFile.h>
-#include <mcld/Support/MemoryArea.h>
 #include <mcld/Target/TargetLDBackend.h>
 
 #include <llvm/ADT/OwningPtr.h>
@@ -59,7 +57,6 @@
 // Enable or disable FastISel. Both options are needed, because
 // FastISel is enabled by default with -fast, and we wish to be
 // able to enable or disable fast-isel independently from -O0.
-
 static cl::opt<cl::boolOrDefault>
 ArgEnableFastISelOption("lfast-isel", cl::Hidden,
   cl::desc("Enable the \"fast\" instruction selector"));
@@ -90,28 +87,34 @@
 }
 
 
-//===---------------------------------------------------------------------===//
-/// MCLDTargetMachine
+//===----------------------------------------------------------------------===//
+// MCLDTargetMachine
 //===----------------------------------------------------------------------===//
 mcld::MCLDTargetMachine::MCLDTargetMachine(llvm::TargetMachine &pTM,
-                                           const mcld::Target& pTarget,
+                                           const llvm::Target& pLLVMTarget,
+                                           const mcld::Target& pMCLDTarget,
                                            const std::string& pTriple)
-  : m_TM(pTM), m_pTarget(&pTarget), m_Triple(pTriple) {
+  : m_TM(pTM),
+    m_pLLVMTarget(&pLLVMTarget),
+    m_pMCLDTarget(&pMCLDTarget),
+    m_Triple(pTriple) {
 }
 
-mcld::MCLDTargetMachine::~MCLDTargetMachine() {
-  m_pTarget = 0;
+mcld::MCLDTargetMachine::~MCLDTargetMachine()
+{
+  m_pLLVMTarget = NULL;
+  m_pMCLDTarget = NULL;
 }
 
 const mcld::Target& mcld::MCLDTargetMachine::getTarget() const
 {
-  return *m_pTarget;
+  return *m_pMCLDTarget;
 }
 
 /// Turn exception handling constructs into something the code generators can
 /// handle.
 static void addPassesToHandleExceptions(llvm::TargetMachine *TM,
-                                        PassManagerBase &PM) {
+                                        llvm::legacy::PassManagerBase &PM) {
   switch (TM->getMCAsmInfo()->getExceptionHandlingType()) {
   case llvm::ExceptionHandling::SjLj:
     // SjLj piggy-backs on dwarf for this bit. The cleanups done apply to both
@@ -137,9 +140,10 @@
 }
 
 
-static llvm::MCContext *addPassesToGenerateCode(llvm::LLVMTargetMachine *TM,
-                                                PassManagerBase &PM,
-                                                bool DisableVerify)
+static llvm::MCContext *
+addPassesToGenerateCode(llvm::LLVMTargetMachine *TM,
+                        llvm::legacy::PassManagerBase &PM,
+                        bool DisableVerify)
 {
   // Targets may override createPassConfig to provide a target-specific sublass.
   TargetPassConfig *PassConfig = TM->createPassConfig(PM);
@@ -184,7 +188,8 @@
 
 }
 
-bool mcld::MCLDTargetMachine::addPassesToEmitFile(PassManagerBase &pPM,
+bool
+mcld::MCLDTargetMachine::addPassesToEmitFile(llvm::legacy::PassManagerBase &pPM,
                                              mcld::ToolOutputFile& pOutput,
                                              mcld::CodeGenFileType pFileType,
                                              CodeGenOpt::Level pOptLvl,
@@ -222,7 +227,7 @@
     if (getTM().hasMCSaveTempLabels())
       Context->setAllowTemporaryLabels(false);
     if (addAssemblerPasses(pPM,
-                           pOutput.mem_os(),
+                           pOutput.formatted_os(),
                            Context))
       return true;
     break;
@@ -232,7 +237,7 @@
     if (addLinkerPasses(pPM,
                         pConfig,
                         pModule,
-                        pOutput.memory(),
+                        pOutput.fd(),
                         Context))
       return true;
     break;
@@ -242,7 +247,7 @@
     if (addLinkerPasses(pPM,
                         pConfig,
                         pModule,
-                        pOutput.memory(),
+                        pOutput.fd(),
                         Context))
       return true;
     break;
@@ -252,7 +257,7 @@
     if (addLinkerPasses(pPM,
                         pConfig,
                         pModule,
-                        pOutput.memory(),
+                        pOutput.fd(),
                         Context))
       return true;
     break;
@@ -262,7 +267,7 @@
     if (addLinkerPasses(pPM,
                         pConfig,
                         pModule,
-                        pOutput.memory(),
+                        pOutput.fd(),
                         Context))
       return true;
     break;
@@ -271,9 +276,10 @@
   return false;
 }
 
-bool mcld::MCLDTargetMachine::addCompilerPasses(PassManagerBase &pPM,
-                                                llvm::formatted_raw_ostream &pOutput,
-                                                llvm::MCContext *&Context)
+bool
+mcld::MCLDTargetMachine::addCompilerPasses(llvm::legacy::PassManagerBase &pPM,
+                                           llvm::formatted_raw_ostream &pOutput,
+                                           llvm::MCContext *&Context)
 {
   const MCAsmInfo &MAI = *getTM().getMCAsmInfo();
   const MCInstrInfo &MII = *getTM().getInstrInfo();
@@ -281,32 +287,31 @@
   const MCSubtargetInfo &STI = getTM().getSubtarget<MCSubtargetInfo>();
 
   MCInstPrinter *InstPrinter =
-    getTarget().get()->createMCInstPrinter(MAI.getAssemblerDialect(), MAI,
-                                           MII,
-                                           *Context->getRegisterInfo(), STI);
+    m_pLLVMTarget->createMCInstPrinter(MAI.getAssemblerDialect(), MAI,
+                                       MII, *Context->getRegisterInfo(), STI);
 
   MCCodeEmitter* MCE = 0;
   MCAsmBackend *MAB = 0;
   if (ArgShowMCEncoding) {
-    MCE = getTarget().get()->createMCCodeEmitter(MII, MRI, STI, *Context);
-    MAB = getTarget().get()->createMCAsmBackend(m_Triple,
-                                                getTM().getTargetCPU());
+    MCE = m_pLLVMTarget->createMCCodeEmitter(MII, MRI, STI, *Context);
+    MAB = m_pLLVMTarget->createMCAsmBackend(MRI, m_Triple,
+                                            getTM().getTargetCPU());
   }
 
 
   // now, we have MCCodeEmitter and MCAsmBackend, we can create AsmStreamer.
   OwningPtr<MCStreamer> AsmStreamer(
-    getTarget().get()->createAsmStreamer(*Context, pOutput,
-                                         getVerboseAsm(),
-                                         getTM().hasMCUseLoc(),
-                                         getTM().hasMCUseCFI(),
-                                         getTM().hasMCUseDwarfDirectory(),
-                                         InstPrinter,
-                                         MCE, MAB,
-                                         ArgShowMCInst));
+    m_pLLVMTarget->createAsmStreamer(*Context, pOutput,
+                                     getVerboseAsm(),
+                                     getTM().hasMCUseLoc(),
+                                     getTM().hasMCUseCFI(),
+                                     getTM().hasMCUseDwarfDirectory(),
+                                     InstPrinter,
+                                     MCE, MAB,
+                                     ArgShowMCInst));
 
   llvm::MachineFunctionPass* funcPass =
-    getTarget().get()->createAsmPrinter(getTM(), *AsmStreamer.get());
+    m_pLLVMTarget->createAsmPrinter(getTM(), *AsmStreamer.get());
 
   if (funcPass == 0)
     return true;
@@ -316,35 +321,32 @@
   return false;
 }
 
-bool mcld::MCLDTargetMachine::addAssemblerPasses(PassManagerBase &pPM,
-                                                 llvm::raw_ostream &pOutput,
-                                                 llvm::MCContext *&Context)
+bool
+mcld::MCLDTargetMachine::addAssemblerPasses(llvm::legacy::PassManagerBase &pPM,
+                                            llvm::raw_ostream &pOutput,
+                                            llvm::MCContext *&Context)
 {
   // MCCodeEmitter
   const MCInstrInfo &MII = *getTM().getInstrInfo();
   const MCRegisterInfo &MRI = *getTM().getRegisterInfo();
   const MCSubtargetInfo &STI = getTM().getSubtarget<MCSubtargetInfo>();
   MCCodeEmitter* MCE =
-    getTarget().get()->createMCCodeEmitter(MII, MRI, STI, *Context);
+    m_pLLVMTarget->createMCCodeEmitter(MII, MRI, STI, *Context);
 
   // MCAsmBackend
   MCAsmBackend* MAB =
-    getTarget().get()->createMCAsmBackend(m_Triple,getTM().getTargetCPU());
+    m_pLLVMTarget->createMCAsmBackend(MRI, m_Triple, getTM().getTargetCPU());
   if (MCE == 0 || MAB == 0)
     return true;
 
   // now, we have MCCodeEmitter and MCAsmBackend, we can create AsmStreamer.
-  OwningPtr<MCStreamer> AsmStreamer(getTarget().get()->createMCObjectStreamer(
-                                                              m_Triple,
-                                                              *Context,
-                                                              *MAB,
-                                                              pOutput,
-                                                              MCE,
-                                                              getTM().hasMCRelaxAll(),
-                                                              getTM().hasMCNoExecStack()));
+  OwningPtr<MCStreamer> AsmStreamer(m_pLLVMTarget->createMCObjectStreamer(
+    m_Triple, *Context, *MAB, pOutput, MCE, getTM().hasMCRelaxAll(),
+    getTM().hasMCNoExecStack()));
+
   AsmStreamer.get()->InitSections();
-  MachineFunctionPass *funcPass = getTarget().get()->createAsmPrinter(getTM(),
-                                                                      *AsmStreamer.get());
+  MachineFunctionPass *funcPass =
+    m_pLLVMTarget->createAsmPrinter(getTM(), *AsmStreamer.get());
   if (funcPass == 0)
     return true;
   // If successful, createAsmPrinter took ownership of AsmStreamer
@@ -353,29 +355,27 @@
   return false;
 }
 
-bool mcld::MCLDTargetMachine::addLinkerPasses(PassManagerBase &pPM,
-                                              LinkerConfig& pConfig,
-                                              mcld::Module& pModule,
-                                              mcld::MemoryArea& pOutput,
-                                              llvm::MCContext *&Context)
+bool
+mcld::MCLDTargetMachine::addLinkerPasses(llvm::legacy::PassManagerBase &pPM,
+                                         LinkerConfig& pConfig,
+                                         mcld::Module& pModule,
+                                         mcld::FileHandle& pFileHandle,
+                                         llvm::MCContext *&Context)
 {
-  if (NULL == pOutput.handler())
-    return true;
-
   // set up output's SOName
   if (pConfig.options().soname().empty()) {
     // if the output is a shared object, and the option -soname was not
     // enable, set soname as the output file name. soname must be UTF-8 string.
-    pModule.setName(pOutput.handler()->path().filename().native());
-  }
-  else {
-    pModule.setName(pConfig.options().soname());
+    pConfig.options().setSOName(pFileHandle.path().filename().native());
   }
 
-  MachineFunctionPass* funcPass = getTarget().createMCLinker(m_Triple,
-                                                             pConfig,
-                                                             pModule,
-                                                             pOutput);
+  // set up output module name
+  pModule.setName(pFileHandle.path().filename().native());
+
+  MachineFunctionPass* funcPass = m_pMCLDTarget->createMCLinker(m_Triple,
+                                                                pConfig,
+                                                                pModule,
+                                                                pFileHandle);
   if (NULL == funcPass)
     return true;
 
diff --git a/lib/CodeGen/MCLinker.cpp b/lib/CodeGen/MCLinker.cpp
index 683cc89..471b0af 100644
--- a/lib/CodeGen/MCLinker.cpp
+++ b/lib/CodeGen/MCLinker.cpp
@@ -14,6 +14,7 @@
 
 #include <mcld/Module.h>
 #include <mcld/LinkerConfig.h>
+#include <mcld/LinkerScript.h>
 #include <mcld/InputTree.h>
 #include <mcld/Linker.h>
 #include <mcld/IRBuilder.h>
@@ -26,7 +27,6 @@
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Support/FileHandle.h>
 #include <mcld/Support/raw_ostream.h>
-#include <mcld/Support/MemoryArea.h>
 
 #include <llvm/IR/Module.h>
 #include <llvm/Support/CommandLine.h>
@@ -186,15 +186,24 @@
                      cl::aliasopt(ArgEndGroupList));
 
 //===----------------------------------------------------------------------===//
+// --defsym
+//===----------------------------------------------------------------------===//
+static cl::list<std::string>
+ArgDefSymList("defsym",
+              cl::ZeroOrMore,
+              cl::desc("Define a symbol"),
+              cl::value_desc("symbol=expression"));
+
+//===----------------------------------------------------------------------===//
 // MCLinker
 //===----------------------------------------------------------------------===//
 MCLinker::MCLinker(LinkerConfig& pConfig,
                    mcld::Module& pModule,
-                   MemoryArea& pOutput)
+                   FileHandle& pFileHandle)
   : MachineFunctionPass(m_ID),
     m_Config(pConfig),
     m_Module(pModule),
-    m_Output(pOutput),
+    m_FileHandle(pFileHandle),
     m_pBuilder(NULL),
     m_pLinker(NULL) {
 }
@@ -225,7 +234,7 @@
   if (!m_pLinker->link(m_Module, *m_pBuilder))
     return true;
 
-  if (!m_pLinker->emit(m_Output))
+  if (!m_pLinker->emit(m_Module, m_FileHandle.handler()))
     return true;
 
   return false;
@@ -258,10 +267,34 @@
                        ArgBStaticList.size() +
                        ArgStartGroupList.size() +
                        ArgEndGroupList.size() +
+                       ArgDefSymList.size() +
                        1; // bitcode
   std::vector<InputAction*> actions;
   actions.reserve(num_actions);
 
+  // -----  scripts  ----- //
+  /// -T
+  if (!m_Config.options().getScriptList().empty()) {
+    GeneralOptions::const_script_iterator ii, ie = m_Config.options().script_end();
+    for (ii = m_Config.options().script_begin(); ii != ie; ++ii) {
+      actions.push_back(new ScriptAction(0x0,
+                                         *ii,
+                                         ScriptFile::LDScript,
+                                         m_Module.getScript().directories()));
+      actions.push_back(new ContextAction(0x0));
+      actions.push_back(new MemoryAreaAction(0x0, FileHandle::ReadOnly));
+    }
+  }
+
+  /// --defsym
+  cl::list<std::string>::iterator defsym, dsBegin, dsEnd;
+  dsBegin = ArgDefSymList.begin();
+  dsEnd = ArgDefSymList.end();
+  for (defsym = dsBegin; defsym != dsEnd; ++defsym) {
+    unsigned int pos = ArgDefSymList.getPosition(defsym - dsBegin);
+    actions.push_back(new DefSymAction(pos, *defsym));
+  }
+
   // -----  inputs  ----- //
   cl::list<mcld::sys::fs::Path>::iterator input, inBegin, inEnd;
   inBegin = ArgInputObjectFiles.begin();
@@ -277,11 +310,10 @@
   cl::list<std::string>::iterator namespec, nsBegin, nsEnd;
   nsBegin = ArgNameSpecList.begin();
   nsEnd = ArgNameSpecList.end();
-  mcld::Module& module = pBuilder.getModule();
   for (namespec = nsBegin; namespec != nsEnd; ++namespec) {
     unsigned int pos = ArgNameSpecList.getPosition(namespec - nsBegin);
     actions.push_back(new NamespecAction(pos, *namespec,
-                                         module.getScript().directories()));
+                                         m_Module.getScript().directories()));
     actions.push_back(new ContextAction(pos));
     actions.push_back(new MemoryAreaAction(pos, FileHandle::ReadOnly));
   }
diff --git a/lib/Core/Environment.cpp b/lib/Core/Environment.cpp
index 0aa7536..5755fe7 100644
--- a/lib/Core/Environment.cpp
+++ b/lib/Core/Environment.cpp
@@ -9,8 +9,6 @@
 #include <mcld/Environment.h>
 #include <mcld/Support/TargetSelect.h>
 
-#include <llvm/Support/TargetSelect.h>
-
 void mcld::Initialize()
 {
   static bool is_initialized = false;
@@ -18,7 +16,6 @@
   if (is_initialized)
     return;
 
-  llvm::InitializeAllTargets();
   mcld::InitializeAllTargets();
   mcld::InitializeAllEmulations();
   mcld::InitializeAllDiagnostics();
diff --git a/lib/Core/GeneralOptions.cpp b/lib/Core/GeneralOptions.cpp
index 71dcb95..442ae51 100644
--- a/lib/Core/GeneralOptions.cpp
+++ b/lib/Core/GeneralOptions.cpp
@@ -7,7 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/GeneralOptions.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
+#include <mcld/MC/ZOption.h>
 
 using namespace mcld;
 
@@ -20,14 +21,14 @@
     m_MaxErrorNum(-1),
     m_MaxWarnNum(-1),
     m_ExecStack(Unknown),
+    m_NoUndefined(Unknown),
+    m_MulDefs(Unknown),
     m_CommPageSize(0x0),
     m_MaxPageSize(0x0),
     m_bCombReloc(true),
-    m_bNoUndefined(false),
     m_bInitFirst(false),
     m_bInterPose(false),
     m_bLoadFltr(false),
-    m_bMulDefs(false),
     m_bNoCopyReloc(false),
     m_bNoDefaultLib(false),
     m_bNoDelete(false),
@@ -52,6 +53,9 @@
     m_bFatalWarnings(false),
     m_bNewDTags(false),
     m_bNoStdlib(false),
+    m_bWarnMismatch(true),
+    m_bGCSections(false),
+    m_bGenUnwindInfo(true),
     m_GPSize(8),
     m_StripSymbols(KeepAllSymbols),
     m_HashStyle(SystemV) {
@@ -61,20 +65,6 @@
 {
 }
 
-bool GeneralOptions::hasDefaultLDScript() const
-{
-  return true;
-}
-
-const char* GeneralOptions::defaultLDScript() const
-{
-  return NULL;
-}
-
-void GeneralOptions::setDefaultLDScript(const std::string& pFilename)
-{
-}
-
 void GeneralOptions::setSOName(const std::string& pName)
 {
   size_t pos = pName.find_last_of(sys::fs::separator);
@@ -94,7 +84,7 @@
       m_bCombReloc = false;
       break;
     case ZOption::Defs:
-      m_bNoUndefined = true;
+      m_NoUndefined = YES;
       break;
     case ZOption::ExecStack:
       m_ExecStack = YES;
@@ -112,7 +102,7 @@
       m_bLoadFltr = true;
       break;
     case ZOption::MulDefs:
-      m_bMulDefs = true;
+      m_MulDefs = YES;
       break;
     case ZOption::NoCopyReloc:
       m_bNoCopyReloc = true;
diff --git a/lib/Core/IRBuilder.cpp b/lib/Core/IRBuilder.cpp
index 1b9747e..080a122 100644
--- a/lib/Core/IRBuilder.cpp
+++ b/lib/Core/IRBuilder.cpp
@@ -7,14 +7,17 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/IRBuilder.h>
+#include <mcld/LinkerScript.h>
 #include <mcld/LD/ELFReader.h>
 #include <mcld/Object/ObjectBuilder.h>
 #include <mcld/LD/SectionData.h>
 #include <mcld/LD/EhFrame.h>
 #include <mcld/LD/RelocData.h>
 #include <mcld/Support/MsgHandling.h>
+#include <mcld/Support/MemoryArea.h>
 #include <mcld/Support/ELF.h>
 #include <mcld/Fragment/FragmentRef.h>
+#include <llvm/ADT/StringRef.h>
 
 using namespace mcld;
 
@@ -66,6 +69,7 @@
   case llvm::ELF::SHT_STRTAB:
   case llvm::ELF::SHT_HASH:
   case llvm::ELF::SHT_DYNAMIC:
+  case llvm::ELF::SHT_SYMTAB_SHNDX:
     return LDFileFormat::NamePool;
   case llvm::ELF::SHT_RELA:
   case llvm::ELF::SHT_REL:
@@ -92,22 +96,6 @@
   return LDFileFormat::MetaData;
 }
 
-bool ShouldForceLocal(const ResolveInfo& pInfo, const LinkerConfig& pConfig)
-{
-  // forced local symbol matches all rules:
-  // 1. We are not doing incremental linking.
-  // 2. The symbol is with Hidden or Internal visibility.
-  // 3. The symbol should be global or weak. Otherwise, local symbol is local.
-  // 4. The symbol is defined or common
-  if (LinkerConfig::Object != pConfig.codeGenType() &&
-      (pInfo.visibility() == ResolveInfo::Hidden ||
-         pInfo.visibility() == ResolveInfo::Internal) &&
-      (pInfo.isGlobal() || pInfo.isWeak()) &&
-      (pInfo.isDefine() || pInfo.isCommon()))
-    return true;
-  return false;
-}
-
 //===----------------------------------------------------------------------===//
 // IRBuilder
 //===----------------------------------------------------------------------===//
@@ -197,29 +185,6 @@
 }
 
 /// ReadInput - To read an input file and append it to the input tree.
-Input* IRBuilder::ReadInput(raw_mem_ostream& pMemOStream)
-{
-  Input* input = NULL;
-  if (pMemOStream.getMemoryArea().hasHandler()) {
-    m_InputBuilder.createNode<InputTree::Positional>(
-                               "memory ostream",
-                               pMemOStream.getMemoryArea().handler()->path());
-
-    input = *m_InputBuilder.getCurrentNode();
-    m_InputBuilder.setContext(*input);
-    input->setMemArea(&pMemOStream.getMemoryArea());
-  }
-  else {
-    m_InputBuilder.createNode<InputTree::Positional>("memory ostream", "NAN");
-    input = *m_InputBuilder.getCurrentNode();
-    m_InputBuilder.setContext(*input, false);
-    input->setMemArea(&pMemOStream.getMemoryArea());
-  }
-
-  return input;
-}
-
-/// ReadInput - To read an input file and append it to the input tree.
 Input* IRBuilder::ReadInput(FileHandle& pFileHandle)
 {
   m_InputBuilder.createNode<InputTree::Positional>("file handler",
@@ -377,12 +342,8 @@
   if (0 == pLength)
     return new FillFragment(0x0, 0, 0);
 
-  MemoryRegion* region = pInput.memArea()->request(pOffset, pLength);
-
-  if (NULL == region)
-    return new FillFragment(0x0, 0, 0);
-
-  return new RegionFragment(*region);
+  llvm::StringRef region = pInput.memArea()->request(pOffset, pLength);
+  return new RegionFragment(region);
 }
 
 /// CreateRegion - To create a region fragment wrapping the given memory
@@ -391,11 +352,8 @@
   if (0 == pLength)
     return new FillFragment(0x0, 0, 0);
 
-  MemoryRegion* region = MemoryRegion::Create(pMemory, pLength);
-  if (NULL == region)
-    return new FillFragment(0x0, 0, 0);
-
-  return new RegionFragment(*region);
+  llvm::StringRef region(reinterpret_cast<const char*>(pMemory), pLength);
+  return new RegionFragment(region);
 }
 
 /// AppendFragment - To append pFrag to the given SectionData pSD
@@ -527,7 +485,7 @@
   else {
     // if the symbol is not local, insert and resolve it immediately
     m_Module.getNamePool().insertSymbol(pName, false, pType, pDesc, pBinding,
-                                        pSize, pVisibility,
+                                        pSize, pValue, pVisibility,
                                         &old_info, resolved_result);
   }
 
@@ -566,36 +524,6 @@
     output_sym->setFragmentRef(pFragmentRef);
     output_sym->setValue(pValue);
   }
-
-  // Step 4. Adjust the position of output LDSymbol.
-  // After symbol resolution, visibility is changed to the most restrict one.
-  // we need to arrange its position in the output symbol. We arrange the
-  // positions by sorting symbols in SymbolCategory.
-  if (pType != ResolveInfo::Section) {
-    if (!has_output_sym) {
-      // We merge sections when reading them. So we do not need to output symbols
-      // with section type
-
-      // No matter the symbol is already in the output or not, add it if it
-      // should be forcefully set local.
-      if (ShouldForceLocal(*resolved_result.info, m_Config))
-        m_Module.getSymbolTable().forceLocal(*output_sym);
-      else {
-        // the symbol should not be forcefully local.
-        m_Module.getSymbolTable().add(*output_sym);
-      }
-    }
-    else if (resolved_result.overriden) {
-      if (!ShouldForceLocal(old_info, m_Config) ||
-          !ShouldForceLocal(*resolved_result.info, m_Config)) {
-        // If the old info and the new info are both forcefully local, then
-        // we should keep the output_sym in forcefully local category. Else,
-        // we should re-sort the output_sym
-        m_Module.getSymbolTable().arrange(*output_sym, old_info);
-      }
-    }
-  }
-
   return input_sym;
 }
 
@@ -628,7 +556,7 @@
   // resolved_result is a triple <resolved_info, existent, override>
   Resolver::Result resolved_result;
   m_Module.getNamePool().insertSymbol(pName, true, pType, pDesc,
-                                      pBinding, pSize, pVisibility,
+                                      pBinding, pSize, pValue, pVisibility,
                                       NULL, resolved_result);
 
   // the return ResolveInfo should not NULL
@@ -642,25 +570,13 @@
   input_sym->setFragmentRef(FragmentRef::Null());
   input_sym->setValue(pValue);
 
-  LDSymbol* output_sym = NULL;
+  // this symbol is seen in a dynamic object, set the InDyn flag
+  resolved_result.info->setInDyn();
+
   if (!resolved_result.existent) {
     // we get a new symbol, leave it as NULL
     resolved_result.info->setSymPtr(NULL);
   }
-  else {
-    // we saw the symbol before, but the output_sym still may be NULL.
-    output_sym = resolved_result.info->outSymbol();
-  }
-
-  if (output_sym != NULL) {
-    // After symbol resolution, visibility is changed to the most restrict one.
-    // If we are not doing incremental linking, then any symbol with hidden
-    // or internal visibility is forcefully set as a local symbol.
-    if (ShouldForceLocal(*resolved_result.info, m_Config)) {
-      m_Module.getSymbolTable().forceLocal(*output_sym);
-    }
-  }
-
   return input_sym;
 }
 
@@ -673,20 +589,11 @@
                                      uint32_t pOffset,
                                      Relocation::Address pAddend)
 {
-  // FIXME: we should dicard sections and symbols first instead
-  // if the symbol is in the discarded input section, then we also need to
-  // discard this relocation.
-  ResolveInfo* resolve_info = pSym.resolveInfo();
-  if (!pSym.hasFragRef() &&
-      ResolveInfo::Section == resolve_info->type() &&
-      ResolveInfo::Undefined == resolve_info->desc())
-    return NULL;
-
   FragmentRef* frag_ref = FragmentRef::Create(*pSection.getLink(), pOffset);
 
   Relocation* relocation = Relocation::Create(pType, *frag_ref, pAddend);
 
-  relocation->setSymInfo(resolve_info);
+  relocation->setSymInfo(pSym.resolveInfo());
   pSection.getRelocData()->append(*relocation);
 
   return relocation;
@@ -711,7 +618,7 @@
     // create a ResolveInfo
     Resolver::Result result;
     m_Module.getNamePool().insertSymbol(pName, false, pType, pDesc,
-                                        pBinding, pSize, pVisibility,
+                                        pBinding, pSize, pValue, pVisibility,
                                         NULL, result);
     assert(!result.existent);
 
@@ -719,7 +626,7 @@
     output_sym = LDSymbol::Create(*result.info);
     result.info->setSymPtr(output_sym);
 
-    if (ShouldForceLocal(*result.info, m_Config))
+    if (result.info->shouldForceLocal(m_Config))
       m_Module.getSymbolTable().forceLocal(*output_sym);
     else
       m_Module.getSymbolTable().add(*output_sym);
@@ -822,7 +729,7 @@
   Resolver::Result result;
   ResolveInfo old_info;
   m_Module.getNamePool().insertSymbol(pName, false, pType, pDesc, pBinding,
-                                      pSize, pVisibility,
+                                      pSize, pValue, pVisibility,
                                       &old_info, result);
 
   LDSymbol* output_sym = result.info->outSymbol();
@@ -840,7 +747,7 @@
 
   // After symbol resolution, the visibility is changed to the most restrict.
   // arrange the output position
-  if (ShouldForceLocal(*result.info, m_Config))
+  if (result.info->shouldForceLocal(m_Config))
     m_Module.getSymbolTable().forceLocal(*output_sym);
   else if (has_output_sym)
     m_Module.getSymbolTable().arrange(*output_sym, old_info);
diff --git a/lib/Core/InputTree.cpp b/lib/Core/InputTree.cpp
index 15f6f5e..5df91d8 100644
--- a/lib/Core/InputTree.cpp
+++ b/lib/Core/InputTree.cpp
@@ -24,7 +24,7 @@
     return *this;
 
   if (!pTree.empty()) {
-    pMover.connect(pRoot, iterator(pTree.m_Root.node.right));
+    pMover.connect(pRoot, pTree.m_Root.node.right);
     BinaryTreeBase<Input>::m_Root.summon(
         pTree.BinaryTreeBase<Input>::m_Root);
     BinaryTreeBase<Input>::m_Root.delegate(pTree.m_Root);
@@ -37,7 +37,7 @@
                                  const InputTree::Mover& pMover)
 {
   NodeBase* node = createNode();
-  pMover.connect(pRoot, iterator(node));
+  pMover.connect(pRoot, node);
   return *this;
 }
 
@@ -47,7 +47,7 @@
 {
   BinaryTree<Input>::node_type* node = createNode();
   node->data = &pInput;
-  pMover.connect(pRoot, iterator(node));
+  pMover.connect(pRoot, node);
   return *this;
 }
 
diff --git a/lib/Core/Linker.cpp b/lib/Core/Linker.cpp
index 1361402..464f039 100644
--- a/lib/Core/Linker.cpp
+++ b/lib/Core/Linker.cpp
@@ -14,7 +14,7 @@
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Support/TargetRegistry.h>
 #include <mcld/Support/FileHandle.h>
-#include <mcld/Support/MemoryArea.h>
+#include <mcld/Support/FileOutputBuffer.h>
 #include <mcld/Support/raw_ostream.h>
 
 #include <mcld/Object/ObjectLinker.h>
@@ -24,9 +24,12 @@
 #include <mcld/LD/LDSymbol.h>
 #include <mcld/LD/SectionData.h>
 #include <mcld/LD/RelocData.h>
+#include <mcld/LD/ObjectWriter.h>
 #include <mcld/Fragment/Relocation.h>
 #include <mcld/Fragment/FragmentRef.h>
 
+#include <llvm/ADT/OwningPtr.h>
+
 #include <cassert>
 
 using namespace mcld;
@@ -67,7 +70,7 @@
   if (!normalize(pModule, pBuilder))
     return false;
 
-  if (!resolve())
+  if (!resolve(pModule))
     return false;
 
   return layout();
@@ -82,10 +85,8 @@
 
   m_pObjLinker = new ObjectLinker(*m_pConfig, *m_pBackend);
 
-  m_pObjLinker->setup(pModule, pBuilder);
-
-  // 2. - initialize FragmentLinker
-  if (!m_pObjLinker->initFragmentLinker())
+  // 2. - initialize ObjectLinker
+  if (!m_pObjLinker->initialize(pModule, pBuilder))
     return false;
 
   // 3. - initialize output's standard sections
@@ -159,7 +160,7 @@
   return true;
 }
 
-bool Linker::resolve()
+bool Linker::resolve(Module& pModule)
 {
   assert(NULL != m_pConfig);
   assert(m_pObjLinker != NULL);
@@ -172,7 +173,11 @@
   //   To collect all edges in the reference graph.
   m_pObjLinker->readRelocations();
 
-  // 7. - merge all sections
+
+  // 7. - data stripping optimizations
+  m_pObjLinker->dataStrippingOpt();
+
+  // 8. - merge all sections
   //   Push sections into Module's SectionTable.
   //   Merge sections that have the same name.
   //   Maintain them as fragments in the section.
@@ -181,10 +186,16 @@
   if (!m_pObjLinker->mergeSections())
     return false;
 
-  // 8. - allocateCommonSymbols
+  // 9.a - add symbols to output
+  //  After all input symbols have been resolved, add them to output symbol
+  //  table at once
+  m_pObjLinker->addSymbolsToOutput(pModule);
+
+  // 9.b - allocateCommonSymbols
   //   Allocate fragments for common symbols to the corresponding sections.
   if (!m_pObjLinker->allocateCommonSymbols())
     return false;
+
   return true;
 }
 
@@ -192,38 +203,38 @@
 {
   assert(NULL != m_pConfig && NULL != m_pObjLinker);
 
-  // 9. - add standard symbols, target-dependent symbols and script symbols
+  // 10. - add standard symbols, target-dependent symbols and script symbols
   // m_pObjLinker->addUndefSymbols();
   if (!m_pObjLinker->addStandardSymbols() ||
       !m_pObjLinker->addTargetSymbols() ||
       !m_pObjLinker->addScriptSymbols())
     return false;
 
-  // 10. - scan all relocation entries by output symbols.
+  // 11. - scan all relocation entries by output symbols.
   //   reserve GOT space for layout.
   //   the space info is needed by pre-layout to compute the section size
   m_pObjLinker->scanRelocations();
 
-  // 11.a - init relaxation stuff.
+  // 12.a - init relaxation stuff.
   m_pObjLinker->initStubs();
 
-  // 11.b - pre-layout
+  // 12.b - pre-layout
   m_pObjLinker->prelayout();
 
-  // 11.c - linear layout
+  // 12.c - linear layout
   //   Decide which sections will be left in. Sort the sections according to
   //   a given order. Then, create program header accordingly.
   //   Finally, set the offset for sections (@ref LDSection)
   //   according to the new order.
   m_pObjLinker->layout();
 
-  // 11.d - post-layout (create segment, instruction relaxing)
+  // 12.d - post-layout (create segment, instruction relaxing)
   m_pObjLinker->postlayout();
 
-  // 12. - finalize symbol value
+  // 13. - finalize symbol value
   m_pObjLinker->finalizeSymbolValue();
 
-  // 13. - apply relocations
+  // 14. - apply relocations
   m_pObjLinker->relocation();
 
   if (!Diagnose())
@@ -231,12 +242,12 @@
   return true;
 }
 
-bool Linker::emit(MemoryArea& pOutput)
+bool Linker::emit(FileOutputBuffer& pOutput)
 {
-  // 13. - write out output
+  // 15. - write out output
   m_pObjLinker->emitOutput(pOutput);
 
-  // 14. - post processing
+  // 16. - post processing
   m_pObjLinker->postProcessing(pOutput);
 
   if (!Diagnose())
@@ -245,10 +256,23 @@
   return true;
 }
 
-bool Linker::emit(const std::string& pPath)
+bool Linker::emit(const Module& pModule, const std::string& pPath)
 {
   FileHandle file;
-  FileHandle::Permission perm = FileHandle::Permission(0x755);
+  FileHandle::Permission perm;
+  switch (m_pConfig->codeGenType()) {
+    case mcld::LinkerConfig::Unknown:
+    case mcld::LinkerConfig::Object:
+      perm = mcld::FileHandle::Permission(0x644);
+      break;
+    case mcld::LinkerConfig::DynObj:
+    case mcld::LinkerConfig::Exec:
+    case mcld::LinkerConfig::Binary:
+      perm = mcld::FileHandle::Permission(0x755);
+      break;
+    default: assert(0 && "Unknown file type");
+  }
+
   if (!file.open(pPath,
             FileHandle::ReadWrite | FileHandle::Truncate | FileHandle::Create,
             perm)) {
@@ -256,25 +280,28 @@
     return false;
   }
 
-  MemoryArea* output = new MemoryArea(file);
+  llvm::OwningPtr<FileOutputBuffer> output;
+  FileOutputBuffer::create(file,
+                           m_pObjLinker->getWriter()->getOutputSize(pModule),
+                           output);
 
-  bool result = emit(*output);
-
-  delete output;
+  bool result = emit(*output.get());
   file.close();
   return result;
 }
 
-bool Linker::emit(int pFileDescriptor)
+bool Linker::emit(const Module& pModule, int pFileDescriptor)
 {
   FileHandle file;
   file.delegate(pFileDescriptor);
-  MemoryArea* output = new MemoryArea(file);
 
-  bool result = emit(*output);
+  llvm::OwningPtr<FileOutputBuffer> output;
+  FileOutputBuffer::create(file,
+                           m_pObjLinker->getWriter()->getOutputSize(pModule),
+                           output);
 
-  delete output;
-  file.close();
+  bool result = emit(*output.get());
+
   return result;
 }
 
@@ -308,9 +335,14 @@
   assert(NULL != m_pConfig);
 
   std::string error;
-  m_pTarget = mcld::TargetRegistry::lookupTarget(m_pConfig->targets().triple().str(), error);
+  llvm::Triple triple(m_pConfig->targets().triple());
+
+  m_pTarget = mcld::TargetRegistry::lookupTarget(m_pConfig->targets().getArch(),
+                                                 triple, error);
+  m_pConfig->targets().setTriple(triple);
+
   if (NULL == m_pTarget) {
-    fatal(diag::fatal_cannot_init_target) << m_pConfig->targets().triple().str() << error;
+    fatal(diag::fatal_cannot_init_target) << triple.str() << error;
     return false;
   }
   return true;
diff --git a/lib/Core/LinkerScript.cpp b/lib/Core/LinkerScript.cpp
index 4bee579..2e891e2 100644
--- a/lib/Core/LinkerScript.cpp
+++ b/lib/Core/LinkerScript.cpp
@@ -36,3 +36,32 @@
   return !sysroot().empty();
 }
 
+const std::string& LinkerScript::entry() const
+{
+  return m_Entry;
+}
+
+void LinkerScript::setEntry(const std::string& pEntry)
+{
+  m_Entry = pEntry;
+}
+
+bool LinkerScript::hasEntry() const
+{
+  return !m_Entry.empty();
+}
+
+const std::string& LinkerScript::outputFile() const
+{
+  return m_OutputFile;
+}
+
+void LinkerScript::setOutputFile(const std::string& pOutputFile)
+{
+  m_OutputFile = pOutputFile;
+}
+
+bool LinkerScript::hasOutputFile() const
+{
+  return !m_OutputFile.empty();
+}
diff --git a/lib/Core/TargetOptions.cpp b/lib/Core/TargetOptions.cpp
index 4f2cea2..710899c 100644
--- a/lib/Core/TargetOptions.cpp
+++ b/lib/Core/TargetOptions.cpp
@@ -38,6 +38,11 @@
   m_Triple.setTriple(pTriple);
 }
 
+void TargetOptions::setArch(const std::string& pArchName)
+{
+  m_ArchName = pArchName;
+}
+
 void TargetOptions::setTargetCPU(const std::string& pCPU)
 {
   m_TargetCPU = pCPU;
diff --git a/lib/Fragment/Android.mk b/lib/Fragment/Android.mk
index 6e875a8..743232f 100644
--- a/lib/Fragment/Android.mk
+++ b/lib/Fragment/Android.mk
@@ -2,10 +2,8 @@
 
 mcld_fragment_SRC_FILES := \
   AlignFragment.cpp \
-  FGNode.cpp \
   FillFragment.cpp \
   Fragment.cpp \
-  FragmentLinker.cpp \
   FragmentRef.cpp \
   NullFragment.cpp \
   RegionFragment.cpp \
diff --git a/lib/Fragment/FGNode.cpp b/lib/Fragment/FGNode.cpp
deleted file mode 100644
index 92706ba..0000000
--- a/lib/Fragment/FGNode.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//===- FGNode.cpp ---------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Fragment/FGNode.h>
-
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// FGNode
-//===----------------------------------------------------------------------===//
-FGNode::FGNode()
-  : m_Index(0x0)
-{
-}
-
-FGNode::FGNode(uint32_t pIndex)
-  : m_Index(pIndex)
-{
-}
-
-void FGNode::addFragment(Fragment* pFrag)
-{
-  m_Fragments.push_back(pFrag);
-}
-
-void FGNode::addSignal(Signal pSignal)
-{
-  m_Signals.push_back(pSignal);
-}
-
-void FGNode::addSlot(Slot pSlot)
-{
-  m_Slots.push_back(pSlot);
-}
-
diff --git a/lib/Fragment/FragmentGraph.cpp b/lib/Fragment/FragmentGraph.cpp
deleted file mode 100644
index 3140447..0000000
--- a/lib/Fragment/FragmentGraph.cpp
+++ /dev/null
@@ -1,412 +0,0 @@
-//===- FragmentGraph.cpp --------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Fragment/FragmentGraph.h>
-#include <mcld/Fragment/Fragment.h>
-#include <mcld/Fragment/Relocation.h>
-#include <mcld/LD/LDContext.h>
-#include <mcld/LD/LDFileFormat.h>
-#include <mcld/LD/LDSection.h>
-#include <mcld/LD/LDSymbol.h>
-#include <mcld/LD/SectionData.h>
-#include <mcld/LD/RelocData.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/Module.h>
-#include <mcld/Support/MsgHandling.h>
-
-#include <llvm/Support/Casting.h>
-#include <llvm/Support/ELF.h>
-
-#include <iostream>
-
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// non-member functions
-//===----------------------------------------------------------------------===//
-static int get_state(Fragment::Type pKind)
-{
-  switch(pKind) {
-    case Fragment::Alignment:
-      return 0;
-    case Fragment::Fillment:
-    case Fragment::Region:
-      return 1;
-    case Fragment::Null:
-      return 2;
-    default:
-      unreachable(diag::unexpected_frag_type) << pKind;
-  }
-  return 0;
-}
-
-//===----------------------------------------------------------------------===//
-// ReachMatrix
-//===----------------------------------------------------------------------===//
-FragmentGraph::ReachMatrix::ReachMatrix(size_t pSize)
-{
-  assert(pSize != 0);
-  m_Data.assign(pSize * pSize, 0x0);
-  m_N = pSize;
-}
-
-uint32_t& FragmentGraph::ReachMatrix::at(uint32_t pX, uint32_t pY)
-{
-  return m_Data[pX * m_N + pY];
-}
-
-uint32_t FragmentGraph::ReachMatrix::at(uint32_t pX, uint32_t pY) const
-{
-  return m_Data[pX * m_N + pY];
-}
-
-//===----------------------------------------------------------------------===//
-// FragmentGraph
-//===----------------------------------------------------------------------===//
-FragmentGraph::FragmentGraph()
- : m_pMatrix(NULL), m_NumOfPNodes(0x0), m_NumOfRNodes(0x0), m_NumOfEdges(0x0)
-{
-  m_pPseudoNodeFactory = new NodeFactoryType();
-  m_pRegularNodeFactory = new NodeFactoryType();
-  m_pFragNodeMap = new FragHashTableType(256);
-  m_pSymNodeMap = new SymHashTableType(256);
-}
-
-FragmentGraph::~FragmentGraph()
-{
-  delete m_pPseudoNodeFactory;
-  delete m_pRegularNodeFactory;
-  delete m_pFragNodeMap;
-}
-
-FGNode* FragmentGraph::getNode(const Fragment& pFrag)
-{
-  FragHashTableType::iterator entry = m_pFragNodeMap->find(&pFrag);
-  if (entry == m_pFragNodeMap->end())
-    return NULL;
-  return entry.getEntry()->value();
-}
-
-const FGNode* FragmentGraph::getNode(const Fragment& pFrag) const
-{
-  FragHashTableType::iterator entry = m_pFragNodeMap->find(&pFrag);
-  if (entry == m_pFragNodeMap->end())
-    return NULL;
-  return entry.getEntry()->value();
-}
-
-FGNode* FragmentGraph::getNode(const ResolveInfo& pSym)
-{
-  SymHashTableType::iterator entry = m_pSymNodeMap->find(&pSym);
-  if (entry == m_pSymNodeMap->end())
-    return NULL;
-  return entry.getEntry()->value();
-}
-
-const FGNode* FragmentGraph::getNode(const ResolveInfo& pSym) const
-{
-  SymHashTableType::iterator entry = m_pSymNodeMap->find(&pSym);
-  if (entry == m_pSymNodeMap->end())
-    return NULL;
-  return entry.getEntry()->value();
-}
-
-FGNode* FragmentGraph::producePseudoNode()
-{
-  FGNode* result = m_pPseudoNodeFactory->allocate();
-  new (result) FGNode(m_NumOfPNodes + m_NumOfRNodes);
-  ++m_NumOfPNodes;
-  return result;
-}
-
-FGNode* FragmentGraph::produceRegularNode()
-{
-  FGNode* result = m_pRegularNodeFactory->allocate();
-  new (result) FGNode(m_NumOfPNodes + m_NumOfRNodes);
-  ++m_NumOfRNodes;
-  return result;
-}
-
-bool FragmentGraph::setNodeSlots(Module& pModule)
-{
-  // symbols are the slots of nodes, push the symbols into the corresponding
-  // nodes.
-
-  // Traverse all defined symbols, including global and local symbols, to add
-  // symbols into the corresponding nodes
-  Module::SymbolTable& sym_tab = pModule.getSymbolTable();
-  SymbolCategory::iterator sym_it, sym_end = sym_tab.end();
-  for (sym_it = sym_tab.begin(); sym_it != sym_end; ++sym_it) {
-    // only the defined symbols with FragmnentRef can form a slot. The defined
-    // symbol with no FragmentRef such as ABS symbol should be skipped
-    LDSymbol* sym = *sym_it;
-    if (!sym->resolveInfo()->isDefine() ||
-        !sym->hasFragRef())
-      continue;
-
-    // FIXME: judge by getNode() is NULL or not
-    LDFileFormat::Kind sect_kind =
-                       sym->fragRef()->frag()->getParent()->getSection().kind();
-    if (sect_kind != LDFileFormat::Regular &&
-        sect_kind != LDFileFormat::BSS)
-      continue;
-
-    FGNode* node = getNode(*sym->fragRef()->frag());
-    assert(NULL != node);
-    node->addSlot(sym->resolveInfo());
-  }
-
-  return true;
-}
-
-bool FragmentGraph::createRegularEdges(Module& pModule)
-{
-  // The reference between nodes are presented by the relocations. Set the
-  // reachability matrix to present the connection
-
-  // Traverse all input relocations to set connection
-  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) {
-      // bypass the discarded relocations
-      // 1. its section kind is changed to Ignore. (The target section is a
-      // discarded group section.)
-      // 2. it has no reloc data. (All symbols in the input relocs are in the
-      // discarded group sections)
-      if (LDFileFormat::Ignore == (*rs)->kind() || !(*rs)->hasRelocData())
-        continue;
-      RelocData::iterator reloc_it, rEnd = (*rs)->getRelocData()->end();
-      for (reloc_it = (*rs)->getRelocData()->begin(); reloc_it != rEnd;
-                                                                   ++reloc_it) {
-        Relocation* reloc = llvm::cast<Relocation>(reloc_it);
-        ResolveInfo* sym = reloc->symInfo();
-        // only the target symbols defined in the input fragments can make the
-        // connection
-        if (NULL == sym)
-          continue;
-        if (!sym->isDefine() || !sym->outSymbol()->hasFragRef())
-          continue;
-
-        // only the relocation target places which defined in the concerned
-        // sections can make the connection
-        // FIXME: judge by getNode() is NULL or not
-        LDFileFormat::Kind sect_kind =
-                   reloc->targetRef().frag()->getParent()->getSection().kind();
-        if (sect_kind != LDFileFormat::Regular &&
-            sect_kind != LDFileFormat::BSS)
-          continue;
-
-        // only the target symbols defined in the concerned sections can make
-        // the connection
-        // FIXME: judge by getNode() is NULL or not
-        sect_kind =
-          sym->outSymbol()->fragRef()->frag()->getParent()->getSection().kind();
-        if (sect_kind != LDFileFormat::Regular &&
-            sect_kind != LDFileFormat::BSS)
-          continue;
-
-        connect(reloc, sym);
-      }
-    }
-  }
-  return true;
-}
-
-bool FragmentGraph::createPseudoEdges(Module& pModule)
-{
-  // the pseudo edges are the edges from pseudo nodes to regular nodes, which
-  // present the reference from out-side world when building shared library
-
-  // Traverse all pseudo relocations in the pseudo nodes to set the connection
-  node_iterator node_it, node_end = m_pPseudoNodeFactory->end();
-  for (node_it = m_pPseudoNodeFactory->begin(); node_it != node_end; ++node_it) {
-    FGNode& node = *node_it;
-    FGNode::signal_iterator sig_it, sig_end = node.signal_end();
-    for (sig_it = node.signal_begin(); sig_it != sig_end; ++sig_it) {
-      connect(node, (*sig_it)->symInfo());
-    }
-  }
-  return true;
-}
-
-bool FragmentGraph::connect(Signal pSignal, Slot pSlot)
-{
-  FGNode* from = getNode(*pSignal->targetRef().frag());
-  assert(NULL != from);
-
-  FGNode* to = getNode(*pSlot->outSymbol()->fragRef()->frag());
-  assert(NULL != to);
-
-  // maintain edge counter
-  if (0 == m_pMatrix->at(from->getIndex(), to->getIndex()))
-    ++m_NumOfEdges;
-  ++m_pMatrix->at(from->getIndex(), to->getIndex());
-  return true;
-}
-
-bool FragmentGraph::connect(FGNode& pFrom, Slot pSlot)
-{
-  FGNode* to = getNode(*pSlot->outSymbol()->fragRef()->frag());
-  assert(NULL != to);
-
-  // maintain edge counter
-  if (0 == m_pMatrix->at(pFrom.getIndex(), to->getIndex()))
-    ++m_NumOfEdges;
-  ++m_pMatrix->at(pFrom.getIndex(), to->getIndex());
-  return true;
-}
-
-bool FragmentGraph::createPseudoNodes(Module& pModule)
-{
-  // when generating shared library, we need to create pseudo node for every
-  // global defined symbols to present the fan-in of a regular node.
-
-  // Traverse all global defined symbols to build the pseudo nodes.
-  Module::SymbolTable& sym_tab = pModule.getSymbolTable();
-  SymbolCategory::iterator sym_it, sym_end = sym_tab.dynamicEnd();
-  for (sym_it = sym_tab.dynamicBegin(); sym_it != sym_end; ++sym_it) {
-    ResolveInfo* sym = (*sym_it)->resolveInfo();
-    if (!sym->isDefine() || !sym->outSymbol()->hasFragRef())
-      continue;
-    FGNode* node = producePseudoNode();
-    // create the pseudo relocation to present the fan-out of the pseudo node
-    Relocation* reloc = Relocation::Create();
-    reloc->setSymInfo(sym);
-
-    // set the signal of the pseudo node
-    node->addSignal(reloc);
-
-    // maintain the map for symbol to pseudo node
-    SymHashTableType::entry_type* entry = 0;
-    bool exist = false;
-    entry = m_pSymNodeMap->insert(sym, exist);
-    entry->setValue(node);
-
-  }
-  return true;
-}
-
-bool FragmentGraph::createRegularNodes(Module& pModule)
-{
-  // Traverse all sections to build the Nodes. We build nodes only for Regular,
-  // and BSS
-  Module::iterator sect_it, sect_end = pModule.end();
-  for (sect_it = pModule.begin(); sect_it != sect_end; ++sect_it) {
-    LDSection* section = *sect_it;
-    SectionData* sect_data = NULL;
-
-    if (LDFileFormat::Regular != section->kind() &&
-        LDFileFormat::BSS != section->kind())
-      continue;
-
-    sect_data = section->getSectionData();
-    if (NULL == sect_data)
-      continue;
-
-    // Traverse all fragments in the sections, create Nodes and push the
-    // fragments into Nodes. Each Region or Fillment fragment belongs to a
-    // unique Node. The corresponding Align fragments and Null fragments belong
-    // to the same Node as the Region or Fillment fragment.
-    SectionData::iterator frag_it  = sect_data->begin();
-    SectionData::iterator frag_end = sect_data->end();
-    if (frag_it == frag_end)
-      continue;
-
-    int cur_stat = 0;
-    int last_stat = 0;
-    // FIXME:
-    // To prevent some cases that we add the redundant NULL or Align fragments
-    // and lead a Region/Fillment fragment has more than one NULL or Align
-    // fragment. We should put all of them into the same Node.
-    static int stat_matrix[3][3] = {{0, 1, 1},
-                                    {0, 1, 1},
-                                    {0, 0, 0}};
-
-    FragHashTableType::entry_type* entry = 0;
-    bool exist = false;
-
-    FGNode* node = produceRegularNode();
-    Fragment* frag = NULL;
-
-    frag = &(*frag_it);
-    cur_stat = get_state(frag->getKind());
-
-    node->addFragment(frag);
-    // maintain the fragment to Node map
-    entry = m_pFragNodeMap->insert(frag, exist);
-    entry->setValue(node);
-    ++frag_it;
-
-    while (frag_it != frag_end) {
-      last_stat = cur_stat;
-      frag = &(*frag_it);
-
-      cur_stat = get_state(frag->getKind());
-
-      if (stat_matrix[cur_stat][last_stat]) {
-        node = produceRegularNode();
-      }
-      node->addFragment(frag);
-      // maintain the fragment to Node map
-      entry = m_pFragNodeMap->insert(frag, exist);
-      entry->setValue(node);
-
-      ++frag_it;
-    }
-  }
-  return true;
-}
-
-void FragmentGraph::initMatrix()
-{
-  m_pMatrix = new ReachMatrix(m_NumOfPNodes + m_NumOfRNodes);
-}
-
-bool FragmentGraph::getEdges(FGNode& pNode, EdgeListType& pEdges)
-{
-  // Traverse all regular nodes to find the connection to pNode
-  node_iterator it, itEnd = m_pRegularNodeFactory->end();
-  for (it = m_pRegularNodeFactory->begin(); it != itEnd; ++it) {
-    FGNode& node_to = *it;
-    uint32_t weight = m_pMatrix->at(pNode.getIndex(), node_to.getIndex());
-    if (weight > 0) {
-      // build an Edge
-      pEdges.push_back(FGEdge(pNode, node_to, weight));
-    }
-  }
-
-  return true;
-}
-
-bool FragmentGraph::construct(const LinkerConfig& pConfig, Module& pModule)
-{
-  // create nodes - traverse all fragments to create the regular nodes, and
-  // then traverse all global defined symbols to create pseudo nodes
-  if (!createRegularNodes(pModule))
-    return false;
-  if (!createPseudoNodes(pModule))
-    return false;
-
-  // after all nodes created, we know the number of the nodes and then can
-  // create the reachability matrix
-  initMatrix();
-
-  // set slots - traverse all symbols to set the slots of regular nodes
-  if(!setNodeSlots(pModule))
-    return false;
-
-  // connect edges - traverse all relocations to set the edges
-  if(!createRegularEdges(pModule))
-    return false;
-  if(!createPseudoEdges(pModule))
-    return false;
-
-  return true;
-}
-
diff --git a/lib/Fragment/FragmentLinker.cpp b/lib/Fragment/FragmentLinker.cpp
deleted file mode 100644
index 5a4b53f..0000000
--- a/lib/Fragment/FragmentLinker.cpp
+++ /dev/null
@@ -1,265 +0,0 @@
-//===- FragmentLinker.cpp -------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the FragmentLinker class
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Fragment/FragmentLinker.h>
-
-#include <llvm/Support/Host.h>
-#include <llvm/Support/raw_ostream.h>
-#include <llvm/Support/Casting.h>
-
-#include <mcld/LinkerConfig.h>
-#include <mcld/Module.h>
-#include <mcld/LD/LDSection.h>
-#include <mcld/MC/MCLDInput.h>
-#include <mcld/LD/LDSection.h>
-#include <mcld/LD/BranchIslandFactory.h>
-#include <mcld/LD/Resolver.h>
-#include <mcld/LD/LDContext.h>
-#include <mcld/LD/RelocationFactory.h>
-#include <mcld/LD/RelocData.h>
-#include <mcld/LD/Relocator.h>
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/FileHandle.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Target/TargetLDBackend.h>
-#include <mcld/Fragment/Relocation.h>
-
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// FragmentLinker
-//===----------------------------------------------------------------------===//
-/// Constructor
-FragmentLinker::FragmentLinker(const LinkerConfig& pConfig,
-                               Module& pModule,
-                               TargetLDBackend& pBackend)
-
-  : m_Config(pConfig),
-    m_Module(pModule),
-    m_Backend(pBackend) {
-}
-
-/// Destructor
-FragmentLinker::~FragmentLinker()
-{
-}
-
-bool FragmentLinker::finalizeSymbols()
-{
-  Module::sym_iterator symbol, symEnd = m_Module.sym_end();
-  for (symbol = m_Module.sym_begin(); symbol != symEnd; ++symbol) {
-
-    if ((*symbol)->resolveInfo()->isAbsolute() ||
-        (*symbol)->resolveInfo()->type() == ResolveInfo::File) {
-      // absolute symbols or symbols with function type should have
-      // zero value
-      (*symbol)->setValue(0x0);
-      continue;
-    }
-
-    if ((*symbol)->resolveInfo()->type() == ResolveInfo::ThreadLocal) {
-      m_Backend.finalizeTLSSymbol(**symbol);
-      continue;
-    }
-
-    if ((*symbol)->hasFragRef()) {
-      // set the virtual address of the symbol. If the output file is
-      // relocatable object file, the section's virtual address becomes zero.
-      // And the symbol's value become section relative offset.
-      uint64_t value = (*symbol)->fragRef()->getOutputOffset();
-      assert(NULL != (*symbol)->fragRef()->frag());
-      uint64_t addr = (*symbol)->fragRef()->frag()->getParent()->getSection().addr();
-      (*symbol)->setValue(value + addr);
-      continue;
-    }
-  }
-
-  return true;
-}
-
-//===----------------------------------------------------------------------===//
-// Relocation Operations
-//===----------------------------------------------------------------------===//
-bool FragmentLinker::applyRelocations()
-{
-  // when producing relocatables, no need to apply relocation
-  if (LinkerConfig::Object == m_Config.codeGenType())
-    return true;
-
-  // apply all relocations of all inputs
-  Module::obj_iterator input, inEnd = m_Module.obj_end();
-  for (input = m_Module.obj_begin(); input != inEnd; ++input) {
-    m_Backend.getRelocator()->initializeApply(**input);
-    LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
-    for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
-      // bypass the reloc section if
-      // 1. its section kind is changed to Ignore. (The target section is a
-      // discarded group section.)
-      // 2. it has no reloc data. (All symbols in the input relocs are in the
-      // discarded group sections)
-      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);
-        relocation->apply(*m_Backend.getRelocator());
-      } // for all relocations
-    } // for all relocation section
-    m_Backend.getRelocator()->finalizeApply(**input);
-  } // for all inputs
-
-  // apply relocations created by relaxation
-  BranchIslandFactory* br_factory = m_Backend.getBRIslandFactory();
-  BranchIslandFactory::iterator facIter, facEnd = br_factory->end();
-  for (facIter = br_factory->begin(); facIter != facEnd; ++facIter) {
-    BranchIsland& island = *facIter;
-    BranchIsland::reloc_iterator iter, iterEnd = island.reloc_end();
-    for (iter = island.reloc_begin(); iter != iterEnd; ++iter)
-      (*iter)->apply(*m_Backend.getRelocator());
-  }
-  return true;
-}
-
-
-void FragmentLinker::syncRelocationResult(MemoryArea& pOutput)
-{
-  if (LinkerConfig::Object != m_Config.codeGenType())
-    normalSyncRelocationResult(pOutput);
-  else
-    partialSyncRelocationResult(pOutput);
-  return;
-}
-
-void FragmentLinker::normalSyncRelocationResult(MemoryArea& pOutput)
-{
-  MemoryRegion* region = pOutput.request(0, pOutput.handler()->size());
-
-  uint8_t* data = region->getBuffer();
-
-  // sync all relocations of all inputs
-  Module::obj_iterator input, inEnd = m_Module.obj_end();
-  for (input = m_Module.obj_begin(); input != inEnd; ++input) {
-    LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
-    for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
-      // bypass the reloc section if
-      // 1. its section kind is changed to Ignore. (The target section is a
-      // discarded group section.)
-      // 2. it has no reloc data. (All symbols in the input relocs are in the
-      // discarded group sections)
-      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);
-
-        // bypass the relocation with NONE type. This is to avoid overwrite the
-        // target result by NONE type relocation if there is a place which has
-        // two relocations to apply to, and one of it is NONE type. The result
-        // we want is the value of the other relocation result. For example,
-        // in .exidx, there are usually an R_ARM_NONE and R_ARM_PREL31 apply to
-        // the same place
-        if (0x0 == relocation->type())
-          continue;
-        writeRelocationResult(*relocation, data);
-      } // for all relocations
-    } // for all relocation section
-  } // for all inputs
-
-  // sync relocations created by relaxation
-  BranchIslandFactory* br_factory = m_Backend.getBRIslandFactory();
-  BranchIslandFactory::iterator facIter, facEnd = br_factory->end();
-  for (facIter = br_factory->begin(); facIter != facEnd; ++facIter) {
-    BranchIsland& island = *facIter;
-    BranchIsland::reloc_iterator iter, iterEnd = island.reloc_end();
-    for (iter = island.reloc_begin(); iter != iterEnd; ++iter) {
-      Relocation* reloc = *iter;
-      writeRelocationResult(*reloc, data);
-    }
-  }
-
-  pOutput.clear();
-}
-
-void FragmentLinker::partialSyncRelocationResult(MemoryArea& pOutput)
-{
-  MemoryRegion* region = pOutput.request(0, pOutput.handler()->size());
-
-  uint8_t* data = region->getBuffer();
-
-  // traverse outputs' LDSection to get RelocData
-  Module::iterator sectIter, sectEnd = m_Module.end();
-  for (sectIter = m_Module.begin(); sectIter != sectEnd; ++sectIter) {
-    if (LDFileFormat::Relocation != (*sectIter)->kind())
-      continue;
-
-    RelocData* reloc_data = (*sectIter)->getRelocData();
-    RelocData::iterator relocIter, relocEnd = reloc_data->end();
-    for (relocIter = reloc_data->begin(); relocIter != relocEnd; ++relocIter) {
-      Relocation* reloc = llvm::cast<Relocation>(relocIter);
-
-      // bypass the relocation with NONE type. This is to avoid overwrite the
-      // target result by NONE type relocation if there is a place which has
-      // two relocations to apply to, and one of it is NONE type. The result
-      // we want is the value of the other relocation result. For example,
-      // in .exidx, there are usually an R_ARM_NONE and R_ARM_PREL31 apply to
-      // the same place
-      if (0x0 == reloc->type())
-        continue;
-      writeRelocationResult(*reloc, data);
-    }
-  }
-
-  pOutput.clear();
-}
-
-void FragmentLinker::writeRelocationResult(Relocation& pReloc, uint8_t* pOutput)
-{
-  // get output file offset
-  size_t out_offset =
-                 pReloc.targetRef().frag()->getParent()->getSection().offset() +
-                 pReloc.targetRef().getOutputOffset();
-
-  uint8_t* target_addr = pOutput + out_offset;
-  // byte swapping if target and host has different endian, and then write back
-  if(llvm::sys::IsLittleEndianHost != m_Config.targets().isLittleEndian()) {
-     uint64_t tmp_data = 0;
-
-     switch(pReloc.size(*m_Backend.getRelocator())) {
-       case 8u:
-         std::memcpy(target_addr, &pReloc.target(), 1);
-         break;
-
-       case 16u:
-         tmp_data = mcld::bswap16(pReloc.target());
-         std::memcpy(target_addr, &tmp_data, 2);
-         break;
-
-       case 32u:
-         tmp_data = mcld::bswap32(pReloc.target());
-         std::memcpy(target_addr, &tmp_data, 4);
-         break;
-
-       case 64u:
-         tmp_data = mcld::bswap64(pReloc.target());
-         std::memcpy(target_addr, &tmp_data, 8);
-         break;
-
-       default:
-         break;
-    }
-  }
-  else
-    std::memcpy(target_addr, &pReloc.target(),
-                                      pReloc.size(*m_Backend.getRelocator())/8);
-}
-
diff --git a/lib/Fragment/FragmentRef.cpp b/lib/Fragment/FragmentRef.cpp
index 9383e87..a22beca 100644
--- a/lib/Fragment/FragmentRef.cpp
+++ b/lib/Fragment/FragmentRef.cpp
@@ -8,21 +8,20 @@
 //===----------------------------------------------------------------------===//
 #include <mcld/Fragment/FragmentRef.h>
 
-#include <cstring>
-#include <cassert>
-
-#include <llvm/Support/Casting.h>
-#include <llvm/Support/ManagedStatic.h>
-
 #include <mcld/Fragment/Fragment.h>
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/SectionData.h>
 #include <mcld/LD/EhFrame.h>
 #include <mcld/Support/GCFactory.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Fragment/RegionFragment.h>
 #include <mcld/Fragment/Stub.h>
 
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/Casting.h>
+#include <llvm/Support/ManagedStatic.h>
+
+#include <cassert>
+
 using namespace mcld;
 
 typedef GCFactory<FragmentRef, MCLD_SECTIONS_PER_INPUT> FragRefFactory;
@@ -61,13 +60,18 @@
       break;
     frag = frag->getNextNode();
   }
-
+  if ((frag != NULL) && (frag->size() != 0)) {
+    if (offset == 0)
+      frag = frag->getNextNode();
+    else
+      offset += frag->size();
+  }
 
   if (NULL == frag)
     return Null();
 
   FragmentRef* result = g_FragRefFactory->allocate();
-  new (result) FragmentRef(*frag, offset + frag->size());
+  new (result) FragmentRef(*frag, offset);
 
   return result;
 }
@@ -132,7 +136,7 @@
       if (total_length < (total_offset+pNBytes))
         pNBytes = total_length - total_offset;
 
-      std::memcpy(pDest, region_frag->getRegion().getBuffer(total_offset), pNBytes);
+      std::memcpy(pDest, region_frag->getRegion().begin() + total_offset, pNBytes);
       return;
     }
     case Fragment::Stub: {
@@ -150,40 +154,6 @@
   }
 }
 
-FragmentRef::Address FragmentRef::deref()
-{
-  if (NULL == m_pFragment)
-    return NULL;
-  Address base = NULL;
-  switch(m_pFragment->getKind()) {
-    case Fragment::Region:
-      base = static_cast<RegionFragment*>(m_pFragment)->getRegion().getBuffer();
-      break;
-    case Fragment::Alignment:
-    case Fragment::Fillment:
-    default:
-      return NULL;
-  }
-  return base + m_Offset;
-}
-
-FragmentRef::ConstAddress FragmentRef::deref() const
-{
-  if (NULL == m_pFragment)
-    return NULL;
-  ConstAddress base = NULL;
-  switch(m_pFragment->getKind()) {
-    case Fragment::Region:
-      base = static_cast<const RegionFragment*>(m_pFragment)->getRegion().getBuffer();
-      break;
-    case Fragment::Alignment:
-    case Fragment::Fillment:
-    default:
-      return NULL;
-  }
-  return base + m_Offset;
-}
-
 FragmentRef::Offset FragmentRef::getOutputOffset() const
 {
   Offset result = 0;
@@ -191,4 +161,3 @@
     result = m_pFragment->getOffset();
   return (result + m_Offset);
 }
-
diff --git a/lib/Fragment/RegionFragment.cpp b/lib/Fragment/RegionFragment.cpp
index 363a0f2..c8971b8 100644
--- a/lib/Fragment/RegionFragment.cpp
+++ b/lib/Fragment/RegionFragment.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/Fragment/RegionFragment.h>
-#include <mcld/Support/MemoryRegion.h>
 
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
 // RegionFragment
 //===----------------------------------------------------------------------===//
-RegionFragment::RegionFragment(MemoryRegion& pRegion, SectionData* pSD)
+RegionFragment::RegionFragment(llvm::StringRef pRegion, SectionData* pSD)
   : Fragment(Fragment::Region, pSD), m_Region(pRegion) {
 }
 
diff --git a/lib/Fragment/Relocation.cpp b/lib/Fragment/Relocation.cpp
index fd042ea..1537c0c 100644
--- a/lib/Fragment/Relocation.cpp
+++ b/lib/Fragment/Relocation.cpp
@@ -91,8 +91,10 @@
 Relocation::Address Relocation::symValue() const
 {
   if (m_pSymInfo->type() == ResolveInfo::Section &&
-     m_pSymInfo->outSymbol()->hasFragRef()) {
-    return m_pSymInfo->outSymbol()->fragRef()->frag()->getParent()->getSection().addr();
+      m_pSymInfo->outSymbol()->hasFragRef()) {
+    const FragmentRef* fragRef = m_pSymInfo->outSymbol()->fragRef();
+    return fragRef->frag()->getParent()->getSection().addr() +
+           fragRef->getOutputOffset();
   }
   return m_pSymInfo->outSymbol()->value();
 }
@@ -156,4 +158,3 @@
     m_Addend += offset;
   }
 }
-
diff --git a/lib/LD/Archive.cpp b/lib/LD/Archive.cpp
index ee2edea..864cedb 100644
--- a/lib/LD/Archive.cpp
+++ b/lib/LD/Archive.cpp
@@ -8,11 +8,8 @@
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/Archive.h>
 #include <mcld/MC/InputBuilder.h>
-#include <mcld/MC/MCLDInput.h>
-#include <mcld/MC/AttributeSet.h>
-#include <mcld/MC/ContextFactory.h>
+#include <mcld/MC/Input.h>
 #include <llvm/ADT/StringRef.h>
-#include <mcld/Support/MemoryAreaFactory.h>
 #include <mcld/Support/MsgHandling.h>
 
 using namespace mcld;
@@ -23,6 +20,7 @@
 const char   Archive::THIN_MAGIC[]       = "!<thin>\n";
 const size_t Archive::MAGIC_LEN          = sizeof(Archive::MAGIC) - 1;
 const char   Archive::SVR4_SYMTAB_NAME[] = "/               ";
+const char   Archive::IRIX6_SYMTAB_NAME[]= "/SYM64/         ";
 const char   Archive::STRTAB_NAME[]      = "//              ";
 const char   Archive::PAD[]              = "\n";
 const char   Archive::MEMBER_MAGIC[]     = "`\n";
diff --git a/lib/LD/BSDArchiveReader.cpp b/lib/LD/BSDArchiveReader.cpp
index bd59844..57d3a52 100644
--- a/lib/LD/BSDArchiveReader.cpp
+++ b/lib/LD/BSDArchiveReader.cpp
@@ -6,7 +6,7 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/LD/BSDArchiveReader.h>
 #include <mcld/LD/Archive.h>
 
@@ -20,14 +20,16 @@
 {
 }
 
-bool BSDArchiveReader::readArchive(Archive& pArchive)
+bool BSDArchiveReader::readArchive(const LinkerConfig& pConfig,
+                                   Archive& pArchive)
 {
   // TODO
   return true;
 }
 
-bool BSDArchiveReader::isMyFormat(Input& pInput) const
+bool BSDArchiveReader::isMyFormat(Input& pInput, bool &pContinue) const
 {
+  pContinue = true;
   // TODO
   return false;
 }
diff --git a/lib/LD/BinaryReader.cpp b/lib/LD/BinaryReader.cpp
new file mode 100644
index 0000000..f5c439f
--- /dev/null
+++ b/lib/LD/BinaryReader.cpp
@@ -0,0 +1,19 @@
+//===- BinaryReader.cpp ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/LD/BinaryReader.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// BinaryReader
+//===----------------------------------------------------------------------===//
+BinaryReader::~BinaryReader()
+{
+}
+
diff --git a/lib/LD/BranchIslandFactory.cpp b/lib/LD/BranchIslandFactory.cpp
index 6a61481..116f075 100644
--- a/lib/LD/BranchIslandFactory.cpp
+++ b/lib/LD/BranchIslandFactory.cpp
@@ -8,6 +8,9 @@
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/BranchIslandFactory.h>
 #include <mcld/Fragment/Fragment.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/Module.h>
 
 using namespace mcld;
 
@@ -31,43 +34,40 @@
 {
 }
 
+/// group - group fragments and create islands when needed
+/// @param pSectionData - the SectionData holds fragments need to be grouped
+void BranchIslandFactory::group(Module& pModule)
+{
+  /* 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_MaxBranchRange - m_MaxIslandSize;
+    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_MaxBranchRange - m_MaxIslandSize;
+        }
+      }
+    }
+    if (find(sd.back()) == NULL)
+      produce(sd.back());
+  }
+}
+
 /// produce - produce a island for the given fragment
 /// @param pFragment - the fragment needs a branch island
 BranchIsland* BranchIslandFactory::produce(Fragment& pFragment)
 {
-  assert(NULL == find(pFragment));
-  uint64_t island_offset = pFragment.getOffset() + m_MaxBranchRange -
-                           (pFragment.getOffset() % m_MaxBranchRange);
-
-  // find out the last fragment whose offset is smaller than the calculated
-  // offset of the island
-  Fragment* frag = &pFragment;
-  while (NULL != frag->getNextNode()) {
-    if (frag->getNextNode()->getOffset() > island_offset)
-      break;
-    frag = frag->getNextNode();
-  }
-
-  // fall back one step if needed
-  if (NULL != frag &&
-      (frag->getOffset() + frag->size()) > island_offset)
-    frag = frag->getPrevNode();
-
-  // check not to break the alignment constraint in the target section
-  // (i.e., do not insert the island after a Alignment fragment)
-  while (NULL != frag &&
-         Fragment::Alignment == frag->getKind()) {
-    frag = frag->getPrevNode();
-  }
-
-  // can not find an entry fragment to bridge the island
-  if (NULL == frag)
-    return NULL;
-
   BranchIsland *island = allocate();
-  new (island) BranchIsland(*frag,           // entry fragment to the island
+  new (island) BranchIsland(pFragment,       // entry fragment to the island
                             m_MaxIslandSize, // the max size of the island
-                            size() - 1u);     // index in the island factory
+                            size() - 1u);    // index in the island factory
   return island;
 }
 
@@ -76,7 +76,7 @@
 BranchIsland* BranchIslandFactory::find(const Fragment& pFragment)
 {
   // Currently we always find the island in a forward direction.
-  // TODO: If we can search backward, then we may reduce the number of islands.
+  // TODO: If we can search backward, then we may reduce the number of stubs.
   for (iterator it = begin(), ie = end(); it != ie; ++it) {
     if ((pFragment.getOffset() < (*it).offset()) &&
         ((pFragment.getOffset() + m_MaxBranchRange) >= (*it).offset()))
diff --git a/lib/LD/DiagnosticInfos.cpp b/lib/LD/DiagnosticInfos.cpp
index 3219d4a..943b046 100644
--- a/lib/LD/DiagnosticInfos.cpp
+++ b/lib/LD/DiagnosticInfos.cpp
@@ -42,12 +42,14 @@
 static const DiagStaticInfo DiagCommonInfo[] = {
 #define DIAG(ENUM, CLASS, ADDRDESC, LOCDESC) \
   { diag::ENUM, CLASS, STR_SIZE(ADDRDESC, uint16_t), ADDRDESC },
+#include "mcld/LD/DiagAttribute.inc"
 #include "mcld/LD/DiagCommonKinds.inc"
 #include "mcld/LD/DiagReaders.inc"
 #include "mcld/LD/DiagSymbolResolutions.inc"
 #include "mcld/LD/DiagRelocations.inc"
 #include "mcld/LD/DiagLayouts.inc"
 #include "mcld/LD/DiagGOTPLT.inc"
+#include "mcld/LD/DiagLDScript.inc"
 #undef DIAG
   { 0, DiagnosticEngine::None, 0, 0}
 };
@@ -58,11 +60,14 @@
 static const DiagStaticInfo DiagLoCInfo[] = {
 #define DIAG(ENUM, CLASS, ADDRDESC, LOCDESC) \
   { diag::ENUM, CLASS, STR_SIZE(LOCDESC, uint16_t), LOCDESC },
+#include "mcld/LD/DiagAttribute.inc"
+#include "mcld/LD/DiagCommonKinds.inc"
 #include "mcld/LD/DiagReaders.inc"
 #include "mcld/LD/DiagSymbolResolutions.inc"
 #include "mcld/LD/DiagRelocations.inc"
 #include "mcld/LD/DiagLayouts.inc"
 #include "mcld/LD/DiagGOTPLT.inc"
+#include "mcld/LD/DiagLDScript.inc"
 #undef DIAG
   { 0, DiagnosticEngine::None, 0, 0}
 };
@@ -114,12 +119,13 @@
 
   switch (ID) {
     case diag::multiple_definitions: {
-      if (m_Config.options().hasMulDefs()) {
+      if (m_Config.options().isMulDefs()) {
         severity = DiagnosticEngine::Ignore;
       }
       break;
     }
-    case diag::undefined_reference: {
+    case diag::undefined_reference:
+    case diag::undefined_reference_text: {
       // we have not implement --unresolved-symbols=method yet. So far, MCLinker
       // provides the easier --allow-shlib-undefined and --no-undefined (i.e. -z defs)
       switch(m_Config.codeGenType()) {
diff --git a/lib/LD/DynObjReader.cpp b/lib/LD/DynObjReader.cpp
index 60b5cf7..552e893 100644
--- a/lib/LD/DynObjReader.cpp
+++ b/lib/LD/DynObjReader.cpp
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 #include "mcld/LD/DynObjReader.h"
 #include "mcld/Target/TargetLDBackend.h"
-#include "mcld/MC/MCLDInput.h"
+#include "mcld/MC/Input.h"
 
 using namespace mcld;
 
diff --git a/lib/LD/ELFBinaryReader.cpp b/lib/LD/ELFBinaryReader.cpp
index 68deea0..ee537c2 100644
--- a/lib/LD/ELFBinaryReader.cpp
+++ b/lib/LD/ELFBinaryReader.cpp
@@ -10,9 +10,8 @@
 
 #include <mcld/IRBuilder.h>
 #include <mcld/LinkerConfig.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/Support/MemoryArea.h>
-#include <mcld/Target/GNULDBackend.h>
 
 #include <llvm/Support/ELF.h>
 
@@ -24,13 +23,9 @@
 // ELFBinaryReader
 //===----------------------------------------------------------------------===//
 /// constructor
-ELFBinaryReader::ELFBinaryReader(GNULDBackend& pBackend,
-                                 IRBuilder& pBuilder,
+ELFBinaryReader::ELFBinaryReader(IRBuilder& pBuilder,
                                  const LinkerConfig& pConfig)
-  : BinaryReader(),
-    m_Backend(pBackend),
-    m_Builder(pBuilder),
-    m_Config(pConfig) {
+  : m_Builder(pBuilder), m_Config(pConfig) {
 }
 
 /// destructor
@@ -38,6 +33,12 @@
 {
 }
 
+bool ELFBinaryReader::isMyFormat(Input& pInput, bool &pContinue) const
+{
+  pContinue = true;
+  return m_Config.options().isBinaryInput();
+}
+
 bool ELFBinaryReader::readBinary(Input& pInput)
 {
   // section: NULL
@@ -57,7 +58,7 @@
 
 
   SectionData* data = m_Builder.CreateSectionData(*data_sect);
-  size_t data_size = pInput.memArea()->handler()->size();
+  size_t data_size = pInput.memArea()->size();
   Fragment* frag = m_Builder.CreateRegion(pInput, 0x0, data_size);
   m_Builder.AppendFragment(*frag, *data);
 
diff --git a/lib/LD/ELFDynObjReader.cpp b/lib/LD/ELFDynObjReader.cpp
index 4f8c7ba..ebeba63 100644
--- a/lib/LD/ELFDynObjReader.cpp
+++ b/lib/LD/ELFDynObjReader.cpp
@@ -11,10 +11,11 @@
 #include <mcld/LinkerConfig.h>
 #include <mcld/IRBuilder.h>
 #include <mcld/LD/ELFReader.h>
-#include <mcld/MC/MCLDInput.h>
-#include <mcld/Support/MemoryRegion.h>
+#include <mcld/MC/Input.h>
 #include <mcld/Target/GNULDBackend.h>
+#include <mcld/Support/MemoryArea.h>
 
+#include <llvm/ADT/StringRef.h>
 #include <llvm/ADT/Twine.h>
 #include <llvm/ADT/OwningPtr.h>
 #include <llvm/Support/ErrorHandling.h>
@@ -44,27 +45,34 @@
 }
 
 /// isMyFormat
-bool ELFDynObjReader::isMyFormat(Input &pInput) const
+bool ELFDynObjReader::isMyFormat(Input &pInput, bool &pContinue) const
 {
   assert(pInput.hasMemArea());
 
   // Don't warning about the frequently requests.
   // MemoryArea has a list of cache to handle this.
   size_t hdr_size = m_pELFReader->getELFHeaderSize();
-  MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(),
-                                                   hdr_size);
+  if (pInput.memArea()->size() < hdr_size)
+    return false;
 
-  uint8_t* ELF_hdr = region->start();
+  llvm::StringRef region = pInput.memArea()->request(pInput.fileOffset(),
+                                                     hdr_size);
+
+  const char* ELF_hdr = region.begin();
   bool result = true;
-  if (!m_pELFReader->isELF(ELF_hdr))
+  if (!m_pELFReader->isELF(ELF_hdr)) {
+    pContinue = true;
     result = false;
-  else if (!m_pELFReader->isMyEndian(ELF_hdr))
+  } else if (Input::DynObj != m_pELFReader->fileType(ELF_hdr)) {
+    pContinue = true;
     result = false;
-  else if (!m_pELFReader->isMyMachine(ELF_hdr))
+  } else if (!m_pELFReader->isMyEndian(ELF_hdr)) {
+    pContinue = false;
     result = false;
-  else if (Input::DynObj != m_pELFReader->fileType(ELF_hdr))
+  } else if (!m_pELFReader->isMyMachine(ELF_hdr)) {
+    pContinue = false;
     result = false;
-  pInput.memArea()->release(region);
+  }
   return result;
 }
 
@@ -74,12 +82,11 @@
   assert(pInput.hasMemArea());
 
   size_t hdr_size = m_pELFReader->getELFHeaderSize();
-  MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(),
-                                                   hdr_size);
-  uint8_t* ELF_hdr = region->start();
+  llvm::StringRef region = pInput.memArea()->request(pInput.fileOffset(),
+                                                     hdr_size);
+  const char* ELF_hdr = region.begin();
 
   bool shdr_result = m_pELFReader->readSectionHeaders(pInput, ELF_hdr);
-  pInput.memArea()->release(region);
 
   // read .dynamic to get the correct SONAME
   bool dyn_result = m_pELFReader->readDynamic(pInput);
@@ -108,17 +115,14 @@
     return false;
   }
 
-  MemoryRegion* symtab_region = pInput.memArea()->request(
-              pInput.fileOffset() + symtab_shdr->offset(), symtab_shdr->size());
+  llvm::StringRef symtab_region = pInput.memArea()->request(
+      pInput.fileOffset() + symtab_shdr->offset(), symtab_shdr->size());
 
-  MemoryRegion* strtab_region = pInput.memArea()->request(
-              pInput.fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
-  char* strtab = reinterpret_cast<char*>(strtab_region->start());
+  llvm::StringRef strtab_region = pInput.memArea()->request(
+      pInput.fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
+  const char* strtab = strtab_region.begin();
   bool result = m_pELFReader->readSymbols(pInput, m_Builder,
-                                          *symtab_region, strtab);
-  pInput.memArea()->release(symtab_region);
-  pInput.memArea()->release(strtab_region);
-
+                                          symtab_region, strtab);
   return result;
 }
 
diff --git a/lib/LD/ELFObjectReader.cpp b/lib/LD/ELFObjectReader.cpp
index b645570..a34739a 100644
--- a/lib/LD/ELFObjectReader.cpp
+++ b/lib/LD/ELFObjectReader.cpp
@@ -8,21 +8,23 @@
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/ELFObjectReader.h>
 
-#include <string>
-#include <cassert>
-
-#include <llvm/Support/ELF.h>
-#include <llvm/ADT/Twine.h>
-
 #include <mcld/IRBuilder.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/LD/ELFReader.h>
 #include <mcld/LD/EhFrameReader.h>
 #include <mcld/LD/EhFrame.h>
 #include <mcld/Target/GNULDBackend.h>
 #include <mcld/Support/MsgHandling.h>
+#include <mcld/Support/MemoryArea.h>
 #include <mcld/Object/ObjectBuilder.h>
 
+#include <llvm/Support/ELF.h>
+#include <llvm/ADT/Twine.h>
+#include <llvm/ADT/StringRef.h>
+
+#include <string>
+#include <cassert>
+
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
@@ -57,27 +59,34 @@
 }
 
 /// isMyFormat
-bool ELFObjectReader::isMyFormat(Input &pInput) const
+bool ELFObjectReader::isMyFormat(Input &pInput, bool &pContinue) const
 {
   assert(pInput.hasMemArea());
 
   // Don't warning about the frequently requests.
   // MemoryArea has a list of cache to handle this.
   size_t hdr_size = m_pELFReader->getELFHeaderSize();
-  MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(),
+  if (pInput.memArea()->size() < hdr_size)
+    return false;
+
+  llvm::StringRef region = pInput.memArea()->request(pInput.fileOffset(),
                                                      hdr_size);
 
-  uint8_t* ELF_hdr = region->start();
+  const char* ELF_hdr = region.begin();
   bool result = true;
-  if (!m_pELFReader->isELF(ELF_hdr))
+  if (!m_pELFReader->isELF(ELF_hdr)) {
+    pContinue = true;
     result = false;
-  else if (!m_pELFReader->isMyEndian(ELF_hdr))
+  } else if (Input::Object != m_pELFReader->fileType(ELF_hdr)) {
+    pContinue = true;
     result = false;
-  else if (!m_pELFReader->isMyMachine(ELF_hdr))
+  } else if (!m_pELFReader->isMyEndian(ELF_hdr)) {
+    pContinue = false;
     result = false;
-  else if (Input::Object != m_pELFReader->fileType(ELF_hdr))
+  } else if (!m_pELFReader->isMyMachine(ELF_hdr)) {
+    pContinue = false;
     result = false;
-  pInput.memArea()->release(region);
+  }
   return result;
 }
 
@@ -87,11 +96,13 @@
   assert(pInput.hasMemArea());
 
   size_t hdr_size = m_pELFReader->getELFHeaderSize();
-  MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(),
+  if (pInput.memArea()->size() < hdr_size)
+    return false;
+
+  llvm::StringRef region = pInput.memArea()->request(pInput.fileOffset(),
                                                      hdr_size);
-  uint8_t* ELF_hdr = region->start();
+  const char* ELF_hdr = region.begin();
   bool result = m_pELFReader->readSectionHeaders(pInput, ELF_hdr);
-  pInput.memArea()->release(region);
   return result;
 }
 
@@ -110,9 +121,9 @@
       case LDFileFormat::Group: {
         assert(NULL != (*section)->getLink());
         ResolveInfo* signature =
-              m_pELFReader->readSignature(pInput,
-                                          *(*section)->getLink(),
-                                          (*section)->getInfo());
+            m_pELFReader->readSignature(pInput,
+                                        *(*section)->getLink(),
+                                        (*section)->getInfo());
 
         bool exist = false;
         if (0 == signature->nameSize() &&
@@ -127,18 +138,17 @@
         if (exist) {
           // if this is not the first time we see this group signature, then
           // ignore all the members in this group (set Ignore)
-          MemoryRegion* region = pInput.memArea()->request(
+          llvm::StringRef region = pInput.memArea()->request(
                pInput.fileOffset() + (*section)->offset(), (*section)->size());
-          llvm::ELF::Elf32_Word* value =
-                     reinterpret_cast<llvm::ELF::Elf32_Word*>(region->start());
+          const llvm::ELF::Elf32_Word* value =
+              reinterpret_cast<const llvm::ELF::Elf32_Word*>(region.begin());
 
-          size_t size = region->size() / sizeof(llvm::ELF::Elf32_Word);
+          size_t size = region.size() / sizeof(llvm::ELF::Elf32_Word);
           if (llvm::ELF::GRP_COMDAT == *value) {
             for (size_t index = 1; index < size; ++index) {
               pInput.context()->getSection(value[index])->setKind(LDFileFormat::Ignore);
             }
           }
-          pInput.memArea()->release(region);
         }
         ResolveInfo::Destroy(signature);
         break;
@@ -212,10 +222,9 @@
       case LDFileFormat::EhFrame: {
         EhFrame* eh_frame = IRBuilder::CreateEhFrame(**section);
 
-        if (m_Config.options().hasEhFrameHdr() &&
+        // We don't really parse EhFrame if this is a partial linking
+        if ((m_Config.codeGenType() != LinkerConfig::Object) &&
             (m_ReadFlag & ParseEhFrame)) {
-
-          // if --eh-frame-hdr option is given, parse .eh_frame.
           if (!m_pEhFrameReader->read<32, true>(pInput, *eh_frame)) {
             // if we failed to parse a .eh_frame, we should not parse the rest
             // .eh_frame.
@@ -284,17 +293,15 @@
     return false;
   }
 
-  MemoryRegion* symtab_region = pInput.memArea()->request(
-             pInput.fileOffset() + symtab_shdr->offset(), symtab_shdr->size());
-  MemoryRegion* strtab_region = pInput.memArea()->request(
-             pInput.fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
-  char* strtab = reinterpret_cast<char*>(strtab_region->start());
+  llvm::StringRef symtab_region = pInput.memArea()->request(
+      pInput.fileOffset() + symtab_shdr->offset(), symtab_shdr->size());
+  llvm::StringRef strtab_region = pInput.memArea()->request(
+      pInput.fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
+  const char* strtab = strtab_region.begin();
   bool result = m_pELFReader->readSymbols(pInput,
                                           m_Builder,
-                                          *symtab_region,
+                                          symtab_region,
                                           strtab);
-  pInput.memArea()->release(symtab_region);
-  pInput.memArea()->release(strtab_region);
   return result;
 }
 
@@ -310,30 +317,26 @@
 
     uint32_t offset = pInput.fileOffset() + (*rs)->offset();
     uint32_t size = (*rs)->size();
-    MemoryRegion* region = mem->request(offset, size);
+    llvm::StringRef region = mem->request(offset, size);
     IRBuilder::CreateRelocData(**rs); ///< create relocation data for the header
     switch ((*rs)->type()) {
       case llvm::ELF::SHT_RELA: {
-        if (!m_pELFReader->readRela(pInput, **rs, *region)) {
-          mem->release(region);
+        if (!m_pELFReader->readRela(pInput, **rs, region)) {
           return false;
         }
         break;
       }
       case llvm::ELF::SHT_REL: {
-        if (!m_pELFReader->readRel(pInput, **rs, *region)) {
-          mem->release(region);
+        if (!m_pELFReader->readRel(pInput, **rs, region)) {
           return false;
         }
         break;
       }
       default: { ///< should not enter
-        mem->release(region);
         return false;
       }
     } // end of switch
 
-    mem->release(region);
   } // end of for all relocation data
 
   return true;
diff --git a/lib/LD/ELFObjectWriter.cpp b/lib/LD/ELFObjectWriter.cpp
index ddd3551..dca6936 100644
--- a/lib/LD/ELFObjectWriter.cpp
+++ b/lib/LD/ELFObjectWriter.cpp
@@ -10,23 +10,24 @@
 
 #include <mcld/Module.h>
 #include <mcld/LinkerConfig.h>
+#include <mcld/LinkerScript.h>
 #include <mcld/Target/GNULDBackend.h>
-#include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/ADT/SizeTraits.h>
-#include <mcld/Fragment/FragmentLinker.h>
 #include <mcld/Fragment/AlignFragment.h>
 #include <mcld/Fragment/FillFragment.h>
 #include <mcld/Fragment/RegionFragment.h>
 #include <mcld/Fragment/Stub.h>
 #include <mcld/Fragment/NullFragment.h>
+#include <mcld/LD/LDSymbol.h>
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/SectionData.h>
 #include <mcld/LD/ELFSegment.h>
 #include <mcld/LD/ELFSegmentFactory.h>
 #include <mcld/LD/RelocData.h>
 #include <mcld/LD/EhFrame.h>
+#include <mcld/LD/ELFFileFormat.h>
+#include <mcld/Target/GNUInfo.h>
 
 #include <llvm/Support/ErrorHandling.h>
 #include <llvm/Support/system_error.h>
@@ -50,9 +51,10 @@
 {
 }
 
-void ELFObjectWriter::writeSection(MemoryArea& pOutput, LDSection *section)
+void ELFObjectWriter::writeSection(Module& pModule,
+                                   FileOutputBuffer& pOutput, LDSection *section)
 {
-  MemoryRegion* region;
+  MemoryRegion region;
   // Request output region
   switch (section->kind()) {
   case LDFileFormat::Note:
@@ -66,10 +68,8 @@
   case LDFileFormat::GCCExceptTable:
   case LDFileFormat::EhFrame: {
     region = pOutput.request(section->offset(), section->size());
-    if (NULL == region) {
-      llvm::report_fatal_error(llvm::Twine("cannot get enough memory region for output section `") +
-                               llvm::Twine(section->name()) +
-                               llvm::Twine("'.\n"));
+    if (region.size() == 0) {
+      return;
     }
     break;
   }
@@ -94,19 +94,22 @@
   // Write out sections with data
   switch(section->kind()) {
   case LDFileFormat::GCCExceptTable:
-  case LDFileFormat::EhFrame:
   case LDFileFormat::Regular:
   case LDFileFormat::Debug:
   case LDFileFormat::Note:
-    // FIXME: if optimization of exception handling sections is enabled,
-    // then we should emit these sections by the other way.
-    emitSectionData(*section, *region);
+    emitSectionData(*section, region);
+    break;
+  case LDFileFormat::EhFrame:
+    emitEhFrame(pModule, *section->getEhFrame(), region);
     break;
   case LDFileFormat::Relocation:
-    emitRelocation(m_Config, *section, *region);
+    // sort relocation for the benefit of the dynamic linker.
+    target().sortRelocation(*section);
+
+    emitRelocation(m_Config, *section, region);
     break;
   case LDFileFormat::Target:
-    target().emitSectionData(*section, *region);
+    target().emitSectionData(*section, region);
     break;
   default:
     llvm_unreachable("invalid section kind");
@@ -114,7 +117,7 @@
 }
 
 llvm::error_code ELFObjectWriter::writeObject(Module& pModule,
-                                              MemoryArea& pOutput)
+                                              FileOutputBuffer& pOutput)
 {
   bool is_dynobj = m_Config.codeGenType() == LinkerConfig::DynObj;
   bool is_exec = m_Config.codeGenType() == LinkerConfig::Exec;
@@ -144,17 +147,17 @@
     ELFSegmentFactory::iterator seg, segEnd = target().elfSegmentTable().end();
 
     for (seg = target().elfSegmentTable().begin(); seg != segEnd; ++seg) {
-      if (llvm::ELF::PT_LOAD == (*seg).type()) {
-        ELFSegment::sect_iterator sect, sectEnd = (*seg).end();
-        for (sect = (*seg).begin(); sect != sectEnd; ++sect)
-          writeSection(pOutput, *sect);
+      if (llvm::ELF::PT_LOAD == (*seg)->type()) {
+        ELFSegment::iterator sect, sectEnd = (*seg)->end();
+        for (sect = (*seg)->begin(); sect != sectEnd; ++sect)
+          writeSection(pModule, pOutput, *sect);
       }
     }
   } else {
     // Write out regular ELF sections
     Module::iterator sect, sectEnd = pModule.end();
     for (sect = pModule.begin(); sect != sectEnd; ++sect)
-      writeSection(pOutput, *sect);
+      writeSection(pModule, pOutput, *sect);
 
     emitShStrTab(target().getOutputFormat()->getShStrTab(), pModule, pOutput);
 
@@ -180,23 +183,37 @@
       return make_error_code(errc::not_supported);
   }
 
-  pOutput.clear();
   return llvm::make_error_code(llvm::errc::success);
 }
 
+// getOutputSize - count the final output size
+size_t ELFObjectWriter::getOutputSize(const Module& pModule) const
+{
+  if (m_Config.targets().is32Bits()) {
+    return getLastStartOffset<32>(pModule) +
+           sizeof(ELFSizeTraits<32>::Shdr) * pModule.size();
+  } else if (m_Config.targets().is64Bits()) {
+    return getLastStartOffset<64>(pModule) +
+           sizeof(ELFSizeTraits<64>::Shdr) * pModule.size();
+  } else {
+    assert(0 && "Invalid ELF Class");
+    return 0;
+  }
+}
+
 // writeELFHeader - emit ElfXX_Ehdr
 template<size_t SIZE>
 void ELFObjectWriter::writeELFHeader(const LinkerConfig& pConfig,
                                      const Module& pModule,
-                                     MemoryArea& pOutput) const
+                                     FileOutputBuffer& pOutput) const
 {
   typedef typename ELFSizeTraits<SIZE>::Ehdr ElfXX_Ehdr;
   typedef typename ELFSizeTraits<SIZE>::Shdr ElfXX_Shdr;
   typedef typename ELFSizeTraits<SIZE>::Phdr ElfXX_Phdr;
 
   // ELF header must start from 0x0
-  MemoryRegion *region = pOutput.request(0, sizeof(ElfXX_Ehdr));
-  ElfXX_Ehdr* header = (ElfXX_Ehdr*)region->start();
+  MemoryRegion region = pOutput.request(0, sizeof(ElfXX_Ehdr));
+  ElfXX_Ehdr* header = (ElfXX_Ehdr*)region.begin();
 
   memcpy(header->e_ident, ElfMagic, EI_MAG3+1);
 
@@ -235,7 +252,7 @@
   header->e_flags     = target().getInfo().flags();
   header->e_ehsize    = sizeof(ElfXX_Ehdr);
   header->e_phentsize = sizeof(ElfXX_Phdr);
-  header->e_phnum     = target().numOfSegments();
+  header->e_phnum     = target().elfSegmentTable().size();
   header->e_shentsize = sizeof(ElfXX_Shdr);
   header->e_shnum     = pModule.size();
   header->e_shstrndx  = pModule.getSection(".shstrtab")->index();
@@ -245,15 +262,10 @@
 uint64_t ELFObjectWriter::getEntryPoint(const LinkerConfig& pConfig,
                                         const Module& pModule) const
 {
-  llvm::StringRef entry_name;
-  if (pConfig.options().hasEntry())
-    entry_name = pConfig.options().entry();
-  else
-    entry_name = target().getInfo().entry();
-
+  llvm::StringRef entry_name = target().getEntry(pModule);
   uint64_t result = 0x0;
 
-  bool issue_warning = (pConfig.options().hasEntry() &&
+  bool issue_warning = (pModule.getScript().hasEntry() &&
                         LinkerConfig::Object != pConfig.codeGenType() &&
                         LinkerConfig::DynObj != pConfig.codeGenType());
 
@@ -290,16 +302,16 @@
 template<size_t SIZE>
 void ELFObjectWriter::emitSectionHeader(const Module& pModule,
                                         const LinkerConfig& pConfig,
-                                        MemoryArea& pOutput) const
+                                        FileOutputBuffer& pOutput) const
 {
   typedef typename ELFSizeTraits<SIZE>::Shdr ElfXX_Shdr;
 
   // emit section header
   unsigned int sectNum = pModule.size();
   unsigned int header_size = sizeof(ElfXX_Shdr) * sectNum;
-  MemoryRegion* region = pOutput.request(getLastStartOffset<SIZE>(pModule),
-                                         header_size);
-  ElfXX_Shdr* shdr = (ElfXX_Shdr*)region->start();
+  MemoryRegion region = pOutput.request(getLastStartOffset<SIZE>(pModule),
+                                        header_size);
+  ElfXX_Shdr* shdr = (ElfXX_Shdr*)region.begin();
 
   // Iterate the SectionTable in LDContext
   unsigned int sectIdx = 0;
@@ -324,7 +336,7 @@
 
 // emitProgramHeader - emit ElfXX_Phdr
 template<size_t SIZE>
-void ELFObjectWriter::emitProgramHeader(MemoryArea& pOutput) const
+void ELFObjectWriter::emitProgramHeader(FileOutputBuffer& pOutput) const
 {
   typedef typename ELFSizeTraits<SIZE>::Ehdr ElfXX_Ehdr;
   typedef typename ELFSizeTraits<SIZE>::Phdr ElfXX_Phdr;
@@ -334,24 +346,24 @@
   start_offset = sizeof(ElfXX_Ehdr);
   phdr_size = sizeof(ElfXX_Phdr);
   // Program header must start directly after ELF header
-  MemoryRegion *region = pOutput.request(start_offset,
-                                         target().numOfSegments() * phdr_size);
+  MemoryRegion region = pOutput.request(start_offset,
+      target().elfSegmentTable().size() * phdr_size);
 
-  ElfXX_Phdr* phdr = (ElfXX_Phdr*)region->start();
+  ElfXX_Phdr* phdr = (ElfXX_Phdr*)region.begin();
 
   // Iterate the elf segment table in GNULDBackend
   size_t index = 0;
   ELFSegmentFactory::const_iterator seg = target().elfSegmentTable().begin(),
                                  segEnd = target().elfSegmentTable().end();
   for (; seg != segEnd; ++seg, ++index) {
-    phdr[index].p_type   = (*seg).type();
-    phdr[index].p_flags  = (*seg).flag();
-    phdr[index].p_offset = (*seg).offset();
-    phdr[index].p_vaddr  = (*seg).vaddr();
-    phdr[index].p_paddr  = (*seg).paddr();
-    phdr[index].p_filesz = (*seg).filesz();
-    phdr[index].p_memsz  = (*seg).memsz();
-    phdr[index].p_align  = (*seg).align();
+    phdr[index].p_type   = (*seg)->type();
+    phdr[index].p_flags  = (*seg)->flag();
+    phdr[index].p_offset = (*seg)->offset();
+    phdr[index].p_vaddr  = (*seg)->vaddr();
+    phdr[index].p_paddr  = (*seg)->paddr();
+    phdr[index].p_filesz = (*seg)->filesz();
+    phdr[index].p_memsz  = (*seg)->memsz();
+    phdr[index].p_align  = (*seg)->align();
   }
 }
 
@@ -359,11 +371,11 @@
 void
 ELFObjectWriter::emitShStrTab(const LDSection& pShStrTab,
                               const Module& pModule,
-                              MemoryArea& pOutput)
+                              FileOutputBuffer& pOutput)
 {
   // write out data
-  MemoryRegion* region = pOutput.request(pShStrTab.offset(), pShStrTab.size());
-  unsigned char* data = region->start();
+  MemoryRegion region = pOutput.request(pShStrTab.offset(), pShStrTab.size());
+  char* data = (char*)region.begin();
   size_t shstrsize = 0;
   Module::const_iterator section, sectEnd = pModule.end();
   for (section = pModule.begin(); section != sectEnd; ++section) {
@@ -394,6 +406,50 @@
   emitSectionData(*sd, pRegion);
 }
 
+/// emitEhFrame
+void ELFObjectWriter::emitEhFrame(Module& pModule,
+                                  EhFrame& pFrame, MemoryRegion& pRegion) const
+{
+  emitSectionData(*pFrame.getSectionData(), pRegion);
+
+  // Patch FDE field (offset to CIE)
+  for (EhFrame::cie_iterator i = pFrame.cie_begin(), e = pFrame.cie_end();
+       i != e; ++i) {
+    EhFrame::CIE& cie = **i;
+    for (EhFrame::fde_iterator fi = cie.begin(), fe = cie.end();
+         fi != fe; ++fi) {
+      EhFrame::FDE& fde = **fi;
+      if (fde.getRecordType() == EhFrame::RECORD_GENERATED) {
+        // Patch PLT offset
+        LDSection* plt_sect = pModule.getSection(".plt");
+        assert (plt_sect && "We have no plt but have corresponding eh_frame?");
+        uint64_t plt_offset = plt_sect->offset();
+        // FDE entry for PLT is always 32-bit
+        uint64_t fde_offset = pFrame.getSection().offset() + fde.getOffset() +
+                              EhFrame::getDataStartOffset<32>();
+        int32_t offset = fde_offset - plt_offset;
+        if (plt_offset < fde_offset)
+          offset = -offset;
+        memcpy(pRegion.begin() + fde.getOffset() +
+                                 EhFrame::getDataStartOffset<32>(),
+                                 &offset, 4);
+        uint32_t size = plt_sect->size();
+        memcpy(pRegion.begin() + fde.getOffset() +
+                                 EhFrame::getDataStartOffset<32>() + 4,
+                                 &size, 4);
+      }
+      uint64_t fde_cie_ptr_offset = fde.getOffset() +
+                                    EhFrame::getDataStartOffset<32>() -
+                                    /*ID*/4;
+      uint64_t cie_start_offset = cie.getOffset();
+      int32_t offset = fde_cie_ptr_offset - cie_start_offset;
+      if (fde_cie_ptr_offset < cie_start_offset)
+        offset = -offset;
+      memcpy(pRegion.begin() + fde_cie_ptr_offset, &offset, 4);
+    } // for loop fde_iterator
+  } // for loop cie_iterator
+}
+
 /// emitRelocation
 void ELFObjectWriter::emitRelocation(const LinkerConfig& pConfig,
                                      const LDSection& pSection,
@@ -435,34 +491,36 @@
   typedef typename ELFSizeTraits<SIZE>::Addr ElfXX_Addr;
   typedef typename ELFSizeTraits<SIZE>::Word ElfXX_Word;
 
-  ElfXX_Rel* rel = reinterpret_cast<ElfXX_Rel*>(pRegion.start());
+  ElfXX_Rel* rel = reinterpret_cast<ElfXX_Rel*>(pRegion.begin());
 
   const Relocation* relocation = 0;
   const FragmentRef* frag_ref = 0;
 
   for (RelocData::const_iterator it = pRelocData.begin(),
        ie = pRelocData.end(); it != ie; ++it, ++rel) {
+    ElfXX_Addr r_offset = 0;
+    ElfXX_Word r_sym = 0;
 
     relocation = &(llvm::cast<Relocation>(*it));
     frag_ref = &(relocation->targetRef());
 
     if(LinkerConfig::DynObj == pConfig.codeGenType() ||
        LinkerConfig::Exec == pConfig.codeGenType()) {
-      rel->r_offset = static_cast<ElfXX_Addr>(
+      r_offset = static_cast<ElfXX_Addr>(
                       frag_ref->frag()->getParent()->getSection().addr() +
                       frag_ref->getOutputOffset());
     }
     else {
-      rel->r_offset = static_cast<ElfXX_Addr>(frag_ref->getOutputOffset());
+      r_offset = static_cast<ElfXX_Addr>(frag_ref->getOutputOffset());
     }
-    ElfXX_Word Index;
+
     if( relocation->symInfo() == NULL )
-      Index = 0;
+      r_sym = 0;
     else
-      Index = static_cast<ElfXX_Word>(
+      r_sym = static_cast<ElfXX_Word>(
               target().getSymbolIdx(relocation->symInfo()->outSymbol()));
 
-    rel->setSymbolAndType(Index, relocation->type());
+    target().emitRelocation(*rel, relocation->type(), r_sym, r_offset);
   }
 }
 
@@ -476,36 +534,37 @@
   typedef typename ELFSizeTraits<SIZE>::Addr ElfXX_Addr;
   typedef typename ELFSizeTraits<SIZE>::Word ElfXX_Word;
 
-  ElfXX_Rela* rel = reinterpret_cast<ElfXX_Rela*>(pRegion.start());
+  ElfXX_Rela* rel = reinterpret_cast<ElfXX_Rela*>(pRegion.begin());
 
   const Relocation* relocation = 0;
   const FragmentRef* frag_ref = 0;
 
   for (RelocData::const_iterator it = pRelocData.begin(),
        ie = pRelocData.end(); it != ie; ++it, ++rel) {
+    ElfXX_Addr r_offset = 0;
+    ElfXX_Word r_sym = 0;
 
     relocation = &(llvm::cast<Relocation>(*it));
     frag_ref = &(relocation->targetRef());
 
     if(LinkerConfig::DynObj == pConfig.codeGenType() ||
        LinkerConfig::Exec == pConfig.codeGenType()) {
-      rel->r_offset = static_cast<ElfXX_Addr>(
+      r_offset = static_cast<ElfXX_Addr>(
                       frag_ref->frag()->getParent()->getSection().addr() +
                       frag_ref->getOutputOffset());
     }
     else {
-      rel->r_offset = static_cast<ElfXX_Addr>(frag_ref->getOutputOffset());
+      r_offset = static_cast<ElfXX_Addr>(frag_ref->getOutputOffset());
     }
 
-    ElfXX_Word Index;
     if( relocation->symInfo() == NULL )
-      Index = 0;
+      r_sym = 0;
     else
-      Index = static_cast<ElfXX_Word>(
+      r_sym = static_cast<ElfXX_Word>(
               target().getSymbolIdx(relocation->symInfo()->outSymbol()));
 
-    rel->setSymbolAndType(Index, relocation->type());
-    rel->r_addend = relocation->addend();
+    target().emitRelocation(*rel, relocation->type(),
+                            r_sym, r_offset, relocation->addend());
   }
 }
 
@@ -532,6 +591,12 @@
     return sizeof(ElfXX_Word);
   if (llvm::ELF::SHT_DYNAMIC == pSection.type())
     return sizeof(ElfXX_Dyn);
+  // FIXME: We should get the entsize from input since the size of each
+  // character is specified in the section header's sh_entsize field.
+  // For example, traditional string is 0x1, UCS-2 is 0x2, ... and so on.
+  // Ref: http://www.sco.com/developers/gabi/2003-12-17/ch4.sheader.html
+  if (pSection.flag() & llvm::ELF::SHF_STRINGS)
+    return 0x1;
   return 0x0;
 }
 
@@ -607,8 +672,8 @@
     switch(fragIter->getKind()) {
       case Fragment::Region: {
         const RegionFragment& region_frag = llvm::cast<RegionFragment>(*fragIter);
-        const uint8_t* from = region_frag.getRegion().start();
-        memcpy(pRegion.getBuffer(cur_offset), from, size);
+        const char* from = region_frag.getRegion().begin();
+        memcpy(pRegion.begin() + cur_offset, from, size);
         break;
       }
       case Fragment::Alignment: {
@@ -617,7 +682,7 @@
         uint64_t count = size / align_frag.getValueSize();
         switch (align_frag.getValueSize()) {
           case 1u:
-            std::memset(pRegion.getBuffer(cur_offset),
+            std::memset(pRegion.begin() + cur_offset,
                         align_frag.getValue(),
                         count);
             break;
@@ -638,7 +703,7 @@
 
         uint64_t num_tiles = fill_frag.size() / fill_frag.getValueSize();
         for (uint64_t i = 0; i != num_tiles; ++i) {
-          std::memset(pRegion.getBuffer(cur_offset),
+          std::memset(pRegion.begin() + cur_offset,
                       fill_frag.getValue(),
                       fill_frag.getValueSize());
         }
@@ -646,7 +711,7 @@
       }
       case Fragment::Stub: {
         const Stub& stub_frag = llvm::cast<Stub>(*fragIter);
-        memcpy(pRegion.getBuffer(cur_offset), stub_frag.getContent(), size);
+        memcpy(pRegion.begin() + cur_offset, stub_frag.getContent(), size);
         break;
       }
       case Fragment::Null: {
diff --git a/lib/LD/ELFReader.cpp b/lib/LD/ELFReader.cpp
index f7b047f..119f8a7 100644
--- a/lib/LD/ELFReader.cpp
+++ b/lib/LD/ELFReader.cpp
@@ -13,8 +13,9 @@
 #include <mcld/LD/EhFrame.h>
 #include <mcld/LD/SectionData.h>
 #include <mcld/Target/GNULDBackend.h>
-#include <mcld/Support/MemoryRegion.h>
+#include <mcld/Target/GNUInfo.h>
 #include <mcld/Support/MsgHandling.h>
+#include <mcld/Support/MemoryArea.h>
 #include <mcld/Object/ObjectBuilder.h>
 
 #include <cstring>
@@ -42,10 +43,10 @@
 }
 
 /// isELF - is this a ELF file
-bool ELFReader<32, true>::isELF(void* pELFHeader) const
+bool ELFReader<32, true>::isELF(const void* pELFHeader) const
 {
-  llvm::ELF::Elf32_Ehdr* hdr =
-                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf32_Ehdr* hdr =
+      reinterpret_cast<const llvm::ELF::Elf32_Ehdr*>(pELFHeader);
   if (0 == memcmp(llvm::ELF::ElfMagic, hdr, 4))
     return true;
   return false;
@@ -66,13 +67,13 @@
 /// readSymbols - read ELF symbols and create LDSymbol
 bool ELFReader<32, true>::readSymbols(Input& pInput,
                                       IRBuilder& pBuilder,
-                                      const MemoryRegion& pRegion,
+                                      llvm::StringRef pRegion,
                                       const char* pStrTab) const
 {
   // get number of symbols
   size_t entsize = pRegion.size()/sizeof(llvm::ELF::Elf32_Sym);
   const llvm::ELF::Elf32_Sym* symtab =
-                 reinterpret_cast<const llvm::ELF::Elf32_Sym*>(pRegion.start());
+      reinterpret_cast<const llvm::ELF::Elf32_Sym*>(pRegion.begin());
 
   uint32_t st_name  = 0x0;
   uint32_t st_value = 0x0;
@@ -144,22 +145,22 @@
       ld_name = std::string(pStrTab + st_name);
     }
 
-    LDSymbol *psym =
-        pBuilder.AddSymbol(pInput,
-                           ld_name,
-                           ld_type,
-                           ld_desc,
-                           ld_binding,
-                           st_size,
-                           ld_value,
-                           section, ld_vis);
+    LDSymbol* psym = pBuilder.AddSymbol(pInput,
+                                        ld_name,
+                                        ld_type,
+                                        ld_desc,
+                                        ld_binding,
+                                        st_size,
+                                        ld_value,
+                                        section,
+                                        ld_vis);
 
-    if ( is_dyn_obj
-         && NULL!=psym
-         && ResolveInfo::Undefined!=ld_desc
-         && (ResolveInfo::Global==ld_binding ||
-             ResolveInfo::Weak==ld_binding)
-         && ResolveInfo::Object==ld_type ) {
+    if (is_dyn_obj
+        && NULL != psym
+        && ResolveInfo::Undefined != ld_desc
+        && (ResolveInfo::Global == ld_binding ||
+            ResolveInfo::Weak == ld_binding)
+        && ResolveInfo::Object == ld_type) {
       AliasInfo p;
       p.pt_alias = psym;
       p.ld_binding = ld_binding;
@@ -174,9 +175,9 @@
   //        1. eliminate code duplication
   //        2. easy to know if a symbol is from .so
   //           (so that it may be a potential alias)
-  if ( is_dyn_obj ) {
+  if (is_dyn_obj) {
     // sort symbols by symbol value and then weak before strong
-    std::sort( potential_aliases.begin(), potential_aliases.end(), less);
+    std::sort(potential_aliases.begin(), potential_aliases.end(), less);
 
     // for each weak symbol, find out all its aliases, and
     // then link them as a circular list in Module
@@ -189,16 +190,16 @@
       Module& pModule = pBuilder.getModule();
       std::vector<AliasInfo>::iterator alias_it = sym_it+1;
       while(alias_it!=sym_e) {
-        if ( sym_it->ld_value != alias_it->ld_value )
+        if (sym_it->ld_value != alias_it->ld_value)
           break;
 
-        if (sym_it+1==alias_it)
+        if (sym_it + 1 == alias_it)
           pModule.CreateAliasList(*sym_it->pt_alias->resolveInfo());
         pModule.addAlias(*alias_it->pt_alias->resolveInfo());
         ++alias_it;
       }
 
-      sym_it = alias_it-1;
+      sym_it = alias_it - 1;
     }// end of for loop
   }
 
@@ -211,30 +212,21 @@
 /// ELFReader::readRela - read ELF rela and create Relocation
 bool ELFReader<32, true>::readRela(Input& pInput,
                                    LDSection& pSection,
-                                   const MemoryRegion& pRegion) const
+                                   llvm::StringRef pRegion) const
 {
   // get the number of rela
   size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf32_Rela);
   const llvm::ELF::Elf32_Rela* relaTab =
-                reinterpret_cast<const llvm::ELF::Elf32_Rela*>(pRegion.start());
+      reinterpret_cast<const llvm::ELF::Elf32_Rela*>(pRegion.begin());
 
   for (size_t idx=0; idx < entsize; ++idx) {
+    Relocation::Type r_type = 0x0;
+    uint32_t r_sym = 0x0;
     uint32_t r_offset = 0x0;
-    uint32_t r_info   = 0x0;
     int32_t  r_addend = 0;
-    if (llvm::sys::IsLittleEndianHost) {
-      r_offset = relaTab[idx].r_offset;
-      r_info   = relaTab[idx].r_info;
-      r_addend = relaTab[idx].r_addend;
-    }
-    else {
-      r_offset = mcld::bswap32(relaTab[idx].r_offset);
-      r_info   = mcld::bswap32(relaTab[idx].r_info);
-      r_addend = mcld::bswap32(relaTab[idx].r_addend);
-    }
+    if (!target().readRelocation(relaTab[idx], r_type, r_sym, r_offset, r_addend))
+      return false;
 
-    uint8_t  r_type = static_cast<unsigned char>(r_info);
-    uint32_t r_sym  = (r_info >> 8);
     LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
     if (NULL == symbol) {
       fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
@@ -248,27 +240,20 @@
 /// readRel - read ELF rel and create Relocation
 bool ELFReader<32, true>::readRel(Input& pInput,
                                   LDSection& pSection,
-                                  const MemoryRegion& pRegion) const
+                                  llvm::StringRef pRegion) const
 {
   // get the number of rel
   size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf32_Rel);
   const llvm::ELF::Elf32_Rel* relTab =
-                 reinterpret_cast<const llvm::ELF::Elf32_Rel*>(pRegion.start());
+      reinterpret_cast<const llvm::ELF::Elf32_Rel*>(pRegion.begin());
 
   for (size_t idx=0; idx < entsize; ++idx) {
+    Relocation::Type r_type = 0x0;
+    uint32_t r_sym = 0x0;
     uint32_t r_offset = 0x0;
-    uint32_t r_info   = 0x0;
-    if (llvm::sys::IsLittleEndianHost) {
-      r_offset = relTab[idx].r_offset;
-      r_info   = relTab[idx].r_info;
-    }
-    else {
-      r_offset = mcld::bswap32(relTab[idx].r_offset);
-      r_info   = mcld::bswap32(relTab[idx].r_info);
-    }
 
-    uint8_t  r_type = static_cast<unsigned char>(r_info);
-    uint32_t r_sym  = (r_info >> 8);
+    if (!target().readRelocation(relTab[idx], r_type, r_sym, r_offset))
+      return false;
 
     LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
     if (NULL == symbol) {
@@ -281,19 +266,19 @@
 }
 
 /// isMyEndian - is this ELF file in the same endian to me?
-bool ELFReader<32, true>::isMyEndian(void* pELFHeader) const
+bool ELFReader<32, true>::isMyEndian(const void* pELFHeader) const
 {
-  llvm::ELF::Elf32_Ehdr* hdr =
-                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf32_Ehdr* hdr =
+      reinterpret_cast<const llvm::ELF::Elf32_Ehdr*>(pELFHeader);
 
   return (hdr->e_ident[llvm::ELF::EI_DATA] == llvm::ELF::ELFDATA2LSB);
 }
 
 /// isMyMachine - is this ELF file generated for the same machine.
-bool ELFReader<32, true>::isMyMachine(void* pELFHeader) const
+bool ELFReader<32, true>::isMyMachine(const void* pELFHeader) const
 {
-  llvm::ELF::Elf32_Ehdr* hdr =
-                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf32_Ehdr* hdr =
+      reinterpret_cast<const llvm::ELF::Elf32_Ehdr*>(pELFHeader);
 
   if (llvm::sys::IsLittleEndianHost)
     return (hdr->e_machine == target().getInfo().machine());
@@ -301,10 +286,10 @@
 }
 
 /// fileType - return the file type
-Input::Type ELFReader<32, true>::fileType(void* pELFHeader) const
+Input::Type ELFReader<32, true>::fileType(const void* pELFHeader) const
 {
-  llvm::ELF::Elf32_Ehdr* hdr =
-                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf32_Ehdr* hdr =
+      reinterpret_cast<const llvm::ELF::Elf32_Ehdr*>(pELFHeader);
   uint32_t type = 0x0;
   if (llvm::sys::IsLittleEndianHost)
     type = hdr->e_type;
@@ -327,11 +312,11 @@
 }
 
 /// readSectionHeaders - read ELF section header table and create LDSections
-bool
-ELFReader<32, true>::readSectionHeaders(Input& pInput, void* pELFHeader) const
+bool ELFReader<32, true>::readSectionHeaders(Input& pInput,
+                                             const void* pELFHeader) const
 {
-  llvm::ELF::Elf32_Ehdr* ehdr =
-                          reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf32_Ehdr* ehdr =
+      reinterpret_cast<const llvm::ELF::Elf32_Ehdr*>(pELFHeader);
 
   uint32_t shoff     = 0x0;
   uint16_t shentsize = 0x0;
@@ -355,8 +340,8 @@
   if (0x0 == shoff)
     return true;
 
-  llvm::ELF::Elf32_Shdr *shdr = NULL;
-  MemoryRegion* shdr_region = NULL;
+  const llvm::ELF::Elf32_Shdr *shdr = NULL;
+  llvm::StringRef shdr_region;
   uint32_t sh_name      = 0x0;
   uint32_t sh_type      = 0x0;
   uint32_t sh_flags     = 0x0;
@@ -370,7 +355,7 @@
   if (shnum == llvm::ELF::SHN_UNDEF || shstrtab == llvm::ELF::SHN_XINDEX) {
     shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
                                             shentsize);
-    shdr = reinterpret_cast<llvm::ELF::Elf32_Shdr*>(shdr_region->start());
+    shdr = reinterpret_cast<const llvm::ELF::Elf32_Shdr*>(shdr_region.begin());
 
     if (llvm::sys::IsLittleEndianHost) {
       sh_size = shdr->sh_size;
@@ -380,7 +365,6 @@
       sh_size = mcld::bswap32(shdr->sh_size);
       sh_link = mcld::bswap32(shdr->sh_link);
     }
-    pInput.memArea()->release(shdr_region);
 
     if (shnum == llvm::ELF::SHN_UNDEF)
       shnum = sh_size;
@@ -392,8 +376,8 @@
 
   shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
                                           shnum * shentsize);
-  llvm::ELF::Elf32_Shdr * shdrTab =
-    reinterpret_cast<llvm::ELF::Elf32_Shdr*>(shdr_region->start());
+  const llvm::ELF::Elf32_Shdr* shdrTab =
+      reinterpret_cast<const llvm::ELF::Elf32_Shdr*>(shdr_region.begin());
 
   // get .shstrtab first
   shdr = &shdrTab[shstrtab];
@@ -406,10 +390,9 @@
     sh_size   = mcld::bswap32(shdr->sh_size);
   }
 
-  MemoryRegion* sect_name_region = pInput.memArea()->request(
-                                      pInput.fileOffset() + sh_offset, sh_size);
-  const char* sect_name =
-                       reinterpret_cast<const char*>(sect_name_region->start());
+  llvm::StringRef sect_name_region = pInput.memArea()->request(
+      pInput.fileOffset() + sh_offset, sh_size);
+  const char* sect_name = sect_name_region.begin();
 
   LinkInfoList link_info_list;
 
@@ -454,21 +437,12 @@
   // set up InfoLink
   LinkInfoList::iterator info, infoEnd = link_info_list.end();
   for (info = link_info_list.begin(); info != infoEnd; ++info) {
-    if (LDFileFormat::NamePool == info->section->kind() ||
-        LDFileFormat::Group == info->section->kind() ||
-        LDFileFormat::Note == info->section->kind()) {
-      info->section->setLink(pInput.context()->getSection(info->sh_link));
-      continue;
-    }
-    if (LDFileFormat::Relocation == info->section->kind()) {
+    if (LDFileFormat::Relocation == info->section->kind())
       info->section->setLink(pInput.context()->getSection(info->sh_info));
-      continue;
-    }
+    else
+      info->section->setLink(pInput.context()->getSection(info->sh_link));
   }
 
-  pInput.memArea()->release(shdr_region);
-  pInput.memArea()->release(sect_name_region);
-
   return true;
 }
 
@@ -484,10 +458,10 @@
 
   uint32_t offset = pInput.fileOffset() + symtab->offset() +
                       sizeof(llvm::ELF::Elf32_Sym) * pSymIdx;
-  MemoryRegion* symbol_region =
-                pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf32_Sym));
-  llvm::ELF::Elf32_Sym* entry =
-                reinterpret_cast<llvm::ELF::Elf32_Sym*>(symbol_region->start());
+  llvm::StringRef symbol_region =
+      pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf32_Sym));
+  const llvm::ELF::Elf32_Sym* entry =
+      reinterpret_cast<const llvm::ELF::Elf32_Sym*>(symbol_region.begin());
 
   uint32_t st_name  = 0x0;
   uint8_t  st_info  = 0x0;
@@ -504,12 +478,11 @@
     st_shndx = mcld::bswap16(entry->st_shndx);
   }
 
-  MemoryRegion* strtab_region = pInput.memArea()->request(
-                       pInput.fileOffset() + strtab->offset(), strtab->size());
+  llvm::StringRef strtab_region = pInput.memArea()->request(
+      pInput.fileOffset() + strtab->offset(), strtab->size());
 
   // get ld_name
-  llvm::StringRef ld_name(
-                    reinterpret_cast<char*>(strtab_region->start() + st_name));
+  llvm::StringRef ld_name(strtab_region.begin() + st_name);
 
   ResolveInfo* result = ResolveInfo::Create(ld_name);
   result->setSource(pInput.type() == Input::DynObj);
@@ -518,10 +491,6 @@
   result->setBinding(getSymBinding((st_info >> 4), st_shndx, st_other));
   result->setVisibility(getSymVisibility(st_other));
 
-  // release regions
-  pInput.memArea()->release(symbol_region);
-  pInput.memArea()->release(strtab_region);
-
   return result;
 }
 
@@ -538,17 +507,15 @@
     fatal(diag::err_cannot_read_section) << ".dynstr";
   }
 
-  MemoryRegion* dynamic_region = pInput.memArea()->request(
-           pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size());
+  llvm::StringRef dynamic_region = pInput.memArea()->request(
+      pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size());
 
-  MemoryRegion* dynstr_region = pInput.memArea()->request(
-             pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size());
-
-  assert(NULL != dynamic_region && NULL != dynstr_region);
+  llvm::StringRef dynstr_region = pInput.memArea()->request(
+      pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size());
 
   const llvm::ELF::Elf32_Dyn* dynamic =
-    (llvm::ELF::Elf32_Dyn*) dynamic_region->start();
-  const char* dynstr = (const char*) dynstr_region->start();
+      reinterpret_cast<const llvm::ELF::Elf32_Dyn*>(dynamic_region.begin());
+  const char* dynstr = dynstr_region.begin();
   bool hasSOName = false;
   size_t numOfEntries = dynamic_sect->size() / sizeof(llvm::ELF::Elf32_Dyn);
 
@@ -584,8 +551,6 @@
   if (!hasSOName)
     pInput.setName(pInput.path().filename().native());
 
-  pInput.memArea()->release(dynamic_region);
-  pInput.memArea()->release(dynstr_region);
   return true;
 }
 
@@ -603,10 +568,10 @@
 }
 
 /// isELF - is this a ELF file
-bool ELFReader<64, true>::isELF(void* pELFHeader) const
+bool ELFReader<64, true>::isELF(const void* pELFHeader) const
 {
-  llvm::ELF::Elf64_Ehdr* hdr =
-                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf64_Ehdr* hdr =
+      reinterpret_cast<const llvm::ELF::Elf64_Ehdr*>(pELFHeader);
   if (0 == memcmp(llvm::ELF::ElfMagic, hdr, 4))
     return true;
   return false;
@@ -627,13 +592,13 @@
 /// readSymbols - read ELF symbols and create LDSymbol
 bool ELFReader<64, true>::readSymbols(Input& pInput,
                                       IRBuilder& pBuilder,
-                                      const MemoryRegion& pRegion,
+                                      llvm::StringRef pRegion,
                                       const char* pStrTab) const
 {
   // get number of symbols
-  size_t entsize = pRegion.size()/sizeof(llvm::ELF::Elf64_Sym);
+  size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Sym);
   const llvm::ELF::Elf64_Sym* symtab =
-                 reinterpret_cast<const llvm::ELF::Elf64_Sym*>(pRegion.start());
+      reinterpret_cast<const llvm::ELF::Elf64_Sym*>(pRegion.begin());
 
   uint32_t st_name  = 0x0;
   uint64_t st_value = 0x0;
@@ -705,22 +670,22 @@
       ld_name = std::string(pStrTab + st_name);
     }
 
-    LDSymbol *psym =
-            pBuilder.AddSymbol(pInput,
-                               ld_name,
-                               ld_type,
-                               ld_desc,
-                               ld_binding,
-                               st_size,
-                               ld_value,
-                               section, ld_vis);
+    LDSymbol* psym = pBuilder.AddSymbol(pInput,
+                                        ld_name,
+                                        ld_type,
+                                        ld_desc,
+                                        ld_binding,
+                                        st_size,
+                                        ld_value,
+                                        section,
+                                        ld_vis);
 
-    if ( is_dyn_obj
-         && NULL!=psym
-         && ResolveInfo::Undefined!=ld_desc
-         && (ResolveInfo::Global==ld_binding ||
-             ResolveInfo::Weak==ld_binding)
-         && ResolveInfo::Object==ld_type ) {
+    if (is_dyn_obj
+        && NULL != psym
+        && ResolveInfo::Undefined != ld_desc
+        && (ResolveInfo::Global == ld_binding ||
+            ResolveInfo::Weak == ld_binding)
+        && ResolveInfo::Object == ld_type ) {
       AliasInfo p;
       p.pt_alias = psym;
       p.ld_binding = ld_binding;
@@ -731,9 +696,9 @@
   } // end of for loop
 
   // analyze weak alias here
-  if ( is_dyn_obj ) {
+  if (is_dyn_obj) {
     // sort symbols by symbol value and then weak before strong
-    std::sort( potential_aliases.begin(), potential_aliases.end(), less);
+    std::sort(potential_aliases.begin(), potential_aliases.end(), less);
 
     // for each weak symbol, find out all its aliases, and
     // then link them as a circular list in Module
@@ -746,16 +711,16 @@
       Module& pModule = pBuilder.getModule();
       std::vector<AliasInfo>::iterator alias_it = sym_it+1;
       while(alias_it!=sym_e) {
-        if ( sym_it->ld_value != alias_it->ld_value )
+        if (sym_it->ld_value != alias_it->ld_value)
           break;
 
-        if (sym_it+1==alias_it)
+        if (sym_it + 1 == alias_it)
           pModule.CreateAliasList(*sym_it->pt_alias->resolveInfo());
         pModule.addAlias(*alias_it->pt_alias->resolveInfo());
         ++alias_it;
       }
 
-      sym_it = alias_it-1;
+      sym_it = alias_it - 1;
     }// end of for loop
   }
   return true;
@@ -767,30 +732,23 @@
 /// ELFReader::readRela - read ELF rela and create Relocation
 bool ELFReader<64, true>::readRela(Input& pInput,
                                    LDSection& pSection,
-                                   const MemoryRegion& pRegion) const
+                                   llvm::StringRef pRegion) const
 {
   // get the number of rela
   size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Rela);
   const llvm::ELF::Elf64_Rela* relaTab =
-                reinterpret_cast<const llvm::ELF::Elf64_Rela*>(pRegion.start());
+      reinterpret_cast<const llvm::ELF::Elf64_Rela*>(pRegion.begin());
 
   for (size_t idx=0; idx < entsize; ++idx) {
+    Relocation::Type r_type = 0x0;
+    uint32_t r_sym = 0x0;
     uint64_t r_offset = 0x0;
-    uint64_t r_info   = 0x0;
     int64_t  r_addend = 0;
-    if (llvm::sys::IsLittleEndianHost) {
-      r_offset = relaTab[idx].r_offset;
-      r_info   = relaTab[idx].r_info;
-      r_addend = relaTab[idx].r_addend;
-    }
-    else {
-      r_offset = mcld::bswap64(relaTab[idx].r_offset);
-      r_info   = mcld::bswap64(relaTab[idx].r_info);
-      r_addend = mcld::bswap64(relaTab[idx].r_addend);
+    if (!target().readRelocation(relaTab[idx],
+                                 r_type, r_sym, r_offset, r_addend)) {
+      return false;
     }
 
-    uint32_t  r_type = static_cast<uint32_t>(r_info);
-    uint32_t r_sym  = (r_info >> 32);
     LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
     if (NULL == symbol) {
       fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
@@ -804,27 +762,19 @@
 /// readRel - read ELF rel and create Relocation
 bool ELFReader<64, true>::readRel(Input& pInput,
                                   LDSection& pSection,
-                                  const MemoryRegion& pRegion) const
+                                  llvm::StringRef pRegion) const
 {
   // get the number of rel
   size_t entsize = pRegion.size() / sizeof(llvm::ELF::Elf64_Rel);
   const llvm::ELF::Elf64_Rel* relTab =
-                 reinterpret_cast<const llvm::ELF::Elf64_Rel*>(pRegion.start());
+      reinterpret_cast<const llvm::ELF::Elf64_Rel*>(pRegion.begin());
 
   for (size_t idx=0; idx < entsize; ++idx) {
+    Relocation::Type r_type = 0x0;
+    uint32_t r_sym = 0x0;
     uint64_t r_offset = 0x0;
-    uint64_t r_info   = 0x0;
-    if (llvm::sys::IsLittleEndianHost) {
-      r_offset = relTab[idx].r_offset;
-      r_info   = relTab[idx].r_info;
-    }
-    else {
-      r_offset = mcld::bswap64(relTab[idx].r_offset);
-      r_info   = mcld::bswap64(relTab[idx].r_info);
-    }
-
-    uint32_t  r_type = static_cast<uint32_t>(r_info);
-    uint32_t r_sym  = (r_info >> 32);
+    if (!target().readRelocation(relTab[idx], r_type, r_sym, r_offset))
+      return false;
 
     LDSymbol* symbol = pInput.context()->getSymbol(r_sym);
     if (NULL == symbol) {
@@ -837,19 +787,19 @@
 }
 
 /// isMyEndian - is this ELF file in the same endian to me?
-bool ELFReader<64, true>::isMyEndian(void* pELFHeader) const
+bool ELFReader<64, true>::isMyEndian(const void* pELFHeader) const
 {
-  llvm::ELF::Elf64_Ehdr* hdr =
-                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf64_Ehdr* hdr =
+      reinterpret_cast<const llvm::ELF::Elf64_Ehdr*>(pELFHeader);
 
   return (hdr->e_ident[llvm::ELF::EI_DATA] == llvm::ELF::ELFDATA2LSB);
 }
 
 /// isMyMachine - is this ELF file generated for the same machine.
-bool ELFReader<64, true>::isMyMachine(void* pELFHeader) const
+bool ELFReader<64, true>::isMyMachine(const void* pELFHeader) const
 {
-  llvm::ELF::Elf64_Ehdr* hdr =
-                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf64_Ehdr* hdr =
+      reinterpret_cast<const llvm::ELF::Elf64_Ehdr*>(pELFHeader);
 
   if (llvm::sys::IsLittleEndianHost)
     return (hdr->e_machine == target().getInfo().machine());
@@ -857,10 +807,10 @@
 }
 
 /// fileType - return the file type
-Input::Type ELFReader<64, true>::fileType(void* pELFHeader) const
+Input::Type ELFReader<64, true>::fileType(const void* pELFHeader) const
 {
-  llvm::ELF::Elf64_Ehdr* hdr =
-                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf64_Ehdr* hdr =
+      reinterpret_cast<const llvm::ELF::Elf64_Ehdr*>(pELFHeader);
   uint32_t type = 0x0;
   if (llvm::sys::IsLittleEndianHost)
     type = hdr->e_type;
@@ -883,11 +833,11 @@
 }
 
 /// readSectionHeaders - read ELF section header table and create LDSections
-bool
-ELFReader<64, true>::readSectionHeaders(Input& pInput, void* pELFHeader) const
+bool ELFReader<64, true>::readSectionHeaders(Input& pInput,
+                                             const void* pELFHeader) const
 {
-  llvm::ELF::Elf64_Ehdr* ehdr =
-                          reinterpret_cast<llvm::ELF::Elf64_Ehdr*>(pELFHeader);
+  const llvm::ELF::Elf64_Ehdr* ehdr =
+      reinterpret_cast<const llvm::ELF::Elf64_Ehdr*>(pELFHeader);
 
   uint64_t shoff     = 0x0;
   uint16_t shentsize = 0x0;
@@ -911,8 +861,8 @@
   if (0x0 == shoff)
     return true;
 
-  llvm::ELF::Elf64_Shdr *shdr = NULL;
-  MemoryRegion* shdr_region = NULL;
+  const llvm::ELF::Elf64_Shdr *shdr = NULL;
+  llvm::StringRef shdr_region;
   uint32_t sh_name      = 0x0;
   uint32_t sh_type      = 0x0;
   uint64_t sh_flags     = 0x0;
@@ -926,7 +876,7 @@
   if (shnum == llvm::ELF::SHN_UNDEF || shstrtab == llvm::ELF::SHN_XINDEX) {
     shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
                                             shentsize);
-    shdr = reinterpret_cast<llvm::ELF::Elf64_Shdr*>(shdr_region->start());
+    shdr = reinterpret_cast<const llvm::ELF::Elf64_Shdr*>(shdr_region.begin());
 
     if (llvm::sys::IsLittleEndianHost) {
       sh_size = shdr->sh_size;
@@ -936,7 +886,6 @@
       sh_size = mcld::bswap64(shdr->sh_size);
       sh_link = mcld::bswap32(shdr->sh_link);
     }
-    pInput.memArea()->release(shdr_region);
 
     if (shnum == llvm::ELF::SHN_UNDEF)
       shnum = sh_size;
@@ -948,8 +897,8 @@
 
   shdr_region = pInput.memArea()->request(pInput.fileOffset() + shoff,
                                           shnum * shentsize);
-  llvm::ELF::Elf64_Shdr * shdrTab =
-    reinterpret_cast<llvm::ELF::Elf64_Shdr*>(shdr_region->start());
+  const llvm::ELF::Elf64_Shdr* shdrTab =
+      reinterpret_cast<const llvm::ELF::Elf64_Shdr*>(shdr_region.begin());
 
   // get .shstrtab first
   shdr = &shdrTab[shstrtab];
@@ -962,10 +911,9 @@
     sh_size   = mcld::bswap64(shdr->sh_size);
   }
 
-  MemoryRegion* sect_name_region = pInput.memArea()->request(
-                                      pInput.fileOffset() + sh_offset, sh_size);
-  const char* sect_name =
-                       reinterpret_cast<const char*>(sect_name_region->start());
+  llvm::StringRef sect_name_region = pInput.memArea()->request(
+      pInput.fileOffset() + sh_offset, sh_size);
+  const char* sect_name = sect_name_region.begin();
 
   LinkInfoList link_info_list;
 
@@ -1010,21 +958,12 @@
   // set up InfoLink
   LinkInfoList::iterator info, infoEnd = link_info_list.end();
   for (info = link_info_list.begin(); info != infoEnd; ++info) {
-    if (LDFileFormat::NamePool == info->section->kind() ||
-        LDFileFormat::Group == info->section->kind() ||
-        LDFileFormat::Note == info->section->kind()) {
-      info->section->setLink(pInput.context()->getSection(info->sh_link));
-      continue;
-    }
-    if (LDFileFormat::Relocation == info->section->kind()) {
+    if (LDFileFormat::Relocation == info->section->kind())
       info->section->setLink(pInput.context()->getSection(info->sh_info));
-      continue;
-    }
+    else
+      info->section->setLink(pInput.context()->getSection(info->sh_link));
   }
 
-  pInput.memArea()->release(shdr_region);
-  pInput.memArea()->release(sect_name_region);
-
   return true;
 }
 
@@ -1040,10 +979,10 @@
 
   uint64_t offset = pInput.fileOffset() + symtab->offset() +
                       sizeof(llvm::ELF::Elf64_Sym) * pSymIdx;
-  MemoryRegion* symbol_region =
-                pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf64_Sym));
-  llvm::ELF::Elf64_Sym* entry =
-                reinterpret_cast<llvm::ELF::Elf64_Sym*>(symbol_region->start());
+  llvm::StringRef symbol_region =
+      pInput.memArea()->request(offset, sizeof(llvm::ELF::Elf64_Sym));
+  const llvm::ELF::Elf64_Sym* entry =
+      reinterpret_cast<const llvm::ELF::Elf64_Sym*>(symbol_region.begin());
 
   uint32_t st_name  = 0x0;
   uint8_t  st_info  = 0x0;
@@ -1060,12 +999,11 @@
     st_shndx = mcld::bswap16(entry->st_shndx);
   }
 
-  MemoryRegion* strtab_region = pInput.memArea()->request(
-                       pInput.fileOffset() + strtab->offset(), strtab->size());
+  llvm::StringRef strtab_region = pInput.memArea()->request(
+      pInput.fileOffset() + strtab->offset(), strtab->size());
 
   // get ld_name
-  llvm::StringRef ld_name(
-                    reinterpret_cast<char*>(strtab_region->start() + st_name));
+  llvm::StringRef ld_name(strtab_region.begin() + st_name);
 
   ResolveInfo* result = ResolveInfo::Create(ld_name);
   result->setSource(pInput.type() == Input::DynObj);
@@ -1074,10 +1012,6 @@
   result->setBinding(getSymBinding((st_info >> 4), st_shndx, st_other));
   result->setVisibility(getSymVisibility(st_other));
 
-  // release regions
-  pInput.memArea()->release(symbol_region);
-  pInput.memArea()->release(strtab_region);
-
   return result;
 }
 
@@ -1094,17 +1028,15 @@
     fatal(diag::err_cannot_read_section) << ".dynstr";
   }
 
-  MemoryRegion* dynamic_region = pInput.memArea()->request(
-           pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size());
+  llvm::StringRef dynamic_region = pInput.memArea()->request(
+      pInput.fileOffset() + dynamic_sect->offset(), dynamic_sect->size());
 
-  MemoryRegion* dynstr_region = pInput.memArea()->request(
-             pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size());
-
-  assert(NULL != dynamic_region && NULL != dynstr_region);
+  llvm::StringRef dynstr_region = pInput.memArea()->request(
+      pInput.fileOffset() + dynstr_sect->offset(), dynstr_sect->size());
 
   const llvm::ELF::Elf64_Dyn* dynamic =
-    (llvm::ELF::Elf64_Dyn*) dynamic_region->start();
-  const char* dynstr = (const char*) dynstr_region->start();
+      reinterpret_cast<const llvm::ELF::Elf64_Dyn*>(dynamic_region.begin());
+  const char* dynstr = dynstr_region.begin();
   bool hasSOName = false;
   size_t numOfEntries = dynamic_sect->size() / sizeof(llvm::ELF::Elf64_Dyn);
 
@@ -1140,8 +1072,5 @@
   if (!hasSOName)
     pInput.setName(pInput.path().filename().native());
 
-  pInput.memArea()->release(dynamic_region);
-  pInput.memArea()->release(dynstr_region);
   return true;
 }
-
diff --git a/lib/LD/ELFReaderIf.cpp b/lib/LD/ELFReaderIf.cpp
index 4d56b14..7d72596 100644
--- a/lib/LD/ELFReaderIf.cpp
+++ b/lib/LD/ELFReaderIf.cpp
@@ -13,10 +13,6 @@
 #include <mcld/LD/EhFrame.h>
 #include <mcld/LD/SectionData.h>
 #include <mcld/Target/GNULDBackend.h>
-//#include <mcld/Support/MemoryArea.h>
-//#include <mcld/Support/MemoryRegion.h>
-//#include <mcld/Support/MsgHandling.h>
-//#include <mcld/Object/ObjectBuilder.h>
 
 #include <cstring>
 
diff --git a/lib/LD/ELFSegment.cpp b/lib/LD/ELFSegment.cpp
index ae328ca..1c09514 100644
--- a/lib/LD/ELFSegment.cpp
+++ b/lib/LD/ELFSegment.cpp
@@ -7,61 +7,100 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/ELFSegment.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/Support/GCFactory.h>
+#include <mcld/Config/Config.h>
+#include <llvm/Support/ManagedStatic.h>
+#include <cassert>
 
 using namespace mcld;
 
-//==========================
+typedef GCFactory<ELFSegment, MCLD_SEGMENTS_PER_OUTPUT> ELFSegmentFactory;
+static llvm::ManagedStatic<ELFSegmentFactory> g_ELFSegmentFactory;
+
+//===----------------------------------------------------------------------===//
 // ELFSegment
-ELFSegment::ELFSegment(uint32_t pType,
-                       uint32_t pFlag,
-                       uint64_t pOffset,
-                       uint64_t pVaddr,
-                       uint64_t pPaddr,
-                       uint64_t pFilesz,
-                       uint64_t pMemsz,
-                       uint64_t pAlign,
-                       uint64_t pMaxSectAlign)
+//===----------------------------------------------------------------------===//
+ELFSegment::ELFSegment()
+  : m_Type(llvm::ELF::PT_NULL),
+    m_Flag(llvm::ELF::PF_R),
+    m_Offset(0x0),
+    m_Vaddr(0x0),
+    m_Paddr(0x0),
+    m_Filesz(0x0),
+    m_Memsz(0x0),
+    m_Align(0x0),
+    m_MaxSectionAlign(0x0)
+{
+}
+
+ELFSegment::ELFSegment(uint32_t pType, uint32_t pFlag)
   : m_Type(pType),
     m_Flag(pFlag),
-    m_Offset(pOffset),
-    m_Vaddr(pVaddr),
-    m_Paddr(pPaddr),
-    m_Filesz(pFilesz),
-    m_Memsz(pMemsz),
-    m_Align(pAlign),
-    m_MaxSectionAlign(pMaxSectAlign) {
+    m_Offset(0x0),
+    m_Vaddr(0x0),
+    m_Paddr(0x0),
+    m_Filesz(0x0),
+    m_Memsz(0x0),
+    m_Align(0x0),
+    m_MaxSectionAlign(0x0)
+{
 }
 
 ELFSegment::~ELFSegment()
 {
 }
 
+bool ELFSegment::isLoadSegment() const
+{
+  return type() == llvm::ELF::PT_LOAD;
+}
+
 bool ELFSegment::isDataSegment() const
 {
-  bool result = false;
-  if ((type() == llvm::ELF::PT_LOAD) && (flag() & llvm::ELF::PF_W) != 0x0) {
-    for (const_sect_iterator it = begin(), ie = end(); it != ie; ++it) {
-      if ((*it)->kind() != LDFileFormat::BSS) {
-        result = true;
-        break;
-      }
-    }
-  }
-  return result;
+  return (type() == llvm::ELF::PT_LOAD) && ((flag() & llvm::ELF::PF_W) != 0x0);
 }
 
 bool ELFSegment::isBssSegment() const
 {
-  bool result = false;
-  if ((type() == llvm::ELF::PT_LOAD) && (flag() & llvm::ELF::PF_W) != 0x0) {
-    const_sect_iterator it = begin(), ie = end();
-    for (; it != ie; ++it) {
-      if ((*it)->kind() != LDFileFormat::BSS)
-        break;
-    }
-    if (it == ie)
-      result = true;
+  if (!isDataSegment())
+    return false;
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
+    if ((*it)->kind() != LDFileFormat::BSS)
+      return false;
   }
-  return result;
+  return true;
 }
 
+ELFSegment::iterator ELFSegment::insert(ELFSegment::iterator pPos,
+                                        LDSection* pSection)
+{
+  return m_SectionList.insert(pPos, pSection);
+}
+
+void ELFSegment::append(LDSection* pSection)
+{
+  assert(NULL != pSection);
+  if (pSection->align() > m_MaxSectionAlign)
+    m_MaxSectionAlign = pSection->align();
+  m_SectionList.push_back(pSection);
+}
+
+ELFSegment* ELFSegment::Create(uint32_t pType, uint32_t pFlag)
+{
+  ELFSegment* seg = g_ELFSegmentFactory->allocate();
+  new (seg) ELFSegment(pType, pFlag);
+  return seg;
+}
+
+void ELFSegment::Destroy(ELFSegment*& pSegment)
+{
+  g_ELFSegmentFactory->destroy(pSegment);
+  g_ELFSegmentFactory->deallocate(pSegment);
+  pSegment = NULL;
+}
+
+void ELFSegment::Clear()
+{
+  g_ELFSegmentFactory->clear();
+}
diff --git a/lib/LD/ELFSegmentFactory.cpp b/lib/LD/ELFSegmentFactory.cpp
index af0f588..4d06629 100644
--- a/lib/LD/ELFSegmentFactory.cpp
+++ b/lib/LD/ELFSegmentFactory.cpp
@@ -7,58 +7,83 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/ELFSegmentFactory.h>
+#include <mcld/LD/ELFSegment.h>
 
 using namespace mcld;
 
-//==========================
+//===----------------------------------------------------------------------===//
 // ELFSegmentFactory
+//===----------------------------------------------------------------------===//
 
-ELFSegmentFactory::ELFSegmentFactory(size_t pNum)
-  : GCFactory<ELFSegment, 0>(pNum)
-{
-}
-
-ELFSegmentFactory::~ELFSegmentFactory()
-{
-}
-
-/// produce - produce an empty ELF segment information.
-/// this function will create an ELF segment
-/// @param pType - p_type in ELF program header
-ELFSegment* ELFSegmentFactory::produce(uint32_t pType, uint32_t pFlag)
-{
-  ELFSegment* segment = allocate();
-  new (segment) ELFSegment(pType, pFlag);
-  return segment;
-}
-
-ELFSegment*
+ELFSegmentFactory::iterator
 ELFSegmentFactory::find(uint32_t pType, uint32_t pFlagSet, uint32_t pFlagClear)
 {
   iterator segment, segEnd = end();
   for (segment = begin(); segment != segEnd; ++segment) {
-    if ((*segment).type() == pType &&
-        ((*segment).flag() & pFlagSet) == pFlagSet &&
-        ((*segment).flag() & pFlagClear) == 0x0) {
-      return &(*segment);
+    if ((*segment)->type() == pType &&
+        ((*segment)->flag() & pFlagSet) == pFlagSet &&
+        ((*segment)->flag() & pFlagClear) == 0x0) {
+      return segment;
     }
   }
-  return NULL;
+  return segEnd;
 }
 
-const ELFSegment*
+ELFSegmentFactory::const_iterator
 ELFSegmentFactory::find(uint32_t pType,
                         uint32_t pFlagSet,
                         uint32_t pFlagClear) const
 {
   const_iterator segment, segEnd = end();
   for (segment = begin(); segment != segEnd; ++segment) {
-    if ((*segment).type() == pType &&
-        ((*segment).flag() & pFlagSet) == pFlagSet &&
-        ((*segment).flag() & pFlagClear) == 0x0) {
-      return &(*segment);
+    if ((*segment)->type() == pType &&
+        ((*segment)->flag() & pFlagSet) == pFlagSet &&
+        ((*segment)->flag() & pFlagClear) == 0x0) {
+      return segment;
     }
   }
-  return NULL;
+  return segEnd;
 }
 
+ELFSegmentFactory::iterator
+ELFSegmentFactory::find(uint32_t pType, const LDSection* pSection)
+{
+  iterator segment, segEnd = end();
+  for (segment = begin(); segment != segEnd; ++segment) {
+    if ((*segment)->type() == pType) {
+      ELFSegment::iterator sect, sectEnd = (*segment)->end();
+      for (sect = (*segment)->begin(); sect != sectEnd; ++sect) {
+        if (*sect == pSection)
+          return segment;
+      } // for each section
+    }
+  } // for each segment
+  return segEnd;
+}
+
+ELFSegmentFactory::const_iterator
+ELFSegmentFactory::find(uint32_t pType, const LDSection* pSection) const
+{
+  const_iterator segment, segEnd = end();
+  for (segment = begin(); segment != segEnd; ++segment) {
+    if ((*segment)->type() == pType) {
+      ELFSegment::const_iterator sect, sectEnd = (*segment)->end();
+      for (sect = (*segment)->begin(); sect != sectEnd; ++sect) {
+        if (*sect == pSection)
+          return segment;
+      } // for each section
+    }
+  } // for each segment
+  return segEnd;
+}
+
+ELFSegment* ELFSegmentFactory::produce(uint32_t pType, uint32_t pFlag)
+{
+  m_Segments.push_back(ELFSegment::Create(pType, pFlag));
+  return back();
+}
+
+void ELFSegmentFactory::erase(iterator pSegment)
+{
+  m_Segments.erase(pSegment);
+}
diff --git a/lib/LD/EhFrame.cpp b/lib/LD/EhFrame.cpp
index 0bd6511..5ac3e72 100644
--- a/lib/LD/EhFrame.cpp
+++ b/lib/LD/EhFrame.cpp
@@ -6,11 +6,16 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include <mcld/Fragment/Relocation.h>
 #include <mcld/LD/EhFrame.h>
+#include <mcld/LD/LDContext.h>
 #include <mcld/LD/LDSection.h>
+#include <mcld/LD/LDSymbol.h>
+#include <mcld/LD/RelocData.h>
+#include <mcld/LD/ResolveInfo.h>
 #include <mcld/LD/SectionData.h>
+#include <mcld/MC/Input.h>
 #include <mcld/Object/ObjectBuilder.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/GCFactory.h>
 
 #include <llvm/Support/ManagedStatic.h>
@@ -22,21 +27,66 @@
 static llvm::ManagedStatic<EhFrameFactory> g_EhFrameFactory;
 
 //===----------------------------------------------------------------------===//
+// EhFrame::Record
+//===----------------------------------------------------------------------===//
+EhFrame::Record::Record(llvm::StringRef pRegion)
+  : RegionFragment(pRegion) {
+}
+
+EhFrame::Record::~Record()
+{
+  // llvm::iplist will manage and delete the fragments
+}
+
+//===----------------------------------------------------------------------===//
 // EhFrame::CIE
 //===----------------------------------------------------------------------===//
-EhFrame::CIE::CIE(MemoryRegion& pRegion)
-  : RegionFragment(pRegion) {
+EhFrame::CIE::CIE(llvm::StringRef pRegion)
+  : EhFrame::Record(pRegion),
+    m_FDEEncode(0u), m_Mergeable(false), m_pReloc(0), m_PersonalityOffset(0) {
+}
+
+EhFrame::CIE::~CIE()
+{
 }
 
 //===----------------------------------------------------------------------===//
 // EhFrame::FDE
 //===----------------------------------------------------------------------===//
-EhFrame::FDE::FDE(MemoryRegion& pRegion,
-                  const EhFrame::CIE& pCIE,
-                  uint32_t pDataStart)
-  : RegionFragment(pRegion),
-    m_CIE(pCIE),
-    m_DataStart(pDataStart) {
+EhFrame::FDE::FDE(llvm::StringRef pRegion, EhFrame::CIE& pCIE)
+  : EhFrame::Record(pRegion), m_pCIE(&pCIE) {
+}
+
+EhFrame::FDE::~FDE()
+{
+}
+
+void EhFrame::FDE::setCIE(EhFrame::CIE& pCIE)
+{
+  m_pCIE = &pCIE;
+  m_pCIE->add(*this);
+}
+
+//===----------------------------------------------------------------------===//
+// EhFrame::GeneratedCIE
+//===----------------------------------------------------------------------===//
+EhFrame::GeneratedCIE::GeneratedCIE(llvm::StringRef pRegion)
+  : EhFrame::CIE(pRegion) {
+}
+
+EhFrame::GeneratedCIE::~GeneratedCIE()
+{
+}
+
+//===----------------------------------------------------------------------===//
+// EhFrame::GeneratedFDE
+//===----------------------------------------------------------------------===//
+EhFrame::GeneratedFDE::GeneratedFDE(llvm::StringRef pRegion, CIE &pCIE)
+  : EhFrame::FDE(pRegion, pCIE) {
+}
+
+EhFrame::GeneratedFDE::~GeneratedFDE()
+{
 }
 
 //===----------------------------------------------------------------------===//
@@ -54,8 +104,6 @@
 
 EhFrame::~EhFrame()
 {
-  // Since all CIEs, FDEs and regular fragments are stored in iplist, iplist
-  // will delete the fragments and we do not need to handle with it.
 }
 
 EhFrame* EhFrame::Create(LDSection& pSection)
@@ -89,52 +137,247 @@
   return *m_pSection;
 }
 
-void EhFrame::addFragment(RegionFragment& pFrag)
+void EhFrame::addFragment(Fragment& pFrag)
 {
   uint32_t offset = 0;
   if (!m_pSectionData->empty())
     offset = m_pSectionData->back().getOffset() + m_pSectionData->back().size();
 
   m_pSectionData->getFragmentList().push_back(&pFrag);
+  pFrag.setParent(m_pSectionData);
   pFrag.setOffset(offset);
 }
 
-void EhFrame::addFragment(NullFragment& pFrag)
-{
-  uint32_t offset = 0;
-  if (!m_pSectionData->empty())
-    offset = m_pSectionData->back().getOffset() + m_pSectionData->back().size();
-
-  m_pSectionData->getFragmentList().push_back(&pFrag);
-  pFrag.setOffset(offset);
-}
-
-void EhFrame::addCIE(EhFrame::CIE& pCIE)
+void EhFrame::addCIE(EhFrame::CIE& pCIE, bool pAlsoAddFragment)
 {
   m_CIEs.push_back(&pCIE);
-  addFragment(pCIE);
+  if (pAlsoAddFragment)
+    addFragment(pCIE);
 }
 
-void EhFrame::addFDE(EhFrame::FDE& pFDE)
+void EhFrame::addFDE(EhFrame::FDE& pFDE, bool pAlsoAddFragment)
 {
-  m_FDEs.push_back(&pFDE);
-  addFragment(pFDE);
+  pFDE.getCIE().add(pFDE);
+  if (pAlsoAddFragment)
+    addFragment(pFDE);
 }
 
-EhFrame& EhFrame::merge(EhFrame& pOther)
+size_t EhFrame::numOfFDEs() const
 {
-  ObjectBuilder::MoveSectionData(*pOther.getSectionData(), *m_pSectionData);
+  // FDE number only used by .eh_frame_hdr computation, and the number of CIE
+  // is usually not too many. It is worthy to compromise space by time
+  size_t size = 0u;
+  for (const_cie_iterator i = cie_begin(), e = cie_end(); i != e; ++i)
+    size += (*i)->numOfFDEs();
+  return size;
+}
 
-  m_CIEs.reserve(pOther.numOfCIEs() + m_CIEs.size());
-  for (cie_iterator cie = pOther.cie_begin(); cie != pOther.cie_end(); ++cie)
-    m_CIEs.push_back(*cie);
+EhFrame& EhFrame::merge(const Input& pInput, EhFrame& pFrame)
+{
+  assert (this != &pFrame);
+  if (pFrame.emptyCIEs()) {
+    // May be a partial linking, or the eh_frame has no data.
+    // Just append the fragments.
+    moveInputFragments(pFrame);
+    return *this;
+  }
 
-  m_FDEs.reserve(pOther.numOfFDEs() + m_FDEs.size());
-  for (fde_iterator fde = pOther.fde_begin(); fde != pOther.fde_end(); ++fde)
-    m_FDEs.push_back(*fde);
+  const LDContext& ctx = *pInput.context();
+  const LDSection* rel_sec = 0;
+  for (LDContext::const_sect_iterator ri = ctx.relocSectBegin(),
+       re = ctx.relocSectEnd(); ri != re; ++ri) {
+    if ((*ri)->getLink() == &pFrame.getSection()) {
+      rel_sec = *ri;
+      break;
+    }
+  }
+  pFrame.setupAttributes(rel_sec);
 
-  pOther.m_CIEs.clear();
-  pOther.m_FDEs.clear();
+  // Most CIE will be merged, so we don't reserve space first.
+  for (cie_iterator i = pFrame.cie_begin(), e = pFrame.cie_end(); i != e; ++i) {
+    CIE& input_cie = **i;
+    // CIE number is usually very few, so we just use vector sequential search.
+    if (!input_cie.getMergeable()) {
+      moveInputFragments(pFrame, input_cie);
+      addCIE(input_cie, /*AlsoAddFragment=*/false);
+      continue;
+    }
+
+    cie_iterator out_i = cie_begin();
+    for (cie_iterator out_e = cie_end(); out_i != out_e; ++out_i) {
+      CIE& output_cie = **out_i;
+      if (output_cie == input_cie) {
+        // This input CIE can be merged
+        moveInputFragments(pFrame, input_cie, &output_cie);
+        removeAndUpdateCIEForFDE(pFrame, input_cie, output_cie, rel_sec);
+        break;
+      }
+    }
+    if (out_i == cie_end()) {
+      moveInputFragments(pFrame, input_cie);
+      addCIE(input_cie, /*AlsoAddFragment=*/false);
+    }
+  }
   return *this;
 }
 
+void EhFrame::setupAttributes(const LDSection* rel_sec)
+{
+  for (cie_iterator i = cie_begin(), e = cie_end(); i != e; ++i) {
+    CIE* cie = *i;
+    removeDiscardedFDE(*cie, rel_sec);
+
+    if (cie->getPersonalityName().size() == 0) {
+      // There's no personality data encoding inside augmentation string.
+      cie->setMergeable();
+    } else {
+      if (!rel_sec) {
+        // No relocation to eh_frame section
+        assert (cie->getPersonalityName() != "" &&
+                "PR name should be a symbol address or offset");
+        continue;
+      }
+      const RelocData* reloc_data = rel_sec->getRelocData();
+      for (RelocData::const_iterator ri = reloc_data->begin(),
+           re = reloc_data->end(); ri != re; ++ri) {
+        const Relocation& rel = *ri;
+        if (rel.targetRef().getOutputOffset() == cie->getOffset() +
+                                                 cie->getPersonalityOffset()) {
+          cie->setMergeable();
+          cie->setPersonalityName(rel.symInfo()->outSymbol()->name());
+          cie->setRelocation(rel);
+          break;
+        }
+      }
+
+      assert (cie->getPersonalityName() != "" &&
+              "PR name should be a symbol address or offset");
+    }
+  }
+}
+
+void EhFrame::removeDiscardedFDE(CIE& pCIE, const LDSection* pRelocSect)
+{
+  if (!pRelocSect)
+    return;
+
+  typedef std::vector<FDE*> FDERemoveList;
+  FDERemoveList to_be_removed_fdes;
+  const RelocData* reloc_data = pRelocSect->getRelocData();
+  for (fde_iterator i = pCIE.begin(), e = pCIE.end(); i != e; ++i) {
+    FDE& fde = **i;
+    for (RelocData::const_iterator ri = reloc_data->begin(),
+         re = reloc_data->end(); ri != re; ++ri) {
+      const Relocation& rel = *ri;
+      if (rel.targetRef().getOutputOffset() == fde.getOffset() +
+                                               getDataStartOffset<32>()) {
+        bool has_section = rel.symInfo()->outSymbol()->hasFragRef();
+        if (!has_section)
+          // The section was discarded, just ignore this FDE.
+          // This may happen when redundant group section was read.
+          to_be_removed_fdes.push_back(&fde);
+        break;
+      }
+    }
+  }
+
+  for (FDERemoveList::iterator i = to_be_removed_fdes.begin(),
+       e = to_be_removed_fdes.end(); i != e; ++i) {
+    FDE& fde = **i;
+    fde.getCIE().remove(fde);
+
+    // FIXME: This traverses relocations from the beginning on each FDE, which
+    // may cause performance degration. Actually relocations will be sequential
+    // order, so we can bookkeep the previously found relocation for next use.
+    // Note: We must ensure FDE order is ordered.
+    for (RelocData::const_iterator ri = reloc_data->begin(),
+         re = reloc_data->end(); ri != re; ) {
+      Relocation& rel = const_cast<Relocation&>(*ri++);
+      if (rel.targetRef().getOutputOffset() >= fde.getOffset() &&
+          rel.targetRef().getOutputOffset() < fde.getOffset() + fde.size()) {
+        const_cast<RelocData*>(reloc_data)->remove(rel);
+      }
+    }
+  }
+}
+
+void EhFrame::removeAndUpdateCIEForFDE(EhFrame& pInFrame, CIE& pInCIE,
+                                       CIE& pOutCIE, const LDSection* rel_sect)
+{
+  // Make this relocation to be ignored.
+  Relocation* rel = const_cast<Relocation*>(pInCIE.getRelocation());
+  if (rel && rel_sect)
+    const_cast<RelocData*>(rel_sect->getRelocData())->remove(*rel);
+
+  // Update the CIE-pointed FDEs
+  for (fde_iterator i = pInCIE.begin(), e = pInCIE.end(); i != e; ++i)
+    (*i)->setCIE(pOutCIE);
+
+  // We cannot know whether there are references to this fragment, so just
+  // keep it in input fragment list instead of memory deallocation
+  pInCIE.clearFDEs();
+}
+
+void EhFrame::moveInputFragments(EhFrame& pInFrame)
+{
+  SectionData& in_sd = *pInFrame.getSectionData();
+  SectionData::FragmentListType& in_frag_list = in_sd.getFragmentList();
+  SectionData& out_sd = *getSectionData();
+  SectionData::FragmentListType& out_frag_list = out_sd.getFragmentList();
+
+  while (!in_frag_list.empty()) {
+    Fragment* frag = in_frag_list.remove(in_frag_list.begin());
+    out_frag_list.push_back(frag);
+    frag->setParent(&out_sd);
+  }
+}
+
+void EhFrame::moveInputFragments(EhFrame& pInFrame,
+                                 CIE& pInCIE, CIE* pOutCIE)
+{
+  SectionData& in_sd = *pInFrame.getSectionData();
+  SectionData::FragmentListType& in_frag_list = in_sd.getFragmentList();
+  SectionData& out_sd = *getSectionData();
+  SectionData::FragmentListType& out_frag_list = out_sd.getFragmentList();
+
+  if (!pOutCIE) {
+    // Newly inserted
+    Fragment* frag = in_frag_list.remove(SectionData::iterator(pInCIE));
+    out_frag_list.push_back(frag);
+    frag->setParent(&out_sd);
+    for (fde_iterator i = pInCIE.begin(), e = pInCIE.end(); i != e; ++i) {
+      frag = in_frag_list.remove(SectionData::iterator(**i));
+      out_frag_list.push_back(frag);
+      frag->setParent(&out_sd);
+    }
+    return;
+  }
+
+  SectionData::iterator cur_iter(*pOutCIE);
+  assert (cur_iter != out_frag_list.end());
+  for (fde_iterator i = pInCIE.begin(), e = pInCIE.end(); i != e; ++i) {
+    Fragment* frag = in_frag_list.remove(SectionData::iterator(**i));
+    cur_iter = out_frag_list.insertAfter(cur_iter, frag);
+    frag->setParent(&out_sd);
+  }
+}
+
+size_t EhFrame::computeOffsetSize()
+{
+  size_t offset = 0u;
+  SectionData::FragmentListType& frag_list = getSectionData()->getFragmentList();
+  for (SectionData::iterator i = frag_list.begin(), e = frag_list.end();
+       i != e; ++i) {
+    Fragment& frag = *i;
+    frag.setOffset(offset);
+    offset += frag.size();
+  }
+  getSection().setSize(offset);
+  return offset;
+}
+
+bool mcld::operator==(const EhFrame::CIE& p1, const EhFrame::CIE& p2)
+{
+  return p1.getPersonalityName() == p2.getPersonalityName() &&
+         p1.getAugmentationData() == p2.getAugmentationData();
+}
diff --git a/lib/LD/EhFrameHdr.cpp b/lib/LD/EhFrameHdr.cpp
index 89b828f..74516d1 100644
--- a/lib/LD/EhFrameHdr.cpp
+++ b/lib/LD/EhFrameHdr.cpp
@@ -8,8 +8,6 @@
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/EhFrameHdr.h>
 
-#include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/LD/EhFrame.h>
 #include <mcld/LD/LDSection.h>
 
@@ -39,16 +37,15 @@
 //===----------------------------------------------------------------------===//
 /// emitOutput<32> - write out eh_frame_hdr
 template<>
-void EhFrameHdr::emitOutput<32>(MemoryArea& pOutput)
+void EhFrameHdr::emitOutput<32>(FileOutputBuffer& pOutput)
 {
-  MemoryRegion* ehframehdr_region =
-    pOutput.request(m_EhFrameHdr.offset(), m_EhFrameHdr.size());
+  MemoryRegion ehframehdr_region = pOutput.request(m_EhFrameHdr.offset(),
+                                                   m_EhFrameHdr.size());
 
-  MemoryRegion* ehframe_region =
-    pOutput.request(m_EhFrame.offset(),
-                    m_EhFrame.size());
+  MemoryRegion ehframe_region = pOutput.request(m_EhFrame.offset(),
+                                                m_EhFrame.size());
 
-  uint8_t* data = (uint8_t*)ehframehdr_region->start();
+  uint8_t* data = ehframehdr_region.begin();
   // version
   data[0] = 1;
   // eh_frame_ptr_enc
@@ -80,16 +77,21 @@
     // prepare the binary search table
     typedef std::vector<bit32::Entry> SearchTableType;
     SearchTableType search_table;
-    EhFrame::const_fde_iterator fde, fde_end = m_EhFrame.getEhFrame()->fde_end();
-    for(fde = m_EhFrame.getEhFrame()->fde_begin(); fde != fde_end; ++fde) {
-      assert(*fde != NULL);
-      SizeTraits<32>::Offset offset;
-      SizeTraits<32>::Address fde_pc;
-      SizeTraits<32>::Address fde_addr;
-      offset = (*fde)->getOffset();
-      fde_pc = computePCBegin(**fde, *ehframe_region);
-      fde_addr = m_EhFrame.addr() + offset;
-      search_table.push_back(std::make_pair(fde_pc, fde_addr));
+
+    for (EhFrame::const_cie_iterator i = m_EhFrame.getEhFrame()->cie_begin(),
+         e = m_EhFrame.getEhFrame()->cie_end(); i != e; ++i) {
+      EhFrame::CIE& cie = **i;
+      for (EhFrame::const_fde_iterator fi = cie.begin(), fe = cie.end();
+           fi != fe; ++fi) {
+        EhFrame::FDE& fde = **fi;
+        SizeTraits<32>::Offset offset;
+        SizeTraits<32>::Address fde_pc;
+        SizeTraits<32>::Address fde_addr;
+        offset = fde.getOffset();
+        fde_pc = computePCBegin(fde, ehframe_region);
+        fde_addr = m_EhFrame.addr() + offset;
+        search_table.push_back(std::make_pair(fde_pc, fde_addr));
+      }
     }
 
     std::sort(search_table.begin(), search_table.end(), bit32::EntryCompare);
@@ -103,8 +105,6 @@
       bst[id++] = (*entry).second - m_EhFrameHdr.addr();
     }
   }
-  pOutput.release(ehframehdr_region);
-  pOutput.release(ehframe_region);
 }
 
 //===----------------------------------------------------------------------===//
@@ -168,9 +168,9 @@
   }
 
   SizeTraits<32>::Address pc = 0x0;
-  const uint8_t* offset = (const uint8_t*) pEhFrameRegion.start() +
+  const uint8_t* offset = (const uint8_t*) pEhFrameRegion.begin() +
                           pFDE.getOffset() +
-                          pFDE.getDataStart();
+                          EhFrame::getDataStartOffset<32>();
   std::memcpy(&pc, offset, pc_size);
 
   // adjust the signed value
@@ -184,7 +184,8 @@
     case DW_EH_PE_absptr:
       break;
     case DW_EH_PE_pcrel:
-      pc += m_EhFrame.addr() + pFDE.getOffset() + pFDE.getDataStart();
+      pc += m_EhFrame.addr() + pFDE.getOffset() +
+                               EhFrame::getDataStartOffset<32>();
       break;
     case DW_EH_PE_datarel:
       // TODO
diff --git a/lib/LD/EhFrameReader.cpp b/lib/LD/EhFrameReader.cpp
index 69a7a05..49950a0 100644
--- a/lib/LD/EhFrameReader.cpp
+++ b/lib/LD/EhFrameReader.cpp
@@ -8,14 +8,15 @@
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/EhFrameReader.h>
 
+#include <mcld/Fragment/NullFragment.h>
+#include <mcld/MC/Input.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/Support/MsgHandling.h>
+#include <mcld/Support/MemoryArea.h>
+
 #include <llvm/ADT/StringRef.h>
 #include <llvm/Support/Dwarf.h>
-
-#include <mcld/MC/MCLDInput.h>
-#include <mcld/LD/EhFrame.h>
-#include <mcld/LD/LDSection.h>
-#include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/MsgHandling.h>
+#include <llvm/Support/LEB128.h>
 
 using namespace mcld;
 using namespace llvm::dwarf;
@@ -45,7 +46,7 @@
 template<> EhFrameReader::Token
 EhFrameReader::scan<true>(ConstAddress pHandler,
                           uint64_t pOffset,
-                          const MemoryRegion& pData) const
+                          llvm::StringRef pData) const
 {
   Token result;
   result.file_off = pOffset;
@@ -71,6 +72,8 @@
     extended |= data[cur_idx++];
     result.size = extended + 12;
     result.data_off = 16;
+    // 64-bit obj file still uses 32-bit eh_frame.
+    assert (false && "We don't support 64-bit eh_frame.");
   }
   else {
     result.size = length + 4;
@@ -129,17 +132,17 @@
 
   // get file offset and address
   uint64_t file_off = pInput.fileOffset() + section.offset();
-  MemoryRegion* sect_reg =
-                       pInput.memArea()->request(file_off, section.size());
-  ConstAddress handler = (ConstAddress)sect_reg->start();
+  llvm::StringRef sect_reg =
+      pInput.memArea()->request(file_off, section.size());
+  ConstAddress handler = (ConstAddress)sect_reg.begin();
 
   State cur_state = Q0;
   while (Reject != cur_state && Accept != cur_state) {
 
-    Token token = scan<true>(handler, file_off, *sect_reg);
-    MemoryRegion* entry = pInput.memArea()->request(token.file_off, token.size);
+    Token token = scan<true>(handler, file_off, sect_reg);
+    llvm::StringRef entry = pInput.memArea()->request(token.file_off, token.size);
 
-    if (!transition[cur_state][token.kind](pEhFrame, *entry, token)) {
+    if (!transition[cur_state][token.kind](pEhFrame, entry, token)) {
       // fail to scan
       debug(diag::debug_cannot_scan_eh) << pInput.name();
       return false;
@@ -148,9 +151,9 @@
     file_off += token.size;
     handler += token.size;
 
-    if (handler == sect_reg->end())
+    if (handler == sect_reg.end())
       cur_state = Accept;
-    else if (handler > sect_reg->end()) {
+    else if (handler > sect_reg.end()) {
       cur_state = Reject;
     }
     else
@@ -166,12 +169,14 @@
 }
 
 bool EhFrameReader::addCIE(EhFrame& pEhFrame,
-                           MemoryRegion& pRegion,
+                           llvm::StringRef pRegion,
                            const EhFrameReader::Token& pToken)
 {
   // skip Length, Extended Length and CIE ID.
-  ConstAddress handler = pRegion.start() + pToken.data_off;
+  ConstAddress handler = pRegion.begin() + pToken.data_off;
   ConstAddress cie_end = pRegion.end();
+  ConstAddress handler_start = handler;
+  uint64_t pr_ptr_data_offset = pToken.data_off;
 
   // the version should be 1 or 3
   uint8_t version = *handler++;
@@ -211,6 +216,7 @@
     EhFrame::CIE* cie = new EhFrame::CIE(pRegion);
     cie->setFDEEncode(llvm::dwarf::DW_EH_PE_absptr);
     pEhFrame.addCIE(*cie);
+    pEhFrame.getCIEMap().insert(std::make_pair(pToken.file_off, cie));
     return true;
   }
 
@@ -222,12 +228,13 @@
 
   // parse the Augmentation String to get the FDE encodeing if 'z' existed
   uint8_t fde_encoding = llvm::dwarf::DW_EH_PE_absptr;
+  std::string augdata;
+  std::string pr_ptr_data;
   if ('z' == augment[0]) {
-
-    // skip the Augumentation Data Length
-    if (!skip_LEB128(&handler, cie_end)) {
-      return false;
-    }
+    unsigned offset;
+    size_t augdata_size = llvm::decodeULEB128((const uint8_t*)handler, &offset);
+    handler += offset;
+    augdata = std::string((const char*)handler, augdata_size);
 
     // parse the Augmentation String
     for (size_t i = 1; i < augment.size(); ++i) {
@@ -285,6 +292,8 @@
           if (static_cast<uint32_t>(cie_end - handler) < per_length) {
             return false;
           }
+          pr_ptr_data_offset += handler - handler_start;
+          pr_ptr_data = std::string((const char*)handler, per_length);
           handler += per_length;
           break;
         } // end of case 'P'
@@ -316,38 +325,46 @@
   // create and push back the CIE entry
   EhFrame::CIE* cie = new EhFrame::CIE(pRegion);
   cie->setFDEEncode(fde_encoding);
+  cie->setPersonalityOffset(pr_ptr_data_offset);
+  cie->setPersonalityName(pr_ptr_data);
+  cie->setAugmentationData(augdata);
   pEhFrame.addCIE(*cie);
+  pEhFrame.getCIEMap().insert(std::make_pair(pToken.file_off, cie));
   return true;
 }
 
 bool EhFrameReader::addFDE(EhFrame& pEhFrame,
-                           MemoryRegion& pRegion,
+                           llvm::StringRef pRegion,
                            const EhFrameReader::Token& pToken)
 {
   if (pToken.data_off == pRegion.size())
     return false;
 
+  const int32_t offset = *(const int32_t*) (pRegion.begin() + pToken.data_off
+                                            - 4);
+  size_t cie_offset = (size_t) ((int64_t) (pToken.file_off + 4) -
+                                (int32_t) offset);
+
+  EhFrame::CIEMap::iterator iter = pEhFrame.getCIEMap().find(cie_offset);
+  if (iter == pEhFrame.getCIEMap().end())
+    return false;
+
   // create and push back the FDE entry
-  EhFrame::FDE* fde = new EhFrame::FDE(pRegion,
-                                       pEhFrame.cie_back(),
-                                       pToken.data_off);
+  EhFrame::FDE* fde = new EhFrame::FDE(pRegion, *iter->second);
   pEhFrame.addFDE(*fde);
   return true;
 }
 
 bool EhFrameReader::addTerm(EhFrame& pEhFrame,
-                            MemoryRegion& pRegion,
+                            llvm::StringRef pRegion,
                             const EhFrameReader::Token& pToken)
 {
-  RegionFragment* frag = new RegionFragment(pRegion);
-  pEhFrame.addFragment(*frag);
   return true;
 }
 
 bool EhFrameReader::reject(EhFrame& pEhFrame,
-                           MemoryRegion& pRegion,
+                           llvm::StringRef pRegion,
                            const EhFrameReader::Token& pToken)
 {
   return true;
 }
-
diff --git a/lib/LD/GNUArchiveReader.cpp b/lib/LD/GNUArchiveReader.cpp
index e391b20..3dc95a5 100644
--- a/lib/LD/GNUArchiveReader.cpp
+++ b/lib/LD/GNUArchiveReader.cpp
@@ -10,14 +10,14 @@
 
 #include <mcld/Module.h>
 #include <mcld/InputTree.h>
+#include <mcld/LinkerConfig.h>
 #include <mcld/MC/Attribute.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/LD/ResolveInfo.h>
 #include <mcld/LD/ELFObjectReader.h>
 #include <mcld/Support/FileSystem.h>
 #include <mcld/Support/FileHandle.h>
 #include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Support/Path.h>
 #include <mcld/ADT/SizeTraits.h>
@@ -42,19 +42,22 @@
 }
 
 /// isMyFormat
-bool GNUArchiveReader::isMyFormat(Input& pInput) const
+bool GNUArchiveReader::isMyFormat(Input& pInput, bool &pContinue) const
 {
   assert(pInput.hasMemArea());
-  MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(),
-                                                   Archive::MAGIC_LEN);
-  const char* str = reinterpret_cast<const char*>(region->getBuffer());
+  if (pInput.memArea()->size() < Archive::MAGIC_LEN)
+    return false;
+
+  llvm::StringRef region =
+      pInput.memArea()->request(pInput.fileOffset(), Archive::MAGIC_LEN);
+  const char* str = region.begin();
 
   bool result = false;
   assert(NULL != str);
+  pContinue = true;
   if (isArchive(str) || isThinArchive(str))
     result = true;
 
-  pInput.memArea()->release(region);
   return result;
 }
 
@@ -74,27 +77,27 @@
 bool GNUArchiveReader::isThinArchive(Input& pInput) const
 {
   assert(pInput.hasMemArea());
-  MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(),
-                                                   Archive::MAGIC_LEN);
-  const char* str = reinterpret_cast<const char*>(region->getBuffer());
+  llvm::StringRef region =
+      pInput.memArea()->request(pInput.fileOffset(), Archive::MAGIC_LEN);
+  const char* str = region.begin();
 
   bool result = false;
   assert(NULL != str);
   if (isThinArchive(str))
     result = true;
 
-  pInput.memArea()->release(region);
   return result;
 }
 
-bool GNUArchiveReader::readArchive(Archive& pArchive)
+bool GNUArchiveReader::readArchive(const LinkerConfig& pConfig,
+                                   Archive& pArchive)
 {
   // bypass the empty archive
-  if (Archive::MAGIC_LEN == pArchive.getARFile().memArea()->handler()->size())
+  if (Archive::MAGIC_LEN == pArchive.getARFile().memArea()->size())
     return true;
 
   if (pArchive.getARFile().attribute()->isWholeArchive())
-    return includeAllMembers(pArchive);
+    return includeAllMembers(pConfig, pArchive);
 
   // if this is the first time read this archive, setup symtab and strtab
   if (pArchive.getSymbolTable().empty()) {
@@ -133,7 +136,7 @@
 
       if (Archive::Symbol::Include == status) {
         // include the object member from the given offset
-        includeMember(pArchive, pArchive.getObjFileOffset(idx));
+        includeMember(pConfig, pArchive, pArchive.getObjFileOffset(idx));
         willSymResolved = true;
       } // end of if
     } // end of for
@@ -159,11 +162,11 @@
 {
   assert(pArchiveFile.hasMemArea());
 
-  MemoryRegion* header_region =
+  llvm::StringRef header_region =
     pArchiveFile.memArea()->request((pArchiveFile.fileOffset() + pFileOffset),
                                     sizeof(Archive::MemberHeader));
   const Archive::MemberHeader* header =
-    reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer());
+    reinterpret_cast<const Archive::MemberHeader*>(header_region.begin());
 
   assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, sizeof(header->fmag)));
 
@@ -233,59 +236,71 @@
                                         input_path);
   }
 
-  pArchiveFile.memArea()->release(header_region);
   return member;
 }
 
+template <size_t SIZE>
+static void readSymbolTableEntries(Archive& pArchive, llvm::StringRef pMemRegion)
+{
+  typedef typename SizeTraits<SIZE>::Offset Offset;
+
+  const Offset* data = reinterpret_cast<const Offset*>(pMemRegion.begin());
+
+  // read the number of symbols
+  Offset number = 0;
+  if (llvm::sys::IsLittleEndianHost)
+    number = mcld::bswap<SIZE>(*data);
+  else
+    number = *data;
+
+  // set up the pointers for file offset and name offset
+  ++data;
+  const char* name = reinterpret_cast<const char*>(data + number);
+
+  // add the archive symbols
+  for (Offset i = 0; i < number; ++i) {
+    if (llvm::sys::IsLittleEndianHost)
+      pArchive.addSymbol(name, mcld::bswap<SIZE>(*data));
+    else
+      pArchive.addSymbol(name, *data);
+    name += strlen(name) + 1;
+    ++data;
+  }
+}
+
 /// readSymbolTable - read the archive symbol map (armap)
 bool GNUArchiveReader::readSymbolTable(Archive& pArchive)
 {
   assert(pArchive.getARFile().hasMemArea());
 
-  MemoryRegion* header_region =
+  llvm::StringRef header_region =
     pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() +
                                              Archive::MAGIC_LEN),
                                             sizeof(Archive::MemberHeader));
   const Archive::MemberHeader* header =
-    reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer());
+    reinterpret_cast<const Archive::MemberHeader*>(header_region.begin());
   assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, sizeof(header->fmag)));
 
   int symtab_size = atoi(header->size);
   pArchive.setSymTabSize(symtab_size);
 
   if (!pArchive.getARFile().attribute()->isWholeArchive()) {
-    MemoryRegion* symtab_region =
-      pArchive.getARFile().memArea()->request(
-                                            (pArchive.getARFile().fileOffset() +
-                                             Archive::MAGIC_LEN +
-                                             sizeof(Archive::MemberHeader)),
-                                            symtab_size);
-    const uint32_t* data =
-      reinterpret_cast<const uint32_t*>(symtab_region->getBuffer());
+    llvm::StringRef symtab_region = pArchive.getARFile().memArea()->request(
+        (pArchive.getARFile().fileOffset() +
+         Archive::MAGIC_LEN +
+         sizeof(Archive::MemberHeader)),
+        symtab_size);
 
-    // read the number of symbols
-    uint32_t number = 0;
-    if (llvm::sys::IsLittleEndianHost)
-      number = mcld::bswap32(*data);
+    if (0 == strncmp(header->name, Archive::SVR4_SYMTAB_NAME,
+                                   strlen(Archive::SVR4_SYMTAB_NAME)))
+      readSymbolTableEntries<32>(pArchive, symtab_region);
+    else if (0 == strncmp(header->name, Archive::IRIX6_SYMTAB_NAME,
+                                        strlen(Archive::IRIX6_SYMTAB_NAME)))
+      readSymbolTableEntries<64>(pArchive, symtab_region);
     else
-      number = *data;
+      unreachable(diag::err_unsupported_archive);
 
-    // set up the pointers for file offset and name offset
-    ++data;
-    const char* name = reinterpret_cast<const char*>(data + number);
-
-    // add the archive symbols
-    for (uint32_t i = 0; i < number; ++i) {
-      if (llvm::sys::IsLittleEndianHost)
-        pArchive.addSymbol(name, mcld::bswap32(*data));
-      else
-        pArchive.addSymbol(name, *data);
-      name += strlen(name) + 1;
-      ++data;
-    }
-    pArchive.getARFile().memArea()->release(symtab_region);
   }
-  pArchive.getARFile().memArea()->release(header_region);
   return true;
 }
 
@@ -301,29 +316,26 @@
 
   assert(pArchive.getARFile().hasMemArea());
 
-  MemoryRegion* header_region =
+  llvm::StringRef header_region =
     pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() +
                                              offset),
                                             sizeof(Archive::MemberHeader));
   const Archive::MemberHeader* header =
-    reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer());
+    reinterpret_cast<const Archive::MemberHeader*>(header_region.begin());
 
   assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, sizeof(header->fmag)));
 
   if (0 == memcmp(header->name, Archive::STRTAB_NAME, sizeof(header->name))) {
     // read the extended name table
     int strtab_size = atoi(header->size);
-    MemoryRegion* strtab_region =
+    llvm::StringRef strtab_region =
       pArchive.getARFile().memArea()->request(
                                    (pArchive.getARFile().fileOffset() +
                                     offset + sizeof(Archive::MemberHeader)),
                                    strtab_size);
-    const char* strtab =
-      reinterpret_cast<const char*>(strtab_region->getBuffer());
+    const char* strtab = strtab_region.begin();
     pArchive.getStrTable().assign(strtab, strtab_size);
-    pArchive.getARFile().memArea()->release(strtab_region);
   }
-  pArchive.getARFile().memArea()->release(header_region);
   return true;
 }
 
@@ -346,9 +358,12 @@
 
 /// includeMember - include the object member in the given file offset, and
 /// return the size of the object
+/// @param pConfig - LinkerConfig
 /// @param pArchiveRoot - the archive root
 /// @param pFileOffset  - file offset of the member header in the archive
-size_t GNUArchiveReader::includeMember(Archive& pArchive, uint32_t pFileOffset)
+size_t GNUArchiveReader::includeMember(const LinkerConfig& pConfig,
+                                       Archive& pArchive,
+                                       uint32_t pFileOffset)
 {
   Input* cur_archive = &(pArchive.getARFile());
   Input* member = NULL;
@@ -382,8 +397,9 @@
     // direction to Afterward for next insertion in this subtree
     parent->move->move(parent->lastPos);
     parent->move = &InputTree::Afterward;
+    bool doContinue = false;
 
-    if (m_ELFObjectReader.isMyFormat(*member)) {
+    if (m_ELFObjectReader.isMyFormat(*member, doContinue)) {
       member->setType(Input::Object);
       pArchive.addObjectMember(pFileOffset, parent->lastPos);
       m_ELFObjectReader.readHeader(*member);
@@ -391,7 +407,7 @@
       m_ELFObjectReader.readSymbols(*member);
       m_Module.getObjectList().push_back(member);
     }
-    else if (isMyFormat(*member)) {
+    else if (doContinue && isMyFormat(*member, doContinue)) {
       member->setType(Input::Archive);
       // when adding a new archive node, set the iterator to archive
       // itself, and set the direction to Downward
@@ -401,13 +417,18 @@
       cur_archive = member;
       file_offset = nested_offset;
     }
+    else {
+      warning(diag::warn_unrecognized_input_file) << member->path()
+        << pConfig.targets().triple().str();
+    }
   } while (Input::Object != member->type());
   return size;
 }
 
 /// includeAllMembers - include all object members. This is called if
 /// --whole-archive is the attribute for this archive file.
-bool GNUArchiveReader::includeAllMembers(Archive& pArchive)
+bool GNUArchiveReader::includeAllMembers(const LinkerConfig& pConfig,
+                                         Archive& pArchive)
 {
   // read the symtab of the archive
   readSymbolTable(pArchive);
@@ -431,12 +452,12 @@
     begin_offset += sizeof(Archive::MemberHeader) +
                     pArchive.getStrTable().size();
   }
-  uint32_t end_offset = pArchive.getARFile().memArea()->handler()->size();
+  uint32_t end_offset = pArchive.getARFile().memArea()->size();
   for (uint32_t offset = begin_offset;
        offset < end_offset;
        offset += sizeof(Archive::MemberHeader)) {
 
-    size_t size = includeMember(pArchive, offset);
+    size_t size = includeMember(pConfig, pArchive, offset);
 
     if (!isThinAR) {
       offset += size;
diff --git a/lib/LD/GarbageCollection.cpp b/lib/LD/GarbageCollection.cpp
new file mode 100644
index 0000000..4ea40ac
--- /dev/null
+++ b/lib/LD/GarbageCollection.cpp
@@ -0,0 +1,343 @@
+//===- GarbageCollection.cpp ----------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Fragment/Fragment.h>
+#include <mcld/Fragment/Relocation.h>
+#include <mcld/LD/GarbageCollection.h>
+#include <mcld/LD/LDContext.h>
+#include <mcld/LD/LDFileFormat.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/LD/LDSymbol.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/LD/RelocData.h>
+#include <mcld/LinkerConfig.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/Module.h>
+#include <mcld/Target/TargetLDBackend.h>
+
+#include <llvm/Support/Casting.h>
+
+#include <queue>
+#if !defined(MCLD_ON_WIN32)
+#include <fnmatch.h>
+#define fnmatch0(pattern,string) (fnmatch(pattern,string,0) == 0)
+#else
+#include <windows.h>
+#include <shlwapi.h>
+#define fnmatch0(pattern,string) (PathMatchSpec(string, pattern) == true)
+#endif
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// Non-member functions
+//===----------------------------------------------------------------------===//
+// FIXME: these rules should be added into SectionMap, while currently adding to
+// SectionMap will cause the output order change in .text section and leads to
+// the .ARM.exidx order incorrect. We should sort the .ARM.exidx.
+static const char* pattern_to_keep[] =
+{
+  ".text*personality*",
+  ".data*personality*",
+  ".gnu.linkonce.d*personality*",
+  ".sdata*personality*"
+};
+
+/// shouldKeep - check the section name for the keep sections
+static bool shouldKeep(const std::string& pName)
+{
+  static const unsigned int pattern_size =
+                           sizeof(pattern_to_keep) / sizeof(pattern_to_keep[0]);
+  for (unsigned int i=0; i < pattern_size; ++i) {
+    if (fnmatch0(pattern_to_keep[i], pName.c_str()))
+      return true;
+  }
+  return false;
+}
+
+/// shouldProcessGC - check if the section kind is handled in GC
+static bool mayProcessGC(const LDSection& pSection)
+{
+  if (pSection.kind() == LDFileFormat::Regular ||
+      pSection.kind() == LDFileFormat::BSS ||
+      pSection.kind() == LDFileFormat::GCCExceptTable)
+    return true;
+  return false;
+}
+
+//===----------------------------------------------------------------------===//
+// GarbageCollection::SectionReachedListMap
+//===----------------------------------------------------------------------===//
+void
+GarbageCollection::SectionReachedListMap::addReference(const LDSection& pFrom,
+                                                       const LDSection& pTo)
+{
+  m_ReachedSections[&pFrom].insert(&pTo);
+}
+
+GarbageCollection::SectionListTy&
+GarbageCollection::SectionReachedListMap::getReachedList(
+                                                      const LDSection& pSection)
+{
+  return m_ReachedSections[&pSection];
+}
+
+GarbageCollection::SectionListTy*
+GarbageCollection::SectionReachedListMap::findReachedList(
+                                                      const LDSection& pSection)
+{
+  ReachedSectionsTy::iterator it = m_ReachedSections.find(&pSection);
+  if (it == m_ReachedSections.end())
+    return NULL;
+  return &it->second;
+}
+
+//===----------------------------------------------------------------------===//
+// GarbageCollection
+//===----------------------------------------------------------------------===//
+GarbageCollection::GarbageCollection(const LinkerConfig& pConfig,
+                                     const TargetLDBackend& pBackend,
+                                     Module& pModule)
+  : m_Config(pConfig), m_Backend(pBackend), m_Module(pModule)
+{
+}
+
+GarbageCollection::~GarbageCollection()
+{
+}
+
+bool GarbageCollection::run()
+{
+  // 1. traverse all the relocations to set up the reached sections of each
+  // section
+  setUpReachedSections();
+  m_Backend.setUpReachedSectionsForGC(m_Module, m_SectionReachedListMap);
+
+  // 2. get all sections defined the entry point
+  SectionVecTy entry;
+  getEntrySections(entry);
+
+  // 3. find all the referenced sections those can be reached by entry
+  findReferencedSections(entry);
+
+  // 4. stripSections - set the unreached sections to Ignore
+  stripSections();
+  return true;
+}
+
+void GarbageCollection::setUpReachedSections()
+{
+  // traverse all the input relocations to setup the reached sections
+  Module::obj_iterator input, inEnd = m_Module.obj_end();
+  for (input = m_Module.obj_begin(); input != inEnd; ++input) {
+    LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
+    for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
+      // bypass the discarded relocation section
+      // 1. its section kind is changed to Ignore. (The target section is a
+      // discarded group section.)
+      // 2. it has no reloc data. (All symbols in the input relocs are in the
+      // discarded group sections)
+      LDSection* reloc_sect = *rs;
+      LDSection* apply_sect = reloc_sect->getLink();
+      if ((LDFileFormat::Ignore == reloc_sect->kind()) ||
+          (!reloc_sect->hasRelocData()))
+        continue;
+
+      // bypass the apply target sections which are not handled by gc
+      if (!mayProcessGC(*apply_sect))
+        continue;
+
+      bool add_first = false;
+      SectionListTy* reached_sects = NULL;
+      RelocData::iterator reloc_it, rEnd = reloc_sect->getRelocData()->end();
+      for (reloc_it = reloc_sect->getRelocData()->begin(); reloc_it != rEnd;
+                                                                   ++reloc_it) {
+        Relocation* reloc = llvm::cast<Relocation>(reloc_it);
+        ResolveInfo* sym = reloc->symInfo();
+        // only the target symbols defined in the input fragments can make the
+        // reference
+        if (NULL == sym)
+          continue;
+        if (!sym->isDefine() || !sym->outSymbol()->hasFragRef())
+          continue;
+
+        // only the target symbols defined in the concerned sections can make
+        // the reference
+        const LDSection* target_sect =
+                &sym->outSymbol()->fragRef()->frag()->getParent()->getSection();
+        if (!mayProcessGC(*target_sect))
+          continue;
+
+        // setup the reached list, if we first add the element to reached list
+        // of this section, create an entry in ReachedSections map
+        if (!add_first) {
+          reached_sects = &m_SectionReachedListMap.getReachedList(*apply_sect);
+          add_first = true;
+        }
+        reached_sects->insert(target_sect);
+      }
+      reached_sects = NULL;
+      add_first = false;
+    }
+  }
+}
+
+void GarbageCollection::getEntrySections(SectionVecTy& pEntry)
+{
+  // all the KEEP sections defined in ldscript are entries, traverse all the
+  // input sections and check the SectionMap to find the KEEP sections
+  Module::obj_iterator obj, objEnd = m_Module.obj_end();
+  SectionMap& sect_map = m_Module.getScript().sectionMap();
+  for (obj = m_Module.obj_begin(); obj != objEnd; ++obj) {
+    const std::string input_name = (*obj)->name();
+    LDContext::sect_iterator sect, sectEnd = (*obj)->context()->sectEnd();
+    for (sect = (*obj)->context()->sectBegin(); sect != sectEnd; ++sect) {
+      LDSection* section = *sect;
+      if (!mayProcessGC(*section))
+        continue;
+
+      SectionMap::Input* sm_input =
+                              sect_map.find(input_name, section->name()).second;
+      if (((sm_input != NULL) && (InputSectDesc::Keep == sm_input->policy())) ||
+          shouldKeep(section->name()))
+        pEntry.push_back(section);
+    }
+  }
+
+  // get the sections those the entry symbols defined in
+  if (LinkerConfig::Exec == m_Config.codeGenType() ||
+                                                   m_Config.options().isPIE()) {
+    // when building executable
+    // 1. the entry symbol is the entry
+    LDSymbol* entry_sym =
+                m_Module.getNamePool().findSymbol(m_Backend.getEntry(m_Module));
+    assert(NULL != entry_sym);
+    pEntry.push_back(&entry_sym->fragRef()->frag()->getParent()->getSection());
+
+    // 2. the symbols have been seen in dynamice objects are entries
+    NamePool::syminfo_iterator info_it,
+                                info_end = m_Module.getNamePool().syminfo_end();
+    for (info_it = m_Module.getNamePool().syminfo_begin(); info_it != info_end;
+                                                                    ++info_it) {
+      ResolveInfo* info = info_it.getEntry();
+      if (!info->isDefine() || info->isLocal())
+        continue;
+
+      if (!info->isInDyn())
+        continue;
+
+      LDSymbol* sym = info->outSymbol();
+      if (NULL == sym || !sym->hasFragRef())
+        continue;
+
+      // only the target symbols defined in the concerned sections can be
+      // entries
+      const LDSection* sect =
+                             &sym->fragRef()->frag()->getParent()->getSection();
+      if (!mayProcessGC(*sect))
+        continue;
+
+      pEntry.push_back(sect);
+    }
+  }
+
+  else {
+    // when building shared objects, the global define symbols are entries
+    NamePool::syminfo_iterator info_it,
+                                info_end = m_Module.getNamePool().syminfo_end();
+    for (info_it = m_Module.getNamePool().syminfo_begin(); info_it != info_end;
+                                                                    ++info_it) {
+      ResolveInfo* info = info_it.getEntry();
+      if (!info->isDefine() ||
+          info->isLocal()   ||
+          info->shouldForceLocal(m_Config))
+        continue;
+      LDSymbol* sym = info->outSymbol();
+      if (NULL == sym || !sym->hasFragRef())
+        continue;
+
+      // only the target symbols defined in the concerned sections can be
+      // entries
+      const LDSection* sect =
+                             &sym->fragRef()->frag()->getParent()->getSection();
+      if (!mayProcessGC(*sect))
+        continue;
+      pEntry.push_back(sect);
+    }
+  }
+}
+
+void GarbageCollection::findReferencedSections(SectionVecTy& pEntry)
+{
+  // list of sections waiting to be processed
+  typedef std::queue<const LDSection*> WorkListTy;
+  WorkListTy work_list;
+  // start from each entry, resolve the transitive closure
+  SectionVecTy::iterator entry_it, entry_end = pEntry.end();
+  for (entry_it = pEntry.begin(); entry_it != entry_end; ++entry_it) {
+    // add entry point to work list
+    work_list.push(*entry_it);
+
+    // add section from the work_list to the referencedSections until every
+    // reached sections are added
+    while (!work_list.empty()) {
+      const LDSection* sect = work_list.front();
+      work_list.pop();
+      // add section to the ReferencedSections, if the section has been put into
+      // referencedSections, skip this section
+      if (!m_ReferencedSections.insert(sect).second)
+        continue;
+
+      // get the section reached list, if the section do not has one, which
+      // means no referenced between it and other sections, then skip it
+      SectionListTy* reach_list =
+                                 m_SectionReachedListMap.findReachedList(*sect);
+      if (NULL == reach_list)
+        continue;
+
+      // put the reached sections to work list, skip the one already be in
+      // referencedSections
+      SectionListTy::iterator it, end = reach_list->end();
+      for (it = reach_list->begin(); it != end; ++it) {
+        if (m_ReferencedSections.find(*it) == m_ReferencedSections.end())
+          work_list.push(*it);
+      }
+    }
+  }
+}
+
+void GarbageCollection::stripSections()
+{
+  // Traverse all the input Regular and BSS sections, if a section is not found
+  // in the ReferencedSections, then it should be garbage collected
+  Module::obj_iterator obj, objEnd = m_Module.obj_end();
+  for (obj = m_Module.obj_begin(); obj != objEnd; ++obj) {
+    LDContext::sect_iterator sect, sectEnd = (*obj)->context()->sectEnd();
+    for (sect = (*obj)->context()->sectBegin(); sect != sectEnd; ++sect) {
+      LDSection* section = *sect;
+      if (!mayProcessGC(*section))
+        continue;
+
+      if (m_ReferencedSections.find(section) == m_ReferencedSections.end())
+        section->setKind(LDFileFormat::Ignore);
+    }
+  }
+
+  // Traverse all the relocation sections, if its target section is set to
+  // Ignore, then set the relocation section to Ignore as well
+  Module::obj_iterator input, inEnd = m_Module.obj_end();
+  for (input = m_Module.obj_begin(); input != inEnd; ++input) {
+    LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
+    for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
+      LDSection* reloc_sect = *rs;
+      if (LDFileFormat::Ignore == reloc_sect->getLink()->kind())
+        reloc_sect->setKind(LDFileFormat::Ignore);
+    }
+  }
+}
+
diff --git a/lib/LD/GroupReader.cpp b/lib/LD/GroupReader.cpp
index a5b612b..b3e6f9e 100644
--- a/lib/LD/GroupReader.cpp
+++ b/lib/LD/GroupReader.cpp
@@ -36,6 +36,7 @@
 }
 
 bool GroupReader::readGroup(Module::input_iterator pRoot,
+                            Module::input_iterator pEnd,
                             InputBuilder& pBuilder,
                             const LinkerConfig& pConfig)
 {
@@ -50,12 +51,8 @@
 
   Module::input_iterator input = --pRoot;
 
-  // Since the end of a sub-tree is the same node to the end of whole tree, we
-  // take the end of the whole input tree for conventience.
-  Module::input_iterator input_end = m_Module.input_end();
-
   // first time read the sub-tree
-  while (input != input_end) {
+  while (input != pEnd) {
     // already got type - for example, bitcode or external OIR (object
     // intermediate representation)
     if ((*input)->type() == Input::Script ||
@@ -75,25 +72,26 @@
       continue;
     }
 
+    bool doContinue = false;
     // is an archive
-    if (m_ArchiveReader.isMyFormat(**input)) {
+    if (m_ArchiveReader.isMyFormat(**input, doContinue)) {
       (*input)->setType(Input::Archive);
       // record the Archive used by each archive node
       Archive* ar = new Archive(**input, pBuilder);
       ArchiveListEntry* entry = new ArchiveListEntry(*ar, input);
       ar_list.push_back(entry);
       // read archive
-      m_ArchiveReader.readArchive(*ar);
+      m_ArchiveReader.readArchive(pConfig, *ar);
       cur_obj_cnt += ar->numOfObjectMember();
     }
     // read input as a binary file
-    else if (pConfig.options().isBinaryInput()) {
+    else if (doContinue && m_BinaryReader.isMyFormat(**input, doContinue)) {
       (*input)->setType(Input::Object);
       m_BinaryReader.readBinary(**input);
       m_Module.getObjectList().push_back(*input);
     }
     // is a relocatable object file
-    else if (m_ObjectReader.isMyFormat(**input)) {
+    else if (doContinue && m_ObjectReader.isMyFormat(**input, doContinue)) {
       (*input)->setType(Input::Object);
       m_ObjectReader.readHeader(**input);
       m_ObjectReader.readSections(**input);
@@ -103,15 +101,15 @@
       ++non_ar_obj_cnt;
     }
     // is a shared object file
-    else if (m_DynObjReader.isMyFormat(**input)) {
+    else if (doContinue && m_DynObjReader.isMyFormat(**input, doContinue)) {
       (*input)->setType(Input::DynObj);
       m_DynObjReader.readHeader(**input);
       m_DynObjReader.readSymbols(**input);
       m_Module.getLibraryList().push_back(*input);
     }
     else {
-      fatal(diag::err_unrecognized_input_file) << (*input)->path()
-                                               << pConfig.targets().triple().str();
+      warning(diag::warn_unrecognized_input_file) << (*input)->path()
+        << pConfig.targets().triple().str();
     }
     ++input;
   }
@@ -128,7 +126,7 @@
       // if --whole-archive is given to this archive, no need to read it again
       if ( ar.getARFile().attribute()->isWholeArchive())
         continue;
-      m_ArchiveReader.readArchive(ar);
+      m_ArchiveReader.readArchive(pConfig, ar);
       cur_obj_cnt += ar.numOfObjectMember();
     }
   }
diff --git a/lib/LD/LDFileFormat.cpp b/lib/LD/LDFileFormat.cpp
index bb878b8..d1f0b80 100644
--- a/lib/LD/LDFileFormat.cpp
+++ b/lib/LD/LDFileFormat.cpp
@@ -7,7 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/LDFileFormat.h>
-#include <mcld/Fragment/FragmentLinker.h>
 
 using namespace mcld;
 
diff --git a/lib/LD/NamePool.cpp b/lib/LD/NamePool.cpp
index 7fb8688..151b1dd 100644
--- a/lib/LD/NamePool.cpp
+++ b/lib/LD/NamePool.cpp
@@ -59,6 +59,7 @@
                               ResolveInfo::Desc pDesc,
                               ResolveInfo::Binding pBinding,
                               ResolveInfo::SizeType pSize,
+                              LDSymbol::ValueType pValue,
                               ResolveInfo::Visibility pVisibility,
                               ResolveInfo* pOldInfo,
                               Resolver::Result& pResult)
@@ -102,7 +103,7 @@
   // symbol resolution
   bool override = false;
   unsigned int action = Resolver::LastAction;
-  if (m_pResolver->resolve(*old_symbol, *new_symbol, override)) {
+  if (m_pResolver->resolve(*old_symbol, *new_symbol, override, pValue)) {
     pResult.info      = old_symbol;
     pResult.existent  = true;
     pResult.overriden = override;
diff --git a/lib/LD/RelocData.cpp b/lib/LD/RelocData.cpp
index 1c9411d..8379872 100644
--- a/lib/LD/RelocData.cpp
+++ b/lib/LD/RelocData.cpp
@@ -53,3 +53,9 @@
   return *this;
 }
 
+Relocation& RelocData::remove(Relocation& pRelocation)
+{
+  iterator iter(pRelocation);
+  Relocation* rel = m_Relocations.remove(iter);
+  return *rel;
+}
diff --git a/lib/LD/Relocator.cpp b/lib/LD/Relocator.cpp
index 767588a..dc9445b 100644
--- a/lib/LD/Relocator.cpp
+++ b/lib/LD/Relocator.cpp
@@ -6,16 +6,48 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include <mcld/Config/Config.h>
 #include <mcld/Fragment/Fragment.h>
+#include <mcld/LD/LDContext.h>
+#include <mcld/LD/LDSection.h>
 #include <mcld/LD/LDSymbol.h>
 #include <mcld/LD/Relocator.h>
 #include <mcld/LD/ResolveInfo.h>
 #include <mcld/LD/SectionData.h>
+#include <mcld/Support/MsgHandling.h>
 #include <mcld/Module.h>
+#if HAVE_CXXABI_H
+#include <cxxabi.h>
+#endif
+#include <sstream>
 
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
+// Helper functions
+//===----------------------------------------------------------------------===//
+std::string demangleSymbol(const std::string& mangled_name) {
+#if HAVE_CXXABI_H
+  // __cxa_demangle needs manually handle the memory release, so we wrap
+  // it into this helper function.
+  size_t output_leng;
+  int status;
+  char* buffer = abi::__cxa_demangle(mangled_name.c_str(), /*buffer=*/0,
+                                     &output_leng, &status);
+  if (status != 0) { // Failed
+    return mangled_name;
+  }
+  std::string demangled_name(buffer);
+  free(buffer);
+
+  return demangled_name;
+#else
+  return mangled_name;
+#endif
+}
+
+
+//===----------------------------------------------------------------------===//
 // Relocator
 //===----------------------------------------------------------------------===//
 Relocator::~Relocator()
@@ -46,3 +78,52 @@
   }
 }
 
+void Relocator::issueUndefRef(Relocation& pReloc,
+                              LDSection& pSection,
+                              Input& pInput)
+{
+  FragmentRef::Offset undef_sym_pos = pReloc.targetRef().offset();
+  std::string sect_name(pSection.name());
+  sect_name = sect_name.substr(sect_name.find('.', /*pos=*/1));  // Drop .rel(a) prefix
+
+  std::string reloc_sym(pReloc.symInfo()->name());
+  if (reloc_sym.substr(0, 2) == "_Z")
+    reloc_sym = demangleSymbol(reloc_sym);
+
+  std::stringstream ss;
+  ss << "0x" << std::hex << undef_sym_pos;
+  std::string undef_sym_pos_hex(ss.str());
+
+  if (sect_name.substr(0, 5) != ".text") {
+    // Function name is only valid for text section
+    fatal(diag::undefined_reference) << reloc_sym
+                                     << pInput.path()
+                                     << sect_name
+                                     << undef_sym_pos_hex;
+    return;
+  }
+
+  std::string caller_file_name;
+  std::string caller_func_name;
+  for (LDContext::sym_iterator i = pInput.context()->symTabBegin(),
+       e = pInput.context()->symTabEnd(); i != e; ++i) {
+    LDSymbol& sym = **i;
+    if (sym.resolveInfo()->type() == ResolveInfo::File)
+      caller_file_name = sym.resolveInfo()->name();
+
+    if (sym.resolveInfo()->type() == ResolveInfo::Function &&
+        sym.value() <= undef_sym_pos &&
+        sym.value() + sym.size() > undef_sym_pos) {
+      caller_func_name = sym.name();
+      break;
+    }
+  }
+
+  if (caller_func_name.substr(0, 2) == "_Z")
+    caller_func_name = demangleSymbol(caller_func_name);
+
+  fatal(diag::undefined_reference_text) << reloc_sym
+                                        << pInput.path()
+                                        << caller_file_name
+                                        << caller_func_name;
+}
diff --git a/lib/LD/ResolveInfo.cpp b/lib/LD/ResolveInfo.cpp
index 4d1f72b..ca26d63 100644
--- a/lib/LD/ResolveInfo.cpp
+++ b/lib/LD/ResolveInfo.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/ResolveInfo.h>
 #include <mcld/LD/LDSection.h>
+#include <mcld/LinkerConfig.h>
 #include <mcld/Support/GCFactory.h>
 #include <llvm/Support/ManagedStatic.h>
 #include <cstdlib>
@@ -90,6 +91,11 @@
     m_BitField &= (~dynamic_flag);
 }
 
+void ResolveInfo::setInDyn()
+{
+  m_BitField |= indyn_flag;
+}
+
 void ResolveInfo::setType(uint32_t pType)
 {
   m_BitField &= ~TYPE_MASK;
@@ -200,6 +206,11 @@
   return (string_flag == (m_BitField & SYMBOL_MASK));
 }
 
+bool ResolveInfo::isInDyn() const
+{
+  return (indyn_flag == (m_BitField & IN_DYN_MASK));
+}
+
 uint32_t ResolveInfo::type() const
 {
   return (m_BitField & TYPE_MASK) >> TYPE_OFFSET;
@@ -239,22 +250,37 @@
   return (0 == std::memcmp(m_Name, pKey.data(), length));
 }
 
+bool ResolveInfo::shouldForceLocal(const LinkerConfig& pConfig)
+{
+  // forced local symbol matches all rules:
+  // 1. We are not doing incremental linking.
+  // 2. The symbol is with Hidden or Internal visibility.
+  // 3. The symbol should be global or weak. Otherwise, local symbol is local.
+  // 4. The symbol is defined or common
+  if (LinkerConfig::Object != pConfig.codeGenType() &&
+      (visibility() == ResolveInfo::Hidden ||
+       visibility() == ResolveInfo::Internal) &&
+      (isGlobal() || isWeak()) &&
+      (isDefine() || isCommon()))
+    return true;
+  return false;
+}
 //===----------------------------------------------------------------------===//
 // ResolveInfo Factory Methods
 //===----------------------------------------------------------------------===//
 ResolveInfo* ResolveInfo::Create(const ResolveInfo::key_type& pKey)
 {
-  ResolveInfo* result = static_cast<ResolveInfo*>(
+  ResolveInfo* info = static_cast<ResolveInfo*>(
                           malloc(sizeof(ResolveInfo)+pKey.size()+1));
-  if (NULL == result)
+  if (NULL == info)
     return NULL;
 
-  new (result) ResolveInfo();
-  std::memcpy(result->m_Name, pKey.data(), pKey.size());
-  result->m_Name[pKey.size()] = '\0';
-  result->m_BitField &= ~ResolveInfo::RESOLVE_MASK;
-  result->m_BitField |= (pKey.size() << ResolveInfo::NAME_LENGTH_OFFSET);
-  return result;
+  new (info) ResolveInfo(); // call constructor at the `result` address.
+  std::memcpy(info->m_Name, pKey.data(), pKey.size());
+  info->m_Name[pKey.size()] = '\0';
+  info->m_BitField &= ~ResolveInfo::RESOLVE_MASK;
+  info->m_BitField |= (pKey.size() << ResolveInfo::NAME_LENGTH_OFFSET);
+  return info;
 }
 
 void ResolveInfo::Destroy(ResolveInfo*& pInfo)
diff --git a/lib/LD/StaticResolver.cpp b/lib/LD/StaticResolver.cpp
index 6401262..21826ef 100644
--- a/lib/LD/StaticResolver.cpp
+++ b/lib/LD/StaticResolver.cpp
@@ -20,14 +20,14 @@
 
 bool StaticResolver::resolve(ResolveInfo& __restrict__ pOld,
                              const ResolveInfo& __restrict__ pNew,
-                             bool &pOverride) const
+                             bool &pOverride, LDSymbol::ValueType pValue) const
 {
 
   /* The state table itself.
    * The first index is a link_row and the second index is a bfd_link_hash_type.
    *
    * Cs -> all rest kind of common (d_C, wd_C)
-   * Is -> all kind of indeirect
+   * Is -> all kind of indirect
    */
   static const enum LinkAction link_action[LAST_ORD][LAST_ORD] =
   {
@@ -169,6 +169,20 @@
       }
       /* Fall through */
       case MDEF: {       /* multiple definition error.  */
+        if (pOld.isDefine() && pNew.isDefine() &&
+            pOld.isAbsolute() && pNew.isAbsolute() &&
+            (pOld.desc() == pNew.desc() || pOld.desc() == ResolveInfo::NoType ||
+             pNew.desc() == ResolveInfo::NoType)) {
+          if (pOld.outSymbol()->value() == pValue) {
+            pOverride = true;
+            old->override(pNew);
+            break;
+          } else {
+            error(diag::multiple_absolute_definitions) << pNew.name()
+              << pOld.outSymbol()->value() << pValue;
+            break;
+          }
+        }
         error(diag::multiple_definitions) << pNew.name();
         break;
       }
diff --git a/lib/LD/StubFactory.cpp b/lib/LD/StubFactory.cpp
index 0124ec0..3d7c56a 100644
--- a/lib/LD/StubFactory.cpp
+++ b/lib/LD/StubFactory.cpp
@@ -50,11 +50,10 @@
     // find the island for the input relocation
     BranchIsland* island = pBRIslandFactory.find(*(pReloc.targetRef().frag()));
     if (NULL == island) {
-      island = pBRIslandFactory.produce(*(pReloc.targetRef().frag()));
+      return NULL;
     }
 
     // find if there is such a stub in the island already
-    assert(NULL != island);
     Stub* stub = island->findStub(prototype, pReloc);
     if (NULL != stub) {
       // reset the branch target to the stub instead!
diff --git a/lib/MC/Android.mk b/lib/MC/Android.mk
index 0f8911b..cbd1962 100644
--- a/lib/MC/Android.mk
+++ b/lib/MC/Android.mk
@@ -9,8 +9,8 @@
   InputAction.cpp  \
   InputBuilder.cpp  \
   InputFactory.cpp  \
+  Input.cpp \
   MCLDDirectory.cpp \
-  MCLDInput.cpp \
   SearchDirs.cpp  \
   SymbolCategory.cpp  \
   ZOption.cpp
diff --git a/lib/MC/CommandAction.cpp b/lib/MC/CommandAction.cpp
index 91b5904..bae5fbf 100644
--- a/lib/MC/CommandAction.cpp
+++ b/lib/MC/CommandAction.cpp
@@ -11,6 +11,8 @@
 #include <mcld/MC/SearchDirs.h>
 #include <mcld/MC/Attribute.h>
 #include <mcld/Support/MsgHandling.h>
+#include <mcld/Support/FileSystem.h>
+#include <mcld/LinkerConfig.h>
 
 using namespace mcld;
 
@@ -35,13 +37,13 @@
 //===----------------------------------------------------------------------===//
 NamespecAction::NamespecAction(unsigned int pPosition,
                                const std::string &pNamespec,
-                               SearchDirs& pSearchDirs)
+                               const SearchDirs& pSearchDirs)
   : InputAction(pPosition), m_Namespec(pNamespec), m_SearchDirs(pSearchDirs) {
 }
 
 bool NamespecAction::activate(InputBuilder& pBuilder) const
 {
-  sys::fs::Path* path = NULL;
+  const sys::fs::Path* path = NULL;
   // find out the real path of the namespec.
   if (pBuilder.getConstraint().isSharedSystem()) {
     // In the system with shared object support, we can find both archive
@@ -218,3 +220,63 @@
   return true;
 }
 
+//===----------------------------------------------------------------------===//
+// DefSymAction
+//===----------------------------------------------------------------------===//
+DefSymAction::DefSymAction(unsigned int pPosition, std::string& pAssignment)
+  : InputAction(pPosition), m_Assignment(pAssignment) {
+}
+
+bool DefSymAction::activate(InputBuilder& pBuilder) const
+{
+  pBuilder.createNode<InputTree::Positional>("defsym", "NAN");
+  Input* input = *pBuilder.getCurrentNode();
+  pBuilder.setContext(*input, false);
+
+  m_Assignment.append(";");
+  pBuilder.setMemory(*input, &m_Assignment[0], m_Assignment.size());
+  return true;
+}
+
+//===----------------------------------------------------------------------===//
+// ScriptAction
+//===----------------------------------------------------------------------===//
+ScriptAction::ScriptAction(unsigned int pPosition,
+                           const std::string& pFileName,
+                           ScriptFile::Kind pKind,
+                           const SearchDirs& pSearchDirs)
+  : InputAction(pPosition),
+    m_FileName(pFileName),
+    m_Kind(pKind),
+    m_SearchDirs(pSearchDirs) {
+}
+
+bool ScriptAction::activate(InputBuilder& pBuilder) const
+{
+  sys::fs::Path path(m_FileName);
+
+  if (!exists(path)) {
+    const sys::fs::Path* res = m_SearchDirs.find(m_FileName, Input::Script);
+    if (res == NULL) {
+      switch (m_Kind) {
+      case ScriptFile::LDScript:
+        fatal(diag::err_cannot_find_scriptfile) << "linker script" << m_FileName;
+        break;
+      case ScriptFile::VersionScript:
+        fatal(diag::err_cannot_find_scriptfile) << "version script" << m_FileName;
+        break;
+      case ScriptFile::DynamicList:
+        fatal(diag::err_cannot_find_scriptfile) << "dynamic list" << m_FileName;
+        break;
+      default:
+        break;
+      }
+      return false;
+    }
+    path.assign(res->native());
+  }
+
+  pBuilder.createNode<InputTree::Positional>(path.stem().native(), path);
+
+  return true;
+}
diff --git a/lib/MC/FileAction.cpp b/lib/MC/FileAction.cpp
index 8660558..1c7e5ae 100644
--- a/lib/MC/FileAction.cpp
+++ b/lib/MC/FileAction.cpp
@@ -7,10 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/MC/FileAction.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/MC/InputBuilder.h>
-#include <mcld/MC/ContextFactory.h>
-#include <mcld/Support/MemoryAreaFactory.h>
 
 using namespace mcld;
 
diff --git a/lib/MC/MCLDInput.cpp b/lib/MC/Input.cpp
similarity index 90%
rename from lib/MC/MCLDInput.cpp
rename to lib/MC/Input.cpp
index a10466b..2d948c2 100644
--- a/lib/MC/MCLDInput.cpp
+++ b/lib/MC/Input.cpp
@@ -1,4 +1,4 @@
-//===- MCLDInput.cpp ------------------------------------------------------===//
+//===- Input.cpp ----------------------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -6,10 +6,9 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/MC/Attribute.h>
 #include <mcld/LD/LDContext.h>
-#include <mcld/Support/MemoryArea.h>
 
 using namespace mcld;
 
@@ -71,7 +70,5 @@
 {
   // Attribute is deleted by AttributeFactory
   // MemoryArea is deleted by MemoryAreaFactory
-  if (NULL != m_pMemArea)
-    m_pMemArea->clear();
 }
 
diff --git a/lib/MC/InputBuilder.cpp b/lib/MC/InputBuilder.cpp
index 9142801..842c476 100644
--- a/lib/MC/InputBuilder.cpp
+++ b/lib/MC/InputBuilder.cpp
@@ -131,10 +131,6 @@
                              FileHandle::Permission pPerm)
 {
   MemoryArea *memory = m_pMemFactory->produce(pInput.path(), pMode, pPerm);
-
-  if (!memory->handler()->isGood())
-    return false;
-
   pInput.setMemArea(memory);
   return true;
 }
diff --git a/lib/MC/SearchDirs.cpp b/lib/MC/SearchDirs.cpp
index 940553e..971f866 100644
--- a/lib/MC/SearchDirs.cpp
+++ b/lib/MC/SearchDirs.cpp
@@ -73,89 +73,136 @@
   return insert(pPath.native());
 }
 
-mcld::sys::fs::Path* SearchDirs::find(const std::string& pNamespec, mcld::Input::Type pType)
+mcld::sys::fs::Path*
+SearchDirs::find(const std::string& pNamespec, mcld::Input::Type pType)
 {
-  assert(Input::DynObj == pType || Input::Archive == pType);
+  assert(Input::DynObj  == pType ||
+         Input::Archive == pType ||
+         Input::Script  == pType);
 
   std::string file;
-  SpecToFilename(pNamespec, file);
+  switch(pType) {
+  case Input::Script:
+    file.assign(pNamespec);
+    break;
+  case Input::DynObj:
+  case Input::Archive :
+    SpecToFilename(pNamespec, file);
+    break;
+  default:
+    break;
+  } // end of switch
+
   // for all MCLDDirectorys
   DirList::iterator mcld_dir, mcld_dir_end = m_DirList.end();
-  for (mcld_dir=m_DirList.begin(); mcld_dir!=mcld_dir_end; ++mcld_dir) {
+  for (mcld_dir = m_DirList.begin(); mcld_dir != mcld_dir_end; ++mcld_dir) {
     // for all entries in MCLDDirectory
     MCLDDirectory::iterator entry = (*mcld_dir)->begin();
     MCLDDirectory::iterator enEnd = (*mcld_dir)->end();
 
     switch(pType) {
-      case Input::DynObj: {
-        while (entry!=enEnd) {
-          if (file == entry.path()->stem().native() ) {
-            if(mcld::sys::fs::detail::shared_library_extension == entry.path()->extension().native()) {
-              return entry.path();
-            }
-          }
-          ++entry;
-        }
+    case Input::Script: {
+      while (entry != enEnd) {
+        if (file == entry.path()->filename())
+          return entry.path();
+        ++entry;
       }
-      /** Fall through **/
-      case Input::Archive : {
-        entry = (*mcld_dir)->begin();
-        enEnd = (*mcld_dir)->end();
-        while ( entry!=enEnd ) {
-          if (file == entry.path()->stem().native() &&
-            mcld::sys::fs::detail::static_library_extension == entry.path()->extension().native()) {
+      break;
+    }
+    case Input::DynObj: {
+      while (entry != enEnd) {
+        if (file == entry.path()->stem().native() ) {
+          if (mcld::sys::fs::detail::shared_library_extension ==
+                entry.path()->extension().native()) {
             return entry.path();
           }
-          ++entry;
         }
+        ++entry;
       }
-      default:
-        break;
+    }
+    /** Fall through **/
+    case Input::Archive : {
+      entry = (*mcld_dir)->begin();
+      enEnd = (*mcld_dir)->end();
+      while (entry != enEnd) {
+        if (file == entry.path()->stem().native() &&
+            mcld::sys::fs::detail::static_library_extension ==
+              entry.path()->extension().native()) {
+          return entry.path();
+        }
+        ++entry;
+      }
+    }
+    default:
+      break;
     } // end of switch
-  } // end of while
+  } // end of for
   return NULL;
 }
 
 const mcld::sys::fs::Path*
 SearchDirs::find(const std::string& pNamespec, mcld::Input::Type pType) const
 {
-  assert(Input::DynObj == pType || Input::Archive == pType);
+  assert(Input::DynObj  == pType ||
+         Input::Archive == pType ||
+         Input::Script  == pType);
 
   std::string file;
-  SpecToFilename(pNamespec, file);
+  switch(pType) {
+  case Input::Script:
+    file.assign(pNamespec);
+    break;
+  case Input::DynObj:
+  case Input::Archive :
+    SpecToFilename(pNamespec, file);
+    break;
+  default:
+    break;
+  } // end of switch
+
   // for all MCLDDirectorys
   DirList::const_iterator mcld_dir, mcld_dir_end = m_DirList.end();
-  for (mcld_dir=m_DirList.begin(); mcld_dir!=mcld_dir_end; ++mcld_dir) {
+  for (mcld_dir = m_DirList.begin(); mcld_dir != mcld_dir_end; ++mcld_dir) {
     // for all entries in MCLDDirectory
     MCLDDirectory::iterator entry = (*mcld_dir)->begin();
     MCLDDirectory::iterator enEnd = (*mcld_dir)->end();
 
     switch(pType) {
-      case Input::DynObj: {
-        while (entry!=enEnd) {
-          if (file == entry.path()->stem().native() ) {
-            if(mcld::sys::fs::detail::shared_library_extension == entry.path()->extension().native()) {
-              return entry.path();
-            }
-          }
-          ++entry;
-        }
+    case Input::Script: {
+      while (entry != enEnd) {
+        if (file == entry.path()->filename())
+          return entry.path();
+        ++entry;
       }
-      /** Fall through **/
-      case Input::Archive : {
-        entry = (*mcld_dir)->begin();
-        enEnd = (*mcld_dir)->end();
-        while ( entry!=enEnd ) {
-          if (file == entry.path()->stem().native() &&
-            mcld::sys::fs::detail::static_library_extension == entry.path()->extension().native()) {
+      break;
+    }
+    case Input::DynObj: {
+      while (entry != enEnd) {
+        if (file == entry.path()->stem().native() ) {
+          if (mcld::sys::fs::detail::shared_library_extension ==
+                entry.path()->extension().native()) {
             return entry.path();
           }
-          ++entry;
         }
+        ++entry;
       }
-      default:
-        break;
+    }
+    /** Fall through **/
+    case Input::Archive : {
+      entry = (*mcld_dir)->begin();
+      enEnd = (*mcld_dir)->end();
+      while ( entry!=enEnd ) {
+        if (file == entry.path()->stem().native() &&
+            mcld::sys::fs::detail::static_library_extension ==
+              entry.path()->extension().native()) {
+          return entry.path();
+        }
+        ++entry;
+      }
+    }
+    default:
+      break;
     } // end of switch
-  } // end of while
+  } // end of for 
   return NULL;
 }
diff --git a/lib/MC/ZOption.cpp b/lib/MC/ZOption.cpp
index a58562d..8b11765 100644
--- a/lib/MC/ZOption.cpp
+++ b/lib/MC/ZOption.cpp
@@ -10,16 +10,10 @@
 
 using namespace mcld;
 
-//==========================
+//===----------------------------------------------------------------------===//
 // ZOption
-
+//===----------------------------------------------------------------------===//
 ZOption::ZOption()
-  : m_Kind(Unknown),
-    m_PageSize(0x0)
-{
-}
-
-ZOption::~ZOption()
-{
+  : m_Kind(Unknown), m_PageSize(0x0) {
 }
 
diff --git a/lib/Object/ObjectBuilder.cpp b/lib/Object/ObjectBuilder.cpp
index f5c9fe5..6738c3c 100644
--- a/lib/Object/ObjectBuilder.cpp
+++ b/lib/Object/ObjectBuilder.cpp
@@ -10,6 +10,7 @@
 
 #include <mcld/Module.h>
 #include <mcld/LinkerConfig.h>
+#include <mcld/LinkerScript.h>
 #include <mcld/IRBuilder.h>
 #include <mcld/Object/SectionMap.h>
 #include <mcld/LD/LDSection.h>
@@ -40,20 +41,35 @@
                                         uint32_t pAlign)
 {
   // try to get one from output LDSection
-  const SectionMap::NamePair& pair = m_Module.getScript().sectionMap().find(pName);
-  std::string output_name = (pair.isNull())?pName:pair.to;
-  LDSection* output_sect = LDSection::Create(output_name, pKind, pType, pFlag);
-  output_sect->setAlign(pAlign);
-  m_Module.getSectionTable().push_back(output_sect);
+  SectionMap::const_mapping pair =
+    m_Module.getScript().sectionMap().find("*", pName);
+
+  std::string output_name = (pair.first == NULL) ? pName : pair.first->name();
+
+  LDSection* output_sect = m_Module.getSection(output_name);
+  if (NULL == output_sect) {
+    output_sect = LDSection::Create(pName, pKind, pType, pFlag);
+    output_sect->setAlign(pAlign);
+    m_Module.getSectionTable().push_back(output_sect);
+  }
   return output_sect;
 }
 
 /// MergeSection - merge the pInput section to the pOutput section
-LDSection* ObjectBuilder::MergeSection(LDSection& pInputSection)
+LDSection* ObjectBuilder::MergeSection(const Input& pInputFile,
+                                       LDSection& pInputSection)
 {
-  const SectionMap::NamePair& pair =
-              m_Module.getScript().sectionMap().find(pInputSection.name());
-  std::string output_name = (pair.isNull())?pInputSection.name():pair.to;
+  SectionMap::mapping pair =
+    m_Module.getScript().sectionMap().find(pInputFile.path().native(),
+                                           pInputSection.name());
+
+  if (pair.first != NULL && pair.first->isDiscard()) {
+    pInputSection.setKind(LDFileFormat::Ignore);
+    return NULL;
+  }
+
+  std::string output_name = (pair.first == NULL) ?
+                            pInputSection.name() : pair.first->name();
   LDSection* target = m_Module.getSection(output_name);
 
   if (NULL == target) {
@@ -66,11 +82,6 @@
   }
 
   switch (target->kind()) {
-    // Some *OUTPUT sections should not be merged.
-    case LDFileFormat::Relocation:
-    case LDFileFormat::NamePool:
-      /** do nothing **/
-      return target;
     case LDFileFormat::EhFrame: {
       EhFrame* eh_frame = NULL;
       if (target->hasEhFrame())
@@ -78,16 +89,22 @@
       else
         eh_frame = IRBuilder::CreateEhFrame(*target);
 
-      eh_frame->merge(*pInputSection.getEhFrame());
-			UpdateSectionAlign(*target, pInputSection);
+      eh_frame->merge(pInputFile, *pInputSection.getEhFrame());
+      UpdateSectionAlign(*target, pInputSection);
       return target;
     }
     default: {
+      if (!target->hasSectionData())
+        IRBuilder::CreateSectionData(*target);
+
       SectionData* data = NULL;
-      if (target->hasSectionData())
+      if (pair.first != NULL) {
+        assert(pair.second != NULL);
+        data = pair.second->getSection()->getSectionData();
+      } else {
+        // orphan section
         data = target->getSectionData();
-      else
-        data = IRBuilder::CreateSectionData(*target);
+      }
 
       if (MoveSectionData(*pInputSection.getSectionData(), *data)) {
         UpdateSectionAlign(*target, pInputSection);
@@ -104,7 +121,7 @@
 {
   assert(&pFrom != &pTo && "Cannot move section data to itself!");
 
-  uint32_t offset = pTo.getSection().size();
+  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
@@ -149,7 +166,7 @@
                                        uint32_t pAlignConstraint)
 {
   // get initial offset.
-  uint32_t offset = 0;
+  uint64_t offset = 0;
   if (!pSD.empty())
     offset = pSD.back().getOffset() + pSD.back().size();
 
diff --git a/lib/Object/ObjectLinker.cpp b/lib/Object/ObjectLinker.cpp
index 1b16f95..f5eec4c 100644
--- a/lib/Object/ObjectLinker.cpp
+++ b/lib/Object/ObjectLinker.cpp
@@ -9,6 +9,7 @@
 #include <mcld/Object/ObjectLinker.h>
 
 #include <mcld/LinkerConfig.h>
+#include <mcld/LinkerScript.h>
 #include <mcld/Module.h>
 #include <mcld/InputTree.h>
 #include <mcld/IRBuilder.h>
@@ -20,27 +21,37 @@
 #include <mcld/LD/DynObjReader.h>
 #include <mcld/LD/GroupReader.h>
 #include <mcld/LD/BinaryReader.h>
+#include <mcld/LD/GarbageCollection.h>
 #include <mcld/LD/ObjectWriter.h>
 #include <mcld/LD/ResolveInfo.h>
 #include <mcld/LD/RelocData.h>
 #include <mcld/LD/Relocator.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/LD/BranchIslandFactory.h>
+#include <mcld/Script/ScriptFile.h>
+#include <mcld/Script/ScriptReader.h>
+#include <mcld/Script/Assignment.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Script/RpnEvaluator.h>
 #include <mcld/Support/RealPath.h>
-#include <mcld/Support/MemoryArea.h>
+#include <mcld/Support/FileOutputBuffer.h>
 #include <mcld/Support/MsgHandling.h>
-#include <mcld/Support/DefSymParser.h>
 #include <mcld/Target/TargetLDBackend.h>
-#include <mcld/Fragment/FragmentLinker.h>
+#include <mcld/Fragment/Relocation.h>
 #include <mcld/Object/ObjectBuilder.h>
 
 #include <llvm/Support/Casting.h>
-
+#include <llvm/Support/Host.h>
 
 using namespace llvm;
 using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// ObjectLinker
+//===----------------------------------------------------------------------===//
 ObjectLinker::ObjectLinker(const LinkerConfig& pConfig,
                            TargetLDBackend& pLDBackend)
   : m_Config(pConfig),
-    m_pLinker(NULL),
     m_pModule(NULL),
     m_pBuilder(NULL),
     m_LDBackend(pLDBackend),
@@ -49,54 +60,39 @@
     m_pArchiveReader(NULL),
     m_pGroupReader(NULL),
     m_pBinaryReader(NULL),
+    m_pScriptReader(NULL),
     m_pWriter(NULL) {
 }
 
 ObjectLinker::~ObjectLinker()
 {
-  delete m_pLinker;
   delete m_pObjectReader;
   delete m_pDynObjReader;
   delete m_pArchiveReader;
   delete m_pGroupReader;
   delete m_pBinaryReader;
+  delete m_pScriptReader;
   delete m_pWriter;
 }
 
-void ObjectLinker::setup(Module& pModule, IRBuilder& pBuilder)
+bool ObjectLinker::initialize(Module& pModule, IRBuilder& pBuilder)
 {
   m_pModule = &pModule;
   m_pBuilder = &pBuilder;
 
-  // set up soname
-  if (!m_Config.options().soname().empty()) {
-    m_pModule->setName(m_Config.options().soname());
-  }
-}
-
-/// initFragmentLinker - initialize FragmentLinker
-///  Connect all components with FragmentLinker
-bool ObjectLinker::initFragmentLinker()
-{
-  if (NULL == m_pLinker) {
-    m_pLinker = new FragmentLinker(m_Config,
-                                   *m_pModule,
-                                   m_LDBackend);
-  }
-
   // initialize the readers and writers
-  // Because constructor can not be failed, we initalize all readers and
-  // writers outside the FragmentLinker constructors.
   m_pObjectReader  = m_LDBackend.createObjectReader(*m_pBuilder);
   m_pArchiveReader = m_LDBackend.createArchiveReader(*m_pModule);
   m_pDynObjReader  = m_LDBackend.createDynObjReader(*m_pBuilder);
   m_pBinaryReader  = m_LDBackend.createBinaryReader(*m_pBuilder);
   m_pGroupReader   = new GroupReader(*m_pModule, *m_pObjectReader,
                          *m_pDynObjReader, *m_pArchiveReader, *m_pBinaryReader);
+  m_pScriptReader  = new ScriptReader(*m_pGroupReader);
   m_pWriter        = m_LDBackend.createWriter();
 
   // initialize Relocator
   m_LDBackend.initRelocator();
+
   return true;
 }
 
@@ -122,7 +118,8 @@
   for (input = m_pModule->input_begin(); input!=inEnd; ++input) {
     // is a group node
     if (isGroup(input)) {
-      getGroupReader()->readGroup(input, m_pBuilder->getInputBuilder(), m_Config);
+      getGroupReader()->readGroup(input, inEnd, m_pBuilder->getInputBuilder(),
+                                  m_Config);
       continue;
     }
 
@@ -143,14 +140,15 @@
       continue;
     }
 
+    bool doContinue = false;
     // read input as a binary file
-    if (m_Config.options().isBinaryInput()) {
+    if (getBinaryReader()->isMyFormat(**input, doContinue)) {
       (*input)->setType(Input::Object);
       getBinaryReader()->readBinary(**input);
       m_pModule->getObjectList().push_back(*input);
     }
     // is a relocatable object file
-    else if (getObjectReader()->isMyFormat(**input)) {
+    else if (doContinue && getObjectReader()->isMyFormat(**input, doContinue)) {
       (*input)->setType(Input::Object);
       getObjectReader()->readHeader(**input);
       getObjectReader()->readSections(**input);
@@ -158,25 +156,39 @@
       m_pModule->getObjectList().push_back(*input);
     }
     // is a shared object file
-    else if (getDynObjReader()->isMyFormat(**input)) {
+    else if (doContinue && getDynObjReader()->isMyFormat(**input, doContinue)) {
       (*input)->setType(Input::DynObj);
       getDynObjReader()->readHeader(**input);
       getDynObjReader()->readSymbols(**input);
       m_pModule->getLibraryList().push_back(*input);
     }
     // is an archive
-    else if (getArchiveReader()->isMyFormat(**input)) {
+    else if (doContinue && getArchiveReader()->isMyFormat(**input, doContinue)) {
       (*input)->setType(Input::Archive);
       Archive archive(**input, m_pBuilder->getInputBuilder());
-      getArchiveReader()->readArchive(archive);
+      getArchiveReader()->readArchive(m_Config, archive);
       if(archive.numOfObjectMember() > 0) {
         m_pModule->getInputTree().merge<InputTree::Inclusive>(input,
-                                                            archive.inputs());
+                                                              archive.inputs());
+      }
+    }
+    // try to parse input as a linker script
+    else if (doContinue && getScriptReader()->isMyFormat(**input, doContinue)) {
+      ScriptFile script(ScriptFile::LDScript, **input,
+                        m_pBuilder->getInputBuilder());
+      if (getScriptReader()->readScript(m_Config, script)) {
+        (*input)->setType(Input::Script);
+        script.activate(*m_pModule);
+        if (script.inputs().size() > 0) {
+          m_pModule->getInputTree().merge<InputTree::Inclusive>(input,
+            script.inputs());
+        }
       }
     }
     else {
-      fatal(diag::err_unrecognized_input_file) << (*input)->path()
-                                          << m_Config.targets().triple().str();
+      if (m_Config.options().warnMismatch())
+        warning(diag::warn_unrecognized_input_file) << (*input)->path()
+          << m_Config.targets().triple().str();
     }
   } // end of for
 }
@@ -217,6 +229,16 @@
   return true;
 }
 
+void ObjectLinker::dataStrippingOpt()
+{
+  // Garbege collection
+  if (m_Config.options().GCSections()) {
+    GarbageCollection GC(m_Config, m_LDBackend, *m_pModule);
+    GC.run();
+  }
+  return;
+}
+
 /// readRelocations - read all relocation entries
 ///
 /// All symbols should be read and resolved before this function.
@@ -247,14 +269,21 @@
         // Some *INPUT sections should not be merged.
         case LDFileFormat::Ignore:
         case LDFileFormat::Null:
-        case LDFileFormat::Relocation:
         case LDFileFormat::NamePool:
         case LDFileFormat::Group:
         case LDFileFormat::StackNote:
           // skip
           continue;
+        case LDFileFormat::Relocation: {
+          if (!(*sect)->hasRelocData())
+            continue; // skip
+
+          if ((*sect)->getLink()->kind() == LDFileFormat::Ignore)
+            (*sect)->setKind(LDFileFormat::Ignore);
+          break;
+        }
         case LDFileFormat::Target:
-          if (!m_LDBackend.mergeSection(*m_pModule, **sect)) {
+          if (!m_LDBackend.mergeSection(*m_pModule, **obj, **sect)) {
             error(diag::err_cannot_merge_section) << (*sect)->name()
                                                   << (*obj)->name();
             return false;
@@ -265,16 +294,12 @@
             continue; // skip
 
           LDSection* out_sect = NULL;
-          if (NULL == (out_sect = builder.MergeSection(**sect))) {
-            error(diag::err_cannot_merge_section) << (*sect)->name()
-                                                  << (*obj)->name();
-            return false;
-          }
-
-          if (!m_LDBackend.updateSectionFlags(*out_sect, **sect)) {
-            error(diag::err_cannot_merge_section) << (*sect)->name()
-                                                  << (*obj)->name();
-            return false;
+          if (NULL != (out_sect = builder.MergeSection(**obj, **sect))) {
+            if (!m_LDBackend.updateSectionFlags(*out_sect, **sect)) {
+              error(diag::err_cannot_merge_section) << (*sect)->name()
+                                                    << (*obj)->name();
+              return false;
+            }
           }
           break;
         }
@@ -283,25 +308,105 @@
             continue; // skip
 
           LDSection* out_sect = NULL;
-          if (NULL == (out_sect = builder.MergeSection(**sect))) {
-            error(diag::err_cannot_merge_section) << (*sect)->name()
-                                                  << (*obj)->name();
-            return false;
-          }
-
-          if (!m_LDBackend.updateSectionFlags(*out_sect, **sect)) {
-            error(diag::err_cannot_merge_section) << (*sect)->name()
-                                                  << (*obj)->name();
-            return false;
+          if (NULL != (out_sect = builder.MergeSection(**obj, **sect))) {
+            if (!m_LDBackend.updateSectionFlags(*out_sect, **sect)) {
+              error(diag::err_cannot_merge_section) << (*sect)->name()
+                                                    << (*obj)->name();
+              return false;
+            }
           }
           break;
         }
       } // end of switch
     } // for each section
   } // for each obj
+
+  RpnEvaluator evaluator(*m_pModule, m_LDBackend);
+  SectionMap::iterator out, outBegin, outEnd;
+  outBegin = m_pModule->getScript().sectionMap().begin();
+  outEnd = m_pModule->getScript().sectionMap().end();
+  for (out = outBegin; out != outEnd; ++out) {
+    uint64_t out_align = 0x0, in_align = 0x0;
+    LDSection* out_sect = (*out)->getSection();
+    SectionMap::Output::iterator in, inBegin, inEnd;
+    inBegin = (*out)->begin();
+    inEnd = (*out)->end();
+
+    // force input alignment from ldscript if any
+    if ((*out)->prolog().hasSubAlign()) {
+      evaluator.eval((*out)->prolog().subAlign(), in_align);
+    }
+
+    for (in = inBegin; in != inEnd; ++in) {
+      LDSection* in_sect = (*in)->getSection();
+      if ((*out)->prolog().hasSubAlign())
+        in_sect->setAlign(in_align);
+
+      if (builder.MoveSectionData(*in_sect->getSectionData(),
+                                  *out_sect->getSectionData())) {
+        builder.UpdateSectionAlign(*out_sect, *in_sect);
+        m_LDBackend.updateSectionFlags(*out_sect, *in_sect);
+      }
+    } // for each input section description
+
+    // force output alignment from ldscript if any
+    if ((*out)->prolog().hasAlign()) {
+      evaluator.eval((*out)->prolog().align(), out_align);
+      out_sect->setAlign(out_align);
+    }
+
+    if ((*out)->hasContent()) {
+      LDSection* target = m_pModule->getSection((*out)->name());
+      assert(target != NULL && target->hasSectionData());
+      if (builder.MoveSectionData(*out_sect->getSectionData(),
+                                  *target->getSectionData())) {
+        builder.UpdateSectionAlign(*target, *out_sect);
+        m_LDBackend.updateSectionFlags(*target, *out_sect);
+      }
+    }
+  } // for each output section description
+
   return true;
 }
 
+void ObjectLinker::addSymbolToOutput(ResolveInfo& pInfo, Module& pModule)
+{
+  // section symbols will be defined by linker later, we should not add section
+  // symbols to output here
+  if (ResolveInfo::Section == pInfo.type() || NULL == pInfo.outSymbol())
+    return;
+
+  // if the symbols defined in the Ignore sections (e.g. discared by GC), then
+  // not to put them to output
+  if (pInfo.outSymbol()->hasFragRef() && LDFileFormat::Ignore ==
+        pInfo.outSymbol()->fragRef()->frag()->getParent()->getSection().kind())
+    return;
+
+  if (pInfo.shouldForceLocal(m_Config))
+    pModule.getSymbolTable().forceLocal(*pInfo.outSymbol());
+  else
+    pModule.getSymbolTable().add(*pInfo.outSymbol());
+}
+
+void ObjectLinker::addSymbolsToOutput(Module& pModule)
+{
+  // Traverse all the free ResolveInfo and add the output symobols to output
+  NamePool::freeinfo_iterator free_it,
+                              free_end = pModule.getNamePool().freeinfo_end();
+  for (free_it = pModule.getNamePool().freeinfo_begin(); free_it != free_end;
+                                                                      ++free_it)
+    addSymbolToOutput(**free_it, pModule);
+
+
+  // Traverse all the resolveInfo and add the output symbol to output
+  NamePool::syminfo_iterator info_it,
+                             info_end = pModule.getNamePool().syminfo_end();
+  for (info_it = pModule.getNamePool().syminfo_begin(); info_it != info_end;
+                                                                      ++info_it)
+    addSymbolToOutput(*info_it.getEntry(), pModule);
+}
+
+
 /// addStandardSymbols - shared object and executable files need some
 /// standard symbols
 ///   @return if there are some input symbols with the same name to the
@@ -331,40 +436,63 @@
 /// scripts.
 bool ObjectLinker::addScriptSymbols()
 {
-  const LinkerScript& script = m_pModule->getScript();
-  LinkerScript::DefSymMap::const_entry_iterator it;
-  LinkerScript::DefSymMap::const_entry_iterator ie = script.defSymMap().end();
-  // go through the entire defSymMap
-  for (it = script.defSymMap().begin(); it != ie; ++it) {
-    const llvm::StringRef sym =  it.getEntry()->key();
-    ResolveInfo* old_info = m_pModule->getNamePool().findInfo(sym);
+  LinkerScript& script = m_pModule->getScript();
+  LinkerScript::Assignments::iterator it, ie = script.assignments().end();
+  // go through the entire symbol assignments
+  for (it = script.assignments().begin(); it != ie; ++it) {
+    LDSymbol* symbol = NULL;
+    assert((*it).second.symbol().type() == Operand::SYMBOL);
+    const llvm::StringRef symName =  (*it).second.symbol().name();
+    ResolveInfo::Type       type = ResolveInfo::NoType;
+    ResolveInfo::Visibility vis  = ResolveInfo::Default;
+    size_t size = 0;
+    ResolveInfo* old_info = m_pModule->getNamePool().findInfo(symName);
     // if the symbol does not exist, we can set type to NOTYPE
     // else we retain its type, same goes for size - 0 or retain old value
     // and visibility - Default or retain
     if (old_info != NULL) {
-      if(!m_pBuilder->AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
-                             sym,
-                             static_cast<ResolveInfo::Type>(old_info->type()),
-                             ResolveInfo::Define,
-                             ResolveInfo::Absolute,
-                             old_info->size(),
-                             0x0,
-                             FragmentRef::Null(),
-                             old_info->visibility()))
-        return false;
+      type = static_cast<ResolveInfo::Type>(old_info->type());
+      vis = old_info->visibility();
+      size = old_info->size();
     }
-    else {
-      if (!m_pBuilder->AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
-                             sym,
-                             ResolveInfo::NoType,
-                             ResolveInfo::Define,
-                             ResolveInfo::Absolute,
-                             0x0,
-                             0x0,
-                             FragmentRef::Null(),
-                             ResolveInfo::Default))
-        return false;
+
+    // Add symbol and refine the visibility if needed
+    // FIXME: bfd linker would change the binding instead, but currently
+    //        ABS is also a kind of Binding in ResolveInfo.
+    switch ((*it).second.type()) {
+    case Assignment::HIDDEN:
+      vis = ResolveInfo::Hidden;
+      // Fall through
+    case Assignment::DEFAULT:
+      symbol =
+        m_pBuilder->AddSymbol<IRBuilder::Force,
+                              IRBuilder::Unresolve>(symName,
+                                                    type,
+                                                    ResolveInfo::Define,
+                                                    ResolveInfo::Absolute,
+                                                    size,
+                                                    0x0,
+                                                    FragmentRef::Null(),
+                                                    vis);
+      break;
+    case Assignment::PROVIDE_HIDDEN:
+      vis = ResolveInfo::Hidden;
+      // Fall through
+    case Assignment::PROVIDE:
+      symbol =
+        m_pBuilder->AddSymbol<IRBuilder::AsReferred,
+                              IRBuilder::Unresolve>(symName,
+                                                    type,
+                                                    ResolveInfo::Define,
+                                                    ResolveInfo::Absolute,
+                                                    size,
+                                                    0x0,
+                                                    FragmentRef::Null(),
+                                                    vis);
+      break;
     }
+    // Set symbol of this assignment.
+    (*it).first = symbol;
   }
   return true;
 }
@@ -387,10 +515,18 @@
       RelocData::iterator reloc, rEnd = (*rs)->getRelocData()->end();
       for (reloc = (*rs)->getRelocData()->begin(); reloc != rEnd; ++reloc) {
         Relocation* relocation = llvm::cast<Relocation>(reloc);
+
+        // bypass the reloc if the symbol is in the discarded input section
+        ResolveInfo* info = relocation->symInfo();
+        if (!info->outSymbol()->hasFragRef() &&
+            ResolveInfo::Section == info->type() &&
+            ResolveInfo::Undefined == info->desc())
+           continue;
+
         // scan relocation
         if (LinkerConfig::Object != m_Config.codeGenType())
           m_LDBackend.getRelocator()->scanRelocation(
-                                    *relocation, *m_pBuilder, *m_pModule, **rs);
+                                    *relocation, *m_pBuilder, *m_pModule, **rs, **input);
         else
           m_LDBackend.getRelocator()->partialScanRelocation(
                                                  *relocation, *m_pModule, **rs);
@@ -450,12 +586,18 @@
   /// In ELF, will compute  the size of.symtab, .strtab, .dynsym, .dynstr,
   /// .hash and .shstrtab sections.
   ///
-  /// dump all symbols and strings from FragmentLinker and build the format-dependent
+  /// dump all symbols and strings from ObjectLinker and build the format-dependent
   /// hash table.
   /// @note sizeNamePools replies on LinkerConfig::CodePosition. Must determine
   /// code position model before calling GNULDBackend::sizeNamePools()
   m_LDBackend.sizeNamePools(*m_pModule);
 
+  // Do this after backend prelayout since it may add eh_frame entries.
+  LDSection* eh_frame_sect = m_pModule->getSection(".eh_frame");
+  if (eh_frame_sect && eh_frame_sect->hasEhFrame())
+    eh_frame_sect->getEhFrame()->computeOffsetSize();
+  m_LDBackend.createAndSizeEhFrameHdr(*m_pModule);
+
   return true;
 }
 
@@ -478,30 +620,69 @@
 }
 
 /// finalizeSymbolValue - finalize the resolved symbol value.
-///   Before relocate(), after layout(), FragmentLinker should correct value of all
+///   Before relocate(), after layout(), ObjectLinker should correct value of all
 ///   symbol.
 bool ObjectLinker::finalizeSymbolValue()
 {
-  bool finalized = m_pLinker->finalizeSymbols() && m_LDBackend.finalizeSymbols();
-  bool scriptSymsAdded = true;
-  uint64_t symVal;
-  const LinkerScript& script = m_pModule->getScript();
-  LinkerScript::DefSymMap::const_entry_iterator it;
-  LinkerScript::DefSymMap::const_entry_iterator ie = script.defSymMap().end();
+  Module::sym_iterator symbol, symEnd = m_pModule->sym_end();
+  for (symbol = m_pModule->sym_begin(); symbol != symEnd; ++symbol) {
 
-  DefSymParser parser(*m_pModule);
-  for (it = script.defSymMap().begin(); it != ie; ++it) {
-    llvm::StringRef symName =  it.getEntry()->key();
-    llvm::StringRef expr =  it.getEntry()->value();
+    if ((*symbol)->resolveInfo()->isAbsolute() ||
+        (*symbol)->resolveInfo()->type() == ResolveInfo::File) {
+      // absolute symbols should just use its value directly (i.e., the result
+      // of symbol resolution)
+      continue;
+    }
 
-    LDSymbol* symbol = m_pModule->getNamePool().findSymbol(symName);
-    assert(NULL != symbol && "--defsym symbol should be in the name pool");
-    scriptSymsAdded &= parser.parse(expr, symVal);
-    if (!scriptSymsAdded)
-      break;
-    symbol->setValue(symVal);
+    if ((*symbol)->resolveInfo()->type() == ResolveInfo::ThreadLocal) {
+      m_LDBackend.finalizeTLSSymbol(**symbol);
+      continue;
+    }
+
+    if ((*symbol)->hasFragRef()) {
+      // set the virtual address of the symbol. If the output file is
+      // relocatable object file, the section's virtual address becomes zero.
+      // And the symbol's value become section relative offset.
+      uint64_t value = (*symbol)->fragRef()->getOutputOffset();
+      assert(NULL != (*symbol)->fragRef()->frag());
+      uint64_t addr =
+        (*symbol)->fragRef()->frag()->getParent()->getSection().addr();
+      (*symbol)->setValue(value + addr);
+      continue;
+    }
   }
-  return finalized && scriptSymsAdded ;
+
+  RpnEvaluator evaluator(*m_pModule, m_LDBackend);
+  bool finalized = m_LDBackend.finalizeSymbols();
+  bool scriptSymsFinalized = true;
+  LinkerScript& script = m_pModule->getScript();
+  LinkerScript::Assignments::iterator assign, assignEnd;
+  assignEnd = script.assignments().end();
+  for (assign = script.assignments().begin(); assign != assignEnd; ++assign) {
+    LDSymbol* symbol = (*assign).first;
+    Assignment& assignment = (*assign).second;
+
+    if (symbol == NULL)
+      continue;
+
+    scriptSymsFinalized &= assignment.assign(evaluator);
+    if (!scriptSymsFinalized)
+      break;
+
+    symbol->setValue(assignment.symbol().value());
+  } // for each script symbol assignment
+
+  bool assertionsPassed = true;
+  LinkerScript::Assertions::iterator assert, assertEnd;
+  assertEnd = script.assertions().end();
+  for (assert = script.assertions().begin(); assert != assertEnd; ++assert) {
+    uint64_t res = 0x0;
+    evaluator.eval((*assert).getRpnExpr(), res);
+    if (res == 0x0)
+      fatal(diag::err_assert_failed) << (*assert).message();
+  } // for each assertion in ldscript
+
+  return finalized && scriptSymsFinalized && assertionsPassed;
 }
 
 /// relocate - applying relocation entries and create relocation
@@ -511,20 +692,66 @@
 /// and push_back into the relocation section
 bool ObjectLinker::relocation()
 {
-  return m_pLinker->applyRelocations();
+  // when producing relocatables, no need to apply relocation
+  if (LinkerConfig::Object == m_Config.codeGenType())
+    return true;
+
+  // apply all relocations of all inputs
+  Module::obj_iterator input, inEnd = m_pModule->obj_end();
+  for (input = m_pModule->obj_begin(); input != inEnd; ++input) {
+    m_LDBackend.getRelocator()->initializeApply(**input);
+    LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
+    for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
+      // bypass the reloc section if
+      // 1. its section kind is changed to Ignore. (The target section is a
+      // discarded group section.)
+      // 2. it has no reloc data. (All symbols in the input relocs are in the
+      // discarded group sections)
+      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);
+
+        // bypass the reloc if the symbol is in the discarded input section
+        ResolveInfo* info = relocation->symInfo();
+        if (!info->outSymbol()->hasFragRef() &&
+            ResolveInfo::Section == info->type() &&
+            ResolveInfo::Undefined == info->desc())
+          continue;
+
+        relocation->apply(*m_LDBackend.getRelocator());
+      } // for all relocations
+    } // for all relocation section
+    m_LDBackend.getRelocator()->finalizeApply(**input);
+  } // for all inputs
+
+  // apply relocations created by relaxation
+  BranchIslandFactory* br_factory = m_LDBackend.getBRIslandFactory();
+  BranchIslandFactory::iterator facIter, facEnd = br_factory->end();
+  for (facIter = br_factory->begin(); facIter != facEnd; ++facIter) {
+    BranchIsland& island = *facIter;
+    BranchIsland::reloc_iterator iter, iterEnd = island.reloc_end();
+    for (iter = island.reloc_begin(); iter != iterEnd; ++iter)
+      (*iter)->apply(*m_LDBackend.getRelocator());
+  }
+  return true;
 }
 
 /// emitOutput - emit the output file.
-bool ObjectLinker::emitOutput(MemoryArea& pOutput)
+bool ObjectLinker::emitOutput(FileOutputBuffer& pOutput)
 {
   return llvm::errc::success == getWriter()->writeObject(*m_pModule, pOutput);
 }
 
 
 /// postProcessing - do modification after all processes
-bool ObjectLinker::postProcessing(MemoryArea& pOutput)
+bool ObjectLinker::postProcessing(FileOutputBuffer& pOutput)
 {
-  m_pLinker->syncRelocationResult(pOutput);
+  if (LinkerConfig::Object != m_Config.codeGenType())
+    normalSyncRelocationResult(pOutput);
+  else
+    partialSyncRelocationResult(pOutput);
 
   // emit .eh_frame_hdr
   // eh_frame_hdr should be emitted after syncRelocation, because eh_frame_hdr
@@ -533,3 +760,125 @@
   return true;
 }
 
+void ObjectLinker::normalSyncRelocationResult(FileOutputBuffer& pOutput)
+{
+  uint8_t* data = pOutput.getBufferStart();
+
+  // sync all relocations of all inputs
+  Module::obj_iterator input, inEnd = m_pModule->obj_end();
+  for (input = m_pModule->obj_begin(); input != inEnd; ++input) {
+    LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
+    for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
+      // bypass the reloc section if
+      // 1. its section kind is changed to Ignore. (The target section is a
+      // discarded group section.)
+      // 2. it has no reloc data. (All symbols in the input relocs are in the
+      // discarded group sections)
+      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);
+
+        // bypass the reloc if the symbol is in the discarded input section
+        ResolveInfo* info = relocation->symInfo();
+        if (!info->outSymbol()->hasFragRef() &&
+            ResolveInfo::Section == info->type() &&
+            ResolveInfo::Undefined == info->desc())
+          continue;
+
+        // bypass the relocation with NONE type. This is to avoid overwrite the
+        // target result by NONE type relocation if there is a place which has
+        // two relocations to apply to, and one of it is NONE type. The result
+        // we want is the value of the other relocation result. For example,
+        // in .exidx, there are usually an R_ARM_NONE and R_ARM_PREL31 apply to
+        // the same place
+        if (0x0 == relocation->type())
+          continue;
+        writeRelocationResult(*relocation, data);
+      } // for all relocations
+    } // for all relocation section
+  } // for all inputs
+
+  // sync relocations created by relaxation
+  BranchIslandFactory* br_factory = m_LDBackend.getBRIslandFactory();
+  BranchIslandFactory::iterator facIter, facEnd = br_factory->end();
+  for (facIter = br_factory->begin(); facIter != facEnd; ++facIter) {
+    BranchIsland& island = *facIter;
+    BranchIsland::reloc_iterator iter, iterEnd = island.reloc_end();
+    for (iter = island.reloc_begin(); iter != iterEnd; ++iter) {
+      Relocation* reloc = *iter;
+      writeRelocationResult(*reloc, data);
+    }
+  }
+}
+
+void ObjectLinker::partialSyncRelocationResult(FileOutputBuffer& pOutput)
+{
+  uint8_t* data = pOutput.getBufferStart();
+
+  // traverse outputs' LDSection to get RelocData
+  Module::iterator sectIter, sectEnd = m_pModule->end();
+  for (sectIter = m_pModule->begin(); sectIter != sectEnd; ++sectIter) {
+    if (LDFileFormat::Relocation != (*sectIter)->kind())
+      continue;
+
+    RelocData* reloc_data = (*sectIter)->getRelocData();
+    RelocData::iterator relocIter, relocEnd = reloc_data->end();
+    for (relocIter = reloc_data->begin(); relocIter != relocEnd; ++relocIter) {
+      Relocation* reloc = llvm::cast<Relocation>(relocIter);
+
+      // bypass the relocation with NONE type. This is to avoid overwrite the
+      // target result by NONE type relocation if there is a place which has
+      // two relocations to apply to, and one of it is NONE type. The result
+      // we want is the value of the other relocation result. For example,
+      // in .exidx, there are usually an R_ARM_NONE and R_ARM_PREL31 apply to
+      // the same place
+      if (0x0 == reloc->type())
+        continue;
+      writeRelocationResult(*reloc, data);
+    }
+  }
+}
+
+void ObjectLinker::writeRelocationResult(Relocation& pReloc, uint8_t* pOutput)
+{
+  // get output file offset
+  size_t out_offset =
+                 pReloc.targetRef().frag()->getParent()->getSection().offset() +
+                 pReloc.targetRef().getOutputOffset();
+
+  uint8_t* target_addr = pOutput + out_offset;
+  // byte swapping if target and host has different endian, and then write back
+  if(llvm::sys::IsLittleEndianHost != m_Config.targets().isLittleEndian()) {
+     uint64_t tmp_data = 0;
+
+     switch(pReloc.size(*m_LDBackend.getRelocator())) {
+       case 8u:
+         std::memcpy(target_addr, &pReloc.target(), 1);
+         break;
+
+       case 16u:
+         tmp_data = mcld::bswap16(pReloc.target());
+         std::memcpy(target_addr, &tmp_data, 2);
+         break;
+
+       case 32u:
+         tmp_data = mcld::bswap32(pReloc.target());
+         std::memcpy(target_addr, &tmp_data, 4);
+         break;
+
+       case 64u:
+         tmp_data = mcld::bswap64(pReloc.target());
+         std::memcpy(target_addr, &tmp_data, 8);
+         break;
+
+       default:
+         break;
+    }
+  }
+  else
+    std::memcpy(target_addr, &pReloc.target(),
+                                      pReloc.size(*m_LDBackend.getRelocator())/8);
+}
+
diff --git a/lib/Object/SectionMap.cpp b/lib/Object/SectionMap.cpp
index d3da574..64c4a87 100644
--- a/lib/Object/SectionMap.cpp
+++ b/lib/Object/SectionMap.cpp
@@ -7,112 +7,385 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/Object/SectionMap.h>
-#include <mcld/ADT/StringHash.h>
+#include <mcld/Script/Assignment.h>
+#include <mcld/Script/WildcardPattern.h>
+#include <mcld/Script/StringList.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Script/Operator.h>
+#include <mcld/Script/RpnExpr.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/Fragment/NullFragment.h>
+#include <llvm/Support/Casting.h>
 #include <cassert>
 #include <cstring>
+#include <climits>
+#if !defined(MCLD_ON_WIN32)
+#include <fnmatch.h>
+#define fnmatch0(pattern,string) (fnmatch(pattern,string,0) == 0)
+#else
+#include <windows.h>
+#include <shlwapi.h>
+#define fnmatch0(pattern,string) (PathMatchSpec(string, pattern) == true)
+#endif
 
 using namespace mcld;
-
-
-SectionMap::NamePair SectionMap::NullName;
-
 //===----------------------------------------------------------------------===//
-// SectionMap::NamePair
+// SectionMap::Input
 //===----------------------------------------------------------------------===//
-SectionMap::NamePair::NamePair()
-  : hash(-1) {
-}
-
-SectionMap::NamePair::NamePair(const std::string& pFrom, const std::string& pTo)
-  : from(pFrom), to(pTo) {
-  hash = SectionMap::hash(pFrom);
-}
-
-bool SectionMap::NamePair::isNull() const
+SectionMap::Input::Input(const std::string& pName,
+                         InputSectDesc::KeepPolicy pPolicy)
+  : m_Policy(pPolicy)
 {
-  return (&NullName == this);
+  m_Spec.m_pWildcardFile =
+    WildcardPattern::create("*", WildcardPattern::SORT_NONE);
+  m_Spec.m_pExcludeFiles = NULL;
+
+  StringList* sections = StringList::create();
+  sections->push_back(
+    WildcardPattern::create(pName, WildcardPattern::SORT_NONE));
+  m_Spec.m_pWildcardSections = sections;
+
+  m_pSection = LDSection::Create(pName, LDFileFormat::Regular, 0, 0);
+  SectionData* sd = SectionData::Create(*m_pSection);
+  m_pSection->setSectionData(sd);
+  new NullFragment(sd);
+  new NullFragment(sd);
+}
+
+SectionMap::Input::Input(const InputSectDesc& pInputDesc)
+  : m_Policy(pInputDesc.policy())
+{
+  m_Spec.m_pWildcardFile = pInputDesc.spec().m_pWildcardFile;
+  m_Spec.m_pExcludeFiles = pInputDesc.spec().m_pExcludeFiles;
+  m_Spec.m_pWildcardSections = pInputDesc.spec().m_pWildcardSections;
+  m_pSection = LDSection::Create("", LDFileFormat::Regular, 0, 0);
+  SectionData* sd = SectionData::Create(*m_pSection);
+  m_pSection->setSectionData(sd);
+  new NullFragment(sd);
+  new NullFragment(sd);
+}
+
+//===----------------------------------------------------------------------===//
+// SectionMap::Output
+//===----------------------------------------------------------------------===//
+SectionMap::Output::Output(const std::string& pName)
+  : m_Name(pName),
+    m_Order(UINT_MAX)
+{
+  m_Prolog.m_pVMA = NULL;
+  m_Prolog.m_Type = OutputSectDesc::LOAD;
+  m_Prolog.m_pLMA = NULL;
+  m_Prolog.m_pAlign = NULL;
+  m_Prolog.m_pSubAlign = NULL;
+  m_Prolog.m_Constraint = OutputSectDesc::NO_CONSTRAINT;
+
+  m_Epilog.m_pRegion = NULL;
+  m_Epilog.m_pLMARegion = NULL;
+  m_Epilog.m_pPhdrs = NULL;
+  m_Epilog.m_pFillExp = NULL;
+
+  m_pSection = LDSection::Create(pName, LDFileFormat::Regular, 0, 0);
+  SectionData* sd = SectionData::Create(*m_pSection);
+  m_pSection->setSectionData(sd);
+
+  m_bIsDiscard = pName.compare("/DISCARD/") == 0;
+}
+
+SectionMap::Output::Output(const OutputSectDesc& pOutputDesc)
+  : m_Name(pOutputDesc.name()),
+    m_Prolog(pOutputDesc.prolog()),
+    m_Epilog(pOutputDesc.epilog()),
+    m_Order(UINT_MAX)
+{
+  m_pSection = LDSection::Create(m_Name, LDFileFormat::Regular, 0, 0);
+  SectionData* sd = SectionData::Create(*m_pSection);
+  m_pSection->setSectionData(sd);
+
+  m_bIsDiscard = m_Name.compare("/DISCARD/") == 0;
+}
+
+bool SectionMap::Output::hasContent() const
+{
+  return m_pSection != NULL && m_pSection->size() != 0;
+}
+
+SectionMap::Output::const_dot_iterator
+SectionMap::Output::find_first_explicit_dot() const
+{
+  for (const_dot_iterator it = dot_begin(), ie = dot_end(); it != ie; ++it) {
+    if ((*it).type() == Assignment::DEFAULT)
+      return it;
+  }
+  return dot_end();
+}
+
+SectionMap::Output::dot_iterator SectionMap::Output::find_first_explicit_dot()
+{
+  for (dot_iterator it = dot_begin(), ie = dot_end(); it != ie; ++it) {
+    if ((*it).type() == Assignment::DEFAULT)
+      return it;
+  }
+  return dot_end();
+}
+
+SectionMap::Output::const_dot_iterator
+SectionMap::Output::find_last_explicit_dot() const
+{
+  typedef DotAssignments::const_reverse_iterator CONST_RIT;
+  for (CONST_RIT rit = dotAssignments().rbegin(), rie = dotAssignments().rend();
+    rit != rie; ++rit) {
+    if ((*rit).type() == Assignment::DEFAULT) {
+      return dot_begin() +
+             (dotAssignments().size() - (rit - dotAssignments().rbegin()) - 1);
+    }
+  }
+  return dot_end();
+}
+
+SectionMap::Output::dot_iterator SectionMap::Output::find_last_explicit_dot()
+{
+  typedef DotAssignments::reverse_iterator RIT;
+  for (RIT rit = dotAssignments().rbegin(), rie = dotAssignments().rend();
+    rit != rie; ++rit) {
+    if ((*rit).type() == Assignment::DEFAULT) {
+      return dot_begin() +
+             (dotAssignments().size() - (rit - dotAssignments().rbegin()) - 1);
+    }
+  }
+  return dot_end();
 }
 
 //===----------------------------------------------------------------------===//
 // SectionMap
 //===----------------------------------------------------------------------===//
-const SectionMap::NamePair& SectionMap::find(const std::string& pFrom) const
+SectionMap::~SectionMap()
 {
-  unsigned int hash = SectionMap::hash(pFrom);
-  return find(pFrom, hash);
-}
-
-SectionMap::NamePair& SectionMap::find(const std::string& pFrom)
-{
-  unsigned int hash = SectionMap::hash(pFrom);
-  return find(pFrom, hash);
-}
-
-const SectionMap::NamePair&
-SectionMap::find(const std::string& pFrom, unsigned int pHash) const
-{
-  NamePairList::const_iterator name_hash, nEnd = m_NamePairList.end();
-  for (name_hash = m_NamePairList.begin(); name_hash != nEnd; ++name_hash) {
-    if (matched(*name_hash, pFrom, pHash)) {
-      return *name_hash;
+  iterator out, outBegin = begin(), outEnd = end();
+  for (out = outBegin; out != outEnd; ++out) {
+    if (*out != NULL) {
+      Output::iterator in, inBegin = (*out)->begin(), inEnd = (*out)->end();
+      for (in = inBegin; in != inEnd; ++in) {
+        if (*in != NULL)
+          delete *in;
+      }
+      delete *out;
     }
   }
-  return NullName;
 }
 
-SectionMap::NamePair&
-SectionMap::find(const std::string& pFrom, unsigned int pHash)
+SectionMap::const_mapping
+SectionMap::find(const std::string& pInputFile,
+                 const std::string& pInputSection) const
 {
-  NamePairList::iterator name_hash, nEnd = m_NamePairList.end();
-  for (name_hash = m_NamePairList.begin(); name_hash != nEnd; ++name_hash) {
-    if (matched(*name_hash, pFrom, pHash)) {
-      return *name_hash;
+  const_iterator out, outBegin = begin(), outEnd = end();
+  for (out = outBegin; out != outEnd; ++out) {
+    Output::const_iterator in, inBegin = (*out)->begin(), inEnd = (*out)->end();
+    for (in = inBegin; in != inEnd; ++in) {
+      if (matched(**in, pInputFile, pInputSection))
+        return std::make_pair(*out, *in);
     }
   }
-  return NullName;
+  return std::make_pair((const Output*)NULL, (const Input*)NULL);
 }
 
-SectionMap::NamePair& SectionMap::append(const std::string &pFrom,
-                                         const std::string &pTo,
-                                         bool &pExist)
+SectionMap::mapping SectionMap::find(const std::string& pInputFile,
+                                     const std::string& pInputSection)
 {
-  NamePair& result = find(pFrom);
-  if (!result.isNull()) {
-    pExist = true;
-    return result;
+  iterator out, outBegin = begin(), outEnd = end();
+  for (out = outBegin; out != outEnd; ++out) {
+    Output::iterator in, inBegin = (*out)->begin(), inEnd = (*out)->end();
+    for (in = inBegin; in != inEnd; ++in) {
+      if (matched(**in, pInputFile, pInputSection))
+        return std::make_pair(*out, *in);
+    }
+  }
+  return std::make_pair((Output*)NULL, (Input*)NULL);
+}
+
+SectionMap::const_iterator
+SectionMap::find(const std::string& pOutputSection) const
+{
+  const_iterator out, outBegin = begin(), outEnd = end();
+  for (out = outBegin; out != outEnd; ++out) {
+    if ((*out)->name().compare(pOutputSection) == 0)
+      return out;
+  }
+  return outEnd;
+}
+
+SectionMap::iterator
+SectionMap::find(const std::string& pOutputSection)
+{
+  iterator out, outBegin = begin(), outEnd = end();
+  for (out = outBegin; out != outEnd; ++out) {
+    if ((*out)->name().compare(pOutputSection) == 0)
+      return out;
+  }
+  return outEnd;
+}
+
+std::pair<SectionMap::mapping, bool>
+SectionMap::insert(const std::string& pInputSection,
+                   const std::string& pOutputSection,
+                   InputSectDesc::KeepPolicy pPolicy)
+{
+  iterator out, outBegin = begin(), outEnd = end();
+  for (out = outBegin; out != outEnd; ++out) {
+    if ((*out)->name().compare(pOutputSection) == 0)
+      break;
+  }
+  if (out != end()) {
+    Output::iterator in, inBegin = (*out)->begin(), inEnd = (*out)->end();
+    for (in = inBegin; in != inEnd; ++in) {
+      if ((*in)->getSection()->name().compare(pInputSection) == 0)
+        break;
+    }
+
+    if (in != (*out)->end()) {
+      return std::make_pair(std::make_pair(*out, *in), false);
+    } else {
+      Input* input = new Input(pInputSection, pPolicy);
+      (*out)->append(input);
+      return std::make_pair(std::make_pair(*out, input), true);
+    }
   }
 
-  pExist = false;
-  NamePair entry(pFrom, pTo);
-  m_NamePairList.push_back(entry);
-  return m_NamePairList.back();
+  Output* output = new Output(pOutputSection);
+  m_OutputDescList.push_back(output);
+  Input* input = new Input(pInputSection, pPolicy);
+  output->append(input);
+
+  return std::make_pair(std::make_pair(output, input), true);
 }
 
-bool SectionMap::matched(const NamePair& pNamePair,
-                         const std::string& pInput,
-                         unsigned int pHashValue) const
+std::pair<SectionMap::mapping, bool>
+SectionMap::insert(const InputSectDesc& pInputDesc,
+                   const OutputSectDesc& pOutputDesc)
 {
-  if ('*' == pNamePair.from[0])
-    return true;
+  iterator out, outBegin = begin(), outEnd = end();
+  for (out = outBegin; out != outEnd; ++out) {
+    if ((*out)->name().compare(pOutputDesc.name()) == 0 &&
+        (*out)->prolog() == pOutputDesc.prolog() &&
+        (*out)->epilog() == pOutputDesc.epilog())
+      break;
+  }
 
-  if (pNamePair.from.size() > pInput.size())
-    return false;
+  if (out != end()) {
+    Output::iterator in, inBegin = (*out)->begin(), inEnd = (*out)->end();
+    for (in = inBegin; in != inEnd; ++in) {
+      if ((*in)->policy() == pInputDesc.policy() &&
+          (*in)->spec() == pInputDesc.spec())
+        break;
+    }
 
-  if (!hash::StringHash<hash::ES>::may_include(pNamePair.hash, pHashValue))
-    return false;
+    if (in != (*out)->end()) {
+      return std::make_pair(std::make_pair(*out, *in), false);
+    } else {
+      Input* input = new Input(pInputDesc);
+      (*out)->append(input);
+      return std::make_pair(std::make_pair(*out, input), true);
+    }
+  }
 
-  if (0 == strncmp(pInput.c_str(),
-                   pNamePair.from.c_str(),
-                   pNamePair.from.size())) {
-    return true;
+  Output* output = new Output(pOutputDesc);
+  m_OutputDescList.push_back(output);
+  Input* input = new Input(pInputDesc);
+  output->append(input);
+
+  return std::make_pair(std::make_pair(output, input), true);
+}
+
+SectionMap::iterator
+SectionMap::insert(iterator pPosition, LDSection* pSection)
+{
+  Output* output = new Output(pSection->name());
+  output->append(new Input(pSection->name(), InputSectDesc::NoKeep));
+  output->setSection(pSection);
+  return m_OutputDescList.insert(pPosition, output);
+}
+
+bool SectionMap::matched(const SectionMap::Input& pInput,
+                         const std::string& pInputFile,
+                         const std::string& pInputSection) const
+{
+  if (pInput.spec().hasFile() && !matched(pInput.spec().file(), pInputFile))
+      return false;
+
+  if (pInput.spec().hasExcludeFiles()) {
+    StringList::const_iterator file, fileEnd;
+    fileEnd = pInput.spec().excludeFiles().end();
+    for (file = pInput.spec().excludeFiles().begin(); file != fileEnd; ++file) {
+      if (matched(llvm::cast<WildcardPattern>(**file), pInputFile)) {
+        return false;
+      }
+    }
+  }
+
+  if (pInput.spec().hasSections()) {
+    StringList::const_iterator sect, sectEnd = pInput.spec().sections().end();
+    for (sect = pInput.spec().sections().begin(); sect != sectEnd; ++sect) {
+      if (matched(llvm::cast<WildcardPattern>(**sect), pInputSection)) {
+        return true;
+      }
+    }
   }
 
   return false;
 }
 
-unsigned int SectionMap::hash(const std::string& pString)
+bool SectionMap::matched(const WildcardPattern& pPattern,
+                         const std::string& pName) const
 {
-  static hash::StringHash<hash::ES> hash_func;
-  return hash_func(pString);
+  if (pPattern.isPrefix()) {
+    llvm::StringRef name(pName);
+    return name.startswith(pPattern.prefix());
+  } else {
+    return fnmatch0(pPattern.name().c_str(), pName.c_str());
+  }
 }
 
+// fixupDotSymbols - ensure the dot symbols are valid
+void SectionMap::fixupDotSymbols()
+{
+  for (iterator it = begin() + 1, ie = end(); it != ie; ++it) {
+    // fixup the 1st explicit dot assignment if needed
+    if (!(*it)->dotAssignments().empty()) {
+      Output::dot_iterator dot = (*it)->find_first_explicit_dot();
+      if (dot != (*it)->dot_end() &&
+          (*dot).symbol().isDot() &&
+          (*dot).getRpnExpr().hasDot()) {
+        Assignment assign(Assignment::OUTPUT_SECTION,
+                          Assignment::DEFAULT,
+                          *SymOperand::create("."),
+                          *RpnExpr::buildHelperExpr(it - 1));
+        Output::dot_iterator ref = (*it)->dotAssignments().insert(dot, assign);
+        for (RpnExpr::iterator tok = (*dot).getRpnExpr().begin(),
+          tokEnd = (*dot).getRpnExpr().end();  tok != tokEnd; ++tok) {
+          if ((*tok)->kind() == ExprToken::OPERAND &&
+              llvm::cast<Operand>(*tok)->isDot())
+            *tok = &((*ref).symbol());
+        } // for each token in the RHS expr of the dot assignment
+      }
+    }
+
+    // fixup dot in output VMA if needed
+    if ((*it)->prolog().hasVMA() && (*it)->prolog().vma().hasDot()) {
+      Output::dot_iterator dot = (*it)->find_last_explicit_dot();
+      if (dot == (*it)->dot_end()) {
+        Assignment assign(Assignment::OUTPUT_SECTION,
+                          Assignment::DEFAULT,
+                          *SymOperand::create("."),
+                          *RpnExpr::buildHelperExpr(it - 1));
+        dot = (*it)->dotAssignments().insert(dot, assign);
+      }
+      for (RpnExpr::iterator tok = (*it)->prolog().vma().begin(),
+        tokEnd = (*it)->prolog().vma().end();  tok != tokEnd; ++tok) {
+        if ((*tok)->kind() == ExprToken::OPERAND &&
+            llvm::cast<Operand>(*tok)->isDot())
+          *tok = &((*dot).symbol());
+      } // for each token in the RHS expr of the dot assignment
+    }
+
+  } // for each output section
+}
diff --git a/lib/Script/AssertCmd.cpp b/lib/Script/AssertCmd.cpp
new file mode 100644
index 0000000..618731d
--- /dev/null
+++ b/lib/Script/AssertCmd.cpp
@@ -0,0 +1,48 @@
+//===- AssertCmd.cpp ------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/AssertCmd.h>
+#include <mcld/Script/RpnExpr.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/Module.h>
+#include <mcld/LinkerScript.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// AssertCmd
+//===----------------------------------------------------------------------===//
+AssertCmd::AssertCmd(RpnExpr& pRpnExpr, const std::string& pMessage)
+  : ScriptCommand(ScriptCommand::ASSERT),
+    m_RpnExpr(pRpnExpr),
+    m_Message(pMessage)
+{
+}
+
+AssertCmd::~AssertCmd()
+{
+}
+
+AssertCmd& AssertCmd::operator=(const AssertCmd& pAssertCmd)
+{
+  return *this;
+}
+
+void AssertCmd::dump() const
+{
+  mcld::outs() << "Assert ( ";
+
+  m_RpnExpr.dump();
+
+  mcld::outs() << " , " << m_Message << " )\n";
+}
+
+void AssertCmd::activate(Module& pModule)
+{
+  pModule.getScript().assertions().push_back(*this);
+}
diff --git a/lib/Script/Assignment.cpp b/lib/Script/Assignment.cpp
new file mode 100644
index 0000000..a7e0f46
--- /dev/null
+++ b/lib/Script/Assignment.cpp
@@ -0,0 +1,175 @@
+//===- Assignment.cpp -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/Assignment.h>
+#include <mcld/Script/RpnExpr.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Script/Operator.h>
+#include <mcld/Script/RpnEvaluator.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/Module.h>
+#include <llvm/Support/Casting.h>
+#include <cassert>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// Assignment
+//===----------------------------------------------------------------------===//
+Assignment::Assignment(Level pLevel,
+                       Type pType,
+                       SymOperand& pSymbol,
+                       RpnExpr& pRpnExpr)
+  : ScriptCommand(ScriptCommand::ASSIGNMENT),
+    m_Level(pLevel),
+    m_Type(pType),
+    m_Symbol(pSymbol),
+    m_RpnExpr(pRpnExpr)
+{
+}
+
+Assignment::~Assignment()
+{
+}
+
+Assignment& Assignment::operator=(const Assignment& pAssignment)
+{
+  return *this;
+}
+
+void Assignment::dump() const
+{
+  switch (type()) {
+  case DEFAULT:
+    break;
+  case HIDDEN:
+    mcld::outs() << "HIDDEN ( ";
+    break;
+  case PROVIDE:
+    mcld::outs() << "PROVIDE ( ";
+    break;
+  case PROVIDE_HIDDEN:
+    mcld::outs() << "PROVIDE_HIDDEN ( ";
+    break;
+  default:
+    break;
+  }
+
+  m_Symbol.dump();
+
+  mcld::outs() << " = ";
+
+  m_RpnExpr.dump();
+
+  if (type() != DEFAULT)
+    mcld::outs() << " )";
+
+  mcld::outs() << ";\n";
+}
+
+void Assignment::activate(Module& pModule)
+{
+  bool isLhsDot = m_Symbol.isDot();
+  LinkerScript& script = pModule.getScript();
+  switch (m_Level) {
+  case OUTSIDE_SECTIONS:
+    assert(!isLhsDot);
+    script.assignments().push_back(std::make_pair((LDSymbol*)NULL, *this));
+    break;
+
+  case OUTPUT_SECTION: {
+    bool hasDotInRhs = m_RpnExpr.hasDot();
+    SectionMap::reference out = script.sectionMap().back();
+    if (hasDotInRhs) {
+      if (!isLhsDot && out->dotAssignments().empty()) {
+        // . = ADDR ( `prev_output_sect' ) + SIZEOF ( `prev_output_sect' )
+        SectionMap::iterator prev = script.sectionMap().begin() +
+                                    script.sectionMap().size() - 2;
+        Assignment assign(OUTPUT_SECTION,
+                          HIDDEN,
+                          *SymOperand::create("."),
+                          *RpnExpr::buildHelperExpr(prev));
+        out->dotAssignments().push_back(assign);
+      }
+
+      if (!out->dotAssignments().empty()) {
+        Assignment& prevDotAssign = out->dotAssignments().back();
+        // If this is the 1st explicit assignment that includes both lhs dot and
+        // rhs dot, then because of possible orphan sections, we are unable to
+        // substitute the rhs dot now.
+        if (!isLhsDot || prevDotAssign.type() == DEFAULT) {
+          for (RpnExpr::iterator it = m_RpnExpr.begin(), ie = m_RpnExpr.end();
+            it != ie; ++it) {
+            // substitute the rhs dot with the appropriate helper expr
+            if ((*it)->kind() == ExprToken::OPERAND &&
+                llvm::cast<Operand>(*it)->isDot())
+              *it = &(prevDotAssign.symbol());
+          } // for each expression token
+        }
+      }
+    }
+
+    if (isLhsDot) {
+      out->dotAssignments().push_back(*this);
+    } else {
+      script.assignments().push_back(std::make_pair((LDSymbol*)NULL, *this));
+    }
+
+    break;
+  }
+
+  case INPUT_SECTION: {
+    bool hasDotInRhs = m_RpnExpr.hasDot();
+    SectionMap::Output::reference in = script.sectionMap().back()->back();
+    if (hasDotInRhs) {
+      if (in->dotAssignments().empty()) {
+        // . = `frag'
+        RpnExpr* expr =
+          RpnExpr::buildHelperExpr(in->getSection()->getSectionData()->front());
+        Assignment assign(INPUT_SECTION,
+                          HIDDEN,
+                          *SymOperand::create("."),
+                          *expr);
+        in->dotAssignments().push_back(std::make_pair((Fragment*)NULL, assign));
+      }
+
+      Assignment& prevDotAssign = in->dotAssignments().back().second;
+      for (RpnExpr::iterator it = m_RpnExpr.begin(), ie = m_RpnExpr.end();
+        it != ie; ++it) {
+        // substitute the rhs dot with the appropriate helper expr
+        if ((*it)->kind() == ExprToken::OPERAND &&
+            llvm::cast<Operand>(*it)->isDot())
+          *it = &(prevDotAssign.symbol());
+      } // end of for
+    }
+
+    if (isLhsDot) {
+      in->dotAssignments().push_back(
+        std::make_pair(in->getSection()->getSectionData()->front().getNextNode(),
+                       *this));
+    } else {
+      script.assignments().push_back(std::make_pair((LDSymbol*)NULL, *this));
+    }
+
+    break;
+  }
+
+  } // end of switch
+}
+
+bool Assignment::assign(RpnEvaluator& pEvaluator)
+{
+  uint64_t result = 0;
+  bool success = pEvaluator.eval(m_RpnExpr, result);
+  if (success)
+    m_Symbol.setValue(result);
+  return success;
+}
diff --git a/lib/Script/BinaryOp.cpp b/lib/Script/BinaryOp.cpp
new file mode 100644
index 0000000..863eb34
--- /dev/null
+++ b/lib/Script/BinaryOp.cpp
@@ -0,0 +1,268 @@
+//===- BinaryOp.cpp -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/BinaryOp.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/ADT/SizeTraits.h>
+#include <mcld/Module.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/Target/TargetLDBackend.h>
+#include <llvm/Support/Casting.h>
+#include <cassert>
+
+using namespace mcld;
+//===----------------------------------------------------------------------===//
+// BinaryOp
+//===----------------------------------------------------------------------===//
+template<>
+IntOperand* BinaryOp<Operator::MUL>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() * m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::DIV>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() / m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::MOD>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() % m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::ADD>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() + m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::SUB>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() - m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::LSHIFT>::eval(const Module& pModule,
+                                             const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() << m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::RSHIFT>::eval(const Module& pModule,
+                                             const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() >> m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::LT>::eval(const Module& pModule,
+                                         const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() < m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::LE>::eval(const Module& pModule,
+                                         const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() <= m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::GT>::eval(const Module& pModule,
+                                         const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() > m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::GE>::eval(const Module& pModule,
+                                         const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() >= m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::EQ>::eval(const Module& pModule,
+                                         const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() == m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::NE>::eval(const Module& pModule,
+                                         const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() != m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand*
+BinaryOp<Operator::BITWISE_AND>::eval(const Module& pModule,
+                                      const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() & m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand*
+BinaryOp<Operator::BITWISE_XOR>::eval(const Module& pModule,
+                                      const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() ^ m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand*
+BinaryOp<Operator::BITWISE_OR>::eval(const Module& pModule,
+                                     const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() | m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand*
+BinaryOp<Operator::LOGICAL_AND>::eval(const Module& pModule,
+                                      const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() && m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand*
+BinaryOp<Operator::LOGICAL_OR>::eval(const Module& pModule,
+                                     const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand[0]->value() || m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::ALIGN>::eval(const Module& pModule,
+                                            const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  uint64_t value = m_pOperand[0]->value();
+  uint64_t align = m_pOperand[1]->value();
+  alignAddress(value, align);
+  res->setValue(value);
+  return res;
+}
+
+template<>
+IntOperand*
+BinaryOp<Operator::DATA_SEGMENT_RELRO_END>::eval(const Module& pModule,
+  const TargetLDBackend& pBackend)
+{
+  /* FIXME: Currently we handle relro in a different way, and now the result
+     of this expression won't affect DATA_SEGMENT_ALIGN. */
+  IntOperand* res = result();
+  uint64_t value = m_pOperand[0]->value() + m_pOperand[1]->value();
+  alignAddress(value, pBackend.commonPageSize());
+  res->setValue(value);
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::MAX>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  if (m_pOperand[0]->value() >= m_pOperand[1]->value())
+    res->setValue(m_pOperand[0]->value());
+  else
+    res->setValue(m_pOperand[1]->value());
+  return res;
+}
+
+template<>
+IntOperand* BinaryOp<Operator::MIN>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  if (m_pOperand[0]->value() <= m_pOperand[1]->value())
+    res->setValue(m_pOperand[0]->value());
+  else
+    res->setValue(m_pOperand[1]->value());
+  return res;
+}
+
+
+/* SEGMENT_START(segment, default) */
+template<>
+IntOperand*
+BinaryOp<Operator::SEGMENT_START>::eval(const Module& pModule,
+                                        const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  /* Currently we look up segment address from -T command line options. */
+  SectOperand* sect = llvm::cast<SectOperand>(m_pOperand[0]);
+  const LinkerScript::AddressMap& addressMap =
+    pModule.getScript().addressMap();
+  LinkerScript::AddressMap::const_iterator addr;
+  if (sect->name().compare("text-segment") == 0)
+    addr = addressMap.find(".text");
+  else if (sect->name().compare("data-segment") == 0)
+    addr = addressMap.find(".data");
+  else if (sect->name().compare("bss-segment") == 0)
+    addr = addressMap.find(".bss");
+  else
+    addr = addressMap.find(sect->name());
+
+  if (addr != addressMap.end())
+    res->setValue(addr.getEntry()->value());
+  else {
+    assert(m_pOperand[1]->type() == Operand::INTEGER);
+    res->setValue(m_pOperand[1]->value());
+  }
+  return res;
+}
diff --git a/lib/Script/CMakeLists.txt b/lib/Script/CMakeLists.txt
new file mode 100644
index 0000000..6fed079
--- /dev/null
+++ b/lib/Script/CMakeLists.txt
@@ -0,0 +1,40 @@
+# flex+bison settings
+find_package(BISON)
+find_package(FLEX)
+BISON_TARGET(PARSER ScriptParser.yy ${CMAKE_CURRENT_BINARY_DIR}/ScriptParser.cpp)
+FLEX_TARGET(LEXER ScriptScanner.ll ${CMAKE_CURRENT_BINARY_DIR}/ScriptScanner.cpp)
+ADD_FLEX_BISON_DEPENDENCY(LEXER PARSER)
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+
+add_mcld_library(MCLDScript
+  AssertCmd.cpp
+  Assignment.cpp
+  BinaryOp.cpp
+  EntryCmd.cpp
+  FileToken.cpp
+  GroupCmd.cpp
+  InputSectDesc.cpp
+  InputToken.cpp
+  NameSpec.cpp
+  NullaryOp.cpp
+  Operand.cpp
+  Operator.cpp
+  OutputArchCmd.cpp
+  OutputCmd.cpp
+  OutputFormatCmd.cpp
+  OutputSectDesc.cpp
+  RpnEvaluator.cpp
+  RpnExpr.cpp
+  ScriptCommand.cpp
+  ScriptFile.cpp
+  ScriptReader.cpp
+  SearchDirCmd.cpp
+  SectionsCmd.cpp
+  StrToken.cpp
+  StringList.cpp
+  TernaryOp.cpp
+  UnaryOp.cpp
+  WildcardPattern.cpp
+  ${BISON_PARSER_OUTPUTS}
+  ${FLEX_LEXER_OUTPUTS}
+  )
diff --git a/lib/Script/EntryCmd.cpp b/lib/Script/EntryCmd.cpp
new file mode 100644
index 0000000..9e33c53
--- /dev/null
+++ b/lib/Script/EntryCmd.cpp
@@ -0,0 +1,40 @@
+//===- EntryCmd.cpp -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/EntryCmd.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/Module.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// EntryCmd
+//===----------------------------------------------------------------------===//
+EntryCmd::EntryCmd(const std::string& pEntry)
+  : ScriptCommand(ScriptCommand::ENTRY),
+    m_Entry(pEntry)
+{
+}
+
+EntryCmd::~EntryCmd()
+{
+}
+
+void EntryCmd::dump() const
+{
+  mcld::outs() << "ENTRY ( " << m_Entry << " )\n";
+}
+
+void EntryCmd::activate(Module& pModule)
+{
+  LinkerScript& script = pModule.getScript();
+  if (!script.hasEntry())
+    script.setEntry(m_Entry);
+}
+
diff --git a/lib/Script/FileToken.cpp b/lib/Script/FileToken.cpp
new file mode 100644
index 0000000..2247d6e
--- /dev/null
+++ b/lib/Script/FileToken.cpp
@@ -0,0 +1,51 @@
+//===- FileToken.cpp ------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/FileToken.h>
+#include <mcld/Support/GCFactory.h>
+#include <llvm/Support/ManagedStatic.h>
+
+using namespace mcld;
+
+typedef GCFactory<FileToken, MCLD_SYMBOLS_PER_INPUT> FileTokenFactory;
+static llvm::ManagedStatic<FileTokenFactory> g_FileTokenFactory;
+
+//===----------------------------------------------------------------------===//
+// FileToken
+//===----------------------------------------------------------------------===//
+FileToken::FileToken()
+{
+}
+
+FileToken::FileToken(const std::string& pName, bool pAsNeeded)
+  : InputToken(InputToken::File, pName, pAsNeeded)
+{
+}
+
+FileToken::~FileToken()
+{
+}
+
+FileToken* FileToken::create(const std::string& pName, bool pAsNeeded)
+{
+  FileToken* result = g_FileTokenFactory->allocate();
+  new (result) FileToken(pName, pAsNeeded);
+  return result;
+}
+
+void FileToken::destroy(FileToken*& pFileToken)
+{
+  g_FileTokenFactory->destroy(pFileToken);
+  g_FileTokenFactory->deallocate(pFileToken);
+  pFileToken = NULL;
+}
+
+void FileToken::clear()
+{
+  g_FileTokenFactory->clear();
+}
diff --git a/lib/Script/GroupCmd.cpp b/lib/Script/GroupCmd.cpp
new file mode 100644
index 0000000..4673242
--- /dev/null
+++ b/lib/Script/GroupCmd.cpp
@@ -0,0 +1,165 @@
+//===- GroupCmd.cpp -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/GroupCmd.h>
+#include <mcld/Script/StringList.h>
+#include <mcld/Script/InputToken.h>
+#include <mcld/MC/InputBuilder.h>
+#include <mcld/MC/Attribute.h>
+#include <mcld/Support/Path.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/Support/MsgHandling.h>
+#include <mcld/InputTree.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/LD/GroupReader.h>
+#include <llvm/Support/Casting.h>
+#include <cassert>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// GroupCmd
+//===----------------------------------------------------------------------===//
+GroupCmd::GroupCmd(StringList& pStringList,
+                   InputTree& pInputTree,
+                   InputBuilder& pBuilder,
+                   GroupReader& pGroupReader,
+                   const LinkerConfig& pConfig)
+  : ScriptCommand(ScriptCommand::GROUP),
+    m_StringList(pStringList),
+    m_InputTree(pInputTree),
+    m_Builder(pBuilder),
+    m_GroupReader(pGroupReader),
+    m_Config(pConfig)
+{
+}
+
+GroupCmd::~GroupCmd()
+{
+}
+
+void GroupCmd::dump() const
+{
+  mcld::outs() << "GROUP ( ";
+  bool prev = false, cur = false;
+  for (StringList::const_iterator it = m_StringList.begin(),
+    ie = m_StringList.end(); it != ie; ++it) {
+    assert((*it)->kind() == StrToken::Input);
+    InputToken* input = llvm::cast<InputToken>(*it);
+    cur = input->asNeeded();
+    if (!prev && cur)
+      mcld::outs() << "AS_NEEDED ( ";
+    else if (prev && !cur)
+      mcld::outs() << " )";
+
+    if (input->type() == InputToken::NameSpec)
+      mcld::outs() << "-l";
+    mcld::outs() << input->name() << " ";
+
+    prev = cur;
+  }
+
+  if (!m_StringList.empty() && prev)
+    mcld::outs() << " )";
+
+  mcld::outs() << " )\n";
+}
+
+void GroupCmd::activate(Module& pModule)
+{
+  LinkerScript& script = pModule.getScript();
+  // construct the Group tree
+  m_Builder.setCurrentTree(m_InputTree);
+  // --start-group
+  m_Builder.enterGroup();
+  InputTree::iterator group = m_Builder.getCurrentNode();
+
+  for (StringList::const_iterator it = m_StringList.begin(),
+    ie = m_StringList.end(); it != ie; ++it) {
+
+    assert((*it)->kind() == StrToken::Input);
+    InputToken* token = llvm::cast<InputToken>(*it);
+    if (token->asNeeded())
+      m_Builder.getAttributes().setAsNeeded();
+    else
+      m_Builder.getAttributes().unsetAsNeeded();
+
+    switch (token->type()) {
+    case InputToken::File: {
+      sys::fs::Path path;
+
+      // 1. Looking for file in the sysroot prefix, if a sysroot prefix is
+      // configured and the filename starts with '/'
+      if (script.hasSysroot() &&
+          (token->name().size() > 0 && token->name()[0] == '/')) {
+          path = script.sysroot();
+          path.append(token->name());
+      } else {
+        // 2. Try to open the file in CWD
+        path.assign(token->name());
+        if (!sys::fs::exists(path)) {
+          // 3. Search through the library search path
+          sys::fs::Path* p =
+            script.directories().find(token->name(), Input::Script);
+          if (p != NULL)
+            path = *p;
+        }
+      }
+
+      if (!sys::fs::exists(path))
+        fatal(diag::err_cannot_open_input) << path.filename() << path;
+
+      m_Builder.createNode<InputTree::Positional>(
+        path.filename().native(), path, Input::Unknown);
+      break;
+    }
+    case InputToken::NameSpec: {
+      const sys::fs::Path* path = NULL;
+      // find out the real path of the namespec.
+      if (m_Builder.getConstraint().isSharedSystem()) {
+        // In the system with shared object support, we can find both archive
+        // and shared object.
+        if (m_Builder.getAttributes().isStatic()) {
+          // with --static, we must search an archive.
+          path = script.directories().find(token->name(), Input::Archive);
+        } else {
+          // otherwise, with --Bdynamic, we can find either an archive or a
+          // shared object.
+          path = script.directories().find(token->name(), Input::DynObj);
+        }
+      } else {
+        // In the system without shared object support, only look for an archive
+        path = script.directories().find(token->name(), Input::Archive);
+      }
+
+      if (NULL == path)
+        fatal(diag::err_cannot_find_namespec) << token->name();
+
+      m_Builder.createNode<InputTree::Positional>(
+        token->name(), *path, Input::Unknown);
+      break;
+    }
+    default:
+      assert(0 && "Invalid script token in GROUP!");
+      break;
+    } // end of switch
+
+    Input* input = *m_Builder.getCurrentNode();
+    assert(input != NULL);
+    if (!m_Builder.setMemory(*input, FileHandle::ReadOnly))
+      error(diag::err_cannot_open_input) << input->name() << input->path();
+    m_Builder.setContext(*input);
+  }
+
+  // --end-group
+  m_Builder.exitGroup();
+
+  // read the group
+  m_GroupReader.readGroup(group, m_InputTree.end(), m_Builder, m_Config);
+}
+
diff --git a/lib/Script/InputSectDesc.cpp b/lib/Script/InputSectDesc.cpp
new file mode 100644
index 0000000..842b720
--- /dev/null
+++ b/lib/Script/InputSectDesc.cpp
@@ -0,0 +1,102 @@
+//===- InputSectDesc.cpp --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/InputSectDesc.h>
+#include <mcld/Script/WildcardPattern.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/Module.h>
+#include <llvm/Support/Casting.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// InputSectDesc
+//===----------------------------------------------------------------------===//
+InputSectDesc::InputSectDesc(KeepPolicy pPolicy,
+                             const Spec& pSpec,
+                             const OutputSectDesc& pOutputDesc)
+  : ScriptCommand(ScriptCommand::INPUT_SECT_DESC),
+    m_KeepPolicy(pPolicy),
+    m_Spec(pSpec),
+    m_OutputSectDesc(pOutputDesc)
+{
+}
+
+InputSectDesc::~InputSectDesc()
+{
+}
+
+void InputSectDesc::dump() const
+{
+  if (m_KeepPolicy == Keep)
+    mcld::outs() << "KEEP (";
+
+  assert (m_Spec.hasFile());
+  if (m_Spec.file().sortPolicy() == WildcardPattern::SORT_BY_NAME)
+    mcld::outs() << "SORT (";
+
+  mcld::outs() << m_Spec.file().name();
+
+  if (m_Spec.hasSections()) {
+    mcld::outs() << "(";
+
+    if (m_Spec.hasExcludeFiles()) {
+      mcld::outs() << "EXCLUDE_FILE (";
+      for (StringList::const_iterator it = m_Spec.excludeFiles().begin(),
+        ie = m_Spec.excludeFiles().end(); it != ie; ++it) {
+        mcld::outs() << (*it)->name() << " ";
+      }
+      mcld::outs() << ")";
+    }
+
+    if (m_Spec.hasSections()) {
+      for (StringList::const_iterator it = m_Spec.sections().begin(),
+        ie = m_Spec.sections().end(); it != ie; ++it) {
+        assert((*it)->kind() == StrToken::Wildcard);
+        WildcardPattern* wildcard = llvm::cast<WildcardPattern>(*it);
+
+        switch (wildcard->sortPolicy()) {
+        case WildcardPattern::SORT_BY_NAME:
+          mcld::outs() << "SORT (";
+          break;
+        case WildcardPattern::SORT_BY_ALIGNMENT:
+          mcld::outs() << "SORT_BY_ALIGNMENT (";
+          break;
+        case WildcardPattern::SORT_BY_NAME_ALIGNMENT:
+          mcld::outs() << "SORT_BY_NAME_ALIGNMENT (";
+          break;
+        case WildcardPattern::SORT_BY_ALIGNMENT_NAME:
+          mcld::outs() << "SORT_BY_ALIGNMENT_NAME (";
+          break;
+        default:
+          break;
+        }
+
+        mcld::outs() << wildcard->name() << " ";
+
+        if (wildcard->sortPolicy() != WildcardPattern::SORT_NONE)
+          mcld::outs() << ")";
+      }
+    }
+    mcld::outs() << ")";
+  }
+
+  if (m_Spec.file().sortPolicy() == WildcardPattern::SORT_BY_NAME)
+    mcld::outs() << ")";
+
+  if (m_KeepPolicy == Keep)
+    mcld::outs() << ")";
+
+  mcld::outs() << "\n";
+}
+
+void InputSectDesc::activate(Module& pModule)
+{
+  pModule.getScript().sectionMap().insert(*this, m_OutputSectDesc);
+}
diff --git a/lib/Script/InputToken.cpp b/lib/Script/InputToken.cpp
new file mode 100644
index 0000000..45b006a
--- /dev/null
+++ b/lib/Script/InputToken.cpp
@@ -0,0 +1,28 @@
+//===- InputToken.cpp -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/InputToken.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// InputToken
+//===----------------------------------------------------------------------===//
+InputToken::InputToken()
+  : m_Type(Unknown), m_bAsNeeded(false)
+{
+}
+
+InputToken::InputToken(Type pType, const std::string& pName, bool pAsNeeded)
+  : StrToken(StrToken::Input, pName), m_Type(pType), m_bAsNeeded(pAsNeeded)
+{
+}
+
+InputToken::~InputToken()
+{
+}
diff --git a/lib/Script/NameSpec.cpp b/lib/Script/NameSpec.cpp
new file mode 100644
index 0000000..da7a62c
--- /dev/null
+++ b/lib/Script/NameSpec.cpp
@@ -0,0 +1,51 @@
+//===- NameSpec.cpp -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/NameSpec.h>
+#include <mcld/Support/GCFactory.h>
+#include <llvm/Support/ManagedStatic.h>
+
+using namespace mcld;
+
+typedef GCFactory<NameSpec, MCLD_SYMBOLS_PER_INPUT> NameSpecFactory;
+static llvm::ManagedStatic<NameSpecFactory> g_NameSpecFactory;
+
+//===----------------------------------------------------------------------===//
+// NameSpec
+//===----------------------------------------------------------------------===//
+NameSpec::NameSpec()
+{
+}
+
+NameSpec::NameSpec(const std::string& pName, bool pAsNeeded)
+  : InputToken(InputToken::NameSpec, pName, pAsNeeded)
+{
+}
+
+NameSpec::~NameSpec()
+{
+}
+
+NameSpec* NameSpec::create(const std::string& pName, bool pAsNeeded)
+{
+  NameSpec* result = g_NameSpecFactory->allocate();
+  new (result) NameSpec(pName, pAsNeeded);
+  return result;
+}
+
+void NameSpec::destroy(NameSpec*& pNameSpec)
+{
+  g_NameSpecFactory->destroy(pNameSpec);
+  g_NameSpecFactory->deallocate(pNameSpec);
+  pNameSpec = NULL;
+}
+
+void NameSpec::clear()
+{
+  g_NameSpecFactory->clear();
+}
diff --git a/lib/Script/NullaryOp.cpp b/lib/Script/NullaryOp.cpp
new file mode 100644
index 0000000..69382ec
--- /dev/null
+++ b/lib/Script/NullaryOp.cpp
@@ -0,0 +1,45 @@
+//===- NullaryOp.cpp ------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/NullaryOp.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Target/TargetLDBackend.h>
+
+using namespace mcld;
+//===----------------------------------------------------------------------===//
+// NullaryOp
+//===----------------------------------------------------------------------===//
+template<>
+IntOperand*
+NullaryOp<Operator::SIZEOF_HEADERS>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(pBackend.sectionStartOffset());
+  return res;
+}
+
+template<>
+IntOperand*
+NullaryOp<Operator::MAXPAGESIZE>::eval(const Module& pModule,
+                                       const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(pBackend.abiPageSize());
+  return res;
+}
+
+template<>
+IntOperand*
+NullaryOp<Operator::COMMONPAGESIZE>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(pBackend.commonPageSize());
+  return res;
+}
diff --git a/lib/Script/Operand.cpp b/lib/Script/Operand.cpp
new file mode 100644
index 0000000..690ba9b
--- /dev/null
+++ b/lib/Script/Operand.cpp
@@ -0,0 +1,241 @@
+//===- Operand.cpp --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/Operand.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/Support/GCFactory.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/Fragment/Fragment.h>
+#include <llvm/Support/ManagedStatic.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// Operand
+//===----------------------------------------------------------------------===//
+Operand::Operand(Type pType)
+  : ExprToken(ExprToken::OPERAND), m_Type(pType)
+{
+}
+
+Operand::~Operand()
+{
+}
+
+//===----------------------------------------------------------------------===//
+// SymOperand
+//===----------------------------------------------------------------------===//
+typedef GCFactory<SymOperand, MCLD_SYMBOLS_PER_INPUT> SymOperandFactory;
+static llvm::ManagedStatic<SymOperandFactory> g_SymOperandFactory;
+
+SymOperand::SymOperand()
+  : Operand(Operand::SYMBOL), m_Value(0)
+{
+}
+
+SymOperand::SymOperand(const std::string& pName)
+  : Operand(Operand::SYMBOL), m_Name(pName), m_Value(0)
+{
+}
+
+void SymOperand::dump() const
+{
+  mcld::outs() << m_Name;
+}
+
+bool SymOperand::isDot() const
+{
+  assert(!m_Name.empty());
+  return m_Name.size() == 1 && m_Name[0] == '.';
+}
+
+SymOperand* SymOperand::create(const std::string& pName)
+{
+  SymOperand* result = g_SymOperandFactory->allocate();
+  new (result) SymOperand(pName);
+  return result;
+}
+
+void SymOperand::destroy(SymOperand*& pOperand)
+{
+  g_SymOperandFactory->destroy(pOperand);
+  g_SymOperandFactory->deallocate(pOperand);
+  pOperand = NULL;
+}
+
+void SymOperand::clear()
+{
+  g_SymOperandFactory->clear();
+}
+
+//===----------------------------------------------------------------------===//
+// IntOperand
+//===----------------------------------------------------------------------===//
+typedef GCFactory<IntOperand, MCLD_SYMBOLS_PER_INPUT> IntOperandFactory;
+static llvm::ManagedStatic<IntOperandFactory> g_IntOperandFactory;
+
+IntOperand::IntOperand()
+  : Operand(Operand::INTEGER), m_Value(0)
+{
+}
+
+IntOperand::IntOperand(uint64_t pValue)
+  : Operand(Operand::INTEGER), m_Value(pValue)
+{
+}
+
+void IntOperand::dump() const
+{
+  mcld::outs() << m_Value;
+}
+
+IntOperand* IntOperand::create(uint64_t pValue)
+{
+  IntOperand* result = g_IntOperandFactory->allocate();
+  new (result) IntOperand(pValue);
+  return result;
+}
+
+void IntOperand::destroy(IntOperand*& pOperand)
+{
+  g_IntOperandFactory->destroy(pOperand);
+  g_IntOperandFactory->deallocate(pOperand);
+  pOperand = NULL;
+}
+
+void IntOperand::clear()
+{
+  g_IntOperandFactory->clear();
+}
+
+//===----------------------------------------------------------------------===//
+// SectOperand
+//===----------------------------------------------------------------------===//
+typedef GCFactory<SectOperand, MCLD_SECTIONS_PER_INPUT> SectOperandFactory;
+static llvm::ManagedStatic<SectOperandFactory> g_SectOperandFactory;
+SectOperand::SectOperand()
+  : Operand(Operand::SECTION)
+{
+}
+
+SectOperand::SectOperand(const std::string& pName)
+  : Operand(Operand::SECTION), m_Name(pName)
+{
+}
+
+void SectOperand::dump() const
+{
+  mcld::outs() << m_Name;
+}
+
+SectOperand* SectOperand::create(const std::string& pName)
+{
+  SectOperand* result = g_SectOperandFactory->allocate();
+  new (result) SectOperand(pName);
+  return result;
+}
+
+void SectOperand::destroy(SectOperand*& pOperand)
+{
+  g_SectOperandFactory->destroy(pOperand);
+  g_SectOperandFactory->deallocate(pOperand);
+  pOperand = NULL;
+}
+
+void SectOperand::clear()
+{
+  g_SectOperandFactory->clear();
+}
+
+//===----------------------------------------------------------------------===//
+// SectDescOperand
+//===----------------------------------------------------------------------===//
+typedef GCFactory<SectDescOperand,
+                  MCLD_SECTIONS_PER_INPUT> SectDescOperandFactory;
+static llvm::ManagedStatic<SectDescOperandFactory> g_SectDescOperandFactory;
+SectDescOperand::SectDescOperand()
+  : Operand(Operand::SECTION_DESC), m_pOutputDesc(NULL)
+{
+}
+
+SectDescOperand::SectDescOperand(const SectionMap::Output* pOutputDesc)
+  : Operand(Operand::SECTION_DESC), m_pOutputDesc(pOutputDesc)
+{
+}
+
+void SectDescOperand::dump() const
+{
+  assert(m_pOutputDesc != NULL);
+  mcld::outs() << m_pOutputDesc->getSection()->name();
+}
+
+SectDescOperand* SectDescOperand::create(const SectionMap::Output* pOutputDesc)
+{
+  SectDescOperand* result = g_SectDescOperandFactory->allocate();
+  new (result) SectDescOperand(pOutputDesc);
+  return result;
+}
+
+void SectDescOperand::destroy(SectDescOperand*& pOperand)
+{
+  g_SectDescOperandFactory->destroy(pOperand);
+  g_SectDescOperandFactory->deallocate(pOperand);
+  pOperand = NULL;
+}
+
+void SectDescOperand::clear()
+{
+  g_SectDescOperandFactory->clear();
+}
+
+//===----------------------------------------------------------------------===//
+// FragOperand
+//===----------------------------------------------------------------------===//
+typedef GCFactory<FragOperand, MCLD_SYMBOLS_PER_INPUT> FragOperandFactory;
+static llvm::ManagedStatic<FragOperandFactory> g_FragOperandFactory;
+
+FragOperand::FragOperand()
+  : Operand(Operand::FRAGMENT), m_pFragment(NULL)
+{
+}
+
+FragOperand::FragOperand(Fragment& pFragment)
+  : Operand(Operand::FRAGMENT), m_pFragment(&pFragment)
+{
+}
+
+void FragOperand::dump() const
+{
+  mcld::outs() << "fragment";
+}
+
+uint64_t FragOperand::value() const
+{
+  return m_pFragment->getOffset() +
+         m_pFragment->getParent()->getSection().addr();
+}
+
+FragOperand* FragOperand::create(Fragment& pFragment)
+{
+  FragOperand* result = g_FragOperandFactory->allocate();
+  new (result) FragOperand(pFragment);
+  return result;
+}
+
+void FragOperand::destroy(FragOperand*& pOperand)
+{
+  g_FragOperandFactory->destroy(pOperand);
+  g_FragOperandFactory->deallocate(pOperand);
+  pOperand = NULL;
+}
+
+void FragOperand::clear()
+{
+  g_FragOperandFactory->clear();
+}
diff --git a/lib/Script/Operator.cpp b/lib/Script/Operator.cpp
new file mode 100644
index 0000000..e50a255
--- /dev/null
+++ b/lib/Script/Operator.cpp
@@ -0,0 +1,390 @@
+//===- Operator.cpp -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/Operator.h>
+#include <mcld/Script/NullaryOp.h>
+#include <mcld/Script/UnaryOp.h>
+#include <mcld/Script/BinaryOp.h>
+#include <mcld/Script/TernaryOp.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Support/raw_ostream.h>
+
+using namespace mcld;
+//===----------------------------------------------------------------------===//
+// Operator
+//===----------------------------------------------------------------------===//
+const char* Operator::OpNames[] = {
+  "+",
+  "-",
+  "!",
+  "~",
+  "*",
+  "/",
+  "%",
+  "+",
+  "-",
+  "<<",
+  ">>",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "==",
+  "!=",
+  "&",
+  "^",
+  "|",
+  "&&",
+  "||",
+  "?:",
+  "=",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "&=",
+  "|=",
+  "<<=",
+  ">>=",
+  "ABSOLUTE",
+  "ADDR",
+  "ALIGN",
+  "ALIGNOF",
+  "BLOCK",
+  "DATA_SEGMENT_ALIGN",
+  "DATA_SEGMENT_END",
+  "DATA_SEGMENT_RELRO_END",
+  "DEFINED",
+  "LENGTH",
+  "LOADADDR",
+  "MAX",
+  "MIN",
+  "NEXT",
+  "ORIGIN",
+  "SEGMENT_START",
+  "SIZEOF",
+  "SIZEOF_HEADERS",
+  "MAXPAGESIZE",
+  "COMMONPAGESIZE"
+};
+
+Operator::Operator(Arity pArity,
+                   Type pType)
+  : ExprToken(ExprToken::OPERATOR),
+    m_Arity(pArity),
+    m_Type(pType)
+{
+  m_pIntOperand = IntOperand::create(0);
+}
+
+Operator::~Operator()
+{
+}
+
+void Operator::dump() const
+{
+  mcld::outs() << OpNames[type()];
+}
+
+/* Nullary operator */
+template<>
+Operator& Operator::create<Operator::SIZEOF_HEADERS>()
+{
+  static NullaryOp<Operator::SIZEOF_HEADERS> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::MAXPAGESIZE>()
+{
+  static NullaryOp<Operator::MAXPAGESIZE> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::COMMONPAGESIZE>()
+{
+  static NullaryOp<Operator::COMMONPAGESIZE> op;
+  return op;
+}
+
+/* Unary operator */
+template<>
+Operator& Operator::create<Operator::UNARY_PLUS>()
+{
+  static UnaryOp<Operator::UNARY_PLUS> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::UNARY_MINUS>()
+{
+  static UnaryOp<Operator::UNARY_MINUS> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::LOGICAL_NOT>()
+{
+  static UnaryOp<Operator::LOGICAL_NOT> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::BITWISE_NOT>()
+{
+  static UnaryOp<Operator::BITWISE_NOT> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::ABSOLUTE>()
+{
+  static UnaryOp<Operator::ABSOLUTE> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::ADDR>()
+{
+  static UnaryOp<Operator::ADDR> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::ALIGNOF>()
+{
+  static UnaryOp<Operator::ALIGNOF> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::DATA_SEGMENT_END>()
+{
+  static UnaryOp<Operator::DATA_SEGMENT_END> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::DEFINED>()
+{
+  static UnaryOp<Operator::DEFINED> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::LENGTH>()
+{
+  static UnaryOp<Operator::LENGTH> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::LOADADDR>()
+{
+  static UnaryOp<Operator::LOADADDR> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::NEXT>()
+{
+  static UnaryOp<Operator::NEXT> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::ORIGIN>()
+{
+  static UnaryOp<Operator::ORIGIN> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::SIZEOF>()
+{
+  static UnaryOp<Operator::SIZEOF> op;
+  return op;
+}
+
+/* Binary operator */
+template<>
+Operator& Operator::create<Operator::MUL>()
+{
+  static BinaryOp<Operator::MUL> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::DIV>()
+{
+  static BinaryOp<Operator::DIV> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::MOD>()
+{
+  static BinaryOp<Operator::MOD> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::ADD>()
+{
+  static BinaryOp<Operator::ADD> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::SUB>()
+{
+  static BinaryOp<Operator::SUB> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::LSHIFT>()
+{
+  static BinaryOp<Operator::LSHIFT> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::RSHIFT>()
+{
+  static BinaryOp<Operator::RSHIFT> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::LT>()
+{
+  static BinaryOp<Operator::LT> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::LE>()
+{
+  static BinaryOp<Operator::LE> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::GT>()
+{
+  static BinaryOp<Operator::GT> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::GE>()
+{
+  static BinaryOp<Operator::GE> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::EQ>()
+{
+  static BinaryOp<Operator::EQ> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::NE>()
+{
+  static BinaryOp<Operator::NE> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::BITWISE_AND>()
+{
+  static BinaryOp<Operator::BITWISE_AND> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::BITWISE_XOR>()
+{
+  static BinaryOp<Operator::BITWISE_XOR> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::BITWISE_OR>()
+{
+  static BinaryOp<Operator::BITWISE_OR> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::LOGICAL_AND>()
+{
+  static BinaryOp<Operator::LOGICAL_AND> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::LOGICAL_OR>()
+{
+  static BinaryOp<Operator::LOGICAL_OR> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::ALIGN>()
+{
+  static BinaryOp<Operator::ALIGN> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::DATA_SEGMENT_RELRO_END>()
+{
+  static BinaryOp<Operator::DATA_SEGMENT_RELRO_END> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::MAX>()
+{
+  static BinaryOp<Operator::MAX> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::MIN>()
+{
+  static BinaryOp<Operator::MIN> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::SEGMENT_START>()
+{
+  static BinaryOp<Operator::SEGMENT_START> op;
+  return op;
+}
+
+/* Ternary operator */
+template<>
+Operator& Operator::create<Operator::TERNARY_IF>()
+{
+  static TernaryOp<Operator::TERNARY_IF> op;
+  return op;
+}
+
+template<>
+Operator& Operator::create<Operator::DATA_SEGMENT_ALIGN>()
+{
+  static TernaryOp<Operator::DATA_SEGMENT_ALIGN> op;
+  return op;
+}
diff --git a/lib/Script/OutputArchCmd.cpp b/lib/Script/OutputArchCmd.cpp
new file mode 100644
index 0000000..4393b84
--- /dev/null
+++ b/lib/Script/OutputArchCmd.cpp
@@ -0,0 +1,36 @@
+//===- OutputArchCmd.cpp --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/OutputArchCmd.h>
+#include <mcld/Support/raw_ostream.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// OutputArchCmd
+//===----------------------------------------------------------------------===//
+OutputArchCmd::OutputArchCmd(const std::string& pArch)
+  : ScriptCommand(ScriptCommand::OUTPUT_ARCH),
+    m_Arch(pArch)
+{
+}
+
+OutputArchCmd::~OutputArchCmd()
+{
+}
+
+void OutputArchCmd::dump() const
+{
+  mcld::outs() << "OUTPUT_ARCH ( " << m_Arch << " )\n";
+}
+
+void OutputArchCmd::activate(Module& pModule)
+{
+  // TODO
+}
+
diff --git a/lib/Script/OutputCmd.cpp b/lib/Script/OutputCmd.cpp
new file mode 100644
index 0000000..c37adcc
--- /dev/null
+++ b/lib/Script/OutputCmd.cpp
@@ -0,0 +1,41 @@
+//===- OutputCmd.cpp -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/OutputCmd.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/Module.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// OutputCmd
+//===----------------------------------------------------------------------===//
+OutputCmd::OutputCmd(const std::string& pOutputFile)
+  : ScriptCommand(ScriptCommand::OUTPUT),
+    m_OutputFile(pOutputFile)
+{
+}
+
+OutputCmd::~OutputCmd()
+{
+}
+
+void OutputCmd::dump() const
+{
+  mcld::outs() << "OUTPUT ( " << m_OutputFile << " )\n";
+}
+
+void OutputCmd::activate(Module& pModule)
+{
+  pModule.getScript().setOutputFile(m_OutputFile);
+  // TODO: set the output name if there is no `-o filename' on the cmdline.
+  // This option is to define a default name for the output file other than the
+  // usual default of a.out.
+}
+
diff --git a/lib/Script/OutputFormatCmd.cpp b/lib/Script/OutputFormatCmd.cpp
new file mode 100644
index 0000000..eca9df5
--- /dev/null
+++ b/lib/Script/OutputFormatCmd.cpp
@@ -0,0 +1,53 @@
+//===- OutputFormatCmd.cpp ------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/OutputFormatCmd.h>
+#include <mcld/Support/raw_ostream.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// OutputFormatCmd
+//===----------------------------------------------------------------------===//
+OutputFormatCmd::OutputFormatCmd(const std::string& pFormat)
+  : ScriptCommand(ScriptCommand::OUTPUT_FORMAT)
+{
+  m_FormatList.push_back(pFormat);
+}
+
+OutputFormatCmd::OutputFormatCmd(const std::string& pDefault,
+                                 const std::string& pBig,
+                                 const std::string& pLittle)
+  : ScriptCommand(ScriptCommand::OUTPUT_FORMAT)
+{
+  m_FormatList.push_back(pDefault);
+  m_FormatList.push_back(pBig);
+  m_FormatList.push_back(pLittle);
+}
+
+OutputFormatCmd::~OutputFormatCmd()
+{
+}
+
+void OutputFormatCmd::dump() const
+{
+  mcld::outs() << "OUTPUT_FORMAT ( ";
+  assert(m_FormatList.size() == 1 || m_FormatList.size() == 3);
+  for (size_t i = 0; i < m_FormatList.size(); ++i) {
+    if (i != 0)
+      mcld::outs() << " , ";
+    mcld::outs() << m_FormatList[i];
+  }
+  mcld::outs() << " )\n";
+}
+
+void OutputFormatCmd::activate(Module& pModule)
+{
+  // TODO
+}
+
diff --git a/lib/Script/OutputSectDesc.cpp b/lib/Script/OutputSectDesc.cpp
new file mode 100644
index 0000000..3442c4e
--- /dev/null
+++ b/lib/Script/OutputSectDesc.cpp
@@ -0,0 +1,196 @@
+//===- OutputSectDesc.cpp -------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/OutputSectDesc.h>
+#include <mcld/Script/RpnExpr.h>
+#include <mcld/Script/StringList.h>
+#include <mcld/Script/StrToken.h>
+#include <mcld/Script/InputSectDesc.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/Module.h>
+#include <llvm/Support/Casting.h>
+#include <cassert>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// OutputSectDesc
+//===----------------------------------------------------------------------===//
+OutputSectDesc::OutputSectDesc(const std::string& pName,
+                               const Prolog& pProlog)
+  : ScriptCommand(ScriptCommand::OUTPUT_SECT_DESC),
+    m_Name(pName),
+    m_Prolog(pProlog)
+{
+}
+
+OutputSectDesc::~OutputSectDesc()
+{
+  for (iterator it = begin(), ie = end(); it != ie; ++it) {
+    if (*it != NULL)
+      delete *it;
+  }
+}
+
+void OutputSectDesc::dump() const
+{
+  mcld::outs() << m_Name << "\t";
+
+  if (m_Prolog.hasVMA()) {
+    m_Prolog.vma().dump();
+    mcld::outs() << "\t";
+  }
+
+  switch (m_Prolog.type()) {
+  case NOLOAD:
+    mcld::outs() << "(NOLOAD)";
+    break;
+  case DSECT:
+    mcld::outs() << "(DSECT)";
+    break;
+  case COPY:
+    mcld::outs() << "(COPY)";
+    break;
+  case INFO:
+    mcld::outs() << "(INFO)";
+    break;
+  case OVERLAY:
+    mcld::outs() << "(OVERLAY)";
+    break;
+  default:
+    break;
+  }
+  mcld::outs() << ":\n";
+
+  if (m_Prolog.hasLMA()) {
+    mcld::outs() << "\tAT ( ";
+    m_Prolog.lma().dump();
+    mcld::outs() << " )\n";
+  }
+
+  if (m_Prolog.hasAlign()) {
+    mcld::outs() << "\tALIGN ( ";
+    m_Prolog.align().dump();
+    mcld::outs() << " )\n";
+  }
+
+  if (m_Prolog.hasSubAlign()) {
+    mcld::outs() << "\tSUBALIGN ( ";
+    m_Prolog.subAlign().dump();
+    mcld::outs() << " )\n";
+  }
+
+  switch (m_Prolog.constraint()) {
+  case ONLY_IF_RO:
+    mcld::outs() << "\tONLY_IF_RO\n";
+    break;
+  case ONLY_IF_RW:
+    mcld::outs() << "\tONLY_IF_RW\n";
+    break;
+  default:
+    break;
+  }
+
+  mcld::outs() << "\t{\n";
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
+    switch ((*it)->getKind()) {
+    case ScriptCommand::ASSIGNMENT:
+    case ScriptCommand::INPUT_SECT_DESC:
+      mcld::outs() << "\t\t";
+      (*it)->dump();
+      break;
+    default:
+      assert(0);
+      break;
+    }
+  }
+  mcld::outs() << "\t}";
+
+  if (m_Epilog.hasRegion())
+    mcld::outs() << "\t>" << m_Epilog.region();
+  if (m_Epilog.hasLMARegion())
+    mcld::outs() << "\tAT>" << m_Epilog.lmaRegion();
+
+  if (m_Epilog.hasPhdrs()) {
+    for (StringList::const_iterator it = m_Epilog.phdrs().begin(),
+      ie = m_Epilog.phdrs().end(); it != ie; ++it) {
+      assert((*it)->kind() == StrToken::String);
+      mcld::outs() << ":" << (*it)->name() << " ";
+    }
+  }
+
+  if (m_Epilog.hasFillExp()) {
+    mcld::outs() << "= ";
+    m_Epilog.fillExp().dump();
+  }
+  mcld::outs() << "\n";
+}
+
+void OutputSectDesc::push_back(ScriptCommand* pCommand)
+{
+  switch (pCommand->getKind()) {
+  case ScriptCommand::ASSIGNMENT:
+  case ScriptCommand::INPUT_SECT_DESC:
+    m_OutputSectCmds.push_back(pCommand);
+    break;
+  default:
+    assert(0);
+    break;
+  }
+}
+
+void OutputSectDesc::setEpilog(const Epilog& pEpilog)
+{
+  m_Epilog.m_pRegion    = pEpilog.m_pRegion;
+  m_Epilog.m_pLMARegion = pEpilog.m_pLMARegion;
+  m_Epilog.m_pPhdrs     = pEpilog.m_pPhdrs;
+  m_Epilog.m_pFillExp   = pEpilog.m_pFillExp;
+}
+
+void OutputSectDesc::activate(Module& pModule)
+{
+  // Assignment in an output section
+  OutputSectCmds assignments;
+
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
+    switch ((*it)->getKind()) {
+    case ScriptCommand::ASSIGNMENT:
+      assignments.push_back(*it);
+      break;
+    case ScriptCommand::INPUT_SECT_DESC: {
+      (*it)->activate(pModule);
+
+      for (iterator assign = assignments.begin(), assignEnd = assignments.end();
+        assign != assignEnd; ++assign) {
+        (*assign)->activate(pModule);
+      }
+      assignments.clear();
+      break;
+    }
+    default:
+      assert(0);
+      break;
+    }
+  }
+
+  if (!assignments.empty()) {
+    InputSectDesc::Spec spec;;
+    spec.m_pWildcardFile = NULL;
+    spec.m_pExcludeFiles = NULL;
+    spec.m_pWildcardSections = NULL;
+    InputSectDesc inputDesc(InputSectDesc::Keep, spec, *this);
+    pModule.getScript().sectionMap().insert(inputDesc, *this);
+
+    for (iterator assign = assignments.begin(), assignEnd = assignments.end();
+      assign != assignEnd; ++assign) {
+      (*assign)->activate(pModule);
+    }
+    assignments.clear();
+  }
+}
diff --git a/lib/Script/RpnEvaluator.cpp b/lib/Script/RpnEvaluator.cpp
new file mode 100644
index 0000000..52cb79f
--- /dev/null
+++ b/lib/Script/RpnEvaluator.cpp
@@ -0,0 +1,114 @@
+//===- RpnEvaluator.cpp ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Support/MsgHandling.h>
+#include <mcld/LD/LDSymbol.h>
+#include <mcld/Script/RpnExpr.h>
+#include <mcld/Script/RpnEvaluator.h>
+#include <mcld/Script/ExprToken.h>
+#include <mcld/Script/Operator.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Module.h>
+#include <llvm/Support/Casting.h>
+#include <llvm/Support/DataTypes.h>
+#include <stack>
+#include <cassert>
+
+using namespace mcld;
+
+RpnEvaluator::RpnEvaluator(const Module& pModule,
+                           const TargetLDBackend& pBackend)
+  : m_Module(pModule),
+    m_Backend(pBackend)
+{
+}
+
+bool RpnEvaluator::eval(const RpnExpr& pExpr, uint64_t& pResult)
+{
+  std::stack<Operand*> operandStack;
+  for (RpnExpr::const_iterator it = pExpr.begin(), ie = pExpr.end(); it != ie;
+    ++it) {
+    switch((*it)->kind()) {
+    case ExprToken::OPERATOR: {
+      Operator* op = llvm::cast<Operator>(*it);
+      switch (op->arity()) {
+      case Operator::NULLARY: {
+        operandStack.push(op->eval(m_Module, m_Backend));
+        break;
+      }
+      case Operator::UNARY: {
+        Operand* opd = operandStack.top();
+        operandStack.pop();
+        op->appendOperand(opd);
+        operandStack.push(op->eval(m_Module, m_Backend));
+        break;
+      }
+      case Operator::BINARY: {
+        Operand* opd2 = operandStack.top();
+        operandStack.pop();
+        Operand* opd1 = operandStack.top();
+        operandStack.pop();
+        op->appendOperand(opd1);
+        op->appendOperand(opd2);
+        operandStack.push(op->eval(m_Module, m_Backend));
+        break;
+      }
+      case Operator::TERNARY: {
+        Operand* opd3 = operandStack.top();
+        operandStack.pop();
+        Operand* opd2 = operandStack.top();
+        operandStack.pop();
+        Operand* opd1 = operandStack.top();
+        operandStack.pop();
+        op->appendOperand(opd1);
+        op->appendOperand(opd2);
+        op->appendOperand(opd3);
+        operandStack.push(op->eval(m_Module, m_Backend));
+        break;
+      }
+      } // end of switch operator arity
+      break;
+    }
+
+    case ExprToken::OPERAND: {
+      Operand* opd = llvm::cast<Operand>(*it);
+      switch (opd->type()) {
+      case Operand::SYMBOL: {
+        // It's possible that there are no operators in an expression, so
+        // we set up symbol operand here.
+        if (!opd->isDot()) {
+          SymOperand* sym_opd = llvm::cast<SymOperand>(opd);
+          const LDSymbol* symbol =
+            m_Module.getNamePool().findSymbol(sym_opd->name());
+          if (symbol == NULL) {
+            fatal(diag::fail_sym_resolution) << __FILE__ << __LINE__
+                                             << "mclinker@googlegroups.com";
+          }
+          sym_opd->setValue(symbol->value());
+        }
+        operandStack.push(opd);
+        break;
+      }
+      default:
+        operandStack.push(opd);
+        break;
+      } // end of switch operand type
+      break;
+    }
+
+    } // end of switch
+  } // end of for
+
+  // stack top is result
+  assert(operandStack.top()->type() == Operand::SYMBOL ||
+         operandStack.top()->type() == Operand::INTEGER ||
+         operandStack.top()->type() == Operand::FRAGMENT);
+  pResult = operandStack.top()->value();
+  return true;
+}
+
diff --git a/lib/Script/RpnExpr.cpp b/lib/Script/RpnExpr.cpp
new file mode 100644
index 0000000..a9a4cae
--- /dev/null
+++ b/lib/Script/RpnExpr.cpp
@@ -0,0 +1,105 @@
+//===- RPNExpr.cpp --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/RpnExpr.h>
+#include <mcld/Script/ExprToken.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Script/Operator.h>
+#include <mcld/Support/GCFactory.h>
+#include <mcld/Support/raw_ostream.h>
+#include <llvm/Support/ManagedStatic.h>
+#include <llvm/Support/Casting.h>
+
+using namespace mcld;
+
+typedef GCFactory<RpnExpr, MCLD_SYMBOLS_PER_INPUT> ExprFactory;
+static llvm::ManagedStatic<ExprFactory> g_ExprFactory;
+
+//===----------------------------------------------------------------------===//
+// RpnExpr
+//===----------------------------------------------------------------------===//
+RpnExpr::RpnExpr()
+{
+}
+
+RpnExpr::~RpnExpr()
+{
+}
+
+bool RpnExpr::hasDot() const
+{
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
+    if ((*it)->kind() == ExprToken::OPERAND &&
+        llvm::cast<Operand>(*it)->isDot())
+      return true;
+  }
+  return false;
+}
+
+void RpnExpr::dump() const
+{
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
+    (*it)->dump();
+    mcld::outs() << " ";
+  }
+}
+
+void RpnExpr::push_back(ExprToken* pToken)
+{
+  m_TokenQueue.push_back(pToken);
+}
+
+RpnExpr* RpnExpr::create()
+{
+  RpnExpr* result = g_ExprFactory->allocate();
+  new (result) RpnExpr();
+  return result;
+}
+
+void RpnExpr::destroy(RpnExpr*& pRpnExpr)
+{
+  g_ExprFactory->destroy(pRpnExpr);
+  g_ExprFactory->deallocate(pRpnExpr);
+  pRpnExpr = NULL;
+}
+
+void RpnExpr::clear()
+{
+  g_ExprFactory->clear();
+}
+
+RpnExpr::iterator RpnExpr::insert(iterator pPosition, ExprToken* pToken)
+{
+  return m_TokenQueue.insert(pPosition, pToken);
+}
+
+void RpnExpr::erase(iterator pPosition)
+{
+  m_TokenQueue.erase(pPosition);
+}
+
+// buildHelperExpr - build the helper expr:
+//                   ADDR ( `output_sect' ) + SIZEOF ( `output_sect' )
+RpnExpr* RpnExpr::buildHelperExpr(SectionMap::iterator pIter)
+{
+  RpnExpr* expr = RpnExpr::create();
+  expr->push_back(SectDescOperand::create(*pIter));
+  expr->push_back(&Operator::create<Operator::ADDR>());
+  expr->push_back(SectDescOperand::create(*pIter));
+  expr->push_back(&Operator::create<Operator::SIZEOF>());
+  expr->push_back(&Operator::create<Operator::ADD>());
+  return expr;
+}
+
+// buildHelperExpr - build the helper expr: `fragment'
+RpnExpr* RpnExpr::buildHelperExpr(Fragment& pFrag)
+{
+  RpnExpr* expr = RpnExpr::create();
+  expr->push_back(FragOperand::create(pFrag));
+  return expr;
+}
diff --git a/lib/Script/ScriptCommand.cpp b/lib/Script/ScriptCommand.cpp
new file mode 100644
index 0000000..e360645
--- /dev/null
+++ b/lib/Script/ScriptCommand.cpp
@@ -0,0 +1,19 @@
+//===- ScriptCommand.cpp --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/ScriptCommand.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// ScriptCommand
+//===----------------------------------------------------------------------===//
+ScriptCommand::~ScriptCommand()
+{
+}
+
diff --git a/lib/Script/ScriptFile.cpp b/lib/Script/ScriptFile.cpp
new file mode 100644
index 0000000..00a8056
--- /dev/null
+++ b/lib/Script/ScriptFile.cpp
@@ -0,0 +1,252 @@
+//===- ScriptFile.cpp -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/ScriptFile.h>
+#include <mcld/Script/StringList.h>
+#include <mcld/Script/ScriptCommand.h>
+#include <mcld/Script/EntryCmd.h>
+#include <mcld/Script/OutputFormatCmd.h>
+#include <mcld/Script/GroupCmd.h>
+#include <mcld/Script/OutputCmd.h>
+#include <mcld/Script/SearchDirCmd.h>
+#include <mcld/Script/OutputArchCmd.h>
+#include <mcld/Script/AssertCmd.h>
+#include <mcld/Script/SectionsCmd.h>
+#include <mcld/Script/RpnExpr.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Script/StrToken.h>
+#include <mcld/MC/Input.h>
+#include <mcld/MC/InputBuilder.h>
+#include <mcld/Support/MemoryArea.h>
+#include <mcld/InputTree.h>
+#include <mcld/ADT/HashEntry.h>
+#include <mcld/ADT/HashTable.h>
+#include <mcld/ADT/StringHash.h>
+#include <llvm/Support/Casting.h>
+#include <llvm/Support/ManagedStatic.h>
+#include <cassert>
+
+using namespace mcld;
+
+typedef HashEntry<std::string,
+                  void*,
+                  hash::StringCompare<std::string> > ParserStrEntry;
+typedef HashTable<ParserStrEntry,
+                  hash::StringHash<hash::DJB>,
+                  EntryFactory<ParserStrEntry> > ParserStrPool;
+static llvm::ManagedStatic<ParserStrPool> g_ParserStrPool;
+
+//===----------------------------------------------------------------------===//
+// ScriptFile
+//===----------------------------------------------------------------------===//
+ScriptFile::ScriptFile(Kind pKind, Input& pInput, InputBuilder& pBuilder)
+  : m_Kind(pKind),
+    m_Input(pInput),
+    m_Name(pInput.path().native()),
+    m_pInputTree(NULL),
+    m_Builder(pBuilder),
+    m_bHasSectionsCmd(false),
+    m_bInSectionsCmd(false),
+    m_bInOutputSectDesc(false),
+    m_pRpnExpr(NULL),
+    m_pStringList(NULL),
+    m_bAsNeeded(false)
+{
+  // FIXME: move creation of input tree out of ScriptFile.
+  m_pInputTree = new InputTree();
+}
+
+ScriptFile::~ScriptFile()
+{
+  for (iterator it = begin(), ie = end(); it != ie; ++it) {
+    if (*it != NULL)
+      delete *it;
+  }
+  if (NULL != m_pInputTree)
+    delete m_pInputTree;
+}
+
+void ScriptFile::dump() const
+{
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it)
+    (*it)->dump();
+}
+
+void ScriptFile::activate(Module& pModule)
+{
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it)
+    (*it)->activate(pModule);
+}
+
+void ScriptFile::addEntryPoint(const std::string& pSymbol)
+{
+  EntryCmd* entry = new EntryCmd(pSymbol);
+
+  if (m_bInSectionsCmd) {
+    assert(!m_CommandQueue.empty());
+    SectionsCmd* sections = llvm::cast<SectionsCmd>(back());
+    sections->push_back(entry);
+  } else {
+    m_CommandQueue.push_back(entry);
+  }
+}
+
+void ScriptFile::addOutputFormatCmd(const std::string& pName)
+{
+  m_CommandQueue.push_back(new OutputFormatCmd(pName));
+}
+
+void ScriptFile::addOutputFormatCmd(const std::string& pDefault,
+                                    const std::string& pBig,
+                                    const std::string& pLittle)
+{
+  m_CommandQueue.push_back(new OutputFormatCmd(pDefault, pBig, pLittle));
+}
+
+void ScriptFile::addGroupCmd(StringList& pStringList,
+                             GroupReader& pGroupReader,
+                             const LinkerConfig& pConfig)
+{
+  m_CommandQueue.push_back(
+    new GroupCmd(pStringList, *m_pInputTree, m_Builder, pGroupReader, pConfig));
+}
+
+void ScriptFile::addOutputCmd(const std::string& pFileName)
+{
+  m_CommandQueue.push_back(new OutputCmd(pFileName));
+}
+
+void ScriptFile::addSearchDirCmd(const std::string& pPath)
+{
+  m_CommandQueue.push_back(new SearchDirCmd(pPath));
+}
+
+void ScriptFile::addOutputArchCmd(const std::string& pArch)
+{
+  m_CommandQueue.push_back(new OutputArchCmd(pArch));
+}
+
+void ScriptFile::addAssertCmd(RpnExpr& pRpnExpr, const std::string& pMessage)
+{
+  m_CommandQueue.push_back(new AssertCmd(pRpnExpr, pMessage));
+}
+
+void ScriptFile::addAssignment(const std::string& pSymbolName,
+                               RpnExpr& pRpnExpr,
+                               Assignment::Type pType)
+{
+  if (m_bInSectionsCmd) {
+    assert(!m_CommandQueue.empty());
+    SectionsCmd* sections = llvm::cast<SectionsCmd>(back());
+    if (m_bInOutputSectDesc) {
+      assert(!sections->empty());
+      OutputSectDesc* output_desc =
+        llvm::cast<OutputSectDesc>(sections->back());
+      output_desc->push_back(new Assignment(Assignment::INPUT_SECTION,
+                                            pType,
+                                            *(SymOperand::create(pSymbolName)),
+                                            pRpnExpr));
+    } else {
+      sections->push_back(new Assignment(Assignment::OUTPUT_SECTION,
+                                         pType,
+                                         *(SymOperand::create(pSymbolName)),
+                                         pRpnExpr));
+    }
+  } else {
+    m_CommandQueue.push_back(new Assignment(Assignment::OUTSIDE_SECTIONS,
+                                            pType,
+                                            *(SymOperand::create(pSymbolName)),
+                                            pRpnExpr));
+  }
+}
+
+bool ScriptFile::hasSectionsCmd() const
+{
+  return m_bHasSectionsCmd;
+}
+
+void ScriptFile::enterSectionsCmd()
+{
+  m_bHasSectionsCmd = true;
+  m_bInSectionsCmd = true;
+  m_CommandQueue.push_back(new SectionsCmd());
+}
+
+void ScriptFile::leaveSectionsCmd()
+{
+  m_bInSectionsCmd = false;
+}
+
+void ScriptFile::enterOutputSectDesc(const std::string& pName,
+                                     const OutputSectDesc::Prolog& pProlog)
+{
+  assert(!m_CommandQueue.empty());
+  assert(m_bInSectionsCmd);
+  SectionsCmd* sections = llvm::cast<SectionsCmd>(back());
+  sections->push_back(new OutputSectDesc(pName, pProlog));
+
+  m_bInOutputSectDesc = true;
+}
+
+void ScriptFile::leaveOutputSectDesc(const OutputSectDesc::Epilog& pEpilog)
+{
+  assert(!m_CommandQueue.empty());
+  assert(m_bInSectionsCmd);
+  SectionsCmd* sections = llvm::cast<SectionsCmd>(back());
+
+  assert(!sections->empty() && m_bInOutputSectDesc);
+  OutputSectDesc* output_desc = llvm::cast<OutputSectDesc>(sections->back());
+  output_desc->setEpilog(pEpilog);
+
+  m_bInOutputSectDesc = false;
+}
+
+void ScriptFile::addInputSectDesc(InputSectDesc::KeepPolicy pPolicy,
+                                  const InputSectDesc::Spec& pSpec)
+{
+  assert(!m_CommandQueue.empty());
+  assert(m_bInSectionsCmd);
+  SectionsCmd* sections = llvm::cast<SectionsCmd>(back());
+
+  assert(!sections->empty() && m_bInOutputSectDesc);
+  OutputSectDesc* output_sect = llvm::cast<OutputSectDesc>(sections->back());
+
+  output_sect->push_back(new InputSectDesc(pPolicy, pSpec, *output_sect));
+}
+
+RpnExpr* ScriptFile::createRpnExpr()
+{
+  m_pRpnExpr = RpnExpr::create();
+  return m_pRpnExpr;
+}
+
+StringList* ScriptFile::createStringList()
+{
+  m_pStringList = StringList::create();
+  return m_pStringList;
+}
+
+void ScriptFile::setAsNeeded(bool pEnable)
+{
+  m_bAsNeeded = pEnable;
+}
+
+const std::string& ScriptFile::createParserStr(const char* pText,
+                                               size_t pLength)
+{
+  bool exist = false;
+  ParserStrEntry* entry =
+    g_ParserStrPool->insert(std::string(pText, pLength), exist);
+  return entry->key();
+}
+
+void ScriptFile::clearParserStrPool()
+{
+  g_ParserStrPool->clear();
+}
+
diff --git a/lib/Script/ScriptParser.yy b/lib/Script/ScriptParser.yy
new file mode 100644
index 0000000..7b35e0e
--- /dev/null
+++ b/lib/Script/ScriptParser.yy
@@ -0,0 +1,936 @@
+/*===- ScriptParser.yy ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===*/
+
+%{
+/* C/C++ Declarations */
+#include <mcld/Script/ScriptReader.h>
+#include <mcld/Script/ScriptScanner.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Script/Operator.h>
+#include <mcld/Script/Assignment.h>
+#include <mcld/Script/RpnExpr.h>
+#include <mcld/Script/FileToken.h>
+#include <mcld/Script/NameSpec.h>
+#include <mcld/Script/WildcardPattern.h>
+#include <mcld/Support/MsgHandling.h>
+using namespace mcld;
+
+#undef yylex
+#define yylex m_ScriptScanner.lex
+%}
+
+%code requires {
+#include <mcld/Script/StrToken.h>
+#include <mcld/Script/StringList.h>
+#include <mcld/Script/OutputSectDesc.h>
+#include <mcld/Script/InputSectDesc.h>
+#include <llvm/Support/DataTypes.h>
+
+using namespace mcld;
+
+}
+
+%pure-parser
+%require "2.4"
+%skeleton "glr.cc"
+%defines "ScriptParser.h"
+%debug
+%error-verbose
+%define namespace "mcld"
+%define "parser_class_name" "ScriptParser"
+%parse-param { const class LinkerConfig& m_LDConfig }
+%parse-param { class ScriptFile& m_ScriptFile }
+%parse-param { class ScriptScanner& m_ScriptScanner }
+%parse-param { class GroupReader& m_GroupReader}
+%lex-param { const class ScriptFile& m_ScriptFile }
+
+%locations
+%initial-action
+{
+  /* Initialize the initial location. */
+  @$.begin.filename = @$.end.filename = &(m_ScriptFile.name());
+}
+
+%start script_file
+
+%union {
+  const std::string* string;
+  uint64_t integer;
+  RpnExpr* rpn_expr;
+  StrToken* str_token;
+  StringList* str_tokens;
+  OutputSectDesc::Prolog output_prolog;
+  OutputSectDesc::Type output_type;
+  OutputSectDesc::Constraint output_constraint;
+  OutputSectDesc::Epilog output_epilog;
+  WildcardPattern* wildcard;
+  InputSectDesc::Spec input_spec;
+}
+
+%token END 0 /* EOF */
+%token <string> STRING LNAMESPEC
+%token <integer> INTEGER
+
+/* Initial states */
+%token LINKER_SCRIPT DEFSYM VERSION_SCRIPT DYNAMIC_LIST
+
+/* Entry point */
+%token ENTRY
+/* File Commands */
+%token INCLUDE
+%token INPUT
+%token GROUP
+%token AS_NEEDED
+%token OUTPUT
+%token SEARCH_DIR
+%token STARTUP
+/* Format Commands */
+%token OUTPUT_FORMAT
+%token TARGET
+/* Misc Commands */
+%token ASSERT
+%token EXTERN
+%token FORCE_COMMON_ALLOCATION
+%token INHIBIT_COMMON_ALLOCATION
+%token INSERT
+%token NOCROSSREFS
+%token OUTPUT_ARCH
+%token LD_FEATURE
+/* Assignments */
+%token HIDDEN
+%token PROVIDE
+%token PROVIDE_HIDDEN
+/* SECTIONS Command */
+%token SECTIONS
+/* MEMORY Command */
+%token MEMORY
+/* PHDRS Command */
+%token PHDRS
+/* Builtin Functions */
+%token ABSOLUTE
+%token ADDR
+%token ALIGN
+%token ALIGNOF
+%token BLOCK
+%token DATA_SEGMENT_ALIGN
+%token DATA_SEGMENT_END
+%token DATA_SEGMENT_RELRO_END
+%token DEFINED
+%token LENGTH
+%token LOADADDR
+%token MAX
+%token MIN
+%token NEXT
+%token ORIGIN
+%token SEGMENT_START
+%token SIZEOF
+%token SIZEOF_HEADERS
+%token CONSTANT
+/* Symbolic Constants */
+%token MAXPAGESIZE
+%token COMMONPAGESIZE
+/* Input Section Description */
+%token EXCLUDE_FILE
+%token COMMON
+%token KEEP
+%token SORT_BY_NAME
+%token SORT_BY_ALIGNMENT
+%token SORT_NONE
+%token SORT_BY_INIT_PRIORITY
+/* Output Section Data */
+%token BYTE
+%token SHORT
+%token LONG
+%token QUAD
+%token SQUAD
+%token FILL
+/* Output Section Discarding */
+%token DISCARD
+/* Output Section Keywords */
+%token CREATE_OBJECT_SYMBOLS
+%token CONSTRUCTORS
+/* Output Section Attributes */
+/* Output Section Type */
+%token NOLOAD
+%token DSECT
+%token COPY
+%token INFO
+%token OVERLAY
+/* Output Section LMA */
+%token AT
+/* Forced Input Alignment */
+%token SUBALIGN
+/* Output Section Constraint */
+%token ONLY_IF_RO
+%token ONLY_IF_RW
+/* Operators are listed top to bottem, in ascending order */
+%left ','
+%right '=' ADD_ASSIGN SUB_ASSIGN MUL_ASSIGN DIV_ASSIGN AND_ASSIGN OR_ASSIGN LS_ASSIGN RS_ASSIGN
+%right '?' ':'
+%left LOGICAL_OR
+%left LOGICAL_AND
+%left '|'
+%left '^'
+%left '&'
+%left EQ NE
+%left '<' LE '>' GE
+%left LSHIFT RSHIFT
+%left '+' '-'
+%left '*' '/' '%'
+%right UNARY_PLUS UNARY_MINUS '!' '~'
+
+%type <integer> exp
+%type <string> string symbol opt_region opt_lma_region wildcard_pattern
+%type <rpn_expr> script_exp opt_lma opt_align opt_subalign opt_fill
+%type <str_token> input phdr
+%type <str_tokens> input_list opt_phdr opt_exclude_files input_sect_wildcard_patterns
+%type <output_prolog> output_desc_prolog opt_vma_and_type
+%type <output_type> opt_type type
+%type <output_constraint> opt_constraint
+%type <output_epilog> output_desc_epilog
+%type <wildcard> wildcard_file wildcard_section
+%type <input_spec> input_sect_spec
+
+%%
+
+script_file : LINKER_SCRIPT
+              { m_ScriptScanner.setLexState(ScriptFile::LDScript); }
+              linker_script
+              { m_ScriptScanner.popLexState(); }
+            ;
+
+linker_script : linker_script script_command
+              | /* Empty */
+              ;
+
+script_command : entry_command
+               | output_format_command
+               | group_command
+               | output_command
+               | search_dir_command
+               | output_arch_command
+               | assert_command
+               | symbol_assignment
+               | sections_command
+               | ';'
+               ;
+
+entry_command : ENTRY '(' STRING ')'
+                { m_ScriptFile.addEntryPoint(*$3); }
+              ;
+
+output_format_command : OUTPUT_FORMAT '(' STRING ')'
+                        { m_ScriptFile.addOutputFormatCmd(*$3); }
+                      | OUTPUT_FORMAT '(' STRING ',' STRING ',' STRING ')'
+                        { m_ScriptFile.addOutputFormatCmd(*$3, *$5, *$7); }
+                      ;
+
+group_command : GROUP '(' input_list ')'
+                { m_ScriptFile.addGroupCmd(*$3, m_GroupReader, m_LDConfig); }
+              ;
+
+search_dir_command : SEARCH_DIR '(' STRING ')'
+                     { m_ScriptFile.addSearchDirCmd(*$3); }
+                   ;
+
+output_command : OUTPUT '(' STRING ')'
+                 { m_ScriptFile.addOutputCmd(*$3); }
+               ;
+
+output_arch_command : OUTPUT_ARCH '(' STRING ')'
+                      { m_ScriptFile.addOutputArchCmd(*$3); }
+                    ;
+
+assert_command : ASSERT '(' script_exp ',' string ')'
+                 { m_ScriptFile.addAssertCmd(*$3, *$5); }
+               ;
+
+input_list : { m_ScriptFile.createStringList(); }
+             inputs
+             { $$ = m_ScriptFile.getCurrentStringList(); }
+           ;
+
+inputs : input
+         { m_ScriptFile.getCurrentStringList()->push_back($1); }
+       | inputs input
+         { m_ScriptFile.getCurrentStringList()->push_back($2); }
+       | inputs ',' input
+         { m_ScriptFile.getCurrentStringList()->push_back($3); }
+       | AS_NEEDED '('
+         { m_ScriptFile.setAsNeeded(true); }
+         inputs ')'
+         { m_ScriptFile.setAsNeeded(false); }
+       | inputs AS_NEEDED '('
+         { m_ScriptFile.setAsNeeded(true); }
+         inputs ')'
+         { m_ScriptFile.setAsNeeded(false); }
+       | inputs ',' AS_NEEDED '('
+         { m_ScriptFile.setAsNeeded(true); }
+         inputs ')'
+         { m_ScriptFile.setAsNeeded(false); }
+       ;
+
+input : string
+        { $$ = FileToken::create(*$1, m_ScriptFile.asNeeded()); }
+      | LNAMESPEC
+        { $$ = NameSpec::create(*$1, m_ScriptFile.asNeeded()); }
+      ;
+
+/*
+  SECTIONS
+  {
+    sections-command
+    sections-command
+    ...
+  }
+*/
+sections_command : SECTIONS
+                   { m_ScriptFile.enterSectionsCmd(); }
+                   '{' sect_commands '}'
+                   { m_ScriptFile.leaveSectionsCmd(); }
+                 ;
+
+sect_commands : sect_commands sect_cmd
+              | /* Empty */
+              ;
+
+/*
+Each sections-command may of be one of the following:
+
+an ENTRY command (see Entry command)
+a symbol assignment (see Assignments)
+an output section description
+an overlay description
+*/
+sect_cmd : entry_command
+         | symbol_assignment
+         | output_sect_desc
+         ;
+
+/*
+The full description of an output section looks like this:
+
+  section [address] [(type)] :
+    [AT(lma)]
+    [ALIGN(section_align)]
+    [SUBALIGN(subsection_align)]
+    [constraint]
+    {
+      output-section-command
+      output-section-command
+      ...
+    } [>region] [AT>lma_region] [:phdr :phdr ...] [=fillexp]
+*/
+output_sect_desc : string output_desc_prolog
+                   { m_ScriptFile.enterOutputSectDesc(*$1, $2); }
+                   '{'
+                       output_sect_commands
+                   '}' output_desc_epilog
+                   { m_ScriptFile.leaveOutputSectDesc($7); }
+                 ;
+
+output_desc_prolog : {
+                       m_ScriptScanner.setLexState(ScriptFile::Expression);
+                       /* create exp for vma */
+                       m_ScriptFile.createRpnExpr();
+                     }
+                     opt_vma_and_type
+                     { m_ScriptScanner.popLexState(); }
+                     ':'
+                     opt_lma opt_align opt_subalign opt_constraint
+                     {
+                       $$.m_pVMA       = $2.m_pVMA;
+                       $$.m_Type       = $2.m_Type;
+                       $$.m_pLMA       = $5;
+                       $$.m_pAlign     = $6;
+                       $$.m_pSubAlign  = $7;
+                       $$.m_Constraint = $8;
+                     }
+                   ;
+
+output_sect_commands : output_sect_commands output_sect_cmd
+                     | /* Empty */
+                     ;
+
+output_desc_epilog : opt_region opt_lma_region opt_phdr opt_fill
+                     {
+                        $$.m_pRegion    = $1;
+                        $$.m_pLMARegion = $2;
+                        $$.m_pPhdrs     = $3;
+                        $$.m_pFillExp   = $4;
+                     }
+                   ;
+
+/* Output Section Attributes */
+opt_vma_and_type : exp opt_type
+                   {
+                     $$.m_pVMA = m_ScriptFile.getCurrentRpnExpr();
+                     $$.m_Type = $2;
+                   }
+                 | opt_type
+                   {
+                     $$.m_pVMA = NULL;
+                     $$.m_Type = $1;
+                   }
+                 ;
+
+opt_type : '(' type ')'
+           { $$ = $2; }
+         | '(' ')'
+           { $$ = OutputSectDesc::LOAD; }
+         | /* Empty */
+           { $$ = OutputSectDesc::LOAD; }
+         ;
+
+type : NOLOAD
+       { $$ = OutputSectDesc::NOLOAD; }
+     | DSECT
+       { $$ = OutputSectDesc::DSECT; }
+     | COPY
+       { $$ = OutputSectDesc::COPY; }
+     | INFO
+       { $$ = OutputSectDesc::INFO; }
+     | OVERLAY
+       { $$ = OutputSectDesc::OVERLAY; }
+     ;
+
+opt_lma : AT '(' script_exp ')'
+          { $$ = $3; }
+        | /* Empty */
+          { $$ = NULL; }
+        ;
+
+/* Forced Output Alignment */
+opt_align : ALIGN '(' script_exp ')'
+            { $$ = $3; }
+          | /* Empty */
+            { $$ = NULL; }
+          ;
+
+/* Forced Input Alignment */
+opt_subalign : SUBALIGN '(' script_exp ')'
+               { $$ = $3; }
+             | /* Empty */
+               { $$ = NULL; }
+             ;
+
+opt_constraint : ONLY_IF_RO
+                 { $$ = OutputSectDesc::ONLY_IF_RO; }
+               | ONLY_IF_RW
+                 { $$ = OutputSectDesc::ONLY_IF_RW; }
+               | /* Empty */
+                 { $$ = OutputSectDesc::NO_CONSTRAINT; }
+               ;
+
+opt_region : '>' string
+             { $$ = $2; }
+           | /* Empty */
+             { $$ = NULL; }
+           ;
+
+opt_lma_region : AT '>' string
+                 { $$ = $3; }
+               | /* Empty */
+                 { $$ = NULL; }
+               ;
+
+opt_phdr : { m_ScriptFile.createStringList(); }
+           phdrs
+           { $$ = m_ScriptFile.getCurrentStringList(); }
+         ;
+
+phdrs : phdrs ':' phdr
+        { m_ScriptFile.getCurrentStringList()->push_back($3); }
+      | /* Empty */
+      ;
+
+phdr : string
+       { $$ = StrToken::create(*$1); }
+     ;
+
+opt_fill : '=' script_exp
+           { $$ = $2; }
+         | /* Empty */
+           { $$ = NULL; }
+         ;
+
+/*
+Each output-section-command may be one of the following:
+
+a symbol assignment (see Assignments)
+an input section description (see Input Section)
+data values to include directly (see Output Section Data)
+a special output section keyword (see Output Section Keywords)
+*/
+output_sect_cmd : symbol_assignment
+                | input_sect_desc
+                | output_sect_data
+                | output_sect_keyword
+                | ';'
+                ;
+
+input_sect_desc : input_sect_spec
+                  { m_ScriptFile.addInputSectDesc(InputSectDesc::NoKeep, $1); }
+                | KEEP '(' input_sect_spec ')'
+                  { m_ScriptFile.addInputSectDesc(InputSectDesc::Keep, $3); }
+                ;
+
+input_sect_spec : string
+                  {
+                    $$.m_pWildcardFile =
+                      WildcardPattern::create(*$1, WildcardPattern::SORT_NONE);
+                    $$.m_pExcludeFiles = NULL;
+                    $$.m_pWildcardSections = NULL;
+                  }
+                | wildcard_file '(' opt_exclude_files input_sect_wildcard_patterns ')'
+                  {
+                    $$.m_pWildcardFile = $1;
+                    $$.m_pExcludeFiles = $3;
+                    $$.m_pWildcardSections = $4;
+                  }
+                ;
+
+wildcard_file : wildcard_pattern
+                { $$ = WildcardPattern::create(*$1, WildcardPattern::SORT_NONE); }
+              | SORT_BY_NAME '(' wildcard_pattern ')'
+                { $$ = WildcardPattern::create(*$3, WildcardPattern::SORT_BY_NAME); }
+              ;
+
+wildcard_pattern : string
+                   { $$ = $1; }
+                 | '*'
+                   { $$ = &m_ScriptFile.createParserStr("*", 1); }
+                 | '?'
+                   { $$ = &m_ScriptFile.createParserStr("?", 1); }
+                 ;
+
+opt_exclude_files : EXCLUDE_FILE '('
+                    { m_ScriptFile.createStringList(); }
+                    exclude_files ')'
+                    { $$ = m_ScriptFile.getCurrentStringList(); }
+                  | /* Empty */
+                    { $$ = NULL; }
+                  ;
+
+exclude_files : exclude_files wildcard_pattern
+                {
+                  m_ScriptFile.getCurrentStringList()->push_back(
+                    WildcardPattern::create(*$2, WildcardPattern::SORT_NONE));
+                }
+              | wildcard_pattern
+                {
+                  m_ScriptFile.getCurrentStringList()->push_back(
+                    WildcardPattern::create(*$1, WildcardPattern::SORT_NONE));
+                }
+              ;
+
+input_sect_wildcard_patterns : { m_ScriptFile.createStringList(); }
+                               wildcard_sections
+                               { $$ = m_ScriptFile.getCurrentStringList(); }
+                             ;
+
+wildcard_sections : wildcard_sections wildcard_section
+                    {
+                      m_ScriptFile.getCurrentStringList()->push_back($2);
+                    }
+                  | wildcard_section
+                    {
+                      m_ScriptFile.getCurrentStringList()->push_back($1);
+                    }
+                  ;
+
+wildcard_section : wildcard_pattern
+                   { $$ = WildcardPattern::create(*$1, WildcardPattern::SORT_NONE); }
+                 | SORT_NONE '(' wildcard_pattern ')'
+                   { $$ = WildcardPattern::create(*$3, WildcardPattern::SORT_NONE); }
+                 | SORT_BY_NAME '(' wildcard_pattern ')'
+                   { $$ = WildcardPattern::create(*$3, WildcardPattern::SORT_BY_NAME); }
+                 | SORT_BY_ALIGNMENT '(' wildcard_pattern ')'
+                   { $$ = WildcardPattern::create(*$3, WildcardPattern::SORT_BY_ALIGNMENT); }
+                 | SORT_BY_NAME '(' SORT_BY_ALIGNMENT '(' wildcard_pattern ')' ')'
+                   { $$ = WildcardPattern::create(*$5, WildcardPattern::SORT_BY_NAME_ALIGNMENT); }
+                 | SORT_BY_ALIGNMENT '('SORT_BY_NAME '(' wildcard_pattern ')' ')'
+                   { $$ = WildcardPattern::create(*$5, WildcardPattern::SORT_BY_ALIGNMENT_NAME); }
+                 | SORT_BY_NAME '(' SORT_BY_NAME '(' wildcard_pattern ')' ')'
+                   { $$ = WildcardPattern::create(*$5, WildcardPattern::SORT_BY_NAME); }
+                 | SORT_BY_ALIGNMENT '(' SORT_BY_ALIGNMENT '(' wildcard_pattern ')' ')'
+                   { $$ = WildcardPattern::create(*$5, WildcardPattern::SORT_BY_ALIGNMENT); }
+                 | SORT_BY_INIT_PRIORITY '(' wildcard_pattern ')'
+                   { $$ = WildcardPattern::create(*$3, WildcardPattern::SORT_BY_INIT_PRIORITY); }
+                 ;
+
+output_sect_data : BYTE  '(' script_exp ')'
+                 | SHORT '(' script_exp ')'
+                 | LONG  '(' script_exp ')'
+                 | QUAD  '(' script_exp ')'
+                 | SQUAD '(' script_exp ')'
+                 ;
+
+output_sect_keyword : CREATE_OBJECT_SYMBOLS
+                    | CONSTRUCTORS
+                    | SORT_BY_NAME '(' CONSTRUCTORS ')'
+                    ;
+
+symbol_assignment : symbol '=' script_exp ';'
+                    { m_ScriptFile.addAssignment(*$1, *$3); }
+                  | symbol ADD_ASSIGN exp ';'
+                  | symbol SUB_ASSIGN exp ';'
+                  | symbol MUL_ASSIGN exp ';'
+                  | symbol DIV_ASSIGN exp ';'
+                  | symbol AND_ASSIGN exp ';'
+                  | symbol OR_ASSIGN exp ';'
+                  | symbol LS_ASSIGN exp ';'
+                  | symbol RS_ASSIGN exp ';'
+                  | HIDDEN '(' symbol '=' script_exp ')' ';'
+                    {
+                      m_ScriptFile.addAssignment(*$3, *$5,
+                                                 Assignment::HIDDEN);
+                    }
+                  | PROVIDE '(' symbol '=' script_exp ')' ';'
+                    {
+                      m_ScriptFile.addAssignment(*$3, *$5,
+                                                 Assignment::PROVIDE);
+                    }
+                  | PROVIDE_HIDDEN '(' symbol '=' script_exp ')' ';'
+                    {
+                      m_ScriptFile.addAssignment(*$3, *$5,
+                                                 Assignment::PROVIDE_HIDDEN);
+                    }
+                  ;
+
+script_exp : {
+               m_ScriptScanner.setLexState(ScriptFile::Expression);
+               m_ScriptFile.createRpnExpr();
+             }
+             exp
+             {
+               m_ScriptScanner.popLexState();
+               $$ = m_ScriptFile.getCurrentRpnExpr();
+             }
+           ;
+
+exp : '(' exp ')'
+      {
+        $$ = $2;
+      }
+    | '+' exp %prec UNARY_PLUS
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::UNARY_PLUS>());
+        $$ = $2 + 1;
+      }
+    | '-' exp %prec UNARY_MINUS
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::UNARY_MINUS>());
+        $$ = $2 + 1;
+      }
+    | '!' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::LOGICAL_NOT>());
+        $$ = $2 + 1;
+      }
+    | '~' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::BITWISE_NOT>());
+        $$ = $2 + 1;
+      }
+    | exp '*' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::MUL>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '/' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::DIV>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '%' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::MOD>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '+' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::ADD>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '-' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::SUB>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp LSHIFT exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::LSHIFT>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp RSHIFT exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::RSHIFT>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '<' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::LT>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp LE exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::LE>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '>' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::GT>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp GE exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::GE>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp EQ exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::EQ>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp NE exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::NE>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '&' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::BITWISE_AND>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '^' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::BITWISE_XOR>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '|' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::BITWISE_OR>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp LOGICAL_AND exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::LOGICAL_AND>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp LOGICAL_OR exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::LOGICAL_OR>());
+        $$ = $1 + $3 + 1;
+      }
+    | exp '?' exp ':' exp
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::TERNARY_IF>());
+        $$ = $1 + $3 + $5 + 1;
+      }
+    | ABSOLUTE '(' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::ABSOLUTE>());
+        $$ = $3 + 1;
+      }
+    | ADDR '(' string ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(SectOperand::create(*$3));
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::ADDR>());
+        $$ = 2;
+      }
+    | ALIGN '(' exp ')'
+      {
+        RpnExpr::iterator pos = m_ScriptFile.getCurrentRpnExpr()->begin() +
+                                m_ScriptFile.getCurrentRpnExpr()->size() - $3;
+        m_ScriptFile.getCurrentRpnExpr()->insert(pos, SymOperand::create("."));
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::ALIGN>());
+        $$ = $3 + 2;
+      }
+    | ALIGN '(' exp ',' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::ALIGN>());
+        $$ = $3 + $5 + 1;
+      }
+    | ALIGNOF '(' string ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(SectOperand::create(*$3));
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::ALIGNOF>());
+        $$ = 2;
+      }
+    | BLOCK '(' exp ')'
+      {
+        RpnExpr::iterator pos = m_ScriptFile.getCurrentRpnExpr()->begin() +
+                                m_ScriptFile.getCurrentRpnExpr()->size() - $3;
+        m_ScriptFile.getCurrentRpnExpr()->insert(pos, SymOperand::create("."));
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::ALIGN>());
+        $$ = $3 + 2;
+      }
+    | DATA_SEGMENT_ALIGN
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(SymOperand::create("."));
+      }
+      '(' exp ',' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::DATA_SEGMENT_ALIGN>());
+        $$ = $4 + $6 + 2;
+      }
+    | DATA_SEGMENT_END '(' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::DATA_SEGMENT_END>());
+        $$ = $3 + 1;
+      }
+    | DATA_SEGMENT_RELRO_END '(' exp ',' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::DATA_SEGMENT_RELRO_END>());
+        $$ = $3 + $5 + 1;
+      }
+    | DEFINED '(' symbol ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(SymOperand::create(*$3));
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::DEFINED>());
+        $$ = 2;
+      }
+    | LENGTH '(' string ')'
+      {
+        /* TODO */
+      }
+    | LOADADDR '(' string ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(SectOperand::create(*$3));
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::LOADADDR>());
+        $$ = 2;
+      }
+    | MAX '(' exp ',' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::MAX>());
+        $$ = $3 + $5 + 1;
+      }
+    | MIN '(' exp ',' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::MIN>());
+        $$ = $3 + $5 + 1;
+      }
+    | NEXT '(' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::NEXT>());
+        $$ = $3 + 1;
+      }
+    | ORIGIN '(' string ')'
+      {
+        /* TODO */
+      }
+    | SEGMENT_START '(' string
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(SectOperand::create(*$3));
+      }
+      ',' exp ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::SEGMENT_START>());
+        $$ = $6 + 2;
+      }
+    | SIZEOF '(' string ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(SectOperand::create(*$3));
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::SIZEOF>());
+        $$ = 2;
+      }
+    | SIZEOF_HEADERS
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::SIZEOF_HEADERS>());
+        $$ = 1;
+      }
+    | CONSTANT '(' MAXPAGESIZE ')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::MAXPAGESIZE>());
+        $$ = 1;
+      }
+    | CONSTANT '(' COMMONPAGESIZE')'
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(
+          &Operator::create<Operator::COMMONPAGESIZE>());
+        $$ = 1;
+      }
+    | INTEGER
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(IntOperand::create($1));
+        $$ = 1;
+      }
+    | symbol
+      {
+        m_ScriptFile.getCurrentRpnExpr()->push_back(SymOperand::create(*$1));
+        $$ = 1;
+      }
+    ;
+
+symbol : STRING
+         { $$ = $1; }
+       ;
+
+string : STRING
+         { $$ = $1; }
+       | '"' STRING '"'
+         { $$ = $2; }
+       ;
+
+%%
+
+void mcld::ScriptParser::error(const mcld::ScriptParser::location_type& pLoc,
+                               const std::string &pMsg)
+{
+  position last = pLoc.end - 1;
+  std::string filename = "NaN";
+  if (last.filename != NULL)
+    filename = *last.filename;
+
+  mcld::error(diag::err_syntax_error)
+    << filename << last.line << last.column << pMsg;
+}
+
diff --git a/lib/Script/ScriptReader.cpp b/lib/Script/ScriptReader.cpp
new file mode 100644
index 0000000..37c3ce9
--- /dev/null
+++ b/lib/Script/ScriptReader.cpp
@@ -0,0 +1,58 @@
+//===- ScriptReader.cpp ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/ScriptReader.h>
+#include <mcld/Script/ScriptScanner.h>
+#include <mcld/Script/ScriptFile.h>
+#include <mcld/MC/Input.h>
+#include <mcld/Support/MemoryArea.h>
+
+#include <llvm/ADT/StringRef.h>
+
+#include <istream>
+#include <sstream>
+
+using namespace mcld;
+
+ScriptReader::ScriptReader(GroupReader& pGroupReader)
+  : m_GroupReader(pGroupReader)
+{
+}
+
+ScriptReader::~ScriptReader()
+{
+}
+
+/// isMyFormat
+bool ScriptReader::isMyFormat(Input& input, bool &doContinue) const
+{
+  doContinue = true;
+  // always return true now
+  return true;
+}
+
+bool ScriptReader::readScript(const LinkerConfig& pConfig,
+                              ScriptFile& pScriptFile)
+{
+  bool result = false;
+  Input& input = pScriptFile.input();
+  size_t size = input.memArea()->size();
+  llvm::StringRef region = input.memArea()->request(input.fileOffset(), size);
+  std::stringbuf buf(region.data());
+
+  std::istream in(&buf);
+  ScriptScanner scanner(&in);
+  ScriptParser parser(pConfig,
+                      pScriptFile,
+                      scanner,
+                      m_GroupReader);
+  result = (0 == parser.parse());;
+
+  return result;
+}
+
diff --git a/lib/Script/ScriptScanner.ll b/lib/Script/ScriptScanner.ll
new file mode 100644
index 0000000..f3fd921
--- /dev/null
+++ b/lib/Script/ScriptScanner.ll
@@ -0,0 +1,388 @@
+/*===- ScriptScanner.ll ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===*/
+
+%{
+/* C/C++ Declarations */
+
+#include <mcld/Script/ScriptScanner.h>
+#include <mcld/Script/ScriptFile.h>
+#include <mcld/Support/MsgHandling.h>
+#include <llvm/ADT/StringRef.h>
+#include <string>
+
+typedef mcld::ScriptParser::token token;
+typedef mcld::ScriptParser::token_type token_type;
+
+#define yyterminate() return token::END
+#define YY_NO_UNISTD_H
+%}
+
+/* Flex Declarations and Options */
+%option c++
+%option batch
+%option noyywrap
+%option nounput
+%option stack
+
+%{
+#define YY_USER_ACTION  yylloc->columns(yyleng);
+%}
+
+/* abbrev. of RE @ref binutils ld/ldlex.l */
+FILENAMECHAR1   [_a-zA-Z\/\.\\\$\_\~]
+SYMBOLCHARN     [_a-zA-Z\/\.\\\$\_\~0-9]
+NOCFILENAMECHAR [_a-zA-Z0-9\/\.\-\_\+\$\[\]\\\~]
+WILDCHAR        [_a-zA-Z0-9\/\.\-\_\+\$\[\]\\\,\~\?\*\^\!]
+WS [ \t\r]
+
+/* Start conditions */
+%s LDSCRIPT
+%s EXPRESSION
+
+%% /* Regular Expressions */
+
+ /* code to place at the beginning of yylex() */
+%{
+  /* reset location */
+  yylloc->step();
+
+  /* determine the initial parser state */
+  if (m_Kind == ScriptFile::Unknown) {
+    m_Kind = pScriptFile.getKind();
+    switch (pScriptFile.getKind()) {
+    case ScriptFile::LDScript:
+    case ScriptFile::Expression:
+      return token::LINKER_SCRIPT;
+    case ScriptFile::VersionScript:
+    case ScriptFile::DynamicList:
+    default:
+      assert(0 && "Unsupported script type!");
+      break;
+    }
+  }
+%}
+
+ /* Entry Point */
+<LDSCRIPT>"ENTRY"                      { return token::ENTRY; }
+ /* File Commands */
+<LDSCRIPT>"INCLUDE"                    { return token::INCLUDE; }
+<LDSCRIPT>"INPUT"                      { return token::INPUT; }
+<LDSCRIPT>"GROUP"                      { return token::GROUP; }
+<LDSCRIPT>"AS_NEEDED"                  { return token::AS_NEEDED; }
+<LDSCRIPT>"OUTPUT"                     { return token::OUTPUT; }
+<LDSCRIPT>"SEARCH_DIR"                 { return token::SEARCH_DIR; }
+<LDSCRIPT>"STARTUP"                    { return token::STARTUP; }
+ /* Format Commands */
+<LDSCRIPT>"OUTPUT_FORMAT"              { return token::OUTPUT_FORMAT; }
+<LDSCRIPT>"TARGET"                     { return token::TARGET; }
+ /* Misc Commands */
+<LDSCRIPT>"ASSERT"                     { return token::ASSERT; }
+<LDSCRIPT>"EXTERN"                     { return token::EXTERN; }
+<LDSCRIPT>"FORCE_COMMON_ALLOCATION"    { return token::FORCE_COMMON_ALLOCATION; }
+<LDSCRIPT>"INHIBIT_COMMON_ALLOCATION"  { return token::INHIBIT_COMMON_ALLOCATION; }
+<LDSCRIPT>"INSERT"                     { return token::INSERT; }
+<LDSCRIPT>"NOCROSSREFS"                { return token::NOCROSSREFS; }
+<LDSCRIPT>"OUTPUT_ARCH"                { return token::OUTPUT_ARCH; }
+<LDSCRIPT>"LD_FEATURE"                 { return token::LD_FEATURE; }
+ /* Assignemnts */
+<LDSCRIPT,EXPRESSION>"HIDDEN"          { return token::HIDDEN; }
+<LDSCRIPT,EXPRESSION>"PROVIDE"         { return token::PROVIDE; }
+<LDSCRIPT,EXPRESSION>"PROVIDE_HIDDEN"  { return token::PROVIDE_HIDDEN; }
+ /* SECTIONS Command */
+<LDSCRIPT>"SECTIONS"                   { return token::SECTIONS; }
+ /* MEMORY Command */
+<LDSCRIPT>"MEMORY"                     { return token::MEMORY; }
+ /* PHDRS Command */
+<LDSCRIPT>"PHDRS"                      { return token::PHDRS; }
+ /* Builtin Functions */
+<EXPRESSION>"ABSOLUTE"                 { return token::ABSOLUTE; }
+<EXPRESSION>"ADDR"                     { return token::ADDR; }
+<LDSCRIPT,EXPRESSION>"ALIGN"           { return token::ALIGN; }
+<EXPRESSION>"ALIGNOF"                  { return token::ALIGNOF; }
+<EXPRESSION>"BLOCK"                    { return token::BLOCK; }
+<EXPRESSION>"DATA_SEGMENT_ALIGN"       { return token::DATA_SEGMENT_ALIGN; }
+<EXPRESSION>"DATA_SEGMENT_END"         { return token::DATA_SEGMENT_END; }
+<EXPRESSION>"DATA_SEGMENT_RELRO_END"   { return token::DATA_SEGMENT_RELRO_END; }
+<EXPRESSION>"DEFINED"                  { return token::DEFINED; }
+<EXPRESSION>"LENGTH"                   { return token::LENGTH; }
+<EXPRESSION>"LOADADDR"                 { return token::LOADADDR; }
+<EXPRESSION>"MAX"                      { return token::MAX; }
+<EXPRESSION>"MIN"                      { return token::MIN; }
+<EXPRESSION>"NEXT"                     { return token::NEXT; }
+<EXPRESSION>"ORIGIN"                   { return token::ORIGIN; }
+<EXPRESSION>"SEGMENT_START"            { return token::SEGMENT_START; }
+<EXPRESSION>"SIZEOF"                   { return token::SIZEOF; }
+<EXPRESSION>"SIZEOF_HEADERS"           { return token::SIZEOF_HEADERS; }
+<EXPRESSION>"CONSTANT"                 { return token::CONSTANT; }
+ /* Symbolic Constants */
+<EXPRESSION>"MAXPAGESIZE"              { return token::MAXPAGESIZE; }
+<EXPRESSION>"COMMONPAGESIZE"           { return token::COMMONPAGESIZE; }
+ /* Input Section Description */
+<LDSCRIPT>"EXCLUDE_FILE"               { return token::EXCLUDE_FILE; }
+<LDSCRIPT>"KEEP"                       { return token::KEEP; }
+<LDSCRIPT>"SORT"                       { return token::SORT_BY_NAME; }
+<LDSCRIPT>"SORT_BY_NAME"               { return token::SORT_BY_NAME; }
+<LDSCRIPT>"SORT_BY_ALIGNMENT"          { return token::SORT_BY_ALIGNMENT; }
+<LDSCRIPT>"SORT_NONE"                  { return token::SORT_NONE; }
+<LDSCRIPT>"SORT_BY_INIT_PRIORITY"      { return token::SORT_BY_INIT_PRIORITY; }
+ /* Output Section Data */
+<LDSCRIPT>"BYTE"                       { return token::BYTE; }
+<LDSCRIPT>"SHORT"                      { return token::SHORT; }
+<LDSCRIPT>"LONG"                       { return token::LONG; }
+<LDSCRIPT>"QUAD"                       { return token::QUAD; }
+<LDSCRIPT>"SQUAD"                      { return token::SQUAD; }
+<LDSCRIPT>"FILL"                       { return token::FILL; }
+ /* Output Section Discarding */
+<LDSCRIPT>"DISCARD"                    { return token::DISCARD; }
+ /* Output Section Keywords */
+<LDSCRIPT>"CREATE_OBJECT_SYMBOLS"      { return token::CREATE_OBJECT_SYMBOLS; }
+<LDSCRIPT>"CONSTRUCTORS"               { return token::CONSTRUCTORS; }
+ /* Output Section Attributes */
+ /* Output Section Type */
+<LDSCRIPT,EXPRESSION>"NOLOAD"          { return token::NOLOAD; }
+<LDSCRIPT,EXPRESSION>"DSECT"           { return token::DSECT; }
+<LDSCRIPT,EXPRESSION>"COPY"            { return token::COPY; }
+<LDSCRIPT,EXPRESSION>"INFO"            { return token::INFO; }
+<LDSCRIPT,EXPRESSION>"OVERLAY"         { return token::OVERLAY; }
+ /* Output Section LMA */
+<LDSCRIPT>"AT"                         { return token::AT; }
+ /* Forced Input Alignment */
+<LDSCRIPT>"SUBALIGN"                   { return token::SUBALIGN; }
+ /* Output Section Constraint */
+<LDSCRIPT>"ONLY_IF_RO"                 { return token::ONLY_IF_RO; }
+<LDSCRIPT>"ONLY_IF_RW"                 { return token::ONLY_IF_RW; }
+ /* Operators */
+<LDSCRIPT,EXPRESSION>"<<"              { return token::LSHIFT; }
+<LDSCRIPT,EXPRESSION>">>"              { return token::RSHIFT; }
+<LDSCRIPT,EXPRESSION>"=="              { return token::EQ; }
+<LDSCRIPT,EXPRESSION>"!="              { return token::NE; }
+<LDSCRIPT,EXPRESSION>"<="              { return token::LE; }
+<LDSCRIPT,EXPRESSION>">="              { return token::GE; }
+<LDSCRIPT,EXPRESSION>"&&"              { return token::LOGICAL_AND; }
+<LDSCRIPT,EXPRESSION>"||"              { return token::LOGICAL_OR; }
+<LDSCRIPT,EXPRESSION>"+="              { return token::ADD_ASSIGN; }
+<LDSCRIPT,EXPRESSION>"-="              { return token::SUB_ASSIGN; }
+<LDSCRIPT,EXPRESSION>"*="              { return token::MUL_ASSIGN; }
+<LDSCRIPT,EXPRESSION>"/="              { return token::DIV_ASSIGN; }
+<LDSCRIPT,EXPRESSION>"&="              { return token::AND_ASSIGN; }
+<LDSCRIPT,EXPRESSION>"|="              { return token::OR_ASSIGN; }
+<LDSCRIPT,EXPRESSION>"<<="             { return token::LS_ASSIGN; }
+<LDSCRIPT,EXPRESSION>">>="             { return token::RS_ASSIGN; }
+<LDSCRIPT,EXPRESSION>","               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"="               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"?"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>":"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"|"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"^"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"&"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"<"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>">"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"+"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"-"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"*"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"/"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"%"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"!"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"~"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>";"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"("               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>")"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"{"               { return static_cast<token_type>(*yytext); }
+<LDSCRIPT,EXPRESSION>"}"               { return static_cast<token_type>(*yytext); }
+
+ /* Numbers */
+<LDSCRIPT,EXPRESSION>((("$"|0[xX])([0-9A-Fa-f])+)|(([0-9])+))(M|K|m|k)? {
+  llvm::StringRef str(yytext, yyleng);
+  switch (str.back()) {
+  case 'k':
+  case 'K':
+    str.substr(0, yyleng - 1).getAsInteger(0, yylval->integer);
+    yylval->integer *= 1024;
+    break;
+  case 'm':
+  case 'M':
+    str.substr(0, yyleng - 1).getAsInteger(0, yylval->integer);
+    yylval->integer *= 1024 * 1024;
+    break;
+  default:
+    str.getAsInteger(0, yylval->integer);
+    break;
+  }
+  return token::INTEGER;
+}
+
+ /* Expression string */
+<EXPRESSION>{FILENAMECHAR1}{SYMBOLCHARN}* {
+  const std::string& str = pScriptFile.createParserStr(yytext, yyleng);
+  yylval->string = &str;
+  return token::STRING;
+}
+
+ /* String */
+<LDSCRIPT>{FILENAMECHAR1}{NOCFILENAMECHAR}* {
+  const std::string& str = pScriptFile.createParserStr(yytext, yyleng);
+  yylval->string = &str;
+  return token::STRING;
+}
+
+<LDSCRIPT,EXPRESSION>\"(\\.|[^\\"])*\" {
+  /*" c string literal */
+  const std::string& str = pScriptFile.createParserStr(yytext, yyleng);
+  yylval->string = &str;
+  return token::STRING;
+}
+
+ /* -l namespec */
+<LDSCRIPT>"-l"{FILENAMECHAR1}{NOCFILENAMECHAR}* {
+  const std::string& str = pScriptFile.createParserStr(yytext + 2, yyleng - 2);
+  yylval->string = &str;
+  return token::LNAMESPEC;
+}
+
+ /* WILDCHAR String */
+<LDSCRIPT>{WILDCHAR}* {
+  if (yytext[0] == '/' && yytext[1] == '*') {
+    yyless (2);
+    enterComments(*yylloc);
+  } else {
+    const std::string& str = pScriptFile.createParserStr(yytext, yyleng);
+    yylval->string = &str;
+    return token::STRING;
+  }
+}
+
+ /* gobble up C comments */
+<LDSCRIPT,EXPRESSION>"/*" {
+  enterComments(*yylloc);
+  yylloc->step();
+}
+
+ /* gobble up white-spaces */
+<LDSCRIPT,EXPRESSION>{WS}+ {
+  yylloc->step();
+}
+
+ /* gobble up end-of-lines */
+<LDSCRIPT,EXPRESSION>\n {
+  yylloc->lines(1);
+  yylloc->step();
+}
+
+%% /* Additional Code */
+
+namespace mcld {
+
+ScriptScanner::ScriptScanner(std::istream* yyin, std::ostream* yyout)
+  : yyFlexLexer(yyin, yyout), m_Kind(ScriptFile::Unknown)
+{
+}
+
+ScriptScanner::~ScriptScanner()
+{
+}
+
+void ScriptScanner::enterComments(ScriptParser::location_type& pLocation)
+{
+  const int start_line = pLocation.begin.line;
+  const int start_col  = pLocation.begin.column;
+
+  int ch = 0;
+
+  while (true) {
+    ch = yyinput();
+    pLocation.columns(1);
+
+    while (ch != '*' && ch != EOF) {
+      if (ch == '\n') {
+        pLocation.lines(1);
+      }
+
+      ch = yyinput();
+      pLocation.columns(1);
+    }
+
+    if (ch == '*') {
+      ch = yyinput();
+      pLocation.columns(1);
+
+      while (ch == '*') {
+        ch = yyinput();
+        pLocation.columns(1);
+      }
+
+      if (ch == '/')
+        break;
+    }
+
+    if (ch == '\n')
+      pLocation.lines(1);
+
+    if (ch == EOF) {
+      error(diag::err_unterminated_comment) << pLocation.begin.filename
+                                            << start_line
+                                            << start_col;
+      break;
+    }
+  }
+}
+
+void ScriptScanner::setLexState(ScriptFile::Kind pKind)
+{
+  /* push the state into the top of stach */
+  m_StateStack.push(pKind);
+
+  switch (pKind) {
+  case ScriptFile::LDScript:
+    BEGIN(LDSCRIPT);
+    break;
+  case ScriptFile::Expression:
+    BEGIN(EXPRESSION);
+    break;
+  case ScriptFile::VersionScript:
+  case ScriptFile::DynamicList:
+  default:
+    assert(0 && "Unsupported script type!");
+    break;
+  }
+}
+
+void ScriptScanner::popLexState()
+{
+  /* pop the last state */
+  m_StateStack.pop();
+
+  /* resume the appropriate state */
+  if (!m_StateStack.empty()) {
+    switch (m_StateStack.top()) {
+    case ScriptFile::LDScript:
+      BEGIN(LDSCRIPT);
+      break;
+    case ScriptFile::Expression:
+      BEGIN(EXPRESSION);
+      break;
+    case ScriptFile::VersionScript:
+    case ScriptFile::DynamicList:
+    default:
+      assert(0 && "Unsupported script type!");
+      break;
+    }
+  }
+}
+
+} /* namespace of mcld */
+
+#ifdef yylex
+#undef yylex
+#endif
+
+int yyFlexLexer::yylex()
+{
+  return 0;
+}
+
diff --git a/lib/Script/SearchDirCmd.cpp b/lib/Script/SearchDirCmd.cpp
new file mode 100644
index 0000000..dd9a56f
--- /dev/null
+++ b/lib/Script/SearchDirCmd.cpp
@@ -0,0 +1,38 @@
+//===- SearchDirCmd.cpp ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/SearchDirCmd.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/Module.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// SearchDirCmd
+//===----------------------------------------------------------------------===//
+SearchDirCmd::SearchDirCmd(const std::string& pPath)
+  : ScriptCommand(ScriptCommand::SEARCH_DIR),
+    m_Path(pPath)
+{
+}
+
+SearchDirCmd::~SearchDirCmd()
+{
+}
+
+void SearchDirCmd::dump() const
+{
+  mcld::outs() << "SEARCH_DIR ( " << m_Path << " )\n";
+}
+
+void SearchDirCmd::activate(Module& pModule)
+{
+  pModule.getScript().directories().insert(m_Path);
+}
+
diff --git a/lib/Script/SectionsCmd.cpp b/lib/Script/SectionsCmd.cpp
new file mode 100644
index 0000000..4ecc838
--- /dev/null
+++ b/lib/Script/SectionsCmd.cpp
@@ -0,0 +1,94 @@
+//===- SectionsCmd.cpp ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/SectionsCmd.h>
+#include <mcld/Support/raw_ostream.h>
+#include <cassert>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// SectionsCmd
+//===----------------------------------------------------------------------===//
+SectionsCmd::SectionsCmd()
+  : ScriptCommand(ScriptCommand::SECTIONS)
+{
+}
+
+SectionsCmd::~SectionsCmd()
+{
+  for (iterator it = begin(), ie = end(); it != ie; ++it) {
+    if (*it != NULL)
+      delete *it;
+  }
+}
+
+void SectionsCmd::dump() const
+{
+  mcld::outs() << "SECTIONS\n{\n";
+
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
+    switch ((*it)->getKind()) {
+    case ScriptCommand::ENTRY:
+    case ScriptCommand::ASSIGNMENT:
+    case ScriptCommand::OUTPUT_SECT_DESC:
+      mcld::outs() << "\t";
+      (*it)->dump();
+      break;
+    default:
+      assert(0);
+      break;
+    }
+  }
+
+  mcld::outs() << "}\n";
+}
+
+void SectionsCmd::push_back(ScriptCommand* pCommand)
+{
+  switch (pCommand->getKind()) {
+  case ScriptCommand::ENTRY:
+  case ScriptCommand::ASSIGNMENT:
+  case ScriptCommand::OUTPUT_SECT_DESC:
+    m_SectionCommands.push_back(pCommand);
+    break;
+  default:
+    assert(0);
+    break;
+  }
+}
+
+void SectionsCmd::activate(Module& pModule)
+{
+  // Assignment between output sections
+  SectionCommands assignments;
+
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it) {
+    switch ((*it)->getKind()) {
+    case ScriptCommand::ENTRY:
+      (*it)->activate(pModule);
+      break;
+    case ScriptCommand::ASSIGNMENT:
+      assignments.push_back(*it);
+      break;
+    case ScriptCommand::OUTPUT_SECT_DESC: {
+      (*it)->activate(pModule);
+
+      iterator assign, assignEnd = assignments.end();
+      for (assign = assignments.begin(); assign != assignEnd; ++assign)
+        (*assign)->activate(pModule);
+      assignments.clear();
+
+      break;
+    }
+    default:
+      assert(0);
+      break;
+    }
+  }
+}
diff --git a/lib/Script/StrToken.cpp b/lib/Script/StrToken.cpp
new file mode 100644
index 0000000..f886623
--- /dev/null
+++ b/lib/Script/StrToken.cpp
@@ -0,0 +1,52 @@
+//===- StrToken.cpp -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/StrToken.h>
+#include <mcld/Support/GCFactory.h>
+#include <llvm/Support/ManagedStatic.h>
+
+using namespace mcld;
+
+typedef GCFactory<StrToken, MCLD_SYMBOLS_PER_INPUT> StrTokenFactory;
+static llvm::ManagedStatic<StrTokenFactory> g_StrTokenFactory;
+
+//===----------------------------------------------------------------------===//
+// StrToken
+//===----------------------------------------------------------------------===//
+StrToken::StrToken()
+  : m_Kind(Unknown)
+{
+}
+
+StrToken::StrToken(Kind pKind, const std::string& pString)
+  : m_Kind(pKind), m_Name(pString)
+{
+}
+
+StrToken::~StrToken()
+{
+}
+
+StrToken* StrToken::create(const std::string& pString)
+{
+  StrToken* result = g_StrTokenFactory->allocate();
+  new (result) StrToken(String, pString);
+  return result;
+}
+
+void StrToken::destroy(StrToken*& pStrToken)
+{
+  g_StrTokenFactory->destroy(pStrToken);
+  g_StrTokenFactory->deallocate(pStrToken);
+  pStrToken = NULL;
+}
+
+void StrToken::clear()
+{
+  g_StrTokenFactory->clear();
+}
diff --git a/lib/Script/StringList.cpp b/lib/Script/StringList.cpp
new file mode 100644
index 0000000..e5637fb
--- /dev/null
+++ b/lib/Script/StringList.cpp
@@ -0,0 +1,60 @@
+//===- StringList.cpp ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/StringList.h>
+#include <mcld/Script/StrToken.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/Support/GCFactory.h>
+#include <llvm/Support/ManagedStatic.h>
+
+using namespace mcld;
+
+typedef GCFactory<StringList, MCLD_SYMBOLS_PER_INPUT> StringListFactory;
+static llvm::ManagedStatic<StringListFactory> g_StringListFactory;
+
+//===----------------------------------------------------------------------===//
+// StringList
+//===----------------------------------------------------------------------===//
+StringList::StringList()
+{
+}
+
+StringList::~StringList()
+{
+}
+
+void StringList::push_back(StrToken* pToken)
+{
+  m_Tokens.push_back(pToken);
+}
+
+void StringList::dump() const
+{
+  for (const_iterator it = begin(), ie = end(); it != ie; ++it)
+    mcld::outs() << (*it)->name() << "\t";
+  mcld::outs() << "\n";
+}
+
+StringList* StringList::create()
+{
+  StringList* result = g_StringListFactory->allocate();
+  new (result) StringList();
+  return result;
+}
+
+void StringList::destroy(StringList*& pStringList)
+{
+  g_StringListFactory->destroy(pStringList);
+  g_StringListFactory->deallocate(pStringList);
+  pStringList = NULL;
+}
+
+void StringList::clear()
+{
+  g_StringListFactory->clear();
+}
diff --git a/lib/Script/TernaryOp.cpp b/lib/Script/TernaryOp.cpp
new file mode 100644
index 0000000..131f460
--- /dev/null
+++ b/lib/Script/TernaryOp.cpp
@@ -0,0 +1,58 @@
+//===- TernaryOp.cpp ------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/TernaryOp.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/ADT/SizeTraits.h>
+
+using namespace mcld;
+//===----------------------------------------------------------------------===//
+// TernaryOp
+//===----------------------------------------------------------------------===//
+template<>
+IntOperand*
+TernaryOp<Operator::TERNARY_IF>::eval(const Module& pModule,
+                                      const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  if (m_pOperand[0]->value())
+    res->setValue(m_pOperand[1]->value());
+  else
+    res->setValue(m_pOperand[2]->value());
+  return res;
+}
+
+/* DATA_SEGMENT_ALIGN(maxpagesize, commonpagesize) */
+template<>
+IntOperand*
+TernaryOp<Operator::DATA_SEGMENT_ALIGN>::eval(const Module& pModule,
+                                              const TargetLDBackend& pBackend)
+{
+  /* This is equivalent to either
+       (ALIGN(maxpagesize) + (. & (maxpagesize - 1)))
+     or
+       (ALIGN(maxpagesize) + (. & (maxpagesize - commonpagesize)))
+   */
+  IntOperand* res = result();
+  uint64_t dot = m_pOperand[0]->value();
+  uint64_t maxPageSize = m_pOperand[1]->value();
+  uint64_t commonPageSize = m_pOperand[2]->value();
+  uint64_t form1 = 0, form2 = 0;
+
+  alignAddress(dot, maxPageSize);
+
+  form1 = dot + (dot & (maxPageSize - 1));
+  form2 = dot + (dot & (maxPageSize - commonPageSize));
+
+  if (form1 <= form2)
+    res->setValue(form1);
+  else
+    res->setValue(form2);
+  return res;
+}
+
diff --git a/lib/Script/UnaryOp.cpp b/lib/Script/UnaryOp.cpp
new file mode 100644
index 0000000..866bbb2
--- /dev/null
+++ b/lib/Script/UnaryOp.cpp
@@ -0,0 +1,188 @@
+//===- UnaryOp.cpp --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/UnaryOp.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Object/SectionMap.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/Module.h>
+#include <llvm/Support/Casting.h>
+#include <cassert>
+
+using namespace mcld;
+//===----------------------------------------------------------------------===//
+// UnaryOp
+//===----------------------------------------------------------------------===//
+template<>
+IntOperand* UnaryOp<Operator::UNARY_PLUS>::eval(const Module& pModule,
+                                                const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(+ m_pOperand->value());
+  return res;
+}
+
+template<>
+IntOperand*
+UnaryOp<Operator::UNARY_MINUS>::eval(const Module& pModule,
+                                     const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(- m_pOperand->value());
+  return res;
+}
+
+template<>
+IntOperand*
+UnaryOp<Operator::LOGICAL_NOT>::eval(const Module& pModule,
+                                     const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(! m_pOperand->value());
+  return res;
+}
+
+template<>
+IntOperand*
+UnaryOp<Operator::BITWISE_NOT>::eval(const Module& pModule,
+                                     const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(~ m_pOperand->value());
+  return res;
+}
+
+template<>
+IntOperand* UnaryOp<Operator::ABSOLUTE>::eval(const Module& pModule,
+                                              const TargetLDBackend& pBackend)
+{
+  // TODO
+  assert(0);
+  return result();
+}
+
+template<>
+IntOperand* UnaryOp<Operator::ADDR>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  const LDSection* sect = NULL;
+  switch (m_pOperand->type()) {
+  case Operand::SECTION:
+    sect = pModule.getSection(llvm::cast<SectOperand>(m_pOperand)->name());
+    break;
+  case Operand::SECTION_DESC:
+    sect = llvm::cast<SectDescOperand>(m_pOperand)->outputDesc()->getSection();
+    break;
+  default:
+    assert(0);
+    break;
+  }
+  assert(sect != NULL);
+  res->setValue(sect->addr());
+  return res;
+}
+
+template<>
+IntOperand* UnaryOp<Operator::ALIGNOF>::eval(const Module& pModule,
+                                             const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  const LDSection* sect = NULL;
+  switch (m_pOperand->type()) {
+  case Operand::SECTION:
+    sect = pModule.getSection(llvm::cast<SectOperand>(m_pOperand)->name());
+    break;
+  case Operand::SECTION_DESC:
+    sect = llvm::cast<SectDescOperand>(m_pOperand)->outputDesc()->getSection();
+    break;
+  default:
+    assert(0);
+    break;
+  }
+  assert(sect != NULL);
+  res->setValue(sect->align());
+  return res;
+}
+
+template<>
+IntOperand*
+UnaryOp<Operator::DATA_SEGMENT_END>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  res->setValue(m_pOperand->value());
+  return res;
+}
+
+template<>
+IntOperand* UnaryOp<Operator::DEFINED>::eval(const Module& pModule,
+                                             const TargetLDBackend& pBackend)
+{
+  // TODO
+  assert(0);
+  return result();
+}
+
+template<>
+IntOperand* UnaryOp<Operator::LENGTH>::eval(const Module& pModule,
+                                            const TargetLDBackend& pBackend)
+{
+  // TODO
+  assert(0);
+  return result();
+}
+
+template<>
+IntOperand* UnaryOp<Operator::LOADADDR>::eval(const Module& pModule,
+                                              const TargetLDBackend& pBackend)
+{
+  // TODO
+  assert(0);
+  return result();
+}
+
+template<>
+IntOperand* UnaryOp<Operator::NEXT>::eval(const Module& pModule,
+                                          const TargetLDBackend& pBackend)
+{
+  // TODO
+  assert(0);
+  return result();
+}
+
+template<>
+IntOperand* UnaryOp<Operator::ORIGIN>::eval(const Module& pModule,
+                                            const TargetLDBackend& pBackend)
+{
+  // TODO
+  assert(0);
+  return result();
+}
+
+template<>
+IntOperand* UnaryOp<Operator::SIZEOF>::eval(const Module& pModule,
+                                            const TargetLDBackend& pBackend)
+{
+  IntOperand* res = result();
+  const LDSection* sect = NULL;
+  switch (m_pOperand->type()) {
+  case Operand::SECTION:
+    sect = pModule.getSection(llvm::cast<SectOperand>(m_pOperand)->name());
+    break;
+  case Operand::SECTION_DESC:
+    sect = llvm::cast<SectDescOperand>(m_pOperand)->outputDesc()->getSection();
+    break;
+  default:
+    assert(0);
+    break;
+  }
+  assert(sect != NULL);
+  res->setValue(sect->size());
+  return res;
+}
diff --git a/lib/Script/WildcardPattern.cpp b/lib/Script/WildcardPattern.cpp
new file mode 100644
index 0000000..035250e
--- /dev/null
+++ b/lib/Script/WildcardPattern.cpp
@@ -0,0 +1,69 @@
+//===- WildcardPattern.cpp ------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Script/WildcardPattern.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/Support/GCFactory.h>
+#include <llvm/Support/ManagedStatic.h>
+#include <cassert>
+
+using namespace mcld;
+
+typedef GCFactory<WildcardPattern,
+                  MCLD_SYMBOLS_PER_INPUT> WildcardPatternFactory;
+static llvm::ManagedStatic<WildcardPatternFactory> g_WildcardPatternFactory;
+
+//===----------------------------------------------------------------------===//
+// WildcardPattern
+//===----------------------------------------------------------------------===//
+WildcardPattern::WildcardPattern()
+  : m_bIsPrefix(false)
+{
+}
+
+WildcardPattern::WildcardPattern(const std::string& pPattern,
+                                 SortPolicy pPolicy)
+  : StrToken(StrToken::Wildcard, pPattern), m_SortPolicy(pPolicy)
+{
+  if (pPattern.find_first_of('*') == (pPattern.size() - 1))
+    m_bIsPrefix = true;
+  else
+    m_bIsPrefix = false;
+}
+
+WildcardPattern::~WildcardPattern()
+{
+}
+
+llvm::StringRef WildcardPattern::prefix() const
+{
+  if (isPrefix())
+    return llvm::StringRef(name().c_str(), name().size() - 1);
+
+  return llvm::StringRef(name());
+}
+
+WildcardPattern* WildcardPattern::create(const std::string& pPattern,
+                                         SortPolicy pPolicy)
+{
+  WildcardPattern* result = g_WildcardPatternFactory->allocate();
+  new (result) WildcardPattern(pPattern, pPolicy);
+  return result;
+}
+
+void WildcardPattern::destroy(WildcardPattern*& pWildcardPattern)
+{
+  g_WildcardPatternFactory->destroy(pWildcardPattern);
+  g_WildcardPatternFactory->deallocate(pWildcardPattern);
+  pWildcardPattern = NULL;
+}
+
+void WildcardPattern::clear()
+{
+  g_WildcardPatternFactory->clear();
+}
diff --git a/lib/Support/Android.mk b/lib/Support/Android.mk
index ce9c6f1..36983ed 100644
--- a/lib/Support/Android.mk
+++ b/lib/Support/Android.mk
@@ -2,25 +2,21 @@
 
 mcld_support_SRC_FILES := \
   CommandLine.cpp \
-  DefSymParser.cpp \
   Directory.cpp \
-  FileHandle.cpp  \
-  FileSystem.cpp  \
-  HandleToArea.cpp  \
-  LEB128.cpp  \
-  MemoryArea.cpp  \
+  FileHandle.cpp \
+  FileOutputBuffer.cpp \
+  FileSystem.cpp \
+  LEB128.cpp \
+  MemoryArea.cpp \
   MemoryAreaFactory.cpp \
-  MemoryRegion.cpp  \
   MsgHandling.cpp \
-  Path.cpp  \
-  RealPath.cpp  \
-  RegionFactory.cpp \
-  Space.cpp \
+  Path.cpp \
+  raw_ostream.cpp \
+  RealPath.cpp \
   SystemUtils.cpp \
-  TargetRegistry.cpp  \
-  ToolOutputFile.cpp  \
-  raw_mem_ostream.cpp \
-  raw_ostream.cpp
+  Target.cpp \
+  TargetRegistry.cpp \
+  ToolOutputFile.cpp
 
 # For the host
 # =====================================================
diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp
index 96eb60b..033f88b 100644
--- a/lib/Support/CommandLine.cpp
+++ b/lib/Support/CommandLine.cpp
@@ -142,7 +142,8 @@
     long long unsigned size = 0;
     Arg.drop_front(17).getAsInteger(0, size);
     Val.setPageSize(static_cast<uint64_t>(size));
-  } else if (Arg.startswith("max-page-size=")) {
+  }
+  else if (Arg.startswith("max-page-size=")) {
     Val.setKind(ZOption::MaxPageSize);
     long long unsigned size = 0;
     Arg.drop_front(14).getAsInteger(0, size);
diff --git a/lib/Support/DefSymParser.cpp b/lib/Support/DefSymParser.cpp
deleted file mode 100644
index 424364d..0000000
--- a/lib/Support/DefSymParser.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-//===- DefSymParser.cpp ---------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Support/DefSymParser.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/LD/LDSymbol.h>
-
-using namespace llvm;
-using namespace mcld;
-
-DefSymParser::DefSymParser(const Module& pModule)
-  : m_Module(pModule) {
-}
-
-// passing a valid operator will return a number whose quantity relative
-// to other such obtained quantities will give the priority of the operator
-static inline int precedence(const char* x)
-{
-  switch (*x) {
-    case '-' :
-    case '+' : return 0;
-    case '/' :
-    case '*' : return 1;
-    default  : assert("Unsupported operator specified");
-  }
-  return 0;
-}
-
-bool DefSymParser::parse(StringRef pExpr, uint64_t& pSymVal)
-{
-  std::stack<const char*> operatorStack;
-  std::stack<unsigned long> operandStack;
-  unsigned long operand1 = 0,
-                operand2 = 0,
-                result = 0;
-  std::string token;
-  std::vector<std::string> postfixString;
-  std::vector<std::string>::iterator it;
-  llvm::StringRef::iterator si = pExpr.begin();
-
-  // Implement a modified Shunting Yard algorithm to form a RPN of the
-  // given expression
-  while (si != pExpr.end()) {
-    if (*si == '+' || *si == '-' || *si == '*' || *si == '/') {
-      if (token.empty() && (*si == '+' || *si == '-'))
-        // we have a case such as a++b or a+-b or a-+b
-        // pushing 0 when a token begins with a + or - operator
-        // solves unary operator problem
-        token = "0";
-      // An operator encountered means a token ended, push it to
-      // postfix string queue.
-      postfixString.push_back(token);
-      token.clear();
-
-      if (operatorStack.empty()) {
-        operatorStack.push(si);
-      }
-      else {
-        if (precedence(si) <= precedence(operatorStack.top())) {
-          // if the precedence of incoming operator is less or equal to
-          // top of stack, we clear stack till top is lower precedence
-          // or its empty
-          while (!operatorStack.empty()) {
-            if (precedence(si) <= precedence(operatorStack.top())) {
-            postfixString.push_back(std::string(operatorStack.top(),1));
-            operatorStack.pop();
-            }
-            else {
-              break;
-            }
-          }
-        }
-        operatorStack.push(si);
-      }
-      si++;
-      continue;
-    }
-    // keep reading the token when there is no operator encountered
-    token += *si;
-    si++;
-  }
-  postfixString.push_back(token);
-  // pop off any remaining operators from operator stack
-  while (!operatorStack.empty()) {
-    postfixString.push_back(std::string(operatorStack.top(),1));
-    operatorStack.pop();
-  }
-  //evaluate the postfix expression written above
-
-  for (it=postfixString.begin(); it != postfixString.end(); it++) {
-    switch (*((*it).c_str())) {
-      case '*':
-      case '-':
-      case '+':
-      case '/':
-        // when postfix string has an operator, pop first two operands from
-        // operand stack, use them in evaluate expression and push result
-        // back to stack
-        assert(!operandStack.empty() && "Invalid expression: extra operand");
-        operand2 = operandStack.top();
-        operandStack.pop();
-        operand1 = operandStack.top();
-        operandStack.pop();
-        if (*((*it).c_str()) == '*')
-          result = operand1 * operand2;
-        else if (*((*it).c_str()) == '/')
-          result = operand1 / operand2;
-        else if (*((*it).c_str()) == '-')
-          result = operand1 - operand2;
-        else
-          result = operand1 + operand2;
-        operandStack.push(result);
-        break;
-      default:
-        // if the string encountered in postfix queue is a string
-        // try converting it to integer.
-        llvm::StringRef stringOperand(*it);
-        if(stringOperand.getAsInteger(0,result)) {
-          // the integer conversion failed means the token is a symbol
-          // or its invalid if the NamePool has no such symbol;
-          const LDSymbol* symbol =
-                              m_Module.getNamePool().findSymbol(stringOperand);
-
-          if (!symbol)
-            fatal(diag::fail_sym_resolution)
-                  << __FILE__ << __LINE__
-                  << "mclinker@googlegroups.com" ;
-          result = symbol->value();
-        }
-        operandStack.push(result);
-    }
-  }
-  // once complete queue is processed, stack top is result
-  pSymVal = operandStack.top();
-  return true;
-}
diff --git a/lib/Support/FileOutputBuffer.cpp b/lib/Support/FileOutputBuffer.cpp
new file mode 100644
index 0000000..ed8c898
--- /dev/null
+++ b/lib/Support/FileOutputBuffer.cpp
@@ -0,0 +1,59 @@
+//===- FileOutputBuffer.cpp ------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Support/FileOutputBuffer.h>
+#include <mcld/Support/FileHandle.h>
+#include <mcld/Support/Path.h>
+
+using namespace mcld;
+using llvm::sys::fs::mapped_file_region;
+
+FileOutputBuffer::FileOutputBuffer(llvm::sys::fs::mapped_file_region* pRegion,
+                                   FileHandle& pFileHandle)
+  : m_pRegion(pRegion), m_FileHandle(pFileHandle)
+{
+}
+
+FileOutputBuffer::~FileOutputBuffer()
+{
+  // Unmap buffer, letting OS flush dirty pages to file on disk.
+  m_pRegion.reset(0);
+}
+
+llvm::error_code FileOutputBuffer::create(FileHandle& pFileHandle,
+    size_t pSize, llvm::OwningPtr<FileOutputBuffer>& pResult)
+{
+  llvm::error_code EC;
+  llvm::OwningPtr<mapped_file_region> mapped_file(new mapped_file_region(
+      pFileHandle.handler(),
+      false,
+      mapped_file_region::readwrite,
+      pSize,
+      0,
+      EC));
+
+  if (EC)
+    return EC;
+
+  pResult.reset(new FileOutputBuffer(mapped_file.get(), pFileHandle));
+  if (pResult)
+    mapped_file.take();
+  return llvm::error_code::success();
+}
+
+MemoryRegion FileOutputBuffer::request(size_t pOffset, size_t pLength)
+{
+  if (pOffset > getBufferSize() || (pOffset + pLength) > getBufferSize())
+    return MemoryRegion();
+  return MemoryRegion(getBufferStart() + pOffset, pLength);
+}
+
+llvm::StringRef FileOutputBuffer::getPath() const
+{
+  return m_FileHandle.path().native();
+}
diff --git a/lib/Support/HandleToArea.cpp b/lib/Support/HandleToArea.cpp
deleted file mode 100644
index 31a26c5..0000000
--- a/lib/Support/HandleToArea.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//===- HandleToArea.cpp ----------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Support/HandleToArea.h>
-#include <mcld/Support/MemoryArea.h>
-#include <llvm/ADT/StringRef.h>
-
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// HandleToArea
-//===----------------------------------------------------------------------===//
-bool HandleToArea::push_back(FileHandle* pHandle, MemoryArea* pArea)
-{
-  if (NULL == pHandle || NULL == pArea)
-    return false;
-
-  Bucket bucket;
-  bucket.hash_value = HashFunction()(
-                              llvm::StringRef(pHandle->path().native().c_str(),
-                                              pHandle->path().native().size()));
-
-  bucket.handle = pHandle;
-  bucket.area = pArea;
-  m_AreaMap.push_back(bucket);
-  return true;
-}
-
-bool HandleToArea::erase(MemoryArea* pArea)
-{
-  if (NULL == pArea || NULL == pArea->handler())
-    return false;
-
-  return erase(pArea->handler()->path());
-}
-
-bool HandleToArea::erase(const sys::fs::Path& pPath)
-{
-  unsigned int hash_value = HashFunction()(
-                                  llvm::StringRef(pPath.native().c_str(),
-                                                  pPath.native().size()));
-
-  HandleToAreaMap::iterator bucket, bEnd = m_AreaMap.end();
-  for (bucket = m_AreaMap.begin(); bucket != bEnd; ++bucket) {
-    if (bucket->hash_value == hash_value && bucket->handle->path() == pPath) {
-      // found
-      m_AreaMap.erase(bucket);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-HandleToArea::Result HandleToArea::findFirst(const sys::fs::Path& pPath)
-{
-  unsigned int hash_value = HashFunction()(llvm::StringRef(pPath.native().c_str(),
-                                                         pPath.native().size()));
-
-  HandleToAreaMap::iterator bucket, bEnd = m_AreaMap.end();
-
-  for (bucket = m_AreaMap.begin(); bucket != bEnd; ++bucket) {
-    if (bucket->hash_value == hash_value) {
-      if (bucket->handle->path() == pPath) {
-        return Result(bucket->handle, bucket->area);
-      }
-    }
-  }
-
-  return Result(NULL, NULL);
-}
-
-HandleToArea::ConstResult HandleToArea::findFirst(const sys::fs::Path& pPath) const
-{
-  unsigned int hash_value = HashFunction()(llvm::StringRef(pPath.native().c_str(),
-                                                         pPath.native().size()));
-
-  HandleToAreaMap::const_iterator bucket, bEnd = m_AreaMap.end();
-
-  for (bucket = m_AreaMap.begin(); bucket != bEnd; ++bucket) {
-    if (bucket->hash_value == hash_value) {
-      if (bucket->handle->path() == pPath) {
-        return ConstResult(bucket->handle, bucket->area);
-      }
-    }
-  }
-
-  return ConstResult(NULL, NULL);
-}
-
diff --git a/lib/Support/MemoryArea.cpp b/lib/Support/MemoryArea.cpp
index c4015ea..862e6f1 100644
--- a/lib/Support/MemoryArea.cpp
+++ b/lib/Support/MemoryArea.cpp
@@ -7,161 +7,39 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/Space.h>
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/FileHandle.h>
-#include <mcld/Support/MsgHandling.h>
+#include <llvm/Support/system_error.h>
+
+#include <cassert>
 
 using namespace mcld;
 
 //===--------------------------------------------------------------------===//
 // MemoryArea
 //===--------------------------------------------------------------------===//
-// MemoryArea - special constructor
-// This constructor is used for *SPECIAL* situation. I'm sorry I can not
-// reveal what is the special situation.
-MemoryArea::MemoryArea(Space& pUniverse)
-  : m_pFileHandle(NULL) {
-  m_SpaceMap.insert(std::make_pair(Key(pUniverse.start(), pUniverse.size()),
-                                   &pUniverse));
-}
-
-MemoryArea::MemoryArea(FileHandle& pFileHandle)
-  : m_pFileHandle(&pFileHandle) {
-}
-
-MemoryArea::~MemoryArea()
+MemoryArea::MemoryArea(llvm::StringRef pFilename)
 {
+  llvm::MemoryBuffer::getFile(pFilename,
+                              m_pMemoryBuffer,
+                              /*FileSize*/ -1,
+                              /*RequiresNullTerminator*/ false);
 }
 
-// The layout of MemorySpace in the virtual memory space
-//
-// |  : page boundary
-// [,]: MemoryRegion
-// -  : fillment
-// =  : data
-//
-// |---[=|====|====|==]--|
-// ^   ^              ^  ^
-// |   |              |  |
-// | r_start      +r_len |
-// space.data      +space.size
-//
-// space.file_offset is the offset of the mapped file segment from the start of
-// the file. if the MemorySpace's type is ALLOCATED_ARRAY, the distances of
-// (space.data, r_start) and (r_len, space.size) are zero.
-//
-MemoryRegion* MemoryArea::request(size_t pOffset, size_t pLength)
+MemoryArea::MemoryArea(const char* pMemBuffer, size_t pSize)
 {
-  Space* space = find(pOffset, pLength);
-  if (NULL == space) {
-    // not found
-    if (NULL == m_pFileHandle) {
-      // if m_pFileHandle is NULL, clients delegate us an universal Space and
-      // we never remove it. In that way, space can not be NULL.
-      unreachable(diag::err_out_of_range_region) << pOffset << pLength;
-    }
-
-    space = Space::Create(*m_pFileHandle, pOffset, pLength);
-    m_SpaceMap.insert(std::make_pair(Key(space->start(), space->size()), space));
-  }
-
-  // adjust r_start
-  off_t distance = pOffset - space->start();
-  void* r_start = space->memory() + distance;
-
-  // now, we have a legal space to hold the new MemoryRegion
-  return MemoryRegion::Create(r_start, pLength, *space);
+  llvm::StringRef mem(pMemBuffer, pSize);
+  llvm::MemoryBuffer* buffer =
+      llvm::MemoryBuffer::getMemBuffer(mem, /*BufferName*/ "NaN",
+                                       /*RequiresNullTerminator*/ false);
+  assert(buffer != NULL);
+  m_pMemoryBuffer.reset(buffer);
 }
 
-// release - release a MemoryRegion
-void MemoryArea::release(MemoryRegion* pRegion)
+llvm::StringRef MemoryArea::request(size_t pOffset, size_t pLength)
 {
-  if (NULL == pRegion)
-    return;
-
-  Space *space = pRegion->parent();
-  MemoryRegion::Destroy(pRegion);
-
-  if (0 == space->numOfRegions()) {
-
-    if (NULL != m_pFileHandle) {
-      // if m_pFileHandle is NULL, clients delegate us an universal Space and
-      // we never remove it. Otherwise, we have to synchronize and release
-      // Space.
-      if (m_pFileHandle->isWritable()) {
-        // synchronize writable space before we release it.
-        Space::Sync(space, *m_pFileHandle);
-      }
-
-      std::pair<SpaceMapType::iterator, SpaceMapType::iterator> range =
-        m_SpaceMap.equal_range(Key(space->start(), space->size()));
-      SpaceMapType::iterator it;
-      for (it = range.first; it != range.second; ++it) {
-        if (space == it->second)
-          break;
-      }
-      m_SpaceMap.erase(it);
-
-      Space::Release(space, *m_pFileHandle);
-      assert(NULL != space);
-      Space::Destroy(space);
-    }
-  }
+  return llvm::StringRef(m_pMemoryBuffer->getBufferStart() + pOffset, pLength);
 }
 
-// clear - release all MemoryRegions
-void MemoryArea::clear()
+size_t MemoryArea::size() const
 {
-  if (NULL == m_pFileHandle)
-    return;
-
-  SpaceMapType::iterator space, sEnd = m_SpaceMap.end();
-  if (m_pFileHandle->isWritable()) {
-    for (space = m_SpaceMap.begin(); space != sEnd; ++space) {
-      Space::Sync(space->second, *m_pFileHandle);
-      Space::Release(space->second, *m_pFileHandle);
-      assert(NULL != space->second);
-      Space::Destroy(space->second);
-    }
-  }
-  else {
-    for (space = m_SpaceMap.begin(); space != sEnd; ++space) {
-      Space::Release(space->second, *m_pFileHandle);
-      assert(NULL != space->second);
-      Space::Destroy(space->second);
-    }
-  }
-
-  m_SpaceMap.clear();
+  return m_pMemoryBuffer->getBufferSize();
 }
-
-//===--------------------------------------------------------------------===//
-// SpaceList methods
-//===--------------------------------------------------------------------===//
-Space* MemoryArea::find(size_t pOffset, size_t pLength)
-{
-  std::pair<SpaceMapType::iterator, SpaceMapType::iterator> range =
-    m_SpaceMap.equal_range(Key(pOffset, pLength));
-  SpaceMapType::iterator it;
-  for (it = range.first; it != range.second; ++it) {
-    if ((it->second->start() <= pOffset) &&
-        ((pOffset + pLength) <= (it->second->start() + it->second->size())))
-      return it->second;
-  }
-  return NULL;
-}
-
-const Space* MemoryArea::find(size_t pOffset, size_t pLength) const
-{
-  std::pair<SpaceMapType::const_iterator, SpaceMapType::const_iterator> range =
-    m_SpaceMap.equal_range(Key(pOffset, pLength));
-  SpaceMapType::const_iterator it;
-  for (it = range.first; it != range.second; ++it) {
-    if ((it->second->start() <= pOffset) &&
-        ((pOffset + pLength) <= (it->second->start() + it->second->size())))
-      return it->second;
-  }
-  return NULL;
-}
-
diff --git a/lib/Support/MemoryAreaFactory.cpp b/lib/Support/MemoryAreaFactory.cpp
index 224e0a6..655c525 100644
--- a/lib/Support/MemoryAreaFactory.cpp
+++ b/lib/Support/MemoryAreaFactory.cpp
@@ -9,7 +9,6 @@
 #include <mcld/Support/MemoryAreaFactory.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Support/SystemUtils.h>
-#include <mcld/Support/Space.h>
 
 using namespace mcld;
 
@@ -22,88 +21,59 @@
 
 MemoryAreaFactory::~MemoryAreaFactory()
 {
-  HandleToArea::iterator rec, rEnd = m_HandleToArea.end();
-  for (rec = m_HandleToArea.begin(); rec != rEnd; ++rec) {
-    if (rec->handle->isOpened()) {
-      rec->handle->close();
-    }
-    delete rec->handle;
-  }
 }
 
-MemoryArea*
-MemoryAreaFactory::produce(const sys::fs::Path& pPath,
-                           FileHandle::OpenMode pMode)
+MemoryArea* MemoryAreaFactory::produce(const sys::fs::Path& pPath,
+                                       FileHandle::OpenMode pMode)
 {
-  HandleToArea::Result map_result = m_HandleToArea.findFirst(pPath);
-  if (NULL == map_result.area) {
-    // can not found
-    FileHandle* handler = new FileHandle();
-    if (!handler->open(pPath, pMode)) {
-      error(diag::err_cannot_open_file) << pPath
-                                        << sys::strerror(handler->error());
-    }
-
+  llvm::StringRef name(pPath.native());
+  if (m_AreaMap.find(name) == m_AreaMap.end()) {
     MemoryArea* result = allocate();
-    new (result) MemoryArea(*handler);
-
-    m_HandleToArea.push_back(handler, result);
+    new (result) MemoryArea(name);
+    m_AreaMap[name] = result;
     return result;
   }
 
-  return map_result.area;
+  return m_AreaMap[name];
 }
 
-MemoryArea*
-MemoryAreaFactory::produce(const sys::fs::Path& pPath,
-                           FileHandle::OpenMode pMode,
-                           FileHandle::Permission pPerm)
+MemoryArea* MemoryAreaFactory::produce(const sys::fs::Path& pPath,
+                                       FileHandle::OpenMode pMode,
+                                       FileHandle::Permission pPerm)
 {
-  HandleToArea::Result map_result = m_HandleToArea.findFirst(pPath);
-  if (NULL == map_result.area) {
-    // can not found
-    FileHandle* handler = new FileHandle();
-    if (!handler->open(pPath, pMode, pPerm)) {
-      error(diag::err_cannot_open_file) << pPath
-                                        << sys::strerror(handler->error());
-    }
-
+  llvm::StringRef name(pPath.native());
+  if (m_AreaMap.find(name) == m_AreaMap.end()) {
     MemoryArea* result = allocate();
-    new (result) MemoryArea(*handler);
-
-    m_HandleToArea.push_back(handler, result);
+    new (result) MemoryArea(name);
+    m_AreaMap[name] = result;
     return result;
   }
 
-  return map_result.area;
+  return m_AreaMap[name];
 }
 
 MemoryArea* MemoryAreaFactory::produce(void* pMemBuffer, size_t pSize)
 {
-  Space* space = Space::Create(pMemBuffer, pSize);
-  MemoryArea* result = allocate();
-  new (result) MemoryArea(*space);
-  return result;
+  const char* base = reinterpret_cast<const char*>(pMemBuffer);
+  llvm::StringRef name(base, pSize);
+  if (m_AreaMap.find(name) == m_AreaMap.end()) {
+    MemoryArea* result = allocate();
+    new (result) MemoryArea(base, pSize);
+    m_AreaMap[name] = result;
+    return result;
+  }
+
+  return m_AreaMap[name];
 }
 
-MemoryArea*
-MemoryAreaFactory::produce(int pFD, FileHandle::OpenMode pMode)
+MemoryArea* MemoryAreaFactory::produce(int pFD, FileHandle::OpenMode pMode)
 {
-  FileHandle* handler = new FileHandle();
-  handler->delegate(pFD, pMode);
-  
-  MemoryArea* result = allocate();
-  new (result) MemoryArea(*handler);
-
-  return result;
+  // TODO
+  return NULL;
 }
 
 void MemoryAreaFactory::destruct(MemoryArea* pArea)
 {
-  m_HandleToArea.erase(pArea);
-  pArea->clear();
-  pArea->handler()->close();
   destroy(pArea);
   deallocate(pArea);
 }
-
diff --git a/lib/Support/MemoryRegion.cpp b/lib/Support/MemoryRegion.cpp
deleted file mode 100644
index 410500a..0000000
--- a/lib/Support/MemoryRegion.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===- MemoryRegion.cpp ---------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/RegionFactory.h>
-
-#include <llvm/Support/ManagedStatic.h>
-
-using namespace mcld;
-
-static llvm::ManagedStatic<RegionFactory> g_RegionFactory;
-
-//===----------------------------------------------------------------------===//
-// MemoryRegion
-//===----------------------------------------------------------------------===//
-MemoryRegion::MemoryRegion()
-  : m_pParent(NULL), m_VMAStart(0), m_Length(0) {
-}
-
-MemoryRegion::MemoryRegion(MemoryRegion::Address pVMAStart, size_t pSize)
-  : m_pParent(NULL), m_VMAStart(pVMAStart), m_Length(pSize) {
-}
-
-MemoryRegion::~MemoryRegion()
-{
-}
-
-MemoryRegion* MemoryRegion::Create(void* pStart, size_t pSize)
-{
-  return g_RegionFactory->produce(static_cast<Address>(pStart), pSize);
-}
-
-MemoryRegion* MemoryRegion::Create(void* pStart, size_t pSize, Space& pSpace)
-{
-  MemoryRegion* result = g_RegionFactory->produce(static_cast<Address>(pStart),
-                                                  pSize);
-  result->setParent(pSpace);
-  pSpace.addRegion(*result);
-  return result;
-}
-
-void MemoryRegion::Destroy(MemoryRegion*& pRegion)
-{
-  if (NULL == pRegion)
-    return;
-
-  if (pRegion->hasParent())
-    pRegion->parent()->removeRegion(*pRegion);
-  g_RegionFactory->destruct(pRegion);
-  pRegion = NULL;
-}
-
diff --git a/lib/Support/Path.cpp b/lib/Support/Path.cpp
index 563fe1f..57d4bd8 100644
--- a/lib/Support/Path.cpp
+++ b/lib/Support/Path.cpp
@@ -197,9 +197,10 @@
 
 Path Path::extension() const
 {
-  size_t begin_pos = m_PathName.find_last_of('.');
-  Path result_path(m_PathName.substr(begin_pos));
-  return result_path;
+  size_t pos = m_PathName.find_last_of('.');
+  if (pos == StringType::npos)
+    return Path();
+  return Path(m_PathName.substr(pos));
 }
 
 //===--------------------------------------------------------------------===//
diff --git a/lib/Support/RegionFactory.cpp b/lib/Support/RegionFactory.cpp
deleted file mode 100644
index a52921b..0000000
--- a/lib/Support/RegionFactory.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//===- RegionFactory.cpp --------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Support/RegionFactory.h>
-#include <mcld/Support/Space.h>
-
-#include <new>
-
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// RegionFactory
-//===----------------------------------------------------------------------===//
-MemoryRegion*
-RegionFactory::produce(Address pVMAStart, size_t pSize)
-{
-  MemoryRegion* result = Alloc::allocate();
-  new (result) MemoryRegion(pVMAStart, pSize);
-  return result;
-}
-
-void RegionFactory::destruct(MemoryRegion* pRegion)
-{
-  destroy(pRegion);
-  deallocate(pRegion);
-}
-
diff --git a/lib/Support/Space.cpp b/lib/Support/Space.cpp
deleted file mode 100644
index b9a306e..0000000
--- a/lib/Support/Space.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-//===- Space.cpp ----------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Support/Space.h>
-#include <mcld/Support/FileHandle.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Support/SystemUtils.h>
-#include <cstdlib>
-#include <unistd.h>
-
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// constant data
-//===----------------------------------------------------------------------===//
-static const int PageSize = mcld::sys::GetPageSize();
-
-//===----------------------------------------------------------------------===//
-// Non-member functions
-//===----------------------------------------------------------------------===//
-//
-// low address      A page             high address
-// |--------------------|------------------|
-// ^ page_offset        ^ pFileOffset      ^ page_boundary
-//
-// Given a file offset, return the page offset.
-// return the first page boundary \b before pFileOffset
-inline static off_t page_offset(off_t pFileOffset)
-{ return pFileOffset & ~ (PageSize - 1); }
-
-// page_boundary - Given a file size, return the size to read integral pages.
-// return the first page boundary \b after pFileOffset
-inline static off_t page_boundary(off_t pFileOffset)
-{ return (pFileOffset + (PageSize - 1)) & ~ (PageSize - 1); }
-
-inline static Space::Type policy(off_t pOffset, size_t pLength)
-{
-#if defined(MCLD_ON_WIN32)
-  return Space::ALLOCATED_ARRAY;
-#endif
-  const size_t threshold = (PageSize*3)/4; // 3/4 page size in Linux
-  if (pLength < threshold)
-    return Space::ALLOCATED_ARRAY;
-  else
-    return Space::MMAPED;
-}
-
-//===----------------------------------------------------------------------===//
-// Space
-//===----------------------------------------------------------------------===//
-Space::Space()
-  : m_Data(NULL), m_StartOffset(0), m_Size(0),
-    m_RegionCount(0), m_Type(UNALLOCATED) {
-}
-
-Space::Space(Space::Type pType, void* pMemBuffer, size_t pSize)
-  : m_Data(static_cast<Address>(pMemBuffer)), m_StartOffset(0), m_Size(pSize),
-    m_RegionCount(0), m_Type(pType)
-{
-}
-
-Space::~Space()
-{
-  // do nothing. m_Data is deleted by @ref releaseSpace
-}
-
-Space* Space::Create(void* pMemBuffer, size_t pSize)
-{
-  Space* result = new Space(EXTERNAL, pMemBuffer, pSize);
-  return result;
-}
-
-Space* Space::Create(FileHandle& pHandler, size_t pStart, size_t pSize)
-{
-  Type type;
-  void* memory = NULL;
-  Space* result = NULL;
-  size_t start = 0, size = 0, total_offset = 0;
-  switch(type = policy(pStart, pSize)) {
-    case ALLOCATED_ARRAY: {
-      // adjust total_offset, start and size
-      total_offset = pStart + pSize;
-      start = pStart;
-      if (total_offset > pHandler.size()) {
-        if (pHandler.isWritable()) {
-          size = pSize;
-          pHandler.truncate(total_offset);
-        }
-        else if (pHandler.size() > start) {
-          // not writable -> shrink the size
-          size = pHandler.size() - start;
-        }
-        else {
-          // create a space out of a read-only file.
-          fatal(diag::err_cannot_read_small_file) << pHandler.path()
-                                                  << pHandler.size()
-                                                  << start << size;
-        }
-      }
-      else {
-        // within the space.
-        size = pSize;
-      }
-
-      // malloc
-      memory = (void*)malloc(size);
-      if (!pHandler.read(memory, start, size))
-        error(diag::err_cannot_read_file) << pHandler.path() << start << size;
-
-      break;
-    }
-    case MMAPED: {
-      // adjust total_offset, start and size
-      total_offset = page_boundary(pStart + pSize);
-      start = page_offset(pStart);
-      if (total_offset > pHandler.size()) {
-        if (pHandler.isWritable()) {
-          size = page_boundary((pStart - start) + pSize);
-          pHandler.truncate(total_offset);
-        }
-        else if (pHandler.size() > start)
-          size = pHandler.size() - start;
-        else {
-          // create a space out of a read-only file.
-          fatal(diag::err_cannot_read_small_file) << pHandler.path()
-                                                  << pHandler.size()
-                                                  << start << size;
-        }
-      }
-      else
-        size = page_boundary((pStart - start) + pSize);
-
-      // mmap
-      if (!pHandler.mmap(memory, start, size))
-        error(diag::err_cannot_mmap_file) << pHandler.path() << start << size;
-
-      break;
-    }
-    default:
-      break;
-  } // end of switch
-
-  result = new Space(type, memory, size);
-  result->setStart(start);
-  return result;
-}
-
-void Space::Destroy(Space*& pSpace)
-{
-  delete pSpace;
-  pSpace = NULL;
-}
-
-void Space::Release(Space* pSpace, FileHandle& pHandler)
-{
-  if (NULL == pSpace)
-    return;
-
-  switch(pSpace->type()) {
-    case ALLOCATED_ARRAY:
-      free(pSpace->memory());
-      break;
-    case MMAPED:
-      if (!pHandler.munmap(pSpace->memory(), pSpace->size()))
-        error(diag::err_cannot_munmap_file) << pHandler.path();
-      break;
-    default: // external and unallocated memory buffers
-      break;
-  } // end of switch
-}
-
-void Space::Sync(Space* pSpace, FileHandle& pHandler)
-{
-  if (NULL == pSpace || !pHandler.isWritable())
-    return;
-
-  switch(pSpace->type()) {
-    case Space::ALLOCATED_ARRAY: {
-      if (!pHandler.write(pSpace->memory(),
-                          pSpace->start(),
-                          pSpace->size())) {
-        error(diag::err_cannot_write_file) << pHandler.path()
-                                           << pSpace->start()
-                                           << pSpace->size();
-      }
-      return;
-    }
-    case Space::MMAPED:
-    default: {
-      // system will eventually write bakc the memory after
-      // calling ::munmap
-      return;
-    }
-  } // end of switch
-}
-
diff --git a/lib/Support/Target.cpp b/lib/Support/Target.cpp
new file mode 100644
index 0000000..d0e5f29
--- /dev/null
+++ b/lib/Support/Target.cpp
@@ -0,0 +1,81 @@
+//===- Target.cpp ---------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Support/Target.h>
+#include <llvm/ADT/Triple.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// Target
+//===----------------------------------------------------------------------===//
+Target::Target()
+  : Name(NULL),
+    TripleMatchQualityFn(NULL),
+    TargetMachineCtorFn(NULL),
+    MCLinkerCtorFn(NULL),
+    TargetLDBackendCtorFn(NULL),
+    DiagnosticLineInfoCtorFn(NULL) {
+}
+
+unsigned int Target::getTripleQuality(const llvm::Triple& pTriple) const
+{
+  if (NULL == TripleMatchQualityFn)
+    return 0;
+  return TripleMatchQualityFn(pTriple);
+}
+
+MCLDTargetMachine*
+Target::createTargetMachine(const std::string& pTriple,
+                            const llvm::Target& pTarget,
+                            llvm::TargetMachine& pTM) const
+{
+  if (NULL == TargetMachineCtorFn)
+    return NULL;
+  return TargetMachineCtorFn(pTarget, *this, pTM, pTriple);
+}
+
+/// createMCLinker - create target-specific MCLinker
+MCLinker*
+Target::createMCLinker(const std::string &pTriple,
+                       LinkerConfig& pConfig,
+                       Module& pModule,
+                       FileHandle& pFileHandle) const
+{
+  if (NULL == MCLinkerCtorFn)
+    return NULL;
+  return MCLinkerCtorFn(pTriple, pConfig, pModule, pFileHandle);
+}
+
+/// emulate - given MCLinker default values for the other aspects of the
+/// target system.
+bool Target::emulate(LinkerScript& pScript, LinkerConfig& pConfig) const
+{
+  if (NULL == EmulationFn)
+    return false;
+  return EmulationFn(pScript, pConfig);
+}
+
+/// createLDBackend - create target-specific LDBackend
+TargetLDBackend* Target::createLDBackend(const LinkerConfig& pConfig) const
+{
+    if (NULL == TargetLDBackendCtorFn)
+      return NULL;
+    return TargetLDBackendCtorFn(pConfig);
+}
+
+/// createDiagnosticLineInfo - create target-specific DiagnosticLineInfo
+DiagnosticLineInfo*
+Target::createDiagnosticLineInfo(const mcld::Target& pTarget,
+                                 const std::string& pTriple) const
+{
+  if (NULL == DiagnosticLineInfoCtorFn)
+    return NULL;
+  return DiagnosticLineInfoCtorFn(pTarget, pTriple);
+}
+
diff --git a/lib/Support/TargetRegistry.cpp b/lib/Support/TargetRegistry.cpp
index 38074d5..afffc5c 100644
--- a/lib/Support/TargetRegistry.cpp
+++ b/lib/Support/TargetRegistry.cpp
@@ -8,36 +8,98 @@
 //===----------------------------------------------------------------------===//
 #include <mcld/Support/TargetRegistry.h>
 
+using namespace mcld;
 
-mcld::TargetRegistry::TargetListTy mcld::TargetRegistry::s_TargetList;
+TargetRegistry::TargetListTy mcld::TargetRegistry::s_TargetList;
 
-void mcld::TargetRegistry::RegisterTarget(mcld::Target &T)
+//===----------------------------------------------------------------------===//
+// TargetRegistry
+//===----------------------------------------------------------------------===//
+void TargetRegistry::RegisterTarget(Target& pTarget,
+                                    const char* pName,
+                                    Target::TripleMatchQualityFnTy pQualityFn)
 {
-  s_TargetList.push_back(&T);
+  pTarget.Name = pName;
+  pTarget.TripleMatchQualityFn = pQualityFn;
+
+  s_TargetList.push_back(&pTarget);
 }
 
-const mcld::Target*
-mcld::TargetRegistry::lookupTarget(const llvm::Target &pTarget)
+const Target* TargetRegistry::lookupTarget(const std::string &pTriple,
+                                           std::string &pError)
 {
-  mcld::Target *result = 0;
-  TargetListTy::const_iterator TIter, TEnd = s_TargetList.end();
-  for (TIter=s_TargetList.begin(); TIter!=TEnd; ++TIter) {
-    if ((*TIter)->get()==&pTarget) {
-      result = (*TIter);
-      break;
+  if (empty()) {
+    pError = "Unable to find target for this triple (no target are registered)";
+    return NULL;
+  }
+
+  llvm::Triple triple(pTriple);
+  Target* best = NULL, *ambiguity = NULL;
+  unsigned int highest = 0;
+
+  for (iterator target = begin(), ie = end(); target != ie; ++target) {
+    unsigned int quality = (*target)->getTripleQuality(triple);
+    if (quality > 0) {
+      if (NULL == best || highest < quality) {
+        highest = quality;
+        best = *target;
+        ambiguity = NULL;
+      }
+      else if (highest == quality) {
+        ambiguity = *target;
+      }
+    }
+  }
+
+  if (NULL == best) {
+    pError = "No availaible targets are compatible with this triple.";
+    return NULL;
+  }
+
+  if (NULL != ambiguity) {
+    pError = std::string("Ambiguous targets: \"") +
+             best->name() + "\" and \"" + ambiguity->name() + "\"";
+    return NULL;
+  }
+
+  return best;
+}
+
+const Target* TargetRegistry::lookupTarget(const std::string& pArchName,
+                                           llvm::Triple& pTriple,
+                                           std::string& pError)
+{
+  const Target* result = NULL;
+  if (!pArchName.empty()) {
+    for (mcld::TargetRegistry::iterator it = mcld::TargetRegistry::begin(),
+           ie = mcld::TargetRegistry::end(); it != ie; ++it) {
+      if (pArchName == (*it)->name()) {
+        result = *it;
+        break;
+      }
+    }
+
+    if (NULL == result) {
+      pError = std::string("invalid target '") + pArchName + "'.\n";
+      return NULL;
+    }
+
+    // Adjust the triple to match (if known), otherwise stick with the
+    // module/host triple.
+    llvm::Triple::ArchType type =
+                               llvm::Triple::getArchTypeForLLVMName(pArchName);
+    if (llvm::Triple::UnknownArch != type)
+      pTriple.setArch(type);
+  }
+  else {
+    std::string error;
+    result = lookupTarget(pTriple.getTriple(), error);
+    if (NULL == result) {
+      pError = std::string("unable to get target for `") +
+               pTriple.getTriple() + "'\n" +
+               "(Detail: " + error + ")\n";
+      return NULL;
     }
   }
   return result;
 }
-
-const mcld::Target*
-mcld::TargetRegistry::lookupTarget(const std::string &pTriple,
-                                   std::string &pError)
-{
-  const llvm::Target* target = llvm::TargetRegistry::lookupTarget(pTriple, pError);
-  if (!target)
-    return NULL;
-
-  return lookupTarget( *target );
-}
-
diff --git a/lib/Support/ToolOutputFile.cpp b/lib/Support/ToolOutputFile.cpp
index 0554398..1223d93 100644
--- a/lib/Support/ToolOutputFile.cpp
+++ b/lib/Support/ToolOutputFile.cpp
@@ -11,12 +11,12 @@
 #include <mcld/Support/Path.h>
 #include <mcld/Support/FileHandle.h>
 #include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/raw_mem_ostream.h>
 
 #include <mcld/Support/SystemUtils.h>
 #include <mcld/Support/MsgHandling.h>
 
 #include <llvm/Support/Signals.h>
+#include <llvm/Support/Path.h>
 #include <llvm/Support/FormattedStream.h>
 
 using namespace mcld;
@@ -24,56 +24,53 @@
 //===----------------------------------------------------------------------===//
 // CleanupInstaller
 //===----------------------------------------------------------------------===//
-ToolOutputFile::CleanupInstaller::CleanupInstaller(const std::string& pPath)
+ToolOutputFile::CleanupInstaller::CleanupInstaller(const sys::fs::Path& pPath)
   : Keep(false), m_Path(pPath) {
   // Arrange for the file to be deleted if the process is killed.
-  if ("-" != m_Path)
-    llvm::sys::RemoveFileOnSignal(m_Path);
+  if ("-" != m_Path.native())
+    llvm::sys::RemoveFileOnSignal(m_Path.native());
 }
 
 ToolOutputFile::CleanupInstaller::~CleanupInstaller()
 {
   // Delete the file if the client hasn't told us not to.
   // FIXME: In Windows, some path in CJK characters can not be removed by LLVM
-  // sys::fs::remove
-  if (!Keep && "_" != m_Path)
-    llvm::sys::fs::remove(m_Path);
+  // llvm::sys::Path
+  if (!Keep && "_" != m_Path.native()) {
+    bool Existed;
+    llvm::sys::fs::remove(m_Path.native(), Existed);
+  }
 
   // Ok, the file is successfully written and closed, or deleted. There's no
   // further need to clean it up on signals.
-  if ("_" != m_Path)
-    llvm::sys::DontRemoveFileOnSignal(m_Path);
+  if ("_" != m_Path.native())
+    llvm::sys::DontRemoveFileOnSignal(m_Path.native());
 }
 
 //===----------------------------------------------------------------------===//
 // ToolOutputFile
 //===----------------------------------------------------------------------===//
-ToolOutputFile::ToolOutputFile(const std::string& pPath,
+ToolOutputFile::ToolOutputFile(const sys::fs::Path& pPath,
                                FileHandle::OpenMode pMode,
                                FileHandle::Permission pPermission)
   : m_Installer(pPath),
-    m_pMemoryArea(NULL),
-    m_pOStream(NULL),
-    m_pFOStream(NULL) {
+    m_pFdOstream(NULL),
+    m_pFormattedOstream(NULL) {
 
   if (!m_FileHandle.open(pPath, pMode, pPermission)) {
     // If open fails, no clean-up is needed.
     m_Installer.Keep = true;
     fatal(diag::err_cannot_open_output_file)
-                                   << pPath
-                                   << sys::strerror(m_FileHandle.error());
+      << pPath
+      << sys::strerror(m_FileHandle.error());
     return;
   }
-
-  m_pMemoryArea = new MemoryArea(m_FileHandle);
-  m_pOStream = new raw_mem_ostream(*m_pMemoryArea);
 }
 
 ToolOutputFile::~ToolOutputFile()
 {
-  delete m_pFOStream;
-  delete m_pOStream;
-  delete m_pMemoryArea;
+  if (m_pFdOstream != NULL)
+    delete m_pFdOstream;
 }
 
 void ToolOutputFile::keep()
@@ -81,29 +78,24 @@
   m_Installer.Keep = true;
 }
 
-/// mem_os - Return the contained raw_mem_ostream.
-raw_mem_ostream& ToolOutputFile::mem_os()
+/// os - Return the containeed raw_fd_ostream.
+/// Since os is rarely used, we lazily initialize it.
+llvm::raw_fd_ostream& ToolOutputFile::os()
 {
-  assert(NULL != m_pOStream);
-  return *m_pOStream;
+  if (m_pFdOstream == NULL) {
+    assert(m_FileHandle.isOpened() &&
+           m_FileHandle.isGood() &&
+           m_FileHandle.isWritable());
+    m_pFdOstream = new llvm::raw_fd_ostream(m_FileHandle.handler(), false);
+  }
+  return *m_pFdOstream;
 }
 
-/// formatted_os - Return the containeed formatted_raw_ostream.
-/// Since formatted_os is rarely used, we lazily initialize it.
+/// formatted_os - Return the contained formatted_raw_ostream
 llvm::formatted_raw_ostream& ToolOutputFile::formatted_os()
 {
-  if (NULL == m_pFOStream) {
-    assert(NULL != m_pOStream);
-    m_pFOStream = new llvm::formatted_raw_ostream(*m_pOStream);
+  if (m_pFormattedOstream == NULL) {
+    m_pFormattedOstream = new llvm::formatted_raw_ostream(os());
   }
-
-  return *m_pFOStream;
+  return *m_pFormattedOstream;
 }
-
-/// memory - Return the contained MemoryArea.
-MemoryArea& ToolOutputFile::memory()
-{
-  assert(NULL != m_pOStream);
-  return m_pOStream->getMemoryArea();
-}
-
diff --git a/lib/Support/Unix/FileSystem.inc b/lib/Support/Unix/FileSystem.inc
index 7a727e9..811085e 100644
--- a/lib/Support/Unix/FileSystem.inc
+++ b/lib/Support/Unix/FileSystem.inc
@@ -15,6 +15,7 @@
 #include <fcntl.h>
 #include <mcld/Support/FileHandle.h>
 #include <mcld/Support/Directory.h>
+#include <llvm/Support/ErrorHandling.h>
 
 namespace mcld{
 namespace sys{
diff --git a/lib/Support/raw_mem_ostream.cpp b/lib/Support/raw_mem_ostream.cpp
deleted file mode 100644
index c3066dd..0000000
--- a/lib/Support/raw_mem_ostream.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===- raw_mem_ostream.cpp ------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Support/raw_mem_ostream.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/FileHandle.h>
-
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// raw_mem_ostream
-//===----------------------------------------------------------------------===//
-raw_mem_ostream::raw_mem_ostream(MemoryArea &pMemoryArea)
-  : m_MemoryArea(pMemoryArea), m_Position(0) {
-  if (NULL == m_MemoryArea.handler() ||
-      !(m_MemoryArea.handler()->isGood() &&
-        m_MemoryArea.handler()->isWritable())) {
-    fatal(diag::fatal_unwritable_output) << m_MemoryArea.handler()->path();
-  }
-}
-
-raw_mem_ostream::~raw_mem_ostream()
-{
-  flush();
-  m_MemoryArea.clear();
-}
-
-void raw_mem_ostream::write_impl(const char *pPtr, size_t pSize)
-{
-  MemoryRegion* region = m_MemoryArea.request(m_Position, pSize);
-  memcpy(region->start(), pPtr, pSize);
-  m_Position += pSize;
-}
-
-uint64_t raw_mem_ostream::current_pos() const
-{
-  return m_Position;
-}
-
diff --git a/lib/Target/ARM/ARM.h b/lib/Target/ARM/ARM.h
index 53e4795..6fec04e 100644
--- a/lib/Target/ARM/ARM.h
+++ b/lib/Target/ARM/ARM.h
@@ -6,12 +6,17 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_ARM_H
-#define MCLD_ARM_H
+#ifndef MCLD_TARGET_ARM_H
+#define MCLD_TARGET_ARM_H
 #include <string>
-#include <mcld/Target/TargetMachine.h>
+
+namespace llvm {
+class Target;
+} // namespace of llvm
 
 namespace mcld {
+
+class Target;
 class TargetLDBackend;
 
 extern mcld::Target TheARMTarget;
diff --git a/lib/Target/ARM/ARMDiagnostic.cpp b/lib/Target/ARM/ARMDiagnostic.cpp
index b63a192..77cb87e 100644
--- a/lib/Target/ARM/ARMDiagnostic.cpp
+++ b/lib/Target/ARM/ARMDiagnostic.cpp
@@ -6,21 +6,16 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <llvm/ADT/Triple.h>
 #include <mcld/Support/TargetRegistry.h>
 #include <mcld/LD/DWARFLineInfo.h>
 #include "ARM.h"
 
 using namespace mcld;
 
-//===----------------------------------------------------------------------===//
-// ARMDiagnostic
-
-
 namespace mcld {
 //===----------------------------------------------------------------------===//
 // createARMDiagnostic - the help function to create corresponding ARMDiagnostic
-//
+//===----------------------------------------------------------------------===//
 DiagnosticLineInfo* createARMDiagLineInfo(const mcld::Target& pTarget,
                                           const std::string &pTriple)
 {
@@ -29,8 +24,9 @@
 
 } // namespace of mcld
 
-//==========================
+//===----------------------------------------------------------------------===//
 // InitializeARMDiagnostic
+//===----------------------------------------------------------------------===//
 extern "C" void MCLDInitializeARMDiagnosticLineInfo() {
   // Register the linker frontend
   mcld::TargetRegistry::RegisterDiagnosticLineInfo(TheARMTarget, createARMDiagLineInfo);
diff --git a/lib/Target/ARM/ARMELFAttributeData.cpp b/lib/Target/ARM/ARMELFAttributeData.cpp
new file mode 100644
index 0000000..87ed1d3
--- /dev/null
+++ b/lib/Target/ARM/ARMELFAttributeData.cpp
@@ -0,0 +1,1074 @@
+//===- ARMELFAttributeData.h ----------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "ARMELFAttributeData.h"
+
+#include <mcld/LinkerConfig.h>
+#include <mcld/MC/Input.h>
+#include <mcld/Support/LEB128.h>
+#include <mcld/Support/MsgHandling.h>
+
+using namespace mcld;
+
+const ELFAttributeValue *ARMELFAttributeData::getAttributeValue(TagType pTag) const
+{
+  if (pTag <= Tag_Max) {
+    const ELFAttributeValue &attr_value = m_Attrs[pTag];
+
+    if (attr_value.isInitialized()) {
+      return &attr_value;
+    } else {
+      // Don't return uninitialized attribute value.
+      return NULL;
+    }
+  } else {
+    UnknownAttrsMap::const_iterator attr_it = m_UnknownAttrs.find(pTag);
+
+    if (attr_it == m_UnknownAttrs.end()) {
+      return NULL;
+    } else {
+      return &attr_it->second;
+    }
+  }
+}
+
+std::pair<ELFAttributeValue*, bool>
+ARMELFAttributeData::getOrCreateAttributeValue(TagType pTag)
+{
+  ELFAttributeValue *attr_value = NULL;
+
+  if (pTag <= Tag_Max) {
+    attr_value = &m_Attrs[pTag];
+  } else {
+    // An unknown tag encounterred.
+    attr_value = &m_UnknownAttrs[pTag];
+  }
+
+  assert(attr_value != NULL);
+
+  // Setup the value type.
+  if (!attr_value->isUninitialized()) {
+    return std::make_pair(attr_value, false);
+  } else {
+    attr_value->setType(GetAttributeValueType(pTag));
+    return std::make_pair(attr_value, true);
+  }
+}
+
+unsigned int ARMELFAttributeData::GetAttributeValueType(TagType pTag)
+{
+  // See ARM [ABI-addenda], 2.2.6.
+  switch (pTag) {
+    case Tag_compatibility: {
+      return (ELFAttributeValue::Int | ELFAttributeValue::String);
+    }
+    case Tag_nodefaults: {
+      return (ELFAttributeValue::Int | ELFAttributeValue::NoDefault);
+    }
+    case Tag_CPU_raw_name:
+    case Tag_CPU_name: {
+      return ELFAttributeValue::String;
+    }
+    default: {
+      if (pTag < 32)
+        return ELFAttributeValue::Int;
+      else
+        return ((pTag & 1) ? ELFAttributeValue::String :
+                             ELFAttributeValue::Int);
+    }
+  }
+  // unreachable
+}
+
+//===--------------------------------------------------------------------===//
+// Helper Functions for merge()
+//===--------------------------------------------------------------------===//
+
+namespace {
+
+/*
+ * Helper function to decode value in Tag_also_compatible_with.
+ *
+ * @ref ARM [ABI-addenda], 2.3.7.3
+ */
+static int
+decode_secondary_compatibility_attribute(const ELFAttributeValue &pValue)
+{
+  // The encoding of Tag_also_compatible_with is:
+  //
+  // Tag_also_compatible_with (=65), NTSB: data
+  //
+  // The data can be either an ULEB128-encoded number followed by a NULL byte or
+  // a NULL-terminated string. Currently, only the following byte sequence in
+  // data are currently defined:
+  //
+  // Tag_CPU_arch (=6) [The arch] 0
+  assert((pValue.type() == ELFAttributeValue::String) &&
+         "Value of Tag_also_compatible_with must be a string!");
+
+  const std::string &data = pValue.getStringValue();
+
+  // Though the integer is in LEB128 format, but they occupy only 1 byte in
+  // currently defined value.
+  if (data.length() < 2)
+    // Must have a byte for Tag_CPU_arch (=6)
+    //           a byte for specifying the CPU architecture (CPU_Arch_ARM_*)
+    //
+    // Currently, the 2nd byte can only be v4T (=2) or v6-M (=11).
+    return -1;
+
+  if ((static_cast<uint8_t>(data[0]) == ARMELFAttributeData::Tag_CPU_arch) &&
+      ((data[1] == ARMELFAttributeData::CPU_Arch_ARM_V4T) ||
+       (data[1] == ARMELFAttributeData::CPU_Arch_ARM_V6_M)))
+    return static_cast<uint32_t>(data[1]);
+
+  // Tag_also_compatible_with can be safely ignored.
+  return -1;
+}
+
+/*
+ * This helper array keeps the ordering of the values in attributes such as
+ * Tag_ABI_align_needed which are sored as 1 > 2 > 0.
+ */
+static const int value_ordering_120[] = { 0, 2, 1 };
+
+} // anonymous namespace
+
+//===--------------------------------------------------------------------===//
+// End Helper Functions for merge()
+//===--------------------------------------------------------------------===//
+
+bool ARMELFAttributeData::merge(const LinkerConfig& pConfig,
+                                const Input &pInput, TagType pTag,
+                                const ELFAttributeValue& pInAttr)
+{
+  // Pre-condition
+  //  1. The out_attr must be initailized and has value of the same type as
+  //     pInAttr.
+  //  2. The value helf by out_attr and pInAttr must be different.
+  ELFAttributeValue &out_attr = m_Attrs[pTag];
+
+  // Attribute in the output must have value assigned.
+  assert(out_attr.isInitialized() && "No output attribute to be merged!");
+
+  switch (pTag) {
+    case Tag_CPU_arch: {
+      // Need value of Tag_also_compatible_with in the input for merge.
+      if (pInAttr.getIntValue() <= CPU_Arch_Max) {
+        m_CPUArch = pInAttr.getIntValue();
+      } else {
+        error(diag::error_unknown_cpu_arch) << pInput.name();
+        return false;
+      }
+      break;
+    }
+    case Tag_CPU_name: {
+      // need value of Tag_CPU_arch in the input for merge
+      m_CPUName = pInAttr.getStringValue();
+      break;
+    }
+    case Tag_CPU_raw_name: {
+      // need value of Tag_CPU_arch in the input for merge
+      m_CPURawName = pInAttr.getStringValue();
+      break;
+    }
+    case Tag_FP_arch: {
+      // need value of Tag_HardFP_use in the input for merge
+      m_FPArch = pInAttr.getIntValue();
+      break;
+    }
+    case Tag_ABI_HardFP_use: {
+      // need value of Tag_FP_arch in the input for merge
+      m_HardFPUse = pInAttr.getIntValue();
+      break;
+    }
+    case Tag_also_compatible_with: {
+      // need value of Tag_CPU_arch in the input for merge
+      m_SecondaryCPUArch = decode_secondary_compatibility_attribute(pInAttr);
+      break;
+    }
+    case Tag_ABI_VFP_args: {
+      // need value of Tag_ABI_FP_number_model in the input for merge
+      m_VFPArgs = pInAttr.getIntValue();
+      break;
+    }
+    // The value of these tags are integers and after merge, only the greatest
+    // value held by pInAttr and out_attr goes into output.
+    case Tag_ARM_ISA_use:
+    case Tag_THUMB_ISA_use:
+    case Tag_WMMX_arch:
+    case Tag_Advanced_SIMD_arch:
+    case Tag_ABI_FP_rounding:
+    case Tag_ABI_FP_exceptions:
+    case Tag_ABI_FP_user_exceptions:
+    case Tag_ABI_FP_number_model:
+    case Tag_FP_HP_extension:
+    case Tag_CPU_unaligned_access:
+    case Tag_T2EE_use: {
+      assert((out_attr.type() == ELFAttributeValue::Int) &&
+             (pInAttr.type() == ELFAttributeValue::Int) &&
+              "should have integer parameeter!");
+      if (pInAttr.getIntValue() > out_attr.getIntValue())
+        out_attr.setIntValue(pInAttr.getIntValue());
+      break;
+    }
+    // The value of these tags are integers and after merge, only the smallest
+    // value held by pInAttr and out_attr goes into output.
+    case Tag_ABI_align_preserved:
+    case Tag_ABI_PCS_RO_data: {
+      assert((out_attr.type() == ELFAttributeValue::Int) &&
+             (pInAttr.type() == ELFAttributeValue::Int) &&
+              "should have integer parameeter!");
+      if (pInAttr.getIntValue() < out_attr.getIntValue())
+        out_attr.setIntValue(pInAttr.getIntValue());
+      break;
+    }
+    // The values of these attributes are sorted as 1 > 2 > 0. And the greater
+    // value becomes output.
+    case Tag_ABI_align_needed:
+    case Tag_ABI_FP_denormal:
+    case Tag_ABI_PCS_GOT_use: {
+      const int in_val = pInAttr.getIntValue();
+      const int out_val = out_attr.getIntValue();
+
+      if (in_val <= 2) {
+        if (out_val <= 2) {
+          // Use value_ordering_120 to determine the ordering.
+          if (value_ordering_120[in_val] > value_ordering_120[out_val]) {
+            out_attr.setIntValue(in_val);
+          }
+        }
+      } else {
+        // input value > 2, for future-proofing
+        if (in_val > out_val) {
+          out_attr.setIntValue(in_val);
+        }
+      }
+      break;
+    }
+    // These tags use the first value ever seen.
+    case Tag_ABI_optimization_goals:
+    case Tag_ABI_FP_optimization_goals: {
+      break;
+    }
+    // Tag_CPU_arch_profile
+    case Tag_CPU_arch_profile: {
+      if (pInAttr.getIntValue() == Arch_Profile_None)
+        return true;
+
+      switch (out_attr.getIntValue()) {
+        case Arch_Profile_None: {
+          out_attr.setIntValue(pInAttr.getIntValue());
+          break;
+        }
+        case Arch_Profile_RealOrApp: {
+          if (pInAttr.getIntValue() != Arch_Profile_Microcontroller)
+            out_attr.setIntValue(pInAttr.getIntValue());
+          else
+            warning(diag::warn_mismatch_cpu_arch_profile)
+                << pInAttr.getIntValue() << pInput.name();
+          break;
+        }
+        default: {
+          // out_attr is Arch_Profile_Application or Arch_Profile_Realtime or
+          // Arch_Profile_Microcontroller.
+          if ((pInAttr.getIntValue() == Arch_Profile_RealOrApp) &&
+              (out_attr.getIntValue() != Arch_Profile_Microcontroller)) {
+            // do nothing
+          } else {
+            if (pConfig.options().warnMismatch())
+              warning(diag::warn_mismatch_cpu_arch_profile)
+                  << pInAttr.getIntValue() << pInput.name();
+          }
+          break;
+        }
+      }
+      break;
+    }
+    // Tag_MPextension_use and Tag_MPextension_use_legacy
+    case Tag_MPextension_use:
+    case Tag_MPextension_use_legacy: {
+      if (m_MPextensionUse < 0) {
+        m_MPextensionUse = pInAttr.getIntValue();
+      } else {
+        if (static_cast<unsigned>(m_MPextensionUse) != pInAttr.getIntValue()) {
+          warning(diag::error_mismatch_mpextension_use) << pInput.name();
+        }
+      }
+      break;
+    }
+    // Tag_DIV_use
+    case Tag_DIV_use: {
+      if (pInAttr.getIntValue() == 2) {
+        // 2 means the code was permitted to use SDIV/UDIV in anyway.
+        out_attr.setIntValue(2);
+      } else {
+        // Merge until settling down Tag_CPU_arch.
+        m_DIVUse = pInAttr.getIntValue();
+      }
+      break;
+    }
+    // Tag_ABI_enum_size
+    case Tag_ABI_enum_size: {
+      if ((out_attr.getIntValue() == Enum_Unused) ||
+          (out_attr.getIntValue() == Enum_Containerized_As_Possible))
+        out_attr.setIntValue(pInAttr.getIntValue());
+      else if (pInAttr.getIntValue() != Enum_Containerized_As_Possible &&
+               pConfig.options().warnMismatch())
+        warning(diag::warn_mismatch_enum_size)
+            << pInput.name() << pInAttr.getIntValue()
+            << out_attr.getIntValue();
+      break;
+    }
+    // Tag_ABI_FP_16bit_format
+    case Tag_ABI_FP_16bit_format: {
+      // 0: doesn't use any 16-bit FP number
+      // 1: use IEEE 754 format 16-bit FP number
+      // 2: use VFPv3/Advanced SIMD "alternative format" 16-bit FP number
+      if (pInAttr.getIntValue() != 0) {
+        if (out_attr.getIntValue() == 0) {
+          out_attr.setIntValue(pInAttr.getIntValue());
+        } else {
+          if (pConfig.options().warnMismatch())
+            warning(diag::warn_mismatch_fp16_format) << pInput.name();
+        }
+      }
+      break;
+    }
+    // Tag_nodefaults
+    case Tag_nodefaults: {
+      // There's nothing to do for this tag. It doesn't have an actual value.
+      break;
+    }
+    // Tag_conformance
+    case Tag_conformance: {
+      // Throw away the value if the attribute value doesn't match.
+      if (out_attr.getStringValue() != pInAttr.getStringValue())
+        out_attr.setStringValue("");
+      break;
+    }
+    // Tag_Virtualization_use
+    case Tag_Virtualization_use: {
+      // 0: No use of any virtualization extension
+      // 1: TrustZone
+      // 2: Virtualization extension such as HVC and ERET
+      // 3: TrustZone and virtualization extension are permitted
+      if (pInAttr.getIntValue() != 0) {
+        if (out_attr.getIntValue() == 0) {
+          out_attr.setIntValue(pInAttr.getIntValue());
+        } else {
+          if ((out_attr.getIntValue() <= 3) && (pInAttr.getIntValue() <= 3)) {
+            // Promote to 3
+            out_attr.setIntValue(3);
+          } else {
+            warning(diag::warn_unrecognized_virtualization_use)
+                << pInput.name() << pInAttr.getIntValue();
+          }
+        }
+      }
+      break;
+    }
+    // Tag_ABI_WMMX_args
+    case Tag_ABI_WMMX_args: {
+      // There's no way to merge this value (i.e., objects contain different
+      // value in this tag are definitely incompatible.)
+      if (pConfig.options().warnMismatch())
+        warning(diag::warn_mismatch_abi_wmmx_args) << pInput.name();
+      break;
+    }
+    // Tag_PCS_config
+    case Tag_PCS_config: {
+      // 0 means no standard configuration used or no information recorded.
+      if (pInAttr.getIntValue() != 0) {
+        if (out_attr.getIntValue() == 0)
+          out_attr.setIntValue(pInAttr.getIntValue());
+        else {
+          // Different values in these attribute are conflict
+          if (pConfig.options().warnMismatch())
+            warning(diag::warn_mismatch_pcs_config) << pInput.name();
+        }
+      }
+      break;
+    }
+    // Tag_ABI_PCS_R9_use
+    case Tag_ABI_PCS_R9_use: {
+      if (pInAttr.getIntValue() != R9_Unused) {
+        if (out_attr.getIntValue() == R9_Unused)
+          out_attr.setIntValue(pInAttr.getIntValue());
+        else {
+          if (pConfig.options().warnMismatch())
+            warning(diag::warn_mismatch_r9_use) << pInput.name();
+        }
+      }
+      break;
+    }
+    // Tag_ABI_PCS_RW_data
+    case Tag_ABI_PCS_RW_data: {
+      if (pInAttr.getIntValue() == RW_data_SB_Relative) {
+        // Require using R9 as SB (global Static Base register).
+        if ((out_attr.getIntValue() != R9_Unused) &&
+            (out_attr.getIntValue() != R9_SB) &&
+            pConfig.options().warnMismatch())
+          warning(diag::warn_mismatch_r9_use) << pInput.name();
+      }
+      // Choose the smaller value
+      if (pInAttr.getIntValue() < out_attr.getIntValue())
+        out_attr.setIntValue(pInAttr.getIntValue());
+      break;
+    }
+    // Tag_ABI_PCS_wchar_t
+    case Tag_ABI_PCS_wchar_t: {
+      // 0: no use of wchar_t
+      // 2: sizeof(wchar_t) = 2
+      // 4: sizeof(wchar_t) = 4
+      if (pInAttr.getIntValue() != 0) {
+        if (out_attr.getIntValue() == 0)
+          out_attr.setIntValue(pInAttr.getIntValue());
+        else {
+          if (pConfig.options().warnMismatch())
+            warning(diag::warn_mismatch_wchar_size)
+                << pInput.name() << pInAttr.getIntValue()
+                << out_attr.getIntValue();
+        }
+      }
+      break;
+    }
+    default: {
+      // Handle unknown attributes:
+      //
+      // Since we don't know how to merge the value of unknown attribute, we
+      // have to ignore it. There're two rules related to the processing (See
+      // ARM [ABI-addenda] 2.2.6, Coding extensibility and compatibility.):
+      //
+      // 1. For tag N where N >= 128, tag N has the same properties as
+      //    tag N % 128.
+      // 2. Tag 64-127 can be safely ignored.
+      // 3. Tag 0-63 must be comprehended, therefore we cannot ignore.
+      if (pConfig.options().warnMismatch()) {
+        if ((pTag & 127) < 64) {
+          warning(diag::warn_unknown_mandatory_attribute) << pTag
+                                                          << pInput.name();
+        } else {
+          warning(diag::warn_unknown_attribute) << pTag << pInput.name();
+        }
+      }
+      break;
+    }
+  }
+  return true;
+}
+
+//===--------------------------------------------------------------------===//
+// Helper Functions for postMerge()
+//===--------------------------------------------------------------------===//
+
+namespace {
+
+/*
+ * Helper function to encode value in Tag_also_compatible_with.
+ *
+ * @ref ARM [ABI-addenda], 2.3.7.3
+ */
+static void
+encode_secondary_compatibility_attribute(ELFAttributeValue &pValue, int pArch)
+{
+  if ((pArch < 0) || (pArch > ARMELFAttributeData::CPU_Arch_Max)) {
+    pValue.setStringValue("");
+  } else {
+    char new_value[] = {
+        ARMELFAttributeData::Tag_CPU_arch,
+        static_cast<char>(pArch),
+        0
+    };
+    pValue.setStringValue(std::string(new_value, sizeof(new_value)));
+  }
+  return;
+}
+
+/*
+ * Combine the main and secondary CPU arch value
+ */
+static int
+calculate_cpu_arch(int cpu_arch, int secondary_arch)
+{
+  // short-circuit
+  if ((secondary_arch < 0) ||
+      ((cpu_arch + secondary_arch) != (ARMELFAttributeData::CPU_Arch_ARM_V4T +
+                                       ARMELFAttributeData::CPU_Arch_ARM_V6_M)))
+    return cpu_arch;
+
+  if ((cpu_arch == ARMELFAttributeData::CPU_Arch_ARM_V4T) &&
+      (secondary_arch == ARMELFAttributeData::CPU_Arch_ARM_V6_M))
+    return ARMELFAttributeData::CPU_Arch_ARM_V4T_Plus_V6_M;
+  else if ((cpu_arch == ARMELFAttributeData::CPU_Arch_ARM_V6_M) &&
+           (secondary_arch == ARMELFAttributeData::CPU_Arch_ARM_V4T))
+    return ARMELFAttributeData::CPU_Arch_ARM_V4T_Plus_V6_M;
+  else
+    return cpu_arch;
+}
+
+/*
+ * Given a CPU arch X and a CPU arch Y in which Y is newer than X, the value in
+ * cpu_compatibility_table[X][Y] is the CPU arch required to run ISA both from X
+ * and Y. 0 in the table means unreachable and -1 means conflict architecture
+ * profile.
+ */
+#define CPU(C)  ARMELFAttributeData::CPU_Arch_ARM_ ## C
+static const int cpu_compatibility_table[][CPU(V4T_Plus_V6_M) + 1] =
+{
+  /* old\new          ARM v6T2    ARM v6K   ARM v7   ARM v6-M   ARM v6S-M   ARM v7E-M    ARMv8, ARM v4t + v6-M     */
+  /* Pre v4     */ { CPU(V6T2),  CPU(V6K), CPU(V7),        -1,         -1,         -1,      -1,       -1           },
+  /* ARM v4     */ { CPU(V6T2),  CPU(V6K), CPU(V7),        -1,         -1,         -1,      -1,       -1           },
+  /* ARM v4T    */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V4T)           },
+  /* ARM v5T    */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V5T)           },
+  /* ARM v5TE   */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V5TE)          },
+  /* ARM v5TEJ  */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V5TEJ)         },
+  /* ARM v6     */ { CPU(V6T2),  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V6)            },
+  /* ARM v6KZ   */ {   CPU(V7), CPU(V6KZ), CPU(V7), CPU(V6KZ),  CPU(V6KZ), CPU(V7E_M), CPU(V8), CPU(V6KZ)          },
+  /* ARM v6T2   */ { CPU(V6T2),   CPU(V7), CPU(V7),   CPU(V7),    CPU(V7), CPU(V7E_M), CPU(V8), CPU(V6T2)          },
+  /* ARM v6K    */ {         0,  CPU(V6K), CPU(V7),  CPU(V6K),   CPU(V6K), CPU(V7E_M), CPU(V8), CPU(V6K)           },
+  /* ARM v7     */ {         0,         0, CPU(V7),   CPU(V7),    CPU(V7), CPU(V7E_M), CPU(V8), CPU(V7)            },
+  /* ARM v6-M   */ {         0,         0,       0, CPU(V6_M), CPU(V6S_M), CPU(V7E_M), CPU(V8), CPU(V6_M)          },
+  /* ARM v6S-M  */ {         0,         0,       0,         0, CPU(V6S_M), CPU(V7E_M), CPU(V8), CPU(V6S_M)         },
+  /* ARM v7E-M  */ {         0,         0,       0,         0,          0, CPU(V7E_M), CPU(V8), CPU(V7E_M)         },
+  /* ARM v8     */ {         0,         0,       0,         0,          0,          0, CPU(V8), CPU(V8)            },
+  /* v4T + v6-M */ {         0,         0,       0,         0,          0,          0,       0, CPU(V4T_Plus_V6_M) }
+};
+
+/*
+ * Helper function to determine the merge of two different CPU arch.
+ */
+static int merge_cpu_arch(int out_cpu_arch, int in_cpu_arch)
+{
+  if (out_cpu_arch > CPU(V4T_Plus_V6_M))
+    return in_cpu_arch;
+
+  int new_cpu_arch, old_cpu_arch;
+  if (out_cpu_arch > in_cpu_arch) {
+    new_cpu_arch = out_cpu_arch;
+    old_cpu_arch = in_cpu_arch;
+  } else {
+    new_cpu_arch = in_cpu_arch;
+    old_cpu_arch = out_cpu_arch;
+  }
+
+  // No need to check the compatibility since the CPU architectures before
+  // V6KZ add features monotonically.
+  if (new_cpu_arch <= CPU(V6KZ))
+    return new_cpu_arch;
+
+  return cpu_compatibility_table[old_cpu_arch][new_cpu_arch - CPU(V6T2)];
+}
+#undef CPU
+
+/*
+ * Generic CPU name is used when Tag_CPU_name is unable to guess during the
+ * merge of Tag_CPU_arch.
+ */
+static const char* generic_cpu_name_table[] = {
+  /* Pre v4    */"Pre v4",
+  /* Pre v4    */"ARM v4",
+  /* ARM v4T   */"ARM v4T",
+  /* ARM v5T   */"ARM v5T",
+  /* ARM v5TE  */"ARM v5TE",
+  /* ARM v5TEJ */"ARM v5TEJ",
+  /* ARM v6    */"ARM v6",
+  /* ARM v6KZ  */"ARM v6KZ",
+  /* ARM v6T2  */"ARM v6T2",
+  /* ARM v6K   */"ARM v6K",
+  /* ARM v7    */"ARM v7",
+  /* ARM v6-M  */"ARM v6-M",
+  /* ARM v6S-M */"ARM v6S-M",
+  /* ARM v7E-M */"ARM v7E-M",
+  /* ARM v8    */"ARM v8",
+};
+
+static const char* get_generic_cpu_name(int cpu_arch) {
+  assert(cpu_arch < sizeof(generic_cpu_name_table) / sizeof(generic_cpu_name_table[0]));
+  return generic_cpu_name_table[cpu_arch];
+}
+
+/*
+ * Helper functions & data used in the merge of two different FP arch.
+ */
+static const struct fp_config_data {
+  int version;
+  int regs;
+} fp_configs[] = {
+  { 0, 0  },
+  { 1, 16 },
+  { 2, 16 },
+  { 3, 32 },
+  { 3, 16 },
+  { 4, 32 },
+  { 4, 16 },
+  { 8, 32 },
+  { 8, 16 },
+};
+
+static const size_t num_fp_configs =
+    sizeof(fp_configs) / sizeof(fp_config_data);
+
+// Given h(x, y) = (x * (y >> 4) + (y >> 5))
+//
+// fp_config_hash_table[ h(0, 0)  =  0 ] = 0
+// fp_config_hash_table[ h(1, 16) =  1 ] = 1
+// fp_config_hash_table[ h(2, 16) =  2 ] = 2
+// fp_config_hash_table[ h(3, 32) =  7 ] = 3
+// fp_config_hash_table[ h(3, 16) =  3 ] = 4
+// fp_config_hash_table[ h(4, 32) =  9 ] = 5
+// fp_config_hash_table[ h(4, 16) =  4 ] = 6
+// fp_config_hash_table[ h(8, 32) = 17 ] = 7
+// fp_config_hash_table[ h(8, 16) =  8 ] = 8
+//
+// h(0, 0) = 0
+static const uint8_t fp_config_hash_table[] =
+{
+#define UND static_cast<uint8_t>(-1)
+  /*  0 */0,
+  /*  1 */1,
+  /*  2 */2,
+  /*  3 */4,
+  /*  4 */6,
+  /*  5 */UND,
+  /*  6 */UND,
+  /*  7 */3,
+  /*  8 */8,
+  /*  9 */5,
+  /* 10 */UND,
+  /* 11 */UND,
+  /* 12 */UND,
+  /* 13 */UND,
+  /* 14 */UND,
+  /* 15 */UND,
+  /* 16 */UND,
+  /* 17 */7,
+#undef UND
+};
+
+static const size_t num_hash_table_entries =
+    sizeof(fp_config_hash_table) / sizeof(fp_config_hash_table[0]);
+
+static int calculate_fp_config_hash(const struct fp_config_data &pConfig)
+{
+  int x = pConfig.version;
+  int y = pConfig.regs;
+  return (x * (y >> 4) + (y >> 5));
+}
+
+static int get_fp_arch_of_config(const struct fp_config_data &pConfig)
+{
+  int hash = calculate_fp_config_hash(pConfig);
+  assert(hash < num_hash_table_entries);
+  return fp_config_hash_table[hash];
+}
+
+static bool is_allowed_use_of_div(int cpu_arch, int cpu_arch_profile,
+                                  int div_use) {
+  // 0: The code was permitted to use SDIV and UDIV in the Thumb ISA on v7-R or
+  //    v7-M.
+  // 1: The code was not permitted to use SDIV and UDIV.
+  // 2: The code was explicitly permitted to use SDIV and UDIV.
+  switch (div_use) {
+    case 0: {
+      if ((cpu_arch == ARMELFAttributeData::CPU_Arch_ARM_V7) &&
+          ((cpu_arch_profile == 'R') || (cpu_arch_profile == 'M'))) {
+        return true;
+      } else {
+        return (cpu_arch >= ARMELFAttributeData::CPU_Arch_ARM_V7E_M);
+      }
+    }
+    case 1: {
+      return false;
+    }
+    case 2:
+    // For future proofing
+    default: {
+      return true;
+    }
+  }
+}
+
+} // anonymous namespace
+
+//===--------------------------------------------------------------------===//
+// End Helper Functions for postMerge()
+//===--------------------------------------------------------------------===//
+
+bool ARMELFAttributeData::postMerge(const LinkerConfig& pConfig,
+                                    const Input &pInput)
+{
+  // Process Tag_CPU_arch, Tag_CPU_name, Tag_CPU_raw_name, and
+  // Tag_also_compatible_with.
+  ELFAttributeValue &out_cpu_arch_attr = m_Attrs[Tag_CPU_arch];
+  ELFAttributeValue &out_secondary_compatibility_attr =
+      m_Attrs[Tag_also_compatible_with];
+
+  if ((m_CurrentCPUArch < 0) && out_cpu_arch_attr.isInitialized()) {
+    // Current input initializes the value of Tag_CPU_arch. Validate it.
+    int out_cpu_arch = out_cpu_arch_attr.getIntValue();
+
+    if (out_cpu_arch > CPU_Arch_Max) {
+      error(diag::error_unknown_cpu_arch) << pInput.name();
+      return false;
+    }
+
+    // Initialize m_CurrentCPUArch.
+    int out_secondary_arch = -1;
+    if (out_secondary_compatibility_attr.isInitialized())
+      out_secondary_arch = decode_secondary_compatibility_attribute(
+                              out_secondary_compatibility_attr);
+
+    m_CurrentCPUArch = calculate_cpu_arch(out_cpu_arch, out_secondary_arch);
+  }
+
+  if (m_CPUArch >= 0) {
+    assert(out_cpu_arch_attr.isInitialized() && "CPU arch has never set!");
+    assert(m_CurrentCPUArch >= 0);
+
+    int in_cpu_arch = calculate_cpu_arch(m_CPUArch, m_SecondaryCPUArch);
+    int result_cpu_arch = merge_cpu_arch(m_CurrentCPUArch, in_cpu_arch);
+
+    if (result_cpu_arch < 0) {
+      warning(diag::warn_mismatch_cpu_arch_profile)
+          << in_cpu_arch << pInput.name();
+    } else {
+      if (result_cpu_arch != m_CurrentCPUArch) {
+        // Value of Tag_CPU_arch are going to changea.
+        m_CurrentCPUArch = result_cpu_arch;
+
+        // Write the result value to the output.
+        if (result_cpu_arch == CPU_Arch_ARM_V4T_Plus_V6_M) {
+          out_cpu_arch_attr.setIntValue(CPU_Arch_ARM_V4T);
+          encode_secondary_compatibility_attribute(
+              out_secondary_compatibility_attr, CPU_Arch_ARM_V6_M);
+        } else {
+          out_cpu_arch_attr.setIntValue(result_cpu_arch);
+          encode_secondary_compatibility_attribute(
+              out_secondary_compatibility_attr, -1);
+        }
+
+        ELFAttributeValue &out_cpu_name = m_Attrs[Tag_CPU_name];
+        ELFAttributeValue &out_cpu_raw_name = m_Attrs[Tag_CPU_raw_name];
+
+        if (m_CurrentCPUArch != in_cpu_arch) {
+          // Unable to guess the Tag_CPU_name. Use the generic name.
+          if (out_cpu_name.isInitialized()) {
+            out_cpu_name.setStringValue(get_generic_cpu_name(m_CurrentCPUArch));
+          }
+
+          // Tag_CPU_raw_name becomes unknown. Set to default value to disable
+          // it.
+          out_cpu_raw_name.setStringValue("");
+        } else {
+          // Use the value of Tag_CPU_name and Tag_CPU_raw_name from the input.
+          if (!m_CPUName.empty()) {
+            ELFAttributeValue &out_cpu_name = m_Attrs[Tag_CPU_name];
+            assert(out_cpu_name.isInitialized() && "CPU name has never set!");
+            out_cpu_name.setStringValue(m_CPUName);
+          }
+
+          if (!m_CPURawName.empty()) {
+            ELFAttributeValue &out_cpu_raw_name = m_Attrs[Tag_CPU_raw_name];
+            assert(out_cpu_raw_name.isInitialized() &&
+                   "CPU raw name has never set!");
+            out_cpu_raw_name.setStringValue(m_CPURawName);
+          }
+        }
+      }
+    }
+  } // (m_CPUArch >= 0)
+
+  // Process Tag_ABI_VFP_args.
+  if (m_VFPArgs >= 0) {
+    ELFAttributeValue &out_attr = m_Attrs[Tag_ABI_VFP_args];
+    ELFAttributeValue &out_float_number_model_attr =
+        m_Attrs[Tag_ABI_FP_number_model];
+
+    assert(out_attr.isInitialized() && "VFP args has never set!");
+
+    // If the output is not permitted to use floating number, this attribute
+    // is ignored (migrate the value from input directly.)
+    if (out_float_number_model_attr.isUninitialized() ||
+        (out_float_number_model_attr.getIntValue() == 0)) {
+      // Inherit requirement from input.
+      out_attr.setIntValue(m_VFPArgs);
+    } else {
+      if (pConfig.options().warnMismatch())
+        warning(diag::warn_mismatch_vfp_args) << pInput.name();
+    }
+  }
+
+  // Process Tag_FP_arch.
+  ELFAttributeValue &out_fp_arch_attr = m_Attrs[Tag_FP_arch];
+  if (m_FPArch >= 0) {
+    assert(out_fp_arch_attr.isInitialized() && "FP arch has never set!");
+
+    // Tag_FP_arch
+    //  0: instructions requiring FP hardware are not permitted
+    //  1: VFP1
+    //  2: VFP2
+    //  3: VFP3 D32
+    //  4: VFP3 D16
+    //  5: VFP4 D32
+    //  6: VFP4 D16
+    //  7: ARM v8-A D32
+    //  8: ARM v8-A D16
+    if (out_fp_arch_attr.getIntValue() == 0) {
+      // Output has no constraints on FP hardware. Copy the requirement from
+      // input.
+      out_fp_arch_attr.setIntValue(m_FPArch);
+    } else if (m_FPArch == 0) {
+      // Input has no constraints on FP hardware. Do nothing.
+    } else {
+      // If here, both output and input contain non-zero value of Tag_FP_arch.
+
+      // Version greater than num_fp_configs is not defined. Choose the greater
+      // one for future-proofing.
+      if (static_cast<unsigned>(m_FPArch) > num_fp_configs) {
+        if (static_cast<unsigned>(m_FPArch) > out_fp_arch_attr.getIntValue()) {
+          out_fp_arch_attr.setIntValue(m_FPArch);
+        }
+      } else {
+        if (out_fp_arch_attr.getIntValue() < num_fp_configs) {
+          const struct fp_config_data &input_fp_config = fp_configs[ m_FPArch ];
+
+          const struct fp_config_data &output_fp_config =
+              fp_configs[ out_fp_arch_attr.getIntValue() ];
+
+          const struct fp_config_data result_fp_config = {
+            /*version*/((output_fp_config.version > input_fp_config.version) ?
+                         output_fp_config.version : input_fp_config.version),
+            /* regs */((output_fp_config.regs > input_fp_config.regs) ?
+                        output_fp_config.regs : input_fp_config.regs),
+          };
+          // Find the attribute value corresponding the result_fp_config
+          out_fp_arch_attr.setIntValue(get_fp_arch_of_config(result_fp_config));
+        }
+      }
+    }
+  } // (m_FPArch >= 0)
+
+  // Process Tag_ABI_HardFP_use.
+  ELFAttributeValue &out_hardfp_use_attr = m_Attrs[Tag_ABI_HardFP_use];
+
+  if (!m_HardFPUseInitialized && out_hardfp_use_attr.isInitialized()) {
+    m_HardFPUse = out_hardfp_use_attr.getIntValue();
+    m_HardFPUseInitialized = true;
+  }
+
+  if (m_HardFPUse >= 0) {
+    // Tag_ABI_HardFP_use depends on the meaning of Tag_FP_arch when it's 0.
+    assert(out_hardfp_use_attr.isInitialized() && "HardFP use has never set!");
+
+    if (out_fp_arch_attr.isUninitialized() ||
+        (out_fp_arch_attr.getIntValue() == 0)) {
+      // Has no constraints on FP hardware.
+      out_hardfp_use_attr.setIntValue(m_HardFPUse);
+    } else {
+      // Both output and input contain non-zero value of Tag_FP_arch and we have
+      // different Tag_ABI_HaedFP_Use settings other than 0.
+      if ((out_fp_arch_attr.getIntValue() > 0) && (m_HardFPUse > 0))
+        // Promote to 3 (The user permitted this entity to use both SP and DP
+        // VFP instruction.)
+        out_hardfp_use_attr.setIntValue(3);
+    }
+  }
+
+  // Move the value of Tag_MPextension_use_legacy to Tag_MPextension_use.
+  ELFAttributeValue &out_mpextension_use_legacy =
+      m_Attrs[Tag_MPextension_use_legacy];
+
+  ELFAttributeValue &out_mpextension_use = m_Attrs[Tag_MPextension_use];
+
+  // If Tag_MPextension_use_legacy has value, it must be introduced by current
+  // input since it is reset every time after the merge completed.
+  if (out_mpextension_use_legacy.isInitialized()) {
+    if (out_mpextension_use.isInitialized()) {
+      if (m_MPextensionUse < 0) {
+        // The value of Tag_MPextension_use is introduced by the current input.
+        // Check whether it is consistent with the one set in legacy.
+        m_MPextensionUse = out_mpextension_use.getIntValue();
+      } else {
+        // Current input introduces value of Tag_MPextension_use in
+        // m_MPextensionUse.
+      }
+
+      // Check the consistency between m_MPextensionUse and the value of
+      // Tag_MPextension_use_legacy.
+      if (static_cast<unsigned>(m_MPextensionUse) !=
+              out_mpextension_use_legacy.getIntValue()) {
+        error(diag::error_mismatch_mpextension_use) << pInput.name();
+        return false;
+      }
+    } else {
+      if (m_MPextensionUse < 0) {
+        // Tag_MPextension_use is not set. Initialize it and move the value.
+        out_mpextension_use.setType(ELFAttributeValue::Int);
+        out_mpextension_use.setIntValue(out_mpextension_use.getIntValue());
+      } else {
+        // Unreachable case since the value to unitialized attribute is directly
+        // assigned in ELFAttribute::Subsection::merge().
+        assert(false && "Tag_MPextension_use is uninitialized but have value?");
+      }
+    }
+
+    // Reset the attribute to uninitialized so it won't be included in the
+    // output.
+    out_mpextension_use_legacy.setType(ELFAttributeValue::Uninitialized);
+  }
+
+  // Process Tag_MPextension_use.
+  if (m_MPextensionUse > 0) {
+    assert(out_mpextension_use.isInitialized());
+
+    if (static_cast<unsigned>(m_MPextensionUse) >
+            out_mpextension_use.getIntValue()) {
+      out_mpextension_use.setIntValue(m_MPextensionUse);
+    }
+  }
+
+  // Process Tag_DIV_use.
+  ELFAttributeValue &out_div_use_attr = m_Attrs[Tag_DIV_use];
+
+  if (!m_DIVUseInitialized && out_div_use_attr.isInitialized()) {
+    // Perform the merge by reverting value of Tag_DIV_use and setup m_DIVUse.
+    m_DIVUse = out_div_use_attr.getIntValue();
+    out_div_use_attr.setIntValue(0);
+    m_DIVUseInitialized = true;
+  }
+
+  if (m_DIVUse >= 0) {
+    assert(out_div_use_attr.isInitialized());
+
+    const ELFAttributeValue &out_cpu_arch_profile_attr =
+        m_Attrs[Tag_CPU_arch_profile];
+
+    int out_cpu_arch_profile = Arch_Profile_None;
+    if (out_cpu_arch_profile_attr.isInitialized()) {
+      out_cpu_arch_profile = out_cpu_arch_profile_attr.getIntValue();
+    }
+
+    if (m_DIVUse == 1) {
+      // Input (=1) was not permitted to use SDIV and UDIV. See whether current
+      // output was explicitly permitted the use.
+      if (!is_allowed_use_of_div(m_CurrentCPUArch, out_cpu_arch_profile,
+                                 out_div_use_attr.getIntValue())) {
+        out_div_use_attr.setIntValue(1);
+      }
+    } else {
+      if (out_div_use_attr.getIntValue() != 1) {
+        // Output does not explicitly forbid the use of SDIV/UDIV. See whether
+        // the input attribute can allow it under current CPU architecture
+        // profile.
+        if (is_allowed_use_of_div(m_CurrentCPUArch, out_cpu_arch_profile,
+                                  m_DIVUse)) {
+          out_div_use_attr.setIntValue(m_DIVUse);
+        }
+      }
+    }
+  }
+
+  return true;
+}
+
+size_t ARMELFAttributeData::sizeOutput() const {
+  size_t result = 0;
+
+  // Size contributed by known attributes
+  for (unsigned i = 0; i <= Tag_Max; ++i) {
+    TagType tag = static_cast<TagType>(i);
+    const ELFAttributeValue &value = m_Attrs[tag];
+
+    if (value.shouldEmit()) {
+      result += leb128::size(static_cast<uint32_t>(tag));
+      result += value.getSize();
+    }
+  }
+
+  // Size contributed by unknown attributes
+  for (UnknownAttrsMap::const_iterator unknown_attr_it = m_UnknownAttrs.begin(),
+          unknown_attr_end = m_UnknownAttrs.end();
+       unknown_attr_it != unknown_attr_end; ++unknown_attr_it) {
+    TagType tag = unknown_attr_it->first;
+    const ELFAttributeValue &value = unknown_attr_it->second;
+
+    if (value.shouldEmit()) {
+      result += leb128::size(static_cast<uint32_t>(tag));
+      result += value.getSize();
+    }
+  }
+
+  return result;
+}
+
+size_t ARMELFAttributeData::emit(char *pBuf) const {
+  char *buffer = pBuf;
+
+  // Tag_conformance "should be emitted first in a file-scope sub-subsection of
+  // the first public subsection of the attribute section."
+  //
+  // See ARM [ABI-addenda], 2.3.7.4 Conformance tag
+  const ELFAttributeValue &attr_conformance = m_Attrs[Tag_conformance];
+
+  if (attr_conformance.shouldEmit()) {
+    if (!ELFAttributeData::WriteAttribute(Tag_conformance,  attr_conformance,
+                                          buffer)) {
+      return 0;
+    }
+  }
+
+  // Tag_nodefaults "should be emitted before any other tag in an attribute
+  // subsection other that the conformance tag"
+  //
+  // See ARM [ABI-addenda], 2.3.7.5 No defaults tag
+  const ELFAttributeValue &attr_nodefaults = m_Attrs[Tag_nodefaults];
+
+  if (attr_nodefaults.shouldEmit()) {
+    if (!ELFAttributeData::WriteAttribute(Tag_nodefaults,  attr_nodefaults,
+                                          buffer)) {
+      return 0;
+    }
+  }
+
+  // Tag_conformance (=67)
+  // Tag_nodefaults (=64)
+  for (unsigned i = 0; i < Tag_nodefaults; ++i) {
+    TagType tag = static_cast<TagType>(i);
+    const ELFAttributeValue &value = m_Attrs[tag];
+
+    if (value.shouldEmit() &&
+        !ELFAttributeData::WriteAttribute(tag, value, buffer)) {
+      return 0;
+    }
+  }
+
+  for (unsigned i = (Tag_nodefaults + 1); i <= Tag_Max; ++i) {
+    TagType tag = static_cast<TagType>(i);
+    const ELFAttributeValue &value = m_Attrs[tag];
+
+    if (value.shouldEmit() && (i != Tag_conformance) &&
+        !ELFAttributeData::WriteAttribute(tag, value, buffer)) {
+      return 0;
+    }
+  }
+
+  for (UnknownAttrsMap::const_iterator unknown_attr_it = m_UnknownAttrs.begin(),
+          unknown_attr_end = m_UnknownAttrs.end();
+       unknown_attr_it != unknown_attr_end; ++unknown_attr_it) {
+    TagType tag = unknown_attr_it->first;
+    const ELFAttributeValue &value = unknown_attr_it->second;
+
+    if (value.shouldEmit() &&
+        !ELFAttributeData::WriteAttribute(tag, value, buffer)) {
+      return 0;
+    }
+  }
+
+  return (buffer - pBuf);
+}
diff --git a/lib/Target/ARM/ARMELFAttributeData.h b/lib/Target/ARM/ARMELFAttributeData.h
new file mode 100644
index 0000000..01e7816
--- /dev/null
+++ b/lib/Target/ARM/ARMELFAttributeData.h
@@ -0,0 +1,242 @@
+//===- ARMELFAttributeData.h ----------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_ARM_ELF_ATTRIBUTE_DATA_H
+#define MCLD_ARM_ELF_ATTRIBUTE_DATA_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Target/ELFAttributeData.h>
+#include <mcld/Target/ELFAttributeValue.h>
+
+#include <map>
+#include <string>
+
+namespace mcld {
+
+/** \class ARMELFAttributeData
+ *  \brief ARMELFAttributeData handles public ("aeabi") attributes subsection in
+ *  ARM ELF.
+ *
+ */
+class ARMELFAttributeData : public ELFAttributeData {
+public:
+  enum Tag {
+    // 0-3 are generic and are defined in ELFAttributeData.
+    Tag_CPU_raw_name                = 4,
+    Tag_CPU_name                    = 5,
+    Tag_CPU_arch                    = 6,
+    Tag_CPU_arch_profile            = 7,
+    Tag_ARM_ISA_use                 = 8,
+    Tag_THUMB_ISA_use               = 9,
+    Tag_FP_arch                     = 10,
+    Tag_WMMX_arch                   = 11,
+    Tag_Advanced_SIMD_arch          = 12,
+    Tag_PCS_config                  = 13,
+    Tag_ABI_PCS_R9_use              = 14,
+    Tag_ABI_PCS_RW_data             = 15,
+    Tag_ABI_PCS_RO_data             = 16,
+    Tag_ABI_PCS_GOT_use             = 17,
+    Tag_ABI_PCS_wchar_t             = 18,
+    Tag_ABI_FP_rounding             = 19,
+    Tag_ABI_FP_denormal             = 20,
+    Tag_ABI_FP_exceptions           = 21,
+    Tag_ABI_FP_user_exceptions      = 22,
+    Tag_ABI_FP_number_model         = 23,
+    Tag_ABI_align_needed            = 24,
+    Tag_ABI_align_preserved         = 25,
+    Tag_ABI_enum_size               = 26,
+    Tag_ABI_HardFP_use              = 27,
+    Tag_ABI_VFP_args                = 28,
+    Tag_ABI_WMMX_args               = 29,
+    Tag_ABI_optimization_goals      = 30,
+    Tag_ABI_FP_optimization_goals   = 31,
+    Tag_compatibility               = 32,
+
+    Tag_CPU_unaligned_access        = 34,
+
+    Tag_FP_HP_extension             = 36,
+
+    Tag_ABI_FP_16bit_format         = 38,
+
+    Tag_MPextension_use             = 42,
+
+    Tag_DIV_use                     = 44,
+
+    Tag_nodefaults                  = 64,
+    Tag_also_compatible_with        = 65,
+    Tag_T2EE_use                    = 66,
+    Tag_conformance                 = 67,
+    Tag_Virtualization_use          = 68,
+
+    Tag_MPextension_use_legacy      = 70,
+
+    Tag_Max = Tag_MPextension_use_legacy,
+
+    // Alias
+    Tag_VFP_arch                    = Tag_FP_arch,
+    Tag_ABI_align8_needed           = Tag_ABI_align_needed,
+    Tag_ABI_align8_preserved        = Tag_ABI_align_preserved,
+    Tag_VFP_HP_extension            = Tag_FP_HP_extension
+  };
+
+  // For Tag_CPU_arch
+  enum {
+    CPU_Arch_ARM_Pre_V4,
+    CPU_Arch_ARM_V4,    // e.g., SA110
+    CPU_Arch_ARM_V4T,   // e.g., ARM7TDMI
+    CPU_Arch_ARM_V5T,   // e.g., ARM9TDMI
+    CPU_Arch_ARM_V5TE,  // e.g., ARM946E-S
+    CPU_Arch_ARM_V5TEJ, // e.g., ARM926EJ-S
+    CPU_Arch_ARM_V6,    // e.g., ARM1136J-S
+    CPU_Arch_ARM_V6KZ,  // e.g., ARM1176JZ-S
+    CPU_Arch_ARM_V6T2,  // e.g., ARM1156T2F-S
+    CPU_Arch_ARM_V6K,   // e.g., ARM1136J-S
+    CPU_Arch_ARM_V7,    // e.g., Cortex A8, Cortex M3
+    CPU_Arch_ARM_V6_M,  // e.g., Cortex M1
+    CPU_Arch_ARM_V6S_M, // e.g., v6-M with the value of System extensions
+    CPU_Arch_ARM_V7E_M, // e.g., v7-M with DSP extensions
+    CPU_Arch_ARM_V8,
+
+    CPU_Arch_Max = CPU_Arch_ARM_V8,
+
+    // This is a pseudo-architecture to describe an architecture mixed with
+    // the subset of armv4t and armv6-m. This never appears in the value of
+    // Tag_CPU_arch.
+    CPU_Arch_ARM_V4T_Plus_V6_M = (CPU_Arch_Max + 1),
+
+    CPU_Arch_Plus_Pseudo_Max = CPU_Arch_ARM_V4T_Plus_V6_M,
+  };
+
+  // For Tag_CPU_arch_profile
+  enum {
+    Arch_Profile_None             = 0,
+    Arch_Profile_Application      = 'A',
+    Arch_Profile_Realtime         = 'R',
+    Arch_Profile_Microcontroller  = 'M',
+    Arch_Profile_RealOrApp        = 'S'
+  };
+
+  // For Tag_ABI_enum_size
+  enum {
+    Enum_Unused,
+    Enum_Smallest_Container,
+    Enum_32bit_Container,
+    Enum_Containerized_As_Possible
+  };
+
+  // For Tag_ABI_PCS_R9_use
+  enum {
+    R9_V6,
+    R9_SB,
+    R9_TLS,
+    R9_Unused
+  };
+
+  // For Tag_ABI_PCS_RW_data
+  enum {
+    RW_data_Absolute,
+    RW_data_PC_Relative,
+    RW_data_SB_Relative,
+    RW_data_unused
+  };
+
+public:
+  // ARM [ABI-addenda], 2.2.2: A public attributes subsection is named aeabi.
+  ARMELFAttributeData()
+    : ELFAttributeData("aeabi"), m_CurrentCPUArch(-1),
+      m_DIVUseInitialized(false), m_HardFPUseInitialized(false) { }
+
+public:
+  virtual const ELFAttributeValue *getAttributeValue(TagType pTag) const;
+
+  virtual std::pair<ELFAttributeValue*, bool>
+      getOrCreateAttributeValue(TagType pTag);
+
+  virtual bool preMerge(const Input &pInput)
+  {
+    // Reset states.
+    m_CPUArch = -1;
+    m_CPUName.clear();
+    m_CPURawName.clear();
+    m_SecondaryCPUArch = -1;
+    m_VFPArgs = -1;
+    m_FPArch = -1;
+    m_HardFPUse = -1;
+    m_MPextensionUse = -1;
+    m_DIVUse = -1;
+    return true;
+  }
+
+  virtual bool merge(const LinkerConfig& pConfig, const Input &pInput,
+                     TagType pTag, const ELFAttributeValue& pInAttr);
+
+  virtual bool postMerge(const LinkerConfig& pConfig, const Input &pInput);
+
+  virtual size_t sizeOutput() const;
+
+  virtual size_t emit(char *pBuf) const;
+
+private:
+  /// GetAttributeValueType - obtain the value type of the indicated tag.
+  static unsigned int GetAttributeValueType(TagType pTag);
+
+private:
+  // The storage for known tags which is indexed by the tag
+  ELFAttributeValue m_Attrs[Tag_Max + 1];
+
+  // The storage for unknown tags
+  typedef std::map<TagType, ELFAttributeValue> UnknownAttrsMap;
+  UnknownAttrsMap m_UnknownAttrs;
+
+  // This is a cache for the current output architecture calculate from of
+  // Tag_CPU_arch and Tag_also_compatible_with.
+  int m_CurrentCPUArch;
+
+  // Value of Tag_DIV_use and Tag_ABI_HardFP_use requires further examination
+  // for the every time adding to the output. These booleans are initialized to
+  // false and set to true until the corresponding attribute is initialized.
+  bool m_DIVUseInitialized;
+  bool m_HardFPUseInitialized;
+
+  // These attributes have dependency with each other. During the merge, we
+  // record their attribute values in the associated variables as follows and
+  // process them in postmerge() (when all other attributes are settled down.)
+
+  // Record the value of input Tag_CPU_arch.
+  int m_CPUArch;
+
+  // Record the value of input Tag_CPU_name.
+  std::string m_CPUName;
+
+  // Record the value of input Tag_CPU_raw_name.
+  std::string m_CPURawName;
+
+  // Record the value of input Tag_FP_arch.
+  int m_FPArch;
+
+  // Record the value of input Tag_ABI_HardFP_use.
+  int m_HardFPUse;
+
+  // Record the value of input Tag_also_compatible_with.
+  int m_SecondaryCPUArch;
+
+  // Record the value of input Tag_ABI_VFP_args.
+  int m_VFPArgs;
+
+  // Record the value of input Tag_MPextension_use and Tag_MPextension_use_legacy.
+  int m_MPextensionUse;
+
+  // Record the value of input Tag_DIV_use.
+  int m_DIVUse;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/lib/Target/ARM/ARMELFMCLinker.cpp b/lib/Target/ARM/ARMELFMCLinker.cpp
index daccc84..8e9a440 100644
--- a/lib/Target/ARM/ARMELFMCLinker.cpp
+++ b/lib/Target/ARM/ARMELFMCLinker.cpp
@@ -8,15 +8,12 @@
 //===----------------------------------------------------------------------===//
 #include "ARMELFMCLinker.h"
 
-#include <mcld/LinkerConfig.h>
-#include <mcld/Object/SectionMap.h>
-
 using namespace mcld;
 
 ARMELFMCLinker::ARMELFMCLinker(LinkerConfig& pConfig,
                                mcld::Module &pModule,
-                               MemoryArea& pOutput)
-  : ELFMCLinker(pConfig, pModule, pOutput) {
+                               FileHandle& pFileHandle)
+  : ELFMCLinker(pConfig, pModule, pFileHandle) {
 }
 
 ARMELFMCLinker::~ARMELFMCLinker()
diff --git a/lib/Target/ARM/ARMELFMCLinker.h b/lib/Target/ARM/ARMELFMCLinker.h
index 91f297f..1306bc9 100644
--- a/lib/Target/ARM/ARMELFMCLinker.h
+++ b/lib/Target/ARM/ARMELFMCLinker.h
@@ -16,7 +16,7 @@
 namespace mcld {
 
 class Module;
-class MemoryArea;
+class FileHandle;
 
 /** \class ARMELFMCLinker
  *  \brief ARMELFMCLinker sets up the environment for linking.
@@ -26,7 +26,7 @@
 public:
   ARMELFMCLinker(LinkerConfig& pConfig,
                  mcld::Module& pModule,
-                 MemoryArea& pOutput);
+                 FileHandle& pFileHandle);
 
   ~ARMELFMCLinker();
 };
diff --git a/lib/Target/ARM/ARMEmulation.cpp b/lib/Target/ARM/ARMEmulation.cpp
index 8b64f40..a890a87 100644
--- a/lib/Target/ARM/ARMEmulation.cpp
+++ b/lib/Target/ARM/ARMEmulation.cpp
@@ -34,11 +34,11 @@
   pConfig.attribute().predefined().setDynamic();
 
   // set up section map
-  if (pConfig.codeGenType() != LinkerConfig::Object) {
-    bool exist = false;
-    pScript.sectionMap().append(".ARM.exidx", ".ARM.exidx", exist);
-    pScript.sectionMap().append(".ARM.extab", ".ARM.extab", exist);
-    pScript.sectionMap().append(".ARM.attributes", ".ARM.attributes", exist);
+  if (pConfig.options().getScriptList().empty() &&
+      pConfig.codeGenType() != LinkerConfig::Object) {
+    pScript.sectionMap().insert(".ARM.exidx*", ".ARM.exidx");
+    pScript.sectionMap().insert(".ARM.extab*", ".ARM.extab");
+    pScript.sectionMap().insert(".ARM.attributes*", ".ARM.attributes");
   }
   return true;
 }
diff --git a/lib/Target/ARM/ARMFixupKinds.h b/lib/Target/ARM/ARMFixupKinds.h
deleted file mode 100644
index f42b940..0000000
--- a/lib/Target/ARM/ARMFixupKinds.h
+++ /dev/null
@@ -1,98 +0,0 @@
-//===- ARMFixupKinds.h ----------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_LIB_TARGET_ARM_ARM_FIXUP_KINDS_H_
-#define MCLD_LIB_TARGET_ARM_ARM_FIXUP_KINDS_H_
-
-#include <llvm/MC/MCFixup.h>
-
-namespace mcld {
-namespace ARM {
-
-enum Fixups {
-  // fixup_arm_ldst_pcrel_12 - 12-bit PC relative relocation for symbol
-  // addresses
-  fixup_arm_ldst_pcrel_12 = FirstTargetFixupKind,
-
-  // fixup_t2_ldst_pcrel_12 - Equivalent to fixup_arm_ldst_pcrel_12, with
-  // the 16-bit halfwords reordered.
-  fixup_t2_ldst_pcrel_12,
-
-  // fixup_arm_pcrel_10 - 10-bit PC relative relocation for symbol addresses
-  // used in VFP instructions where the lower 2 bits are not encoded
-  // (so it's encoded as an 8-bit immediate).
-  fixup_arm_pcrel_10,
-  // fixup_t2_pcrel_10 - Equivalent to fixup_arm_pcrel_10, accounting for
-  // the short-swapped encoding of Thumb2 instructions.
-  fixup_t2_pcrel_10,
-  // fixup_thumb_adr_pcrel_10 - 10-bit PC relative relocation for symbol
-  // addresses where the lower 2 bits are not encoded (so it's encoded as an
-  // 8-bit immediate).
-  fixup_thumb_adr_pcrel_10,
-  // fixup_arm_adr_pcrel_12 - 12-bit PC relative relocation for the ADR
-  // instruction.
-  fixup_arm_adr_pcrel_12,
-  // fixup_t2_adr_pcrel_12 - 12-bit PC relative relocation for the ADR
-  // instruction.
-  fixup_t2_adr_pcrel_12,
-  // fixup_arm_condbranch - 24-bit PC relative relocation for conditional branch
-  // instructions. 
-  fixup_arm_condbranch,
-  // fixup_arm_uncondbranch - 24-bit PC relative relocation for 
-  // branch instructions. (unconditional)
-  fixup_arm_uncondbranch,
-  // fixup_t2_condbranch - 20-bit PC relative relocation for Thumb2 direct
-  // unconditional branch instructions.
-  fixup_t2_condbranch,
-  // fixup_t2_uncondbranch - 20-bit PC relative relocation for Thumb2 direct
-  // branch unconditional branch instructions.
-  fixup_t2_uncondbranch,
-
-  // fixup_arm_thumb_br - 12-bit fixup for Thumb B instructions.
-  fixup_arm_thumb_br,
-
-  // fixup_arm_thumb_bl - Fixup for Thumb BL instructions.
-  fixup_arm_thumb_bl,
-
-  // fixup_arm_thumb_blx - Fixup for Thumb BLX instructions.
-  fixup_arm_thumb_blx,
-
-  // fixup_arm_thumb_cb - Fixup for Thumb branch instructions.
-  fixup_arm_thumb_cb,
-
-  // fixup_arm_thumb_cp - Fixup for Thumb load/store from constant pool instrs.
-  fixup_arm_thumb_cp,
-
-  // fixup_arm_thumb_bcc - Fixup for Thumb conditional branching instructions.
-  fixup_arm_thumb_bcc,
-
-  // The next two are for the movt/movw pair
-  // the 16bit imm field are split into imm{15-12} and imm{11-0}
-  fixup_arm_movt_hi16, // :upper16:
-  fixup_arm_movw_lo16, // :lower16:
-  fixup_t2_movt_hi16, // :upper16:
-  fixup_t2_movw_lo16, // :lower16:
-
-  // It is possible to create an "immediate" that happens to be pcrel.
-  // movw r0, :lower16:Foo-(Bar+8) and movt  r0, :upper16:Foo-(Bar+8)
-  // result in different reloc tags than the above two.
-  // Needed to support ELF::R_ARM_MOVT_PREL and ELF::R_ARM_MOVW_PREL_NC
-  fixup_arm_movt_hi16_pcrel, // :upper16:
-  fixup_arm_movw_lo16_pcrel, // :lower16:
-  fixup_t2_movt_hi16_pcrel, // :upper16:
-  fixup_t2_movw_lo16_pcrel, // :lower16:
-
-  // Marker
-  LastTargetFixupKind,
-  NumTargetFixupKinds = LastTargetFixupKind - FirstTargetFixupKind
-};
-
-} // namespace ARM
-} // namespace mcld
-
-#endif
diff --git a/lib/Target/ARM/ARMGNUInfo.h b/lib/Target/ARM/ARMGNUInfo.h
index ba51126..531a817 100644
--- a/lib/Target/ARM/ARMGNUInfo.h
+++ b/lib/Target/ARM/ARMGNUInfo.h
@@ -23,9 +23,7 @@
 
   uint64_t defaultTextSegmentAddr() const { return 0x8000; }
 
-  uint64_t flags() const
-  { return llvm::ELF::EF_ARM_EABI_VER5; }
-
+  uint64_t flags() const { return llvm::ELF::EF_ARM_EABI_VER5; }
 };
 
 } // namespace of mcld
diff --git a/lib/Target/ARM/ARMGOT.cpp b/lib/Target/ARM/ARMGOT.cpp
index 1796635..3e9dc31 100644
--- a/lib/Target/ARM/ARMGOT.cpp
+++ b/lib/Target/ARM/ARMGOT.cpp
@@ -12,7 +12,6 @@
 
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/LDFileFormat.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MsgHandling.h>
 
 namespace {
@@ -24,15 +23,11 @@
 //===----------------------------------------------------------------------===//
 // ARMGOT
 ARMGOT::ARMGOT(LDSection& pSection)
-  : GOT(pSection), m_pLast(NULL)
+  : GOT(pSection), m_pGOTPLTFront(NULL), m_pGOTFront(NULL)
 {
-  // Create GOT0 entries.
-  reserve(ARMGOT0Num);
-
-  // Skip GOT0 entries.
-  for (unsigned int i = 0; i < ARMGOT0Num; ++i) {
-    consume();
-  }
+  // create GOT0, and put them into m_SectionData immediately
+  for (unsigned int i = 0; i < ARMGOT0Num; ++i)
+    new ARMGOTEntry(0, m_SectionData);
 }
 
 ARMGOT::~ARMGOT()
@@ -41,86 +36,64 @@
 
 bool ARMGOT::hasGOT1() const
 {
-  return (m_SectionData->size() > ARMGOT0Num);
+  return ((!m_GOT.empty()) || (!m_GOTPLT.empty()));
 }
 
-void ARMGOT::reserve(size_t pNum)
+ARMGOTEntry* ARMGOT::createGOT()
 {
-  for (size_t i = 0; i < pNum; i++) {
-    new ARMGOTEntry(0, m_SectionData);
-  }
+  ARMGOTEntry* entry = new ARMGOTEntry(0, NULL);
+  m_GOT.push_back(entry);
+  return entry;
 }
 
-ARMGOTEntry* ARMGOT::consume()
+ARMGOTEntry* ARMGOT::createGOTPLT()
 {
-  if (NULL == m_pLast) {
-    assert(!empty() && "Consume empty GOT entry!");
-    m_pLast = llvm::cast<ARMGOTEntry>(&m_SectionData->front());
-    return m_pLast;
+  ARMGOTEntry* entry = new ARMGOTEntry(0, NULL);
+  m_GOTPLT.push_back(entry);
+  return entry;
+}
+
+void ARMGOT::finalizeSectionSize()
+{
+  uint32_t offset = 0;
+  SectionData::FragmentListType& frag_list = m_SectionData->getFragmentList();
+  // setup GOT0 offset
+  SectionData::iterator frag, fragEnd = m_SectionData->end();
+  for (frag = m_SectionData->begin(); frag != fragEnd; ++frag) {
+    frag->setOffset(offset);
+    offset += frag->size();
   }
 
-  m_pLast = llvm::cast<ARMGOTEntry>(m_pLast->getNextNode());
-  return m_pLast;
-}
-
-void ARMGOT::reserveGOTPLT()
-{
-  ARMGOTEntry* entry = new ARMGOTEntry(0, m_SectionData);
-  if (NULL == m_GOTPLT.front) {
-    // GOTPLT is empty
-    if (NULL == m_GOT.front) {
-      // GOT part is also empty. Since entry is the last entry, we can assign
-      // it to GOTPLT directly.
-      m_GOTPLT.front = entry;
-    }
-    else {
-      // GOTn is not empty. Shift GOTn backward by one entry.
-      m_GOTPLT.front = m_GOT.front;
-      m_GOT.front = llvm::cast<ARMGOTEntry>(m_GOT.front->getNextNode());
+  // push GOTPLT into the SectionData and setup the offset
+  if (!m_GOTPLT.empty()) {
+    m_pGOTPLTFront = m_GOTPLT.front();
+    entry_iterator it, end = m_GOTPLT.end();
+    for (it = m_GOTPLT.begin(); it != end; ++it) {
+      ARMGOTEntry* entry = *it;
+      frag_list.push_back(entry);
+      entry->setParent(m_SectionData);
+      entry->setOffset(offset);
+      offset += entry->size();
     }
   }
-  else {
-    // GOTPLT is not empty
-    if (NULL != m_GOT.front)
-      m_GOT.front = llvm::cast<ARMGOTEntry>(m_GOT.front->getNextNode());
-  }
-}
+  m_GOTPLT.clear();
 
-void ARMGOT::reserveGOT()
-{
-  ARMGOTEntry* entry = new ARMGOTEntry(0, m_SectionData);
-  if (NULL == m_GOT.front) {
-    // Entry must be the last entry. We can directly assign it to GOT part.
-    m_GOT.front = entry;
+  // push GOT into the SectionData and setup the offset
+  if (!m_GOT.empty()) {
+    m_pGOTFront = m_GOT.front();
+    entry_iterator it, end = m_GOT.end();
+    for (it = m_GOT.begin(); it != end; ++it) {
+      ARMGOTEntry* entry = *it;
+      frag_list.push_back(entry);
+      entry->setParent(m_SectionData);
+      entry->setOffset(offset);
+      offset += entry->size();
+    }
   }
-}
+  m_GOT.clear();
 
-ARMGOTEntry* ARMGOT::consumeGOTPLT()
-{
-  assert(NULL != m_GOTPLT.front && "Consuming empty GOTPLT section!");
-
-  if (NULL == m_GOTPLT.last_used) {
-    m_GOTPLT.last_used = m_GOTPLT.front;
-  }
-  else {
-    m_GOTPLT.last_used = llvm::cast<ARMGOTEntry>(m_GOTPLT.last_used->getNextNode());
-    assert(m_GOTPLT.last_used != m_GOT.front && "No GOT/PLT entry to consume!");
-  }
-  return m_GOTPLT.last_used;
-}
-
-ARMGOTEntry* ARMGOT::consumeGOT()
-{
-  assert(NULL != m_GOT.front && "Consuming empty GOT section!");
-
-  if (NULL == m_GOT.last_used) {
-    m_GOT.last_used = m_GOT.front;
-  }
-  else {
-    m_GOT.last_used = llvm::cast<ARMGOTEntry>(m_GOT.last_used->getNextNode());
-    assert(m_GOT.last_used != NULL && "No GOTn entry to consume!");
-  }
-  return m_GOT.last_used;
+  // set section size
+  m_Section.setSize(offset);
 }
 
 void ARMGOT::applyGOT0(uint64_t pAddress)
@@ -131,15 +104,15 @@
 
 void ARMGOT::applyGOTPLT(uint64_t pPLTBase)
 {
-  if (NULL == m_GOTPLT.front)
+  if (NULL == m_pGOTPLTFront)
     return;
 
-  SectionData::iterator entry(m_GOTPLT.front);
+  SectionData::iterator entry(m_pGOTPLTFront);
   SectionData::iterator e_end;
-  if (NULL == m_GOT.front)
+  if (NULL == m_pGOTFront)
     e_end = m_SectionData->end();
   else
-    e_end = SectionData::iterator(m_GOT.front);
+    e_end = SectionData::iterator(m_pGOTFront);
 
   while (entry != e_end) {
     llvm::cast<ARMGOTEntry>(entry)->setValue(pPLTBase);
@@ -149,7 +122,7 @@
 
 uint64_t ARMGOT::emit(MemoryRegion& pRegion)
 {
-  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
+  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
 
   ARMGOTEntry* got = NULL;
   uint64_t result = 0x0;
diff --git a/lib/Target/ARM/ARMGOT.h b/lib/Target/ARM/ARMGOT.h
index be22c67..dc85fb0 100644
--- a/lib/Target/ARM/ARMGOT.h
+++ b/lib/Target/ARM/ARMGOT.h
@@ -12,14 +12,14 @@
 #include <gtest.h>
 #endif
 
-#include <llvm/ADT/DenseMap.h>
-
 #include <mcld/Target/GOT.h>
+#include <mcld/Support/MemoryRegion.h>
+#include <llvm/ADT/DenseMap.h>
+#include <vector>
 
 namespace mcld {
 
 class LDSection;
-class MemoryRegion;
 
 /** \class ARMGOTEntry
  *  \brief GOT Entry with size of 4 bytes
@@ -56,17 +56,10 @@
 
   ~ARMGOT();
 
-  void reserve(size_t pNum = 1);
+  ARMGOTEntry* createGOT();
+  ARMGOTEntry* createGOTPLT();
 
-  void reserveGOTPLT();
-
-  void reserveGOT();
-
-  ARMGOTEntry* consume();
-
-  ARMGOTEntry* consumeGOT();
-
-  ARMGOTEntry* consumeGOTPLT();
+  void finalizeSectionSize();
 
   uint64_t emit(MemoryRegion& pRegion);
 
@@ -77,20 +70,19 @@
   bool hasGOT1() const;
 
 private:
-  struct Part {
-  public:
-    Part() : front(NULL), last_used(NULL) { }
-
-  public:
-    ARMGOTEntry* front;
-    ARMGOTEntry* last_used;
-  };
+  typedef std::vector<ARMGOTEntry*> EntryListType;
+  typedef EntryListType::iterator entry_iterator;
+  typedef EntryListType::const_iterator const_entry_iterator;
 
 private:
-  Part m_GOTPLT;
-  Part m_GOT;
+  ARMGOTEntry* m_pGOTPLTFront;
+  ARMGOTEntry* m_pGOTFront;
 
-  ARMGOTEntry* m_pLast; ///< the last consumed entry
+  /// m_GOTPLTEntries - a list of gotplt entries
+  EntryListType m_GOTPLT;
+
+  /// m_GOTEntris - a list of got entries
+  EntryListType m_GOT;
 };
 
 } // namespace of mcld
diff --git a/lib/Target/ARM/ARMLDBackend.cpp b/lib/Target/ARM/ARMLDBackend.cpp
index 8e45543..dfcfb0d 100644
--- a/lib/Target/ARM/ARMLDBackend.cpp
+++ b/lib/Target/ARM/ARMLDBackend.cpp
@@ -8,6 +8,7 @@
 //===----------------------------------------------------------------------===//
 #include "ARM.h"
 #include "ARMGNUInfo.h"
+#include "ARMELFAttributeData.h"
 #include "ARMELFDynamic.h"
 #include "ARMLDBackend.h"
 #include "ARMRelocator.h"
@@ -28,17 +29,21 @@
 #include <mcld/Fragment/FillFragment.h>
 #include <mcld/Fragment/AlignFragment.h>
 #include <mcld/Fragment/RegionFragment.h>
+#include <mcld/Fragment/Stub.h>
+#include <mcld/Fragment/NullFragment.h>
 #include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MemoryArea.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Support/TargetRegistry.h>
-#include <mcld/Fragment/Stub.h>
 #include <mcld/LD/BranchIslandFactory.h>
 #include <mcld/LD/StubFactory.h>
-#include <mcld/Object/ObjectBuilder.h>
-#include <mcld/Fragment/NullFragment.h>
 #include <mcld/LD/LDContext.h>
+#include <mcld/LD/ELFFileFormat.h>
+#include <mcld/LD/ELFSegmentFactory.h>
+#include <mcld/LD/ELFSegment.h>
+#include <mcld/Target/ELFAttribute.h>
 #include <mcld/Target/GNUInfo.h>
+#include <mcld/Object/ObjectBuilder.h>
 
 using namespace mcld;
 
@@ -52,6 +57,7 @@
     m_pPLT(NULL),
     m_pRelDyn(NULL),
     m_pRelPLT(NULL),
+    m_pAttrData(NULL),
     m_pDynamic(NULL),
     m_pGOTSymbol(NULL),
     m_pEXIDXStart(NULL),
@@ -69,6 +75,7 @@
   delete m_pRelDyn;
   delete m_pRelPLT;
   delete m_pDynamic;
+  delete m_pAttrData;
 }
 
 void ARMGNULDBackend::initTargetSections(Module& pModule, ObjectBuilder& pBuilder)
@@ -91,6 +98,10 @@
                                            0x0,
                                            0x1);
 
+  // initialize "aeabi" attributes subsection
+  m_pAttrData = new ARMELFAttributeData();
+  attribute().registerAttributeData(*m_pAttrData);
+
   if (LinkerConfig::Object != config().codeGenType()) {
     ELFFileFormat* file_format = getOutputFormat();
 
@@ -206,6 +217,9 @@
   if (!config().isCodeStatic() && NULL == m_pDynamic)
     m_pDynamic = new ARMELFDynamic(*this, config());
 
+  // set attribute section size
+  m_pAttributes->setSize(attribute().sizeOutput());
+
   // set .got size
   // when building shared object, the .got section is must
   if (LinkerConfig::Object != config().codeGenType()) {
@@ -316,77 +330,71 @@
 
   const ELFFileFormat* file_format = getOutputFormat();
 
-  if (&pSection == m_pAttributes ||
-      &pSection == m_pEXIDX ||
-      &pSection == m_pEXTAB) {
-    // FIXME: Currently Emitting .ARM.attributes, .ARM.exidx, and .ARM.extab
-    // directly from the input file.
-    const SectionData* sect_data = pSection.getSectionData();
-    SectionData::const_iterator frag_iter, frag_end = sect_data->end();
-    uint8_t* out_offset = pRegion.start();
-    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 (0 == fill_frag.getValueSize()) {
-            // 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 uint8_t* start = region_frag.getRegion().start();
-          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;
-    } // end for
-    return pRegion.size();
-  } // end if
-
-  if (&pSection == &(file_format->getPLT())) {
-    assert(NULL != m_pPLT && "emitSectionData failed, m_pPLT is NULL!");
+  if (file_format->hasPLT() && (&pSection == &(file_format->getPLT()))) {
     uint64_t result = m_pPLT->emit(pRegion);
     return result;
   }
 
-  if (&pSection == &(file_format->getGOT())) {
-    assert(NULL != m_pGOT && "emitSectionData failed, m_pGOT is NULL!");
+  if (file_format->hasGOT() && (&pSection == &(file_format->getGOT()))) {
     uint64_t result = m_pGOT->emit(pRegion);
     return result;
   }
-  fatal(diag::unrecognized_output_sectoin)
-          << pSection.name()
-          << "mclinker@googlegroups.com";
-  return 0x0;
+
+  if (&pSection == m_pAttributes) {
+    return attribute().emit(pRegion);
+  }
+
+  // FIXME: Currently Emitting .ARM.attributes, .ARM.exidx, and .ARM.extab
+  // directly from the input file.
+  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 (0 == fill_frag.getValueSize()) {
+          // 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;
+  } // end for
+  return pRegion.size();
 }
 
 /// finalizeSymbol - finalize the symbol value
@@ -395,46 +403,110 @@
   return true;
 }
 
-bool ARMGNULDBackend::mergeSection(Module& pModule, LDSection& pSection)
+bool ARMGNULDBackend::mergeSection(Module& pModule,
+                                   const Input& pInput,
+                                   LDSection& pSection)
 {
   switch (pSection.type()) {
     case llvm::ELF::SHT_ARM_ATTRIBUTES: {
-      // FIXME: (Luba)
-      // Handle ARM attributes in the right way.
-      // In current milestone, we goes through the shortcut.
-      // It reads input's ARM attributes and copies the first ARM attributes
-      // into the output file. The correct way is merge these sections, not
-      // just copy.
-      if (0 != m_pAttributes->size())
-        return true;
-
-      // First time we meet a ARM attributes section.
-      SectionData* sd = IRBuilder::CreateSectionData(*m_pAttributes);
-      ObjectBuilder::MoveSectionData(*pSection.getSectionData(), *sd);
-      return true;
+      return attribute().merge(pInput, pSection);
     }
+    case llvm::ELF::SHT_ARM_EXIDX: {
+      assert(NULL != pSection.getLink());
+      if (LDFileFormat::Ignore == pSection.getLink()->kind()) {
+        // if the target section of the .ARM.exidx is Ignore, then it should be
+        // ignored as well
+        pSection.setKind(LDFileFormat::Ignore);
+        return true;
+      }
+    }
+    /** fall through **/
     default: {
       ObjectBuilder builder(config(), pModule);
-      return builder.MergeSection(pSection);
+      builder.MergeSection(pInput, pSection);
+      return true;
     }
   } // end of switch
   return true;
 }
 
+void ARMGNULDBackend::setUpReachedSectionsForGC(const Module& pModule,
+            GarbageCollection::SectionReachedListMap& pSectReachedListMap) const
+{
+  // traverse all the input relocations to find the relocation sections applying
+  // .ARM.exidx sections
+  Module::const_obj_iterator input, inEnd = pModule.obj_end();
+  for (input = pModule.obj_begin(); input != inEnd; ++input) {
+    LDContext::const_sect_iterator rs,
+                                   rsEnd = (*input)->context()->relocSectEnd();
+    for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
+      // bypass the discarded relocation section
+      // 1. its section kind is changed to Ignore. (The target section is a
+      // discarded group section.)
+      // 2. it has no reloc data. (All symbols in the input relocs are in the
+      // discarded group sections)
+      LDSection* reloc_sect = *rs;
+      LDSection* apply_sect = reloc_sect->getLink();
+      if ((LDFileFormat::Ignore == reloc_sect->kind()) ||
+          (!reloc_sect->hasRelocData()))
+        continue;
+
+      if (llvm::ELF::SHT_ARM_EXIDX == apply_sect->type()) {
+        // 1. set up the reference according to relocations
+        bool add_first = false;
+        GarbageCollection::SectionListTy* reached_sects = NULL;
+        RelocData::iterator reloc_it, rEnd = reloc_sect->getRelocData()->end();
+        for (reloc_it = reloc_sect->getRelocData()->begin(); reloc_it != rEnd;
+                                                                   ++reloc_it) {
+          Relocation* reloc = llvm::cast<Relocation>(reloc_it);
+          ResolveInfo* sym = reloc->symInfo();
+          // only the target symbols defined in the input fragments can make the
+          // reference
+          if (NULL == sym)
+            continue;
+          if (!sym->isDefine() || !sym->outSymbol()->hasFragRef())
+            continue;
+
+          // only the target symbols defined in the concerned sections can make
+          // the reference
+          const LDSection* target_sect =
+                &sym->outSymbol()->fragRef()->frag()->getParent()->getSection();
+          if (target_sect->kind() != LDFileFormat::Regular &&
+              target_sect->kind() != LDFileFormat::BSS)
+            continue;
+
+          // setup the reached list, if we first add the element to reached list
+          // of this section, create an entry in ReachedSections map
+          if (!add_first) {
+            reached_sects = &pSectReachedListMap.getReachedList(*apply_sect);
+            add_first = true;
+          }
+          reached_sects->insert(target_sect);
+        }
+        reached_sects = NULL;
+        add_first = false;
+        // 2. set up the reference from XXX to .ARM.exidx.XXX
+        assert(apply_sect->getLink() != NULL);
+        pSectReachedListMap.addReference(*apply_sect->getLink(), *apply_sect);
+      }
+    }
+  }
+}
+
 bool ARMGNULDBackend::readSection(Input& pInput, SectionData& pSD)
 {
   Fragment* frag = NULL;
   uint32_t offset = pInput.fileOffset() + pSD.getSection().offset();
   uint32_t size = pSD.getSection().size();
 
-  MemoryRegion* region = pInput.memArea()->request(offset, size);
-  if (NULL == region) {
+  llvm::StringRef region = pInput.memArea()->request(offset, size);
+  if (region.size() == 0) {
     // If the input section's size is zero, we got a NULL region.
     // use a virtual fill fragment
     frag = new FillFragment(0x0, 0, 0);
   }
   else {
-    frag = new RegionFragment(*region);
+    frag = new RegionFragment(region);
   }
 
   ObjectBuilder::AppendFragment(*frag, pSD);
@@ -489,18 +561,30 @@
   return *m_pRelPLT;
 }
 
+ARMELFAttributeData& ARMGNULDBackend::getAttributeData()
+{
+  assert(NULL != m_pAttrData && ".ARM.attributes section not exist");
+  return *m_pAttrData;
+}
+
+const ARMELFAttributeData& ARMGNULDBackend::getAttributeData() const
+{
+  assert(NULL != m_pAttrData && ".ARM.attributes section not exist");
+  return *m_pAttrData;
+}
+
 unsigned int
 ARMGNULDBackend::getTargetSectionOrder(const LDSection& pSectHdr) const
 {
   const ELFFileFormat* file_format = getOutputFormat();
 
-  if (&pSectHdr == &file_format->getGOT()) {
+  if (file_format->hasGOT() && (&pSectHdr == &file_format->getGOT())) {
     if (config().options().hasNow())
       return SHO_RELRO_LAST;
     return SHO_DATA;
   }
 
-  if (&pSectHdr == &file_format->getPLT())
+  if (file_format->hasPLT() && (&pSectHdr == &file_format->getPLT()))
     return SHO_PLT;
 
   if (&pSectHdr == m_pEXIDX || &pSectHdr == m_pEXTAB) {
@@ -538,8 +622,7 @@
           case llvm::ELF::R_ARM_THM_CALL:
           case llvm::ELF::R_ARM_THM_XPC22:
           case llvm::ELF::R_ARM_THM_JUMP24:
-          case llvm::ELF::R_ARM_THM_JUMP19:
-          case llvm::ELF::R_ARM_V4BX: {
+          case llvm::ELF::R_ARM_THM_JUMP19: {
             // calculate the possible symbol value
             uint64_t sym_value = 0x0;
             LDSymbol* symbol = relocation->symInfo()->outSymbol();
@@ -561,23 +644,32 @@
                                                   pBuilder,
                                                   *getBRIslandFactory());
             if (NULL != stub) {
-              // a stub symbol should be local
-              assert(NULL != stub->symInfo() && stub->symInfo()->isLocal());
-              LDSection& symtab = file_format->getSymTab();
-              LDSection& strtab = file_format->getStrTab();
+              switch (config().options().getStripSymbolMode()) {
+                case GeneralOptions::StripAllSymbols:
+                case GeneralOptions::StripLocals:
+                  break;
+                default: {
+                  // a stub symbol should be local
+                  assert(NULL != stub->symInfo() && stub->symInfo()->isLocal());
+                  LDSection& symtab = file_format->getSymTab();
+                  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.setInfo(symtab.getInfo() + 1);
-              strtab.setSize(strtab.size() + stub->symInfo()->nameSize() + 1);
-
+                  // 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.setInfo(symtab.getInfo() + 1);
+                  strtab.setSize(strtab.size() + stub->symInfo()->nameSize() + 1);
+                }
+              } // end of switch
               isRelaxed = true;
             }
             break;
           }
+          case llvm::ELF::R_ARM_V4BX:
+            /* FIXME: bypass R_ARM_V4BX relocation now */
+            break;
           default:
             break;
         } // end of switch
@@ -639,7 +731,7 @@
      // make PT_ARM_EXIDX
      ELFSegment* exidx_seg = elfSegmentTable().produce(llvm::ELF::PT_ARM_EXIDX,
                                                        llvm::ELF::PF_R);
-     exidx_seg->addSection(m_pEXIDX);
+     exidx_seg->append(m_pEXIDX);
    }
 }
 
@@ -648,8 +740,7 @@
 //===----------------------------------------------------------------------===//
 /// createARMLDBackend - the help funtion to create corresponding ARMLDBackend
 ///
-TargetLDBackend* createARMLDBackend(const llvm::Target& pTarget,
-                                    const LinkerConfig& pConfig)
+TargetLDBackend* createARMLDBackend(const LinkerConfig& pConfig)
 {
   if (pConfig.targets().triple().isOSDarwin()) {
     assert(0 && "MachO linker is not supported yet");
diff --git a/lib/Target/ARM/ARMLDBackend.h b/lib/Target/ARM/ARMLDBackend.h
index 699fb78..5567293 100644
--- a/lib/Target/ARM/ARMLDBackend.h
+++ b/lib/Target/ARM/ARMLDBackend.h
@@ -18,9 +18,9 @@
 
 namespace mcld {
 
+class ARMELFAttributeData;
 class LinkerConfig;
 class GNUInfo;
-class SectionMap;
 
 //===----------------------------------------------------------------------===//
 /// ARMGNULDBackend - linker backend of ARM target of GNU ELF format
@@ -103,6 +103,9 @@
   OutputRelocSection& getRelPLT();
   const OutputRelocSection& getRelPLT() const;
 
+  ARMELFAttributeData& getAttributeData();
+  const ARMELFAttributeData& getAttributeData() const;
+
   LDSymbol* getGOTSymbol()             { return m_pGOTSymbol; }
   const LDSymbol* getGOTSymbol() const { return m_pGOTSymbol; }
 
@@ -113,7 +116,12 @@
   bool finalizeTargetSymbols();
 
   /// mergeSection - merge target dependent sections
-  bool mergeSection(Module& pModule, LDSection& pSection);
+  bool mergeSection(Module& pModule, const Input& pInput, LDSection& pSection);
+
+  /// setUpReachedSectionsForGC - set the reference from section XXX to
+  /// .ARM.exidx.XXX to make sure GC correctly handle section exidx
+  void setUpReachedSectionsForGC(const Module& pModule,
+           GarbageCollection::SectionReachedListMap& pSectReachedListMap) const;
 
   /// readSection - read target dependent sections
   bool readSection(Input& pInput, SectionData& pSD);
@@ -159,6 +167,9 @@
   /// m_RelPLT - dynamic relocation table of .rel.plt
   OutputRelocSection* m_pRelPLT;
 
+  /// m_pAttrData - attribute data in public ("aeabi") attribute subsection
+  ARMELFAttributeData* m_pAttrData;
+
   ARMELFDynamic* m_pDynamic;
   LDSymbol* m_pGOTSymbol;
   LDSymbol* m_pEXIDXStart;
diff --git a/lib/Target/ARM/ARMMCLinker.cpp b/lib/Target/ARM/ARMMCLinker.cpp
index cc9486e..dcee683 100644
--- a/lib/Target/ARM/ARMMCLinker.cpp
+++ b/lib/Target/ARM/ARMMCLinker.cpp
@@ -22,9 +22,9 @@
 MCLinker* createARMMCLinker(const std::string& pTriple,
                             LinkerConfig& pConfig,
                             mcld::Module& pModule,
-                            MemoryArea& pOutput)
+                            FileHandle& pFileHandle)
 {
-  Triple theTriple(pTriple);
+  llvm::Triple theTriple(pTriple);
   if (theTriple.isOSDarwin()) {
     assert(0 && "MachO linker has not supported yet");
     return NULL;
@@ -34,7 +34,7 @@
     return NULL;
   }
 
-  return new ARMELFMCLinker(pConfig, pModule, pOutput);
+  return new ARMELFMCLinker(pConfig, pModule, pFileHandle);
 }
 
 } // namespace of mcld
diff --git a/lib/Target/ARM/ARMPLT.cpp b/lib/Target/ARM/ARMPLT.cpp
index d7342ab..467bbeb 100644
--- a/lib/Target/ARM/ARMPLT.cpp
+++ b/lib/Target/ARM/ARMPLT.cpp
@@ -14,7 +14,6 @@
 #include <llvm/Support/Casting.h>
 
 #include <mcld/LD/LDSection.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MsgHandling.h>
 
 using namespace mcld;
@@ -28,11 +27,9 @@
 //===----------------------------------------------------------------------===//
 // ARMPLT
 
-ARMPLT::ARMPLT(LDSection& pSection,
-               ARMGOT &pGOTPLT)
-  : PLT(pSection), m_GOT(pGOTPLT), m_PLTEntryIterator() {
+ARMPLT::ARMPLT(LDSection& pSection, ARMGOT &pGOTPLT)
+  : PLT(pSection), m_GOT(pGOTPLT) {
   new ARMPLT0(*m_SectionData);
-  m_PLTEntryIterator = m_SectionData->begin();
 }
 
 ARMPLT::~ARMPLT()
@@ -58,39 +55,12 @@
   }
 }
 
-void ARMPLT::reserveEntry(size_t pNum)
+ARMPLT1* ARMPLT::create()
 {
-  ARMPLT1* plt1_entry = 0;
-
-  for (size_t i = 0; i < pNum; ++i) {
-    plt1_entry = new (std::nothrow) ARMPLT1(*m_SectionData);
-
-    if (!plt1_entry)
-      fatal(diag::fail_allocate_memory_plt);
-
-    m_GOT.reserveGOTPLT();
-  }
-}
-
-ARMPLT1* ARMPLT::consume()
-{
-  ++m_PLTEntryIterator;
-  assert(m_PLTEntryIterator != m_SectionData->end() &&
-         "The number of PLT Entries and ResolveInfo doesn't match");
-
-  return llvm::cast<ARMPLT1>(&(*m_PLTEntryIterator));
-}
-
-ARMPLT0* ARMPLT::getPLT0() const {
-
-  iterator first = m_SectionData->getFragmentList().begin();
-
-  assert(first != m_SectionData->getFragmentList().end() &&
-         "FragmentList is empty, getPLT0 failed!");
-
-  ARMPLT0* plt0 = &(llvm::cast<ARMPLT0>(*first));
-
-  return plt0;
+  ARMPLT1* plt1_entry = new (std::nothrow) ARMPLT1(*m_SectionData);
+  if (!plt1_entry)
+    fatal(diag::fail_allocate_memory_plt);
+  return plt1_entry;
 }
 
 void ARMPLT::applyPLT0() {
@@ -181,7 +151,7 @@
   uint64_t result = 0x0;
   iterator it = begin();
 
-  unsigned char* buffer = pRegion.getBuffer();
+  unsigned char* buffer = pRegion.begin();
   memcpy(buffer, llvm::cast<ARMPLT0>((*it)).getValue(), ARMPLT0::EntrySize);
   result += ARMPLT0::EntrySize;
   ++it;
diff --git a/lib/Target/ARM/ARMPLT.h b/lib/Target/ARM/ARMPLT.h
index 9554f0c..e1c8a74 100644
--- a/lib/Target/ARM/ARMPLT.h
+++ b/lib/Target/ARM/ARMPLT.h
@@ -11,6 +11,7 @@
 
 #include <mcld/Target/GOT.h>
 #include <mcld/Target/PLT.h>
+#include <mcld/Support/MemoryRegion.h>
 
 namespace {
 
@@ -33,7 +34,6 @@
 namespace mcld {
 
 class ARMGOT;
-class MemoryRegion;
 
 class ARMPLT0 : public PLT::Entry<sizeof(arm_plt0)>
 {
@@ -62,9 +62,7 @@
   // hasPLT1 - return if this plt section has any plt1 entry
   bool hasPLT1() const;
 
-  void reserveEntry(size_t pNum = 1) ;
-
-  ARMPLT1* consume();
+  ARMPLT1* create();
 
   ARMPLT0* getPLT0() const;
 
@@ -76,9 +74,6 @@
 
 private:
   ARMGOT& m_GOT;
-
-  // Used by getEntry() for mapping a ResolveInfo instance to a PLT1 Entry.
-  iterator m_PLTEntryIterator;
 };
 
 } // namespace of mcld
diff --git a/lib/Target/ARM/ARMRelocationFunctions.h b/lib/Target/ARM/ARMRelocationFunctions.h
index 94df077..790ed1f 100644
--- a/lib/Target/ARM/ARMRelocationFunctions.h
+++ b/lib/Target/ARM/ARMRelocationFunctions.h
@@ -33,6 +33,7 @@
 DECL_ARM_APPLY_RELOC_FUNC(got_prel)         \
 DECL_ARM_APPLY_RELOC_FUNC(tls)              \
 DECL_ARM_APPLY_RELOC_FUNC(thm_jump11)       \
+DECL_ARM_APPLY_RELOC_FUNC(thm_jump19)       \
 DECL_ARM_APPLY_RELOC_FUNC(unsupport)
 
 
@@ -77,7 +78,7 @@
   { &unsupport,         37, "R_ARM_ALU_SBREL_27_20_CK"},  \
   { &abs32,             38, "R_ARM_TARGET1"           },  \
   { &unsupport,         39, "R_ARM_SBREL31"           },  \
-  { &unsupport,         40, "R_ARM_V4BX"              },  \
+  { &none,              40, "R_ARM_V4BX"              },  \
   { &got_prel,          41, "R_ARM_TARGET2"           },  \
   { &prel31,            42, "R_ARM_PREL31"            },  \
   { &movw_abs_nc,       43, "R_ARM_MOVW_ABS_NC"       },  \
@@ -88,7 +89,7 @@
   { &thm_movt_abs,      48, "R_ARM_THM_MOVT_ABS"      },  \
   { &thm_movw_prel_nc,  49, "R_ARM_THM_MOVW_PREL_NC"  },  \
   { &thm_movt_prel,     50, "R_ARM_THM_MOVT_PREL"     },  \
-  { &unsupport,         51, "R_ARM_THM_JUMP19"        },  \
+  { &thm_jump19,        51, "R_ARM_THM_JUMP19"        },  \
   { &unsupport,         52, "R_ARM_THM_JUMP6"         },  \
   { &unsupport,         53, "R_ARM_THM_ALU_PREL_11_0" },  \
   { &unsupport,         54, "R_ARM_THM_PC12"          },  \
diff --git a/lib/Target/ARM/ARMRelocator.cpp b/lib/Target/ARM/ARMRelocator.cpp
index 02e4f14..415c36e 100644
--- a/lib/Target/ARM/ARMRelocator.cpp
+++ b/lib/Target/ARM/ARMRelocator.cpp
@@ -15,12 +15,304 @@
 #include <llvm/Support/Host.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/LD/LDSymbol.h>
+#include <mcld/LD/ELFFileFormat.h>
 #include <mcld/Object/ObjectBuilder.h>
 #include "ARMRelocator.h"
 #include "ARMRelocationFunctions.h"
 
 using namespace mcld;
 
+//=========================================//
+// Relocation helper function              //
+//=========================================//
+static Relocator::DWord getThumbBit(const Relocation& pReloc)
+{
+  // Set thumb bit if
+  // - symbol has type of STT_FUNC, is defined and with bit 0 of its value set
+  Relocator::DWord thumbBit =
+       ((!pReloc.symInfo()->isUndef() || pReloc.symInfo()->isDyn()) &&
+        (pReloc.symInfo()->type() == ResolveInfo::Function) &&
+        ((pReloc.symValue() & 0x1) != 0))?
+        1:0;
+  return thumbBit;
+}
+
+// Using uint64_t to make sure those complicate operations won't cause
+// undefined behavior.
+static
+uint64_t helper_sign_extend(uint64_t pVal, uint64_t pOri_width)
+{
+  assert(pOri_width <= 64);
+  if (pOri_width == 64)
+    return pVal;
+
+  uint64_t mask = (~((uint64_t)0)) >> (64 - pOri_width);
+  pVal &= mask;
+  // Reverse sign bit, then subtract sign bit.
+  uint64_t sign_bit = 1 << (pOri_width - 1);
+  return (pVal ^ sign_bit) - sign_bit;
+}
+
+static
+uint64_t helper_bit_select(uint64_t pA, uint64_t pB, uint64_t pMask)
+{
+  return (pA & ~pMask) | (pB & pMask) ;
+}
+
+// Check if symbol can use relocation R_ARM_RELATIVE
+static bool
+helper_use_relative_reloc(const ResolveInfo& pSym,
+                          const ARMRelocator& pFactory)
+{
+  // if symbol is dynamic or undefine or preemptible
+  if (pSym.isDyn() ||
+      pSym.isUndef() ||
+      pFactory.getTarget().isSymbolPreemptible(pSym))
+    return false;
+  return true;
+}
+
+// Strip LSB (THUMB bit) if "S" is a THUMB target.
+static inline void helper_clear_thumb_bit(ARMRelocator::DWord& pValue)
+{
+  pValue &= (~0x1);
+}
+
+static
+ARMRelocator::Address helper_get_GOT_address(ResolveInfo& pSym,
+                                             ARMRelocator& pParent)
+{
+  ARMGOTEntry* got_entry = pParent.getSymGOTMap().lookUp(pSym);
+  assert(NULL != got_entry);
+  return pParent.getTarget().getGOT().addr() + got_entry->getOffset();
+}
+
+static
+ARMGOTEntry& helper_GOT_init(Relocation& pReloc,
+                             bool pHasRel,
+                             ARMRelocator& pParent)
+{
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.symInfo();
+  ARMGNULDBackend& ld_backend = pParent.getTarget();
+  assert(NULL == pParent.getSymGOTMap().lookUp(*rsym));
+
+  ARMGOTEntry* got_entry = ld_backend.getGOT().createGOT();
+  pParent.getSymGOTMap().record(*rsym, *got_entry);
+  // If we first get this GOT entry, we should initialize it.
+  if (!pHasRel) {
+    // No corresponding dynamic relocation, initialize to the symbol value.
+    got_entry->setValue(ARMRelocator::SymVal);
+  }
+  else {
+    // Initialize corresponding dynamic relocation.
+    Relocation& rel_entry = *ld_backend.getRelDyn().create();
+    if (rsym->isLocal() || helper_use_relative_reloc(*rsym, pParent)) {
+      // Initialize got entry to target symbol address
+      got_entry->setValue(ARMRelocator::SymVal);
+      rel_entry.setType(llvm::ELF::R_ARM_RELATIVE);
+      rel_entry.setSymInfo(NULL);
+    }
+    else {
+      // Initialize got entry to 0 for corresponding dynamic relocation.
+      got_entry->setValue(0);
+      rel_entry.setType(llvm::ELF::R_ARM_GLOB_DAT);
+      rel_entry.setSymInfo(rsym);
+    }
+    rel_entry.targetRef().assign(*got_entry);
+  }
+  return *got_entry;
+}
+
+static
+ARMRelocator::Address helper_GOT_ORG(ARMRelocator& pParent)
+{
+  return pParent.getTarget().getGOT().addr();
+}
+
+static
+ARMRelocator::Address helper_get_PLT_address(ResolveInfo& pSym,
+                                             ARMRelocator& pParent)
+{
+  ARMPLT1* plt_entry = pParent.getSymPLTMap().lookUp(pSym);
+  assert(NULL != plt_entry);
+  return pParent.getTarget().getPLT().addr() + plt_entry->getOffset();
+}
+
+static
+ARMPLT1& helper_PLT_init(Relocation& pReloc, ARMRelocator& pParent)
+{
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.symInfo();
+  ARMGNULDBackend& ld_backend = pParent.getTarget();
+  assert(NULL == pParent.getSymPLTMap().lookUp(*rsym));
+
+  // initialize the plt and the corresponding gotplt and dyn relocation
+  ARMPLT1* plt_entry = ld_backend.getPLT().create();
+  pParent.getSymPLTMap().record(*rsym, *plt_entry);
+
+  assert(NULL == pParent.getSymGOTPLTMap().lookUp(*rsym) &&
+         "PLT entry not exist, but DynRel entry exist!");
+  ARMGOTEntry* gotplt_entry = ld_backend.getGOT().createGOTPLT();
+  pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
+
+  Relocation& rel_entry = *ld_backend.getRelPLT().create();
+  rel_entry.setType(llvm::ELF::R_ARM_JUMP_SLOT);
+  rel_entry.targetRef().assign(*gotplt_entry);
+  rel_entry.setSymInfo(rsym);
+
+  return *plt_entry;
+}
+
+// Get an relocation entry in .rel.dyn and set its type to pType,
+// its FragmentRef to pReloc->targetFrag() and its ResolveInfo to
+// pReloc->symInfo()
+static
+void helper_DynRel_init(Relocation& pReloc,
+                        ARMRelocator::Type pType,
+                        ARMRelocator& pParent)
+{
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.symInfo();
+  ARMGNULDBackend& ld_backend = pParent.getTarget();
+
+  Relocation& rel_entry = *ld_backend.getRelDyn().create();
+  rel_entry.setType(pType);
+  rel_entry.targetRef() = pReloc.targetRef();
+
+  if (pType == llvm::ELF::R_ARM_RELATIVE)
+    rel_entry.setSymInfo(NULL);
+  else
+    rel_entry.setSymInfo(rsym);
+}
+
+static ARMRelocator::DWord
+helper_extract_movw_movt_addend(ARMRelocator::DWord pTarget)
+{
+  // imm16: [19-16][11-0]
+  return helper_sign_extend((((pTarget >> 4)) & 0xf000U) | (pTarget & 0xfffU),
+                            16);
+}
+
+static ARMRelocator::DWord
+helper_insert_val_movw_movt_inst(ARMRelocator::DWord pTarget,
+                                 ARMRelocator::DWord pImm)
+{
+  // imm16: [19-16][11-0]
+  pTarget &= 0xfff0f000U;
+  pTarget |= pImm & 0x0fffU;
+  pTarget |= (pImm & 0xf000U) << 4;
+  return pTarget;
+}
+
+static ARMRelocator::DWord
+helper_extract_thumb_movw_movt_addend(ARMRelocator::DWord pValue)
+{
+  // imm16: [19-16][26][14-12][7-0]
+  return helper_sign_extend((((pValue >> 4) & 0xf000U) |
+                             ((pValue >> 15) & 0x0800U) |
+                             ((pValue >> 4) & 0x0700U) |
+                             (pValue& 0x00ffU)),
+                            16);
+}
+
+static ARMRelocator::DWord
+helper_insert_val_thumb_movw_movt_inst(ARMRelocator::DWord pValue,
+                                       ARMRelocator::DWord pImm)
+{
+  // imm16: [19-16][26][14-12][7-0]
+  pValue &= 0xfbf08f00U;
+  pValue |= (pImm & 0xf000U) << 4;
+  pValue |= (pImm & 0x0800U) << 15;
+  pValue |= (pImm & 0x0700U) << 4;
+  pValue |= (pImm & 0x00ffU);
+  return pValue;
+}
+
+static ARMRelocator::DWord
+helper_thumb32_branch_offset(ARMRelocator::DWord pUpper16,
+                             ARMRelocator::DWord pLower16)
+{
+  ARMRelocator::DWord s = (pUpper16 & (1U << 10)) >> 10,        // 26 bit
+                           u  = pUpper16 & 0x3ffU,              // 25-16
+                           l  = pLower16 & 0x7ffU,              // 10-0
+                           j1 = (pLower16 & (1U << 13)) >> 13,  // 13
+                           j2 = (pLower16 & (1U << 11)) >> 11;  // 11
+  ARMRelocator::DWord i1 = j1 ^ s? 0: 1,
+                              i2 = j2 ^ s? 0: 1;
+
+  // [31-25][24][23][22][21-12][11-1][0]
+  //      0   s  i1  i2      u     l  0
+  return helper_sign_extend((s << 24) | (i1 << 23) | (i2 << 22) |
+                            (u << 12) | (l << 1),
+                            25);
+}
+
+static ARMRelocator::DWord
+helper_thumb32_branch_upper(ARMRelocator::DWord pUpper16,
+                            ARMRelocator::DWord pOffset)
+{
+  uint32_t sign = ((pOffset & 0x80000000U) >> 31);
+  return (pUpper16 & ~0x7ffU) | ((pOffset >> 12) & 0x3ffU) | (sign << 10);
+}
+
+static ARMRelocator::DWord
+helper_thumb32_branch_lower(ARMRelocator::DWord pLower16,
+                            ARMRelocator::DWord pOffset)
+{
+  uint32_t sign = ((pOffset & 0x80000000U) >> 31);
+  return ((pLower16 & ~0x2fffU) |
+          ((((pOffset >> 23) & 1) ^ !sign) << 13) |
+          ((((pOffset >> 22) & 1) ^ !sign) << 11) |
+          ((pOffset >> 1) & 0x7ffU));
+}
+
+static ARMRelocator::DWord
+helper_thumb32_cond_branch_offset(ARMRelocator::DWord pUpper16,
+                                  ARMRelocator::DWord pLower16)
+{
+  uint32_t s = (pUpper16 & 0x0400U) >> 10;
+  uint32_t j1 = (pLower16 & 0x2000U) >> 13;
+  uint32_t j2 = (pLower16 & 0x0800U) >> 11;
+  uint32_t lower = (pLower16 & 0x07ffU);
+  uint32_t upper = (s << 8) | (j2 << 7) | (j1 << 6) | (pUpper16 & 0x003fU);
+  return helper_sign_extend((upper << 12) | (lower << 1), 21);
+}
+
+static ARMRelocator::DWord
+helper_thumb32_cond_branch_upper(ARMRelocator::DWord pUpper16,
+                                 ARMRelocator::DWord pOffset)
+{
+  uint32_t sign = ((pOffset & 0x80000000U) >> 31);
+  return (pUpper16 & 0xfbc0U) | (sign << 10) | ((pOffset & 0x0003f000U) >> 12);
+}
+
+static ARMRelocator::DWord
+helper_thumb32_cond_branch_lower(ARMRelocator::DWord pLower16,
+                                 ARMRelocator::DWord pOffset)
+{
+  uint32_t j2 = (pOffset & 0x00080000U) >> 19;
+  uint32_t j1 = (pOffset & 0x00040000U) >> 18;
+  uint32_t lo = (pOffset & 0x00000ffeU) >> 1;
+  return (pLower16 & 0xd000U) | (j1 << 13) | (j2 << 11) | lo;
+}
+
+// Return true if overflow
+static bool
+helper_check_signed_overflow(ARMRelocator::DWord pValue,
+                             unsigned bits)
+{
+  int32_t signed_val = static_cast<int32_t>(pValue);
+  int32_t max = (1 << (bits - 1)) - 1;
+  int32_t min = -(1 << (bits - 1));
+  if (signed_val > max || signed_val < min) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+
 //===--------------------------------------------------------------------===//
 // Relocation Functions and Tables
 //===--------------------------------------------------------------------===//
@@ -79,7 +371,7 @@
 
 void ARMRelocator::addCopyReloc(ResolveInfo& pSym)
 {
-  Relocation& rel_entry = *getTarget().getRelDyn().consumeEntry();
+  Relocation& rel_entry = *getTarget().getRelDyn().create();
   rel_entry.setType(llvm::ELF::R_ARM_COPY);
   assert(pSym.outSymbol()->hasFragRef());
   rel_entry.targetRef().assign(*pSym.outSymbol()->fragRef());
@@ -188,7 +480,7 @@
       // a dynamic relocations with RELATIVE type to this location is needed.
       // Reserve an entry in .rel.dyn
       if (config().isCodeIndep()) {
-        getTarget().getRelDyn().reserveEntry();
+        helper_DynRel_init(pReloc, llvm::ELF::R_ARM_RELATIVE, *this);
         // set Rel bit
         rsym->setReserved(rsym->reserved() | ReserveRel);
         getTarget().checkAndSetHasTextRel(*pSection.getLink());
@@ -227,21 +519,17 @@
     case llvm::ELF::R_ARM_GOT_PREL: {
       // A GOT entry is needed for these relocation type.
       // return if we already create GOT for this symbol
-      if (rsym->reserved() & (ReserveGOT | GOTRel))
+      if (rsym->reserved() & ReserveGOT)
         return;
-      getTarget().getGOT().reserveGOT();
+
       // If building PIC object, a dynamic relocation with
       // type RELATIVE is needed to relocate this GOT entry.
-      // Reserve an entry in .rel.dyn
-      if (config().isCodeIndep()) {
-        // create .rel.dyn section if not exist
-        getTarget().getRelDyn().reserveEntry();
-        // set GOTRel bit
-        rsym->setReserved(rsym->reserved() | 0x4u);
-        return;
-      }
+      if (config().isCodeIndep())
+         helper_GOT_init(pReloc, true, *this);
+      else
+         helper_GOT_init(pReloc, false, *this);
       // set GOT bit
-      rsym->setReserved(rsym->reserved() | 0x2u);
+      rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
     }
 
@@ -301,18 +589,15 @@
         if (!(rsym->reserved() & ReservePLT)){
           // Symbol needs PLT entry, we need to reserve a PLT entry
           // and the corresponding GOT and dynamic relocation entry
-          // in .got and .rel.plt. (GOT entry will be reserved simultaneously
-          // when calling ARMPLT->reserveEntry())
-          getTarget().getPLT().reserveEntry();
-          getTarget().getRelPLT().reserveEntry();
+          // in .got and .rel.plt.
+          helper_PLT_init(pReloc, *this);
           // set PLT bit
           rsym->setReserved(rsym->reserved() | ReservePLT);
         }
       }
 
-      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT), true)) {
-        // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
-        getTarget().getRelDyn().reserveEntry();
+      if (getTarget().symbolNeedsDynRel(*rsym,
+                                       (rsym->reserved() & ReservePLT), true)) {
         if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
           LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym);
           addCopyReloc(*cpy_sym.resolveInfo());
@@ -320,6 +605,10 @@
         else {
           checkValidReloc(pReloc);
           // set Rel bit
+          if (helper_use_relative_reloc(*rsym, *this))
+            helper_DynRel_init(pReloc, llvm::ELF::R_ARM_RELATIVE, *this);
+          else
+            helper_DynRel_init(pReloc, pReloc.type(), *this);
           rsym->setReserved(rsym->reserved() | ReserveRel);
           getTarget().checkAndSetHasTextRel(*pSection.getLink());
         }
@@ -385,9 +674,9 @@
     case llvm::ELF::R_ARM_MOVT_BREL:
     case llvm::ELF::R_ARM_MOVW_BREL: {
       // Relative addressing relocation, may needs dynamic relocation
-      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT), false)) {
+      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT),
+                                                                       false)) {
         // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
-        getTarget().getRelDyn().reserveEntry();
         if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
           LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym);
           addCopyReloc(*cpy_sym.resolveInfo());
@@ -395,6 +684,7 @@
         else {
           checkValidReloc(pReloc);
           // set Rel bit
+          //helper_DynRel_init(pReloc, pReloc.type(), *this);
           rsym->setReserved(rsym->reserved() | ReserveRel);
           getTarget().checkAndSetHasTextRel(*pSection.getLink());
         }
@@ -434,10 +724,8 @@
 
       // Symbol needs PLT entry, we need to reserve a PLT entry
       // and the corresponding GOT and dynamic relocation entry
-      // in .got and .rel.plt. (GOT entry will be reserved simultaneously
-      // when calling ARMPLT->reserveEntry())
-      getTarget().getPLT().reserveEntry();
-      getTarget().getRelPLT().reserveEntry();
+      // in .got and .rel.plt.
+      helper_PLT_init(pReloc, *this);
       // set PLT bit
       rsym->setReserved(rsym->reserved() | ReservePLT);
       return;
@@ -453,17 +741,14 @@
     case llvm::ELF::R_ARM_GOT_PREL: {
       // Symbol needs GOT entry, reserve entry in .got
       // return if we already create GOT for this symbol
-      if (rsym->reserved() & (ReserveGOT | GOTRel))
+      if (rsym->reserved() & ReserveGOT)
         return;
-      getTarget().getGOT().reserveGOT();
       // if the symbol cannot be fully resolved at link time, then we need a
       // dynamic relocation
-      if (!getTarget().symbolFinalValueIsKnown(*rsym)) {
-        getTarget().getRelDyn().reserveEntry();
-        // set GOTRel bit
-        rsym->setReserved(rsym->reserved() | GOTRel);
-        return;
-      }
+      if (!getTarget().symbolFinalValueIsKnown(*rsym))
+        helper_GOT_init(pReloc, true, *this);
+      else
+        helper_GOT_init(pReloc, false, *this);
       // set GOT bit
       rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
@@ -487,14 +772,14 @@
 void ARMRelocator::scanRelocation(Relocation& pReloc,
                                   IRBuilder& pBuilder,
                                   Module& pModule,
-                                  LDSection& pSection)
+                                  LDSection& pSection,
+                                  Input& pInput)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
   assert(NULL != rsym &&
          "ResolveInfo of relocation not set while scanRelocation");
 
-  pReloc.updateAddend();
   assert(NULL != pSection.getLink());
   if (0 == (pSection.getLink()->flag() & llvm::ELF::SHF_ALLOC))
     return;
@@ -514,293 +799,9 @@
   // check if we shoule issue undefined reference for the relocation target
   // symbol
   if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
-    fatal(diag::undefined_reference) << rsym->name();
+    issueUndefRef(pReloc, pSection, pInput);
 }
 
-//===--------------------------------------------------------------------===//
-// non-member functions
-//===--------------------------------------------------------------------===//
-static Relocator::DWord getThumbBit(const Relocation& pReloc)
-{
-  // Set thumb bit if
-  // - symbol has type of STT_FUNC, is defined and with bit 0 of its value set
-  Relocator::DWord thumbBit =
-       ((!pReloc.symInfo()->isUndef() || pReloc.symInfo()->isDyn()) &&
-        (pReloc.symInfo()->type() == ResolveInfo::Function) &&
-        ((pReloc.symValue() & 0x1) != 0))?
-        1:0;
-  return thumbBit;
-}
-
-//=========================================//
-// Relocation helper function              //
-//=========================================//
-
-// Using uint64_t to make sure those complicate operations won't cause
-// undefined behavior.
-static
-uint64_t helper_sign_extend(uint64_t pVal, uint64_t pOri_width)
-{
-  assert(pOri_width <= 64);
-  if (pOri_width == 64)
-    return pVal;
-  uint64_t mask = (~((uint64_t)0)) >> (64 - pOri_width);
-  pVal &= mask;
-  // Reverse sign bit, then subtract sign bit.
-  uint64_t sign_bit = 1 << (pOri_width - 1);
-  return (pVal ^ sign_bit) - sign_bit;
-}
-
-static
-uint64_t helper_bit_select(uint64_t pA, uint64_t pB, uint64_t pMask)
-{
-  return (pA & ~pMask) | (pB & pMask) ;
-}
-
-// Check if symbol can use relocation R_ARM_RELATIVE
-static bool
-helper_use_relative_reloc(const ResolveInfo& pSym,
-                          const ARMRelocator& pFactory)
-{
-  // if symbol is dynamic or undefine or preemptible
-  if (pSym.isDyn() ||
-      pSym.isUndef() ||
-      pFactory.getTarget().isSymbolPreemptible(pSym))
-    return false;
-  return true;
-}
-
-// Strip LSB (THUMB bit) if "S" is a THUMB target.
-static inline void helper_clear_thumb_bit(ARMRelocator::DWord& pValue)
-{
-  pValue &= (~0x1);
-}
-
-static
-ARMGOTEntry& helper_get_GOT_and_init(Relocation& pReloc,
-                                     ARMRelocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  ARMGNULDBackend& ld_backend = pParent.getTarget();
-
-  ARMGOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
-  if (NULL == got_entry) {
-    got_entry = ld_backend.getGOT().consumeGOT();
-    pParent.getSymGOTMap().record(*rsym, *got_entry);
-    // If we first get this GOT entry, we should initialize it.
-    if (rsym->reserved() & ARMRelocator::ReserveGOT) {
-      // No corresponding dynamic relocation, initialize to the symbol value.
-      got_entry->setValue(pReloc.symValue());
-    }
-    else if (rsym->reserved() & ARMRelocator::GOTRel) {
-
-      // Initialize corresponding dynamic relocation.
-      Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
-      if ( rsym->isLocal() ||
-          helper_use_relative_reloc(*rsym, pParent)) {
-        // Initialize got entry to target symbol address
-        got_entry->setValue(pReloc.symValue());
-        rel_entry.setType(llvm::ELF::R_ARM_RELATIVE);
-        rel_entry.setSymInfo(0);
-      }
-      else {
-        // Initialize got entry to 0 for corresponding dynamic relocation.
-        got_entry->setValue(0);
-        rel_entry.setType(llvm::ELF::R_ARM_GLOB_DAT);
-        rel_entry.setSymInfo(rsym);
-      }
-      rel_entry.targetRef().assign(*got_entry);
-    }
-    else {
-      fatal(diag::reserve_entry_number_mismatch_got);
-    }
-  }
-  return *got_entry;
-}
-
-static
-ARMRelocator::Address helper_GOT_ORG(ARMRelocator& pParent)
-{
-  return pParent.getTarget().getGOT().addr();
-}
-
-
-static
-ARMRelocator::Address helper_GOT(Relocation& pReloc, ARMRelocator& pParent)
-{
-  ARMGOTEntry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
-  return helper_GOT_ORG(pParent) + got_entry.getOffset();
-}
-
-
-static
-ARMPLT1& helper_get_PLT_and_init(Relocation& pReloc, ARMRelocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  ARMGNULDBackend& ld_backend = pParent.getTarget();
-
-  ARMPLT1* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
-  if (NULL != plt_entry)
-    return *plt_entry;
-
-  plt_entry = ld_backend.getPLT().consume();
-  pParent.getSymPLTMap().record(*rsym, *plt_entry);
-
-  // If we first get this PLT entry, we should initialize it.
-  if (rsym->reserved() & ARMRelocator::ReservePLT) {
-    ARMGOTEntry* gotplt_entry = pParent.getSymGOTPLTMap().lookUp(*rsym);
-    assert(NULL == gotplt_entry && "PLT entry not exist, but DynRel entry exist!");
-    gotplt_entry = ld_backend.getGOT().consumeGOTPLT();
-    pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
-
-    // Initialize corresponding dynamic relocation.
-    Relocation& rel_entry = *ld_backend.getRelPLT().consumeEntry();
-    rel_entry.setType(llvm::ELF::R_ARM_JUMP_SLOT);
-    rel_entry.targetRef().assign(*gotplt_entry);
-    rel_entry.setSymInfo(rsym);
-  }
-  else {
-    fatal(diag::reserve_entry_number_mismatch_plt);
-  }
-
-  return *plt_entry;
-}
-
-static
-ARMRelocator::Address helper_PLT_ORG(ARMRelocator& pParent)
-{
-  return pParent.getTarget().getPLT().addr();
-}
-
-
-static
-ARMRelocator::Address helper_PLT(Relocation& pReloc, ARMRelocator& pParent)
-{
-  ARMPLT1& plt_entry = helper_get_PLT_and_init(pReloc, pParent);
-  return helper_PLT_ORG(pParent) + plt_entry.getOffset();
-}
-
-// Get an relocation entry in .rel.dyn and set its type to pType,
-// its FragmentRef to pReloc->targetFrag() and its ResolveInfo to
-// pReloc->symInfo()
-static
-void helper_DynRel(Relocation& pReloc,
-                   ARMRelocator::Type pType,
-                   ARMRelocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  ARMGNULDBackend& ld_backend = pParent.getTarget();
-
-  Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
-  rel_entry.setType(pType);
-  rel_entry.targetRef() = pReloc.targetRef();
-
-  if (pType == llvm::ELF::R_ARM_RELATIVE)
-    rel_entry.setSymInfo(0);
-  else
-    rel_entry.setSymInfo(rsym);
-}
-
-static ARMRelocator::DWord
-helper_extract_movw_movt_addend(ARMRelocator::DWord pTarget)
-{
-  // imm16: [19-16][11-0]
-  return helper_sign_extend((((pTarget >> 4)) & 0xf000U) | (pTarget & 0xfffU),
-                            16);
-}
-
-static ARMRelocator::DWord
-helper_insert_val_movw_movt_inst(ARMRelocator::DWord pTarget,
-                                 ARMRelocator::DWord pImm)
-{
-  // imm16: [19-16][11-0]
-  pTarget &= 0xfff0f000U;
-  pTarget |= pImm & 0x0fffU;
-  pTarget |= (pImm & 0xf000U) << 4;
-  return pTarget;
-}
-
-static ARMRelocator::DWord
-helper_extract_thumb_movw_movt_addend(ARMRelocator::DWord pValue)
-{
-  // imm16: [19-16][26][14-12][7-0]
-  return helper_sign_extend((((pValue >> 4) & 0xf000U) |
-                             ((pValue >> 15) & 0x0800U) |
-                             ((pValue >> 4) & 0x0700U) |
-                             (pValue& 0x00ffU)),
-                            16);
-}
-
-static ARMRelocator::DWord
-helper_insert_val_thumb_movw_movt_inst(ARMRelocator::DWord pValue,
-                                       ARMRelocator::DWord pImm)
-{
-  // imm16: [19-16][26][14-12][7-0]
-  pValue &= 0xfbf08f00U;
-  pValue |= (pImm & 0xf000U) << 4;
-  pValue |= (pImm & 0x0800U) << 15;
-  pValue |= (pImm & 0x0700U) << 4;
-  pValue |= (pImm & 0x00ffU);
-  return pValue;
-}
-
-static ARMRelocator::DWord
-helper_thumb32_branch_offset(ARMRelocator::DWord pUpper16,
-                             ARMRelocator::DWord pLower16)
-{
-  ARMRelocator::DWord s = (pUpper16 & (1U << 10)) >> 10,        // 26 bit
-                           u  = pUpper16 & 0x3ffU,              // 25-16
-                           l  = pLower16 & 0x7ffU,              // 10-0
-                           j1 = (pLower16 & (1U << 13)) >> 13,  // 13
-                           j2 = (pLower16 & (1U << 11)) >> 11;  // 11
-  ARMRelocator::DWord i1 = j1 ^ s? 0: 1,
-                              i2 = j2 ^ s? 0: 1;
-
-  // [31-25][24][23][22][21-12][11-1][0]
-  //      0   s  i1  i2      u     l  0
-  return helper_sign_extend((s << 24) | (i1 << 23) | (i2 << 22) |
-                            (u << 12) | (l << 1),
-                            25);
-}
-
-static ARMRelocator::DWord
-helper_thumb32_branch_upper(ARMRelocator::DWord pUpper16,
-                            ARMRelocator::DWord pOffset)
-{
-  uint32_t sign = ((pOffset & 0x80000000U) >> 31);
-  return (pUpper16 & ~0x7ffU) | ((pOffset >> 12) & 0x3ffU) | (sign << 10);
-}
-
-static ARMRelocator::DWord
-helper_thumb32_branch_lower(ARMRelocator::DWord pLower16,
-                            ARMRelocator::DWord pOffset)
-{
-  uint32_t sign = ((pOffset & 0x80000000U) >> 31);
-  return ((pLower16 & ~0x2fffU) |
-          ((((pOffset >> 23) & 1) ^ !sign) << 13) |
-          ((((pOffset >> 22) & 1) ^ !sign) << 11) |
-          ((pOffset >> 1) & 0x7ffU));
-}
-
-// Return true if overflow
-static bool
-helper_check_signed_overflow(ARMRelocator::DWord pValue,
-                             unsigned bits)
-{
-  int32_t signed_val = static_cast<int32_t>(pValue);
-  int32_t max = (1 << (bits - 1)) - 1;
-  int32_t min = -(1 << (bits - 1));
-  if (signed_val > max || signed_val < min) {
-    return true;
-  } else {
-    return false;
-  }
-}
-
-
 //=========================================//
 // Each relocation function implementation //
 //=========================================//
@@ -821,43 +822,28 @@
   if (T != 0x0)
     helper_clear_thumb_bit(S);
 
-  LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
-
   // If the flag of target section is not ALLOC, we will not scan this relocation
   // but perform static relocation. (e.g., applying .debug section)
-  if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
+  if (0x0 == (llvm::ELF::SHF_ALLOC &
+      pReloc.targetRef().frag()->getParent()->getSection().flag())) {
     pReloc.target() = (S + A) | T;
     return ARMRelocator::OK;
   }
 
-  // A local symbol may need REL Type dynamic relocation
-  if (rsym->isLocal() && (rsym->reserved() & ARMRelocator::ReserveRel)) {
-    helper_DynRel(pReloc, llvm::ELF::R_ARM_RELATIVE, pParent);
-    pReloc.target() = (S + A) | T ;
-    return ARMRelocator::OK;
-  }
-
   // An external symbol may need PLT and dynamic relocation
   if (!rsym->isLocal()) {
     if (rsym->reserved() & ARMRelocator::ReservePLT) {
-      S = helper_PLT(pReloc, pParent);
+      S = helper_get_PLT_address(*rsym, pParent);
       T = 0 ; // PLT is not thumb
     }
     // If we generate a dynamic relocation (except R_ARM_RELATIVE)
     // for a place, we should not perform static relocation on it
     // in order to keep the addend store in the place correct.
-    if (rsym->reserved() & ARMRelocator::ReserveRel) {
-      if (helper_use_relative_reloc(*rsym, pParent)) {
-        helper_DynRel(pReloc, llvm::ELF::R_ARM_RELATIVE, pParent);
-      }
-      else {
-        helper_DynRel(pReloc, pReloc.type(), pParent);
-        return ARMRelocator::OK;
-      }
-    }
+    if ((rsym->reserved() & ARMRelocator::ReserveRel) &&
+        (!helper_use_relative_reloc(*rsym, pParent)))
+      return ARMRelocator::OK;
   }
 
-
   // perform static relocation
   pReloc.target() = (S + A) | T;
   return ARMRelocator::OK;
@@ -870,17 +856,18 @@
   ARMRelocator::Address S = pReloc.symValue();
   ARMRelocator::DWord   T = getThumbBit(pReloc);
   ARMRelocator::DWord   A = pReloc.target() + pReloc.addend();
-  if (T != 0x0)
-    helper_clear_thumb_bit(S);
 
-  // An external symbol may need PLT (this reloc is from stub)
+  // An external symbol may need PLT (this reloc is from a stub/veneer)
   if (!pReloc.symInfo()->isLocal()) {
     if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
-      S = helper_PLT(pReloc, pParent);
+      S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
       T = 0;  // PLT is not thumb.
     }
   }
 
+  if (T != 0x0)
+    helper_clear_thumb_bit(S);
+
   // perform relocation
   pReloc.target() = ((S + A) | T) - pReloc.place();
 
@@ -913,31 +900,41 @@
 // R_ARM_GOT_BREL: GOT(S) + A - GOT_ORG
 ARMRelocator::Result got_brel(Relocation& pReloc, ARMRelocator& pParent)
 {
-  if (!(pReloc.symInfo()->reserved() &
-      (ARMRelocator::ReserveGOT | ARMRelocator::GOTRel))) {
+  if (!(pReloc.symInfo()->reserved() & ARMRelocator::ReserveGOT))
     return ARMRelocator::BadReloc;
-  }
-  ARMRelocator::Address GOT_S   = helper_GOT(pReloc, pParent);
+
+  ARMRelocator::Address GOT_S   = helper_get_GOT_address(*pReloc.symInfo(),
+                                                                       pParent);
   ARMRelocator::DWord   A       = pReloc.target() + pReloc.addend();
   ARMRelocator::Address GOT_ORG = helper_GOT_ORG(pParent);
   // Apply relocation.
   pReloc.target() = GOT_S + A - GOT_ORG;
+
+  // setup got entry value if needed
+  ARMGOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
+  if (NULL != got_entry && ARMRelocator::SymVal == got_entry->getValue())
+    got_entry->setValue(pReloc.symValue());
   return ARMRelocator::OK;
 }
 
 // R_ARM_GOT_PREL: GOT(S) + A - P
 ARMRelocator::Result got_prel(Relocation& pReloc, ARMRelocator& pParent)
 {
-  if (!(pReloc.symInfo()->reserved() &
-      (ARMRelocator::ReserveGOT | ARMRelocator::GOTRel))) {
+  if (!(pReloc.symInfo()->reserved() & ARMRelocator::ReserveGOT)) {
     return ARMRelocator::BadReloc;
   }
-  ARMRelocator::Address GOT_S   = helper_GOT(pReloc, pParent);
+  ARMRelocator::Address GOT_S   = helper_get_GOT_address(*pReloc.symInfo(),
+                                                                       pParent);
   ARMRelocator::DWord   A       = pReloc.target() + pReloc.addend();
   ARMRelocator::Address P = pReloc.place();
 
   // Apply relocation.
   pReloc.target() = GOT_S + A - P;
+
+  // setup got entry value if needed
+  ARMGOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
+  if (NULL != got_entry && ARMRelocator::SymVal == got_entry->getValue())
+    got_entry->setValue(pReloc.symValue());
   return ARMRelocator::OK;
 }
 
@@ -951,7 +948,7 @@
   // S depends on PLT exists or not
   ARMRelocator::Address S = pReloc.symValue();
   if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT)
-    S = helper_PLT(pReloc, pParent);
+    S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
 
   ARMRelocator::DWord X = S + A - P;
   if (helper_check_signed_overflow(X, 11))
@@ -961,6 +958,48 @@
   return ARMRelocator::OK;
 }
 
+// R_ARM_THM_JUMP19: ((S + A) | T) - P
+ARMRelocator::Result thm_jump19(Relocation& pReloc, ARMRelocator& pParent)
+{
+  // get lower and upper 16 bit instructions from relocation targetData
+  uint16_t upper_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()));
+  uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
+
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord A = helper_thumb32_cond_branch_offset(upper_inst,
+                                                                    lower_inst);
+  ARMRelocator::Address P = pReloc.place();
+  ARMRelocator::Address S;
+  // if symbol has plt
+  if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
+    S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
+    T = 0;  // PLT is not thumb.
+  }
+  else {
+    S = pReloc.symValue();
+    if (T != 0x0)
+      helper_clear_thumb_bit(S);
+  }
+
+  if (0x0 == T) {
+    // FIXME: conditional branch to PLT in THUMB-2 not supported yet
+    error(diag::unsupport_cond_branch_reloc) << (int)pReloc.type();
+    return ARMRelocator::BadReloc;
+  }
+
+  ARMRelocator::DWord X = ((S + A) | T) - P;
+  if (helper_check_signed_overflow(X, 21))
+    return ARMRelocator::Overflow;
+
+  upper_inst = helper_thumb32_cond_branch_upper(upper_inst, X);
+  lower_inst = helper_thumb32_cond_branch_lower(lower_inst, X);
+
+  *(reinterpret_cast<uint16_t*>(&pReloc.target())) = upper_inst;
+  *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = lower_inst;
+
+  return ARMRelocator::OK;
+}
+
 // R_ARM_PC24: ((S + A) | T) - P
 // R_ARM_PLT32: ((S + A) | T) - P
 // R_ARM_JUMP24: ((S + A) | T) - P
@@ -990,7 +1029,7 @@
 
   // S depends on PLT exists or not
   if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
-    S = helper_PLT(pReloc, pParent);
+    S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
     T = 0;  // PLT is not thumb.
   }
 
@@ -1039,14 +1078,13 @@
   uint16_t lower_inst = *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1);
 
   ARMRelocator::DWord T = getThumbBit(pReloc);
-  ARMRelocator::DWord A = helper_thumb32_branch_offset(upper_inst,
-                                                               lower_inst);
+  ARMRelocator::DWord A = helper_thumb32_branch_offset(upper_inst, lower_inst);
   ARMRelocator::Address P = pReloc.place();
   ARMRelocator::Address S;
 
   // if symbol has plt
   if (pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
-    S = helper_PLT(pReloc, pParent);
+    S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
     T = 0;  // PLT is not thumb.
   }
   else {
@@ -1111,7 +1149,7 @@
   if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
     // use plt
     if (rsym->reserved() & ARMRelocator::ReservePLT) {
-      S = helper_PLT(pReloc, pParent);
+      S = helper_get_PLT_address(*rsym, pParent);
       T = 0 ; // PLT is not thumb
     }
   }
@@ -1158,7 +1196,7 @@
   if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
     // use plt
     if (rsym->reserved() & ARMRelocator::ReservePLT) {
-      S = helper_PLT(pReloc, pParent);
+      S = helper_get_PLT_address(*rsym, pParent);
     }
   }
 
@@ -1205,7 +1243,7 @@
   if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
     // use plt
     if (rsym->reserved() & ARMRelocator::ReservePLT) {
-      S = helper_PLT(pReloc, pParent);
+      S = helper_get_PLT_address(*rsym, pParent);
       T = 0; // PLT is not thumb
     }
   }
@@ -1287,7 +1325,7 @@
   if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
     // use plt
     if (rsym->reserved() & ARMRelocator::ReservePLT) {
-      S = helper_PLT(pReloc, pParent);
+      S = helper_get_PLT_address(*rsym, pParent);
     }
   }
 
@@ -1340,7 +1378,7 @@
 
   // if symbol has plt
   if ( pReloc.symInfo()->reserved() & ARMRelocator::ReservePLT) {
-    S = helper_PLT(pReloc, pParent);
+    S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
     T = 0;  // PLT is not thumb.
   }
 
diff --git a/lib/Target/ARM/ARMRelocator.h b/lib/Target/ARM/ARMRelocator.h
index bf93380..f1c4643 100644
--- a/lib/Target/ARM/ARMRelocator.h
+++ b/lib/Target/ARM/ARMRelocator.h
@@ -14,7 +14,7 @@
 
 #include <mcld/LD/Relocator.h>
 #include <mcld/Target/GOT.h>
-#include <mcld/Target/SymbolEntryMap.h>
+#include <mcld/Target/KeyEntryMap.h>
 #include "ARMLDBackend.h"
 
 namespace mcld {
@@ -26,50 +26,42 @@
 class ARMRelocator : public Relocator
 {
 public:
-  typedef SymbolEntryMap<ARMGOTEntry> SymGOTMap;
-  typedef SymbolEntryMap<ARMPLT1> SymPLTMap;
+  typedef KeyEntryMap<ResolveInfo, ARMGOTEntry> SymGOTMap;
+  typedef KeyEntryMap<ResolveInfo, ARMPLT1> SymPLTMap;
 
   /** \enum ReservedEntryType
    *  \brief The reserved entry type of reserved space in ResolveInfo.
    *
    *  This is used for sacnRelocation to record what kinds of entries are
-   *  reserved for this resolved symbol
+   *  reserved for this resolved symbol In ARM, there are three kinds of
+   *  entries, GOT, PLT, and dynamic reloction.
    *
-   *  In ARM, there are three kinds of entries, GOT, PLT, and dynamic reloction.
-   *  GOT may needs a corresponding relocation to relocate itself, so we
-   *  separate GOT to two situations: GOT and GOTRel. Besides, for the same
-   *  symbol, there might be two kinds of entries reserved for different location.
-   *  For example, reference to the same symbol, one may use GOT and the other may
-   *  use dynamic relocation.
-   *
-   *  bit:  3       2      1     0
-   *   | PLT | GOTRel | GOT | Rel |
+   *  bit:  3     2     1     0
+   *   |    | PLT | GOT | Rel |
    *
    *  value    Name         - Description
    *
    *  0000     None         - no reserved entry
    *  0001     ReserveRel   - reserve an dynamic relocation entry
    *  0010     ReserveGOT   - reserve an GOT entry
-   *  0011     GOTandRel    - For different relocation, we've reserved GOT and
-   *                          Rel for different location.
-   *  0100     GOTRel       - reserve an GOT entry and the corresponding Dyncamic
-   *                          relocation entry which relocate this GOT entry
-   *  0101     GOTRelandRel - For different relocation, we've reserved GOTRel
-   *                          and relocation entry for different location.
-   *  1000     ReservePLT   - reserve an PLT entry and the corresponding GOT,
-   *                          Dynamic relocation entries
-   *  1001     PLTandRel    - For different relocation, we've reserved PLT and
-   *                          Rel for different location.
+   *  0100     ReservePLT   - reserve an PLT entry and the corresponding GOT,
+   *
    */
   enum ReservedEntryType {
     None         = 0,
     ReserveRel   = 1,
     ReserveGOT   = 2,
-    GOTandRel    = 3,
-    GOTRel       = 4,
-    GOTRelandRel = 5,
-    ReservePLT   = 8,
-    PLTandRel    = 9
+    ReservePLT   = 4,
+  };
+
+  /** \enum EntryValue
+   *  \brief The value of the entries. The symbol value will be decided at after
+   *  layout, so we mark the entry during scanRelocation and fill up the actual
+   *  value when applying relocations.
+   */
+  enum EntryValue {
+    Default = 0,
+    SymVal  = 1
   };
 
 public:
@@ -106,7 +98,8 @@
   void scanRelocation(Relocation& pReloc,
                       IRBuilder& pBuilder,
                       Module& pModule,
-                      LDSection& pSection);
+                      LDSection& pSection,
+                      Input& pInput);
 
 private:
   void scanLocalReloc(Relocation& pReloc, const LDSection& pSection);
diff --git a/lib/Target/ARM/ARMTargetMachine.cpp b/lib/Target/ARM/ARMTargetMachine.cpp
index 7062f31..25caa56 100644
--- a/lib/Target/ARM/ARMTargetMachine.cpp
+++ b/lib/Target/ARM/ARMTargetMachine.cpp
@@ -11,14 +11,13 @@
 
 #include <mcld/Support/TargetRegistry.h>
 
-mcld::ARMBaseTargetMachine::ARMBaseTargetMachine(llvm::TargetMachine& pPM,
-                                                 const mcld::Target &pTarget,
-                                                 const std::string& pTriple)
-  : mcld::MCLDTargetMachine(pPM, pTarget, pTriple) {
-}
+using namespace mcld;
 
-mcld::ARMBaseTargetMachine::~ARMBaseTargetMachine()
-{
+ARMBaseTargetMachine::ARMBaseTargetMachine(llvm::TargetMachine& pPM,
+                                           const llvm::Target &pLLVMTarget,
+                                           const mcld::Target &pMCLDTarget,
+                                           const std::string& pTriple)
+  : MCLDTargetMachine(pPM, pLLVMTarget, pMCLDTarget, pTriple) {
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/Target/ARM/ARMTargetMachine.h b/lib/Target/ARM/ARMTargetMachine.h
index 94a7866..375f7b2 100644
--- a/lib/Target/ARM/ARMTargetMachine.h
+++ b/lib/Target/ARM/ARMTargetMachine.h
@@ -10,18 +10,17 @@
 #define MCLD_ARM_TARGET_MACHINE_H
 
 #include "ARM.h"
-#include <mcld/Target/TargetMachine.h>
+#include <mcld/CodeGen/TargetMachine.h>
 
 namespace mcld {
 
 class ARMBaseTargetMachine : public MCLDTargetMachine
 {
 public:
-  ARMBaseTargetMachine(llvm::TargetMachine &pTM,
-                       const mcld::Target &pTarget,
-                       const std::string &pTriple);
-
-  virtual ~ARMBaseTargetMachine();
+  ARMBaseTargetMachine(llvm::TargetMachine& pTM,
+                       const llvm::Target& pLLVMTarget,
+                       const mcld::Target& pMCLDTarget,
+                       const std::string& pTriple);
 };
 
 } // namespace of mcld
diff --git a/lib/Target/ARM/TargetInfo/ARMTargetInfo.cpp b/lib/Target/ARM/TargetInfo/ARMTargetInfo.cpp
index fd00641..de43662 100644
--- a/lib/Target/ARM/TargetInfo/ARMTargetInfo.cpp
+++ b/lib/Target/ARM/TargetInfo/ARMTargetInfo.cpp
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "mcld/Target/TargetMachine.h"
-#include "mcld/Support/TargetRegistry.h"
+#include <mcld/Support/TargetRegistry.h>
+#include <mcld/Support/Target.h>
 
 namespace mcld {
 
@@ -16,8 +16,8 @@
 
 extern "C" void MCLDInitializeARMLDTargetInfo() {
   // register into mcld::TargetRegistry
-  mcld::RegisterTarget X(TheARMTarget, "arm" );
-  mcld::RegisterTarget Y(TheThumbTarget, "thumb" );
+  mcld::RegisterTarget<llvm::Triple::arm> X(TheARMTarget, "arm");
+  mcld::RegisterTarget<llvm::Triple::thumb> Y(TheThumbTarget, "thumb");
 }
 
 } // namespace of mcld
diff --git a/lib/Target/Android.mk b/lib/Target/Android.mk
index 77ab932..e46a09f 100644
--- a/lib/Target/Android.mk
+++ b/lib/Target/Android.mk
@@ -1,15 +1,17 @@
 LOCAL_PATH:= $(call my-dir)
 
 mcld_target_SRC_FILES := \
-  ELFDynamic.cpp  \
-  ELFEmulation.cpp  \
-  ELFMCLinker.cpp  \
+  ELFAttribute.cpp \
+  ELFAttributeData.cpp \
+  ELFAttributeValue.cpp \
+  ELFDynamic.cpp \
+  ELFEmulation.cpp \
+  ELFMCLinker.cpp \
   GNUInfo.cpp \
-  GNULDBackend.cpp  \
+  GNULDBackend.cpp \
   GOT.cpp \
-  OutputRelocSection.cpp  \
+  OutputRelocSection.cpp \
   PLT.cpp \
-  Target.cpp  \
   TargetLDBackend.cpp
 
 # For the host
diff --git a/lib/Target/ELFAttribute.cpp b/lib/Target/ELFAttribute.cpp
new file mode 100644
index 0000000..76882d3
--- /dev/null
+++ b/lib/Target/ELFAttribute.cpp
@@ -0,0 +1,364 @@
+//===- ELFAttribute.cpp ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Target/ELFAttribute.h>
+
+#include <mcld/ADT/SizeTraits.h>
+#include <mcld/Fragment/RegionFragment.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/LinkerConfig.h>
+#include <mcld/MC/Input.h>
+#include <mcld/Support/LEB128.h>
+#include <mcld/Support/MemoryArea.h>
+#include <mcld/Support/MsgHandling.h>
+#include <mcld/Target/ELFAttributeValue.h>
+#include <mcld/Target/GNULDBackend.h>
+
+#include <llvm/ADT/STLExtras.h>
+#include <llvm/Support/Host.h>
+
+#include <cstring>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// ELFAttribute
+//===----------------------------------------------------------------------===//
+ELFAttribute::~ELFAttribute()
+{
+  llvm::DeleteContainerPointers(m_Subsections);
+  return;
+}
+
+bool ELFAttribute::merge(const Input &pInput, LDSection &pInputAttrSectHdr)
+{
+  // Skip corrupt subsection
+  if (pInputAttrSectHdr.size() < MinimalELFAttributeSectionSize)
+    return true;
+
+  // Obtain the region containing the attribute data. Expect exactly one
+  // RegionFragment in the section data.
+  const SectionData* sect_data = pInputAttrSectHdr.getSectionData();
+
+  // FIXME: Why is 2?
+  if ((sect_data->size() != 2) ||
+      (!llvm::isa<RegionFragment>(sect_data->front()))) {
+    return true;
+  }
+
+  const RegionFragment& region_frag =
+      llvm::cast<RegionFragment>(sect_data->front());
+
+  llvm::StringRef region = region_frag.getRegion();
+
+  // Parse the ELF attribute section header. ARM [ABI-addenda], 2.2.3.
+  //
+  // <format-version: ‘A’>
+  // [ <uint32: subsection-length> NTBS: vendor-name
+  //   <bytes: vendor-data>
+  // ]*
+  const char *attribute_data = region.begin();
+
+  // format-version
+  if (attribute_data[0] != FormatVersion) {
+    warning(diag::warn_unsupported_attribute_section_format)
+        << pInput.name() << attribute_data[0];
+    return true;
+  }
+
+  size_t subsection_offset = FormatVersionFieldSize;
+
+  // Iterate all subsections containing in this attribute section.
+  do {
+    const char *subsection_data = region.begin() + subsection_offset;
+
+    // subsection-length
+    uint32_t subsection_length =
+        *reinterpret_cast<const uint32_t*>(subsection_data);
+
+    if(llvm::sys::IsLittleEndianHost != m_Config.targets().isLittleEndian())
+      bswap32(subsection_length);
+
+    // vendor-name
+    const char* vendor_name = subsection_data + SubsectionLengthFieldSize;
+    const size_t vendor_name_length = ::strlen(vendor_name) + 1 /* '\0' */;
+
+    // Check the length.
+    if ((vendor_name_length <= 1) ||
+        (subsection_length <= (SubsectionLengthFieldSize + vendor_name_length)))
+      return true;
+
+    // Select the attribute subsection.
+    Subsection *subsection = getSubsection(vendor_name);
+
+    // Only process the subsections whose vendor can be recognized.
+    if (subsection == NULL) {
+      warning(diag::warn_unrecognized_vendor_subsection)
+          << vendor_name << pInput.name();
+    } else {
+      // vendor-data
+      size_t vendor_data_offset = subsection_offset +
+                                  SubsectionLengthFieldSize +
+                                  vendor_name_length;
+      size_t vendor_data_size = subsection_length - SubsectionLengthFieldSize -
+                                vendor_name_length;
+
+      ConstAddress vendor_data =
+          reinterpret_cast<ConstAddress>(region.begin()) + vendor_data_offset;
+
+      // Merge the vendor data in the subsection.
+      if (!subsection->merge(pInput, vendor_data, vendor_data_size))
+        return false;
+    }
+
+    subsection_offset += subsection_length;
+  } while ((subsection_offset + SubsectionLengthFieldSize) < pInputAttrSectHdr.size());
+
+  return true;
+}
+
+size_t ELFAttribute::sizeOutput() const
+{
+  size_t total_size = FormatVersionFieldSize;
+
+  for (llvm::SmallVectorImpl<Subsection*>::const_iterator
+          subsec_it = m_Subsections.begin(), subsec_end = m_Subsections.end();
+       subsec_it != subsec_end; ++subsec_it) {
+    total_size += (*subsec_it)->sizeOutput();
+  }
+  return total_size;
+}
+
+size_t ELFAttribute::emit(MemoryRegion &pRegion) const
+{
+  // ARM [ABI-addenda], 2.2.3
+  uint64_t total_size = 0;
+
+  // Write format-version.
+  char* buffer = reinterpret_cast<char*>(pRegion.begin());
+  buffer[0] = FormatVersion;
+  total_size += FormatVersionFieldSize;
+
+  for (llvm::SmallVectorImpl<Subsection*>::const_iterator
+          subsec_it = m_Subsections.begin(), subsec_end = m_Subsections.end();
+       subsec_it != subsec_end; ++subsec_it) {
+    // Write out subsection.
+    total_size += (*subsec_it)->emit(buffer + total_size);
+  }
+
+  return total_size;
+}
+
+void ELFAttribute::registerAttributeData(ELFAttributeData& pAttrData)
+{
+  assert((getSubsection(pAttrData.getVendorName()) == NULL) &&
+         "Multiple attribute data for a vendor!");
+  m_Subsections.push_back(new Subsection(*this, pAttrData));
+  return;
+}
+
+ELFAttribute::Subsection *
+ELFAttribute::getSubsection(llvm::StringRef pVendorName) const
+{
+  // Search m_Subsections linearly.
+  for (llvm::SmallVectorImpl<Subsection*>::const_iterator
+          subsec_it = m_Subsections.begin(), subsec_end = m_Subsections.end();
+       subsec_it != subsec_end; ++subsec_it) {
+    Subsection* const subsection = *subsec_it;
+    if (subsection->isMyAttribute(pVendorName)) {
+      return subsection;
+    }
+  }
+
+  // Not found
+  return NULL;
+}
+
+//===----------------------------------------------------------------------===//
+// ELFAttribute::Subsection
+//===----------------------------------------------------------------------===//
+bool ELFAttribute::Subsection::merge(const Input &pInput,
+                                     ConstAddress pData,
+                                     size_t pSize)
+{
+  const bool need_swap = (llvm::sys::IsLittleEndianHost !=
+                              m_Parent.config().targets().isLittleEndian());
+  // Read attribute sub-subsection from vendor data.
+  //
+  // ARM [ABI-addenda], 2.2.4:
+  //
+  // [   Tag_File    (=1) <uint32: byte-size> <attribute>*
+  //   | Tag_Section (=2) <uint32: byte-size> <section number>* 0 <attribute>*
+  //   | Tag_symbol  (=3) <unit32: byte-size> <symbol number>* 0 <attribute>*
+  // ] +
+  const char *subsubsection_data = reinterpret_cast<const char*>(pData);
+  size_t remaining_size = pSize;
+
+  if (!m_AttrData.preMerge(pInput)) {
+    return false;
+  }
+
+  while (remaining_size > ELFAttribute::MinimalELFAttributeSubsectionSize) {
+    // The tag of sub-subsection is encoded in ULEB128.
+    size_t tag_size;
+    uint64_t tag = leb128::decode<uint64_t>(subsubsection_data, tag_size);
+
+    if ((tag_size + 4 /* byte-size */) >= remaining_size)
+      break;
+
+    size_t subsubsection_length =
+        *reinterpret_cast<const uint32_t*>(subsubsection_data + tag_size);
+
+    if (need_swap)
+      bswap32(subsubsection_length);
+
+    if (subsubsection_length > remaining_size) {
+      // The subsubsection is corrupted. Try our best to process it.
+      subsubsection_length = remaining_size;
+    }
+
+    switch (tag) {
+      case ELFAttributeData::Tag_File: {
+        ELFAttributeData::TagType tag;
+        ELFAttributeValue in_attr;
+        // The offset from the start of sub-subsection that <attribute> located
+        size_t attribute_offset = tag_size + 4 /* byte-size */;
+
+        const char* attr_buf = subsubsection_data + attribute_offset;
+        size_t attr_size = subsubsection_length - attribute_offset;
+
+        // Read attributes from the stream.
+        do {
+          if (!ELFAttributeData::ReadTag(tag, attr_buf, attr_size))
+            break;
+
+          ELFAttributeValue *out_attr;
+          bool is_newly_created;
+
+          llvm::tie(out_attr, is_newly_created) =
+              m_AttrData.getOrCreateAttributeValue(tag);
+
+          assert(out_attr != NULL);
+
+          if (is_newly_created) {
+            // Directly read the attribute value to the out_attr.
+            if (!ELFAttributeData::ReadValue(*out_attr, attr_buf, attr_size))
+              break;
+          } else {
+            // The attribute has been defined previously. Read the attribute
+            // to a temporary storage in_attr and perform the merge.
+            in_attr.reset();
+            in_attr.setType(out_attr->type());
+
+            // Read the attribute value.
+            if (!ELFAttributeData::ReadValue(in_attr, attr_buf, attr_size))
+              break;
+
+            // Merge if the read attribute value is different than current one
+            // in output.
+            if ((in_attr != *out_attr) &&
+                !m_AttrData.merge(m_Parent.config(), pInput, tag, in_attr)) {
+              // Fail to merge the attribute.
+              return false;
+            }
+          }
+        } while (attr_size > 0);
+
+        break;
+      }
+      // Skip sub-subsection tagged with Tag_Section and Tag_Symbol. They are
+      // deprecated since ARM [ABI-addenda] r2.09.
+      case ELFAttributeData::Tag_Section:
+      case ELFAttributeData::Tag_Symbol:
+      // Skip any unknown tags.
+      default: {
+        break;
+      }
+    }
+
+    // Update subsubsection_data and remaining_size for next.
+    subsubsection_data += subsubsection_length;
+    remaining_size -= subsubsection_length;
+  } // while (remaining_size > ELFAttribute::MinimalELFAttributeSubsectionSize)
+
+  return m_AttrData.postMerge(m_Parent.config(), pInput);
+}
+
+size_t ELFAttribute::Subsection::sizeOutput() const
+{
+  // ARM [ABI-addenda], 2.2.3 and 2.2.4
+  return ELFAttribute::SubsectionLengthFieldSize +
+            m_AttrData.getVendorName().length() /* vendor-name */ +
+            1 /* NULL-terminator for vendor-name */ +
+            1 /* Tag_File */ +
+            sizeof(uint32_t) /* length of sub-subsection */ +
+            m_AttrData.sizeOutput();
+}
+
+size_t ELFAttribute::Subsection::emit(char *pBuf) const
+{
+  // ARM [ABI-addenda], 2.2.3 and 2.2.4
+  const bool need_swap = (llvm::sys::IsLittleEndianHost !=
+                              m_Parent.config().targets().isLittleEndian());
+
+  char *buffer = pBuf;
+
+  // The subsection-length and byte-size field in sub-subsection will be patched
+  // later after writing out all attribute data.
+  char *subsection_length_hole = NULL;
+  char *subsubsection_length_hole = NULL;
+
+  // Reserve space for subsection-length.
+  subsection_length_hole = buffer;
+  buffer += 4;
+
+  // Write vendor-name.
+  const std::string &vendor_name = m_AttrData.getVendorName();
+  ::memcpy(buffer, vendor_name.c_str(), vendor_name.length());
+  buffer += vendor_name.length();
+
+  // Write NULL-terminator for vendor-name.
+  *buffer++ = '\0';
+
+  // Write Tag_File (0x01).
+  *buffer++ = '\x01';
+
+  // Reserve space for byte-size for sub-subsection.
+  subsubsection_length_hole = buffer;
+  buffer += sizeof(uint32_t);
+
+  // Write attribute data.
+  uint32_t subsubsection_length = m_AttrData.emit(buffer);
+
+  // Calculate value of subsection-length.
+  uint32_t subsection_length = (buffer - pBuf) + subsubsection_length;
+
+  // ARM [ABI-addenda] 2.2.4
+  //
+  // The byte-size in sub-subsection includes Tag_File (1-byte) and the size
+  // field of itself (4-byte).
+  subsubsection_length += 1 /* Tag_File */ + 4 /* size of byte-size */;
+
+  // Patch subsubsection_length_hole.
+  assert(subsubsection_length_hole != NULL);
+
+  if(need_swap)
+    bswap32(subsubsection_length);
+
+  ::memcpy(subsubsection_length_hole, &subsubsection_length, sizeof(uint32_t));
+
+  // Write subsection-length in subsection_length_hole.
+  if(need_swap)
+    bswap32(subsection_length);
+
+  assert(subsection_length_hole != NULL);
+  ::memcpy(subsection_length_hole, &subsection_length, sizeof(uint32_t));
+
+  return subsection_length;
+}
diff --git a/lib/Target/ELFAttributeData.cpp b/lib/Target/ELFAttributeData.cpp
new file mode 100644
index 0000000..c41918b
--- /dev/null
+++ b/lib/Target/ELFAttributeData.cpp
@@ -0,0 +1,88 @@
+//===- ELFAttributeData.cpp -----------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Target/ELFAttributeData.h>
+
+#include <mcld/Support/LEB128.h>
+#include <mcld/Target/ELFAttributeValue.h>
+#include <cstring>
+#include <cassert>
+
+using namespace mcld;
+
+bool ELFAttributeData::ReadTag(TagType& pTag, const char* &pBuf,
+                               size_t &pBufSize)
+{
+  size_t size = 0;
+
+  pTag = static_cast<ELFAttributeData::TagType>(
+            leb128::decode<uint64_t>(pBuf, size));
+
+  if (size > pBufSize)
+    return false;
+
+  pBuf += size;
+  pBufSize -= size;
+
+  return true;
+}
+
+bool ELFAttributeData::ReadValue(ELFAttributeValue& pValue, const char* &pBuf,
+                                 size_t &pBufSize)
+{
+  // An ULEB128-encoded value
+  if (pValue.isIntValue()) {
+    size_t size = 0;
+    uint64_t int_value = leb128::decode<uint64_t>(pBuf, size);
+    pValue.setIntValue(static_cast<unsigned int>(int_value));
+
+    if (size > pBufSize)
+      return false;
+
+    pBuf += size;
+    pBufSize -= size;
+  }
+
+  // A null-terminated byte string
+  if (pValue.isStringValue()) {
+    pValue.setStringValue(pBuf);
+
+    size_t size = pValue.getStringValue().length() + 1 /* '\0' */;
+    assert(size <= pBufSize);
+    pBuf += size;
+    pBufSize -= size;
+  }
+
+  return true;
+}
+
+bool ELFAttributeData::WriteAttribute(TagType pTag,
+                                      const ELFAttributeValue& pValue,
+                                      char* &pBuf)
+{
+  // Write the attribute tag.
+  leb128::encode<uint32_t>(pBuf, pTag);
+
+  // Write the attribute value.
+  if (pValue.isIntValue())
+    leb128::encode<uint32_t>(pBuf, pValue.getIntValue());
+
+  if (pValue.isStringValue()) {
+    // Write string data.
+    size_t str_val_len = pValue.getStringValue().length();
+
+    if (str_val_len > 0)
+      ::memcpy(pBuf, pValue.getStringValue().c_str(), str_val_len);
+    pBuf += str_val_len;
+
+    // Write NULL-terminator.
+    *pBuf++ = '\0';
+  }
+
+  return true;
+}
diff --git a/lib/Target/ELFAttributeValue.cpp b/lib/Target/ELFAttributeValue.cpp
new file mode 100644
index 0000000..0f99325
--- /dev/null
+++ b/lib/Target/ELFAttributeValue.cpp
@@ -0,0 +1,66 @@
+//===- ELFAttributeValue.cpp ----------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <mcld/Target/ELFAttributeValue.h>
+
+#include <llvm/Support/ErrorHandling.h>
+
+#include <mcld/Support/LEB128.h>
+
+using namespace mcld;
+
+size_t ELFAttributeValue::getSize() const
+{
+  size_t size = 0;
+
+  if (isIntValue())
+    size += leb128::size<uint32_t>(m_IntValue);
+
+  if (isStringValue())
+    size += m_StringValue.length() + 1 /* for NULL-terminator */;
+
+  if (size <= 0)
+    // unknown type of the value
+    llvm::report_fatal_error("Unknown type of attribtue value!");
+
+  return size;
+}
+
+bool ELFAttributeValue::isDefaultValue() const
+{
+  if (isUninitialized()) {
+    // Uninitialized attribute means default value
+    return true;
+  } else {
+    if (isIntValue() && (m_IntValue != 0))
+      return false;
+    if (isStringValue() && !m_StringValue.empty())
+      return false;
+
+    // The value hold in the storage is the "default value by default" (i.e., 0
+    // for int type, empty string for string type), but we need to check whether
+    // the "default value" is defined (that is, hasNoDefault() = false.)
+    return !hasNoDefault();
+  }
+  // unreachable
+}
+
+bool ELFAttributeValue::equals(const ELFAttributeValue& pValue) const
+{
+  if ((pValue.type() != m_Type) || isUninitialized())
+    return false;
+
+  if (isIntValue() && (m_IntValue != pValue.getIntValue()))
+    return false;
+
+  if (isStringValue() && (m_StringValue != pValue.getStringValue()))
+    return false;
+
+  return true;
+}
diff --git a/lib/Target/ELFDynamic.cpp b/lib/Target/ELFDynamic.cpp
index aeccd92..25c56c1 100644
--- a/lib/Target/ELFDynamic.cpp
+++ b/lib/Target/ELFDynamic.cpp
@@ -12,7 +12,6 @@
 #include <mcld/Target/GNULDBackend.h>
 #include <mcld/LD/ELFFileFormat.h>
 #include <mcld/LinkerConfig.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MsgHandling.h>
 
 using namespace mcld;
@@ -140,10 +139,8 @@
 
   reserveTargetEntries(pFormat); // DT_PLTGOT
 
-  if (pFormat.hasRelPlt() || pFormat.hasRelaPlt())
+  if (pFormat.hasRelPlt() || pFormat.hasRelaPlt()) {
     reserveOne(llvm::ELF::DT_PLTREL); // DT_PLTREL
-
-  if (pFormat.hasPLT()) {
     reserveOne(llvm::ELF::DT_JMPREL); // DT_JMPREL
     reserveOne(llvm::ELF::DT_PLTRELSZ); // DT_PLTRELSZ
   }
@@ -343,7 +340,7 @@
                              llvm::Twine(" than the section's demaind.\n"));
   }
 
-  uint8_t* address = (uint8_t*)pRegion.start();
+  uint8_t* address = (uint8_t*)pRegion.begin();
   EntryListType::const_iterator entry, entryEnd = m_NeedList.end();
   for (entry = m_NeedList.begin(); entry != entryEnd; ++entry)
     address += (*entry)->emit(address);
diff --git a/lib/Target/ELFEmulation.cpp b/lib/Target/ELFEmulation.cpp
index ff4a757..a68e485 100644
--- a/lib/Target/ELFEmulation.cpp
+++ b/lib/Target/ELFEmulation.cpp
@@ -9,6 +9,7 @@
 #include <mcld/Target/ELFEmulation.h>
 #include <mcld/LinkerScript.h>
 #include <mcld/LinkerConfig.h>
+#include <mcld/Script/InputSectDesc.h>
 
 #include <llvm/Support/Host.h>
 
@@ -17,63 +18,73 @@
 struct NameMap {
   const char* from; ///< the prefix of the input string. (match FROM*)
   const char* to;   ///< the output string.
+  InputSectDesc::KeepPolicy policy; /// mark whether the input is kept in GC
 };
 
 static const NameMap map[] =
 {
-  {".text", ".text"},
-  {".rodata", ".rodata"},
-  {".data.rel.ro.local", ".data.rel.ro.local"},
-  {".data.rel.ro", ".data.rel.ro"},
-  {".data", ".data"},
-  {".bss", ".bss"},
-  {".tdata", ".tdata"},
-  {".tbss", ".tbss"},
-  {".init_array", ".init_array"},
-  {".fini_array", ".fini_array"},
+  {".text*", ".text", InputSectDesc::NoKeep},
+  {".rodata*", ".rodata", InputSectDesc::NoKeep},
+  {".data.rel.ro.local*", ".data.rel.ro.local", InputSectDesc::NoKeep},
+  {".data.rel.ro*", ".data.rel.ro", InputSectDesc::NoKeep},
+  {".data*", ".data", InputSectDesc::NoKeep},
+  {".bss*", ".bss", InputSectDesc::NoKeep},
+  {".tdata*", ".tdata", InputSectDesc::NoKeep},
+  {".tbss*", ".tbss", InputSectDesc::NoKeep},
+  {".init", ".init", InputSectDesc::Keep},
+  {".fini", ".fini", InputSectDesc::Keep},
+  {".preinit_array*", ".preinit_array", InputSectDesc::Keep},
+  {".init_array*", ".init_array", InputSectDesc::Keep},
+  {".fini_array*", ".fini_array", InputSectDesc::Keep},
   // TODO: Support DT_INIT_ARRAY for all constructors?
-  {".ctors", ".ctors"},
-  {".dtors", ".dtors"},
+  {".ctors*", ".ctors", InputSectDesc::Keep},
+  {".dtors*", ".dtors", InputSectDesc::Keep},
+  {".jcr", ".jcr", InputSectDesc::Keep},
   // FIXME: in GNU ld, if we are creating a shared object .sdata2 and .sbss2
   // sections would be handled differently.
-  {".sdata2", ".sdata"},
-  {".sbss2", ".sbss"},
-  {".sdata", ".sdata"},
-  {".sbss", ".sbss"},
-  {".lrodata", ".lrodata"},
-  {".ldata", ".ldata"},
-  {".lbss", ".lbss"},
-  {".gcc_except_table", ".gcc_except_table"},
-  {".gnu.linkonce.d.rel.ro.local", ".data.rel.ro.local"},
-  {".gnu.linkonce.d.rel.ro", ".data.rel.ro"},
-  {".gnu.linkonce.r", ".rodata"},
-  {".gnu.linkonce.d", ".data"},
-  {".gnu.linkonce.b", ".bss"},
-  {".gnu.linkonce.sb2", ".sbss"},
-  {".gnu.linkonce.sb", ".sbss"},
-  {".gnu.linkonce.s2", ".sdata"},
-  {".gnu.linkonce.s", ".sdata"},
-  {".gnu.linkonce.wi", ".debug_info"},
-  {".gnu.linkonce.td", ".tdata"},
-  {".gnu.linkonce.tb", ".tbss"},
-  {".gnu.linkonce.t", ".text"},
-  {".gnu.linkonce.lr", ".lrodata"},
-  {".gnu.linkonce.lb", ".lbss"},
-  {".gnu.linkonce.l", ".ldata"},
+  {".sdata2*", ".sdata", InputSectDesc::NoKeep},
+  {".sbss2*", ".sbss", InputSectDesc::NoKeep},
+  {".sdata*", ".sdata", InputSectDesc::NoKeep},
+  {".sbss*", ".sbss", InputSectDesc::NoKeep},
+  {".lrodata*", ".lrodata", InputSectDesc::NoKeep},
+  {".ldata*", ".ldata", InputSectDesc::NoKeep},
+  {".lbss*", ".lbss", InputSectDesc::NoKeep},
+  {".gcc_except_table*", ".gcc_except_table", InputSectDesc::Keep},
+  {".gnu.linkonce.d.rel.ro.local*", ".data.rel.ro.local", InputSectDesc::NoKeep},
+  {".gnu.linkonce.d.rel.ro*", ".data.rel.ro", InputSectDesc::NoKeep},
+  {".gnu.linkonce.r*", ".rodata", InputSectDesc::NoKeep},
+  {".gnu.linkonce.d*", ".data", InputSectDesc::NoKeep},
+  {".gnu.linkonce.b*", ".bss", InputSectDesc::NoKeep},
+  {".gnu.linkonce.sb2*", ".sbss", InputSectDesc::NoKeep},
+  {".gnu.linkonce.sb*", ".sbss", InputSectDesc::NoKeep},
+  {".gnu.linkonce.s2*", ".sdata", InputSectDesc::NoKeep},
+  {".gnu.linkonce.s*", ".sdata", InputSectDesc::NoKeep},
+  {".gnu.linkonce.wi*", ".debug_info", InputSectDesc::NoKeep},
+  {".gnu.linkonce.td*", ".tdata", InputSectDesc::NoKeep},
+  {".gnu.linkonce.tb*", ".tbss", InputSectDesc::NoKeep},
+  {".gnu.linkonce.t*", ".text", InputSectDesc::NoKeep},
+  {".gnu.linkonce.lr*", ".lrodata", InputSectDesc::NoKeep},
+  {".gnu.linkonce.lb*", ".lbss", InputSectDesc::NoKeep},
+  {".gnu.linkonce.l*", ".ldata", InputSectDesc::NoKeep},
 };
 
 bool mcld::MCLDEmulateELF(LinkerScript& pScript, LinkerConfig& pConfig)
 // FIXME: LinkerConfig& pConfig should be constant
 {
   // set up section map
-  if (pConfig.codeGenType() != LinkerConfig::Object) {
+  if (pConfig.options().getScriptList().empty() &&
+      pConfig.codeGenType() != LinkerConfig::Object) {
     const unsigned int map_size =  (sizeof(map) / sizeof(map[0]) );
     for (unsigned int i = 0; i < map_size; ++i) {
-      bool exist = false;
-      pScript.sectionMap().append(map[i].from, map[i].to, exist);
-      if (exist)
+      std::pair<SectionMap::mapping, bool> res =
+        pScript.sectionMap().insert(map[i].from, map[i].to, map[i].policy);
+      if (!res.second)
         return false;
     }
+  } else {
+    // FIXME: this is the hack to help assignment processing in current
+    // implementation.
+    pScript.sectionMap().insert("", "");
   }
 
   if (!pConfig.options().nostdlib()) {
diff --git a/lib/Target/ELFMCLinker.cpp b/lib/Target/ELFMCLinker.cpp
index 3fa9b90..fae5c8c 100644
--- a/lib/Target/ELFMCLinker.cpp
+++ b/lib/Target/ELFMCLinker.cpp
@@ -7,9 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/Target/ELFMCLinker.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/Object/SectionMap.h>
-#include <mcld/Support/MsgHandling.h>
 
 using namespace mcld;
 
@@ -18,8 +15,8 @@
 //===----------------------------------------------------------------------===//
 ELFMCLinker::ELFMCLinker(LinkerConfig& pConfig,
                          mcld::Module& pModule,
-                         MemoryArea& pOutput)
-  : MCLinker(pConfig, pModule, pOutput) {
+                         FileHandle& pFileHandle)
+  : MCLinker(pConfig, pModule, pFileHandle) {
 
 }
 
diff --git a/lib/Target/GNULDBackend.cpp b/lib/Target/GNULDBackend.cpp
index c624f14..796c93e 100644
--- a/lib/Target/GNULDBackend.cpp
+++ b/lib/Target/GNULDBackend.cpp
@@ -17,25 +17,39 @@
 
 #include <mcld/Module.h>
 #include <mcld/LinkerConfig.h>
+#include <mcld/LinkerScript.h>
 #include <mcld/IRBuilder.h>
 #include <mcld/InputTree.h>
 #include <mcld/Config/Config.h>
 #include <mcld/ADT/SizeTraits.h>
 #include <mcld/LD/LDSymbol.h>
 #include <mcld/LD/LDContext.h>
-#include <mcld/Fragment/FillFragment.h>
 #include <mcld/LD/EhFrame.h>
 #include <mcld/LD/EhFrameHdr.h>
 #include <mcld/LD/RelocData.h>
 #include <mcld/LD/RelocationFactory.h>
-#include <mcld/MC/Attribute.h>
-#include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Support/MemoryAreaFactory.h>
 #include <mcld/LD/BranchIslandFactory.h>
+#include <mcld/LD/ELFSegmentFactory.h>
+#include <mcld/LD/ELFSegment.h>
 #include <mcld/LD/StubFactory.h>
+#include <mcld/LD/ELFFileFormat.h>
+#include <mcld/LD/ELFObjectFileFormat.h>
+#include <mcld/LD/ELFDynObjFileFormat.h>
+#include <mcld/LD/ELFExecFileFormat.h>
+#include <mcld/Target/ELFAttribute.h>
+#include <mcld/Target/ELFDynamic.h>
+#include <mcld/Target/GNUInfo.h>
+#include <mcld/Support/FileOutputBuffer.h>
+#include <mcld/Support/MsgHandling.h>
 #include <mcld/Object/ObjectBuilder.h>
+#include <mcld/Object/SectionMap.h>
+#include <mcld/Script/RpnEvaluator.h>
+#include <mcld/Script/Operand.h>
+#include <mcld/Script/OutputSectDesc.h>
+#include <mcld/Fragment/FillFragment.h>
+#include <mcld/MC/Attribute.h>
+
+#include <llvm/Support/Host.h>
 
 namespace {
 
@@ -69,10 +83,11 @@
     m_pExecFileFormat(NULL),
     m_pObjectFileFormat(NULL),
     m_pInfo(pInfo),
-    m_ELFSegmentTable(9), // magic number
+    m_pELFSegmentTable(NULL),
     m_pBRIslandFactory(NULL),
     m_pStubFactory(NULL),
     m_pEhFrameHdr(NULL),
+    m_pAttribute(NULL),
     m_bHasTextRel(false),
     m_bHasStaticTLS(false),
     f_pPreInitArrayStart(NULL),
@@ -94,17 +109,21 @@
     f_pBSSStart(NULL),
     f_pEnd(NULL),
     f_p_End(NULL) {
+  m_pELFSegmentTable = new ELFSegmentFactory();
   m_pSymIndexMap = new HashTableType(1024);
+  m_pAttribute = new ELFAttribute(*this, pConfig);
 }
 
 GNULDBackend::~GNULDBackend()
 {
+  delete m_pELFSegmentTable;
   delete m_pInfo;
   delete m_pDynObjFileFormat;
   delete m_pExecFileFormat;
   delete m_pObjectFileFormat;
   delete m_pSymIndexMap;
   delete m_pEhFrameHdr;
+  delete m_pAttribute;
   delete m_pBRIslandFactory;
   delete m_pStubFactory;
 }
@@ -117,10 +136,10 @@
   switch (config().targets().bitclass()) {
     case 32u:
       return sizeof(llvm::ELF::Elf32_Ehdr) +
-             numOfSegments() * sizeof(llvm::ELF::Elf32_Phdr);
+             elfSegmentTable().size() * sizeof(llvm::ELF::Elf32_Phdr);
     case 64u:
       return sizeof(llvm::ELF::Elf64_Ehdr) +
-             numOfSegments() * sizeof(llvm::ELF::Elf64_Phdr);
+             elfSegmentTable().size() * sizeof(llvm::ELF::Elf64_Phdr);
     default:
       fatal(diag::unsupported_bitclass) << config().targets().triple().str()
                                         << config().targets().bitclass();
@@ -160,7 +179,7 @@
 
 ELFBinaryReader* GNULDBackend::createBinaryReader(IRBuilder& pBuilder)
 {
-  return new ELFBinaryReader(*this, pBuilder, config());
+  return new ELFBinaryReader(pBuilder, config());
 }
 
 ELFObjectWriter* GNULDBackend::createWriter()
@@ -572,11 +591,12 @@
 
   // -----  segment symbols  ----- //
   if (NULL != f_pExecutableStart) {
-    ELFSegment* exec_start = m_ELFSegmentTable.find(llvm::ELF::PT_LOAD, 0x0, 0x0);
-    if (NULL != exec_start) {
+    ELFSegmentFactory::const_iterator exec_start =
+      elfSegmentTable().find(llvm::ELF::PT_LOAD, 0x0, 0x0);
+    if (elfSegmentTable().end() != exec_start) {
       if (ResolveInfo::ThreadLocal != f_pExecutableStart->type()) {
         f_pExecutableStart->setValue(f_pExecutableStart->value() +
-                                     exec_start->vaddr());
+                                     (*exec_start)->vaddr());
       }
     }
     else
@@ -584,24 +604,25 @@
   }
 
   if (NULL != f_pEText || NULL != f_p_EText || NULL !=f_p__EText) {
-    ELFSegment* etext = m_ELFSegmentTable.find(llvm::ELF::PT_LOAD,
-                                               llvm::ELF::PF_X,
-                                               llvm::ELF::PF_W);
-    if (NULL != etext) {
+    ELFSegmentFactory::const_iterator etext =
+      elfSegmentTable().find(llvm::ELF::PT_LOAD,
+                             llvm::ELF::PF_X,
+                             llvm::ELF::PF_W);
+    if (elfSegmentTable().end() != etext) {
       if (NULL != f_pEText && ResolveInfo::ThreadLocal != f_pEText->type()) {
         f_pEText->setValue(f_pEText->value() +
-                           etext->vaddr() +
-                           etext->memsz());
+                           (*etext)->vaddr() +
+                           (*etext)->memsz());
       }
       if (NULL != f_p_EText && ResolveInfo::ThreadLocal != f_p_EText->type()) {
         f_p_EText->setValue(f_p_EText->value() +
-                            etext->vaddr() +
-                            etext->memsz());
+                            (*etext)->vaddr() +
+                            (*etext)->memsz());
       }
       if (NULL != f_p__EText && ResolveInfo::ThreadLocal != f_p__EText->type()) {
         f_p__EText->setValue(f_p__EText->value() +
-                            etext->vaddr() +
-                            etext->memsz());
+                            (*etext)->vaddr() +
+                            (*etext)->memsz());
       }
     }
     else {
@@ -616,35 +637,34 @@
 
   if (NULL != f_pEData || NULL != f_p_EData || NULL != f_pBSSStart ||
       NULL != f_pEnd || NULL != f_p_End) {
-    ELFSegment* edata = m_ELFSegmentTable.find(llvm::ELF::PT_LOAD,
-                                               llvm::ELF::PF_W,
-                                               0x0);
-    if (NULL != edata) {
+    ELFSegmentFactory::const_iterator edata =
+      elfSegmentTable().find(llvm::ELF::PT_LOAD, llvm::ELF::PF_W, 0x0);
+    if (elfSegmentTable().end() != edata) {
       if (NULL != f_pEData && ResolveInfo::ThreadLocal != f_pEData->type()) {
         f_pEData->setValue(f_pEData->value() +
-                            edata->vaddr() +
-                            edata->filesz());
+                           (*edata)->vaddr() +
+                           (*edata)->filesz());
       }
       if (NULL != f_p_EData && ResolveInfo::ThreadLocal != f_p_EData->type()) {
         f_p_EData->setValue(f_p_EData->value() +
-                            edata->vaddr() +
-                            edata->filesz());
+                            (*edata)->vaddr() +
+                            (*edata)->filesz());
       }
       if (NULL != f_pBSSStart && ResolveInfo::ThreadLocal != f_pBSSStart->type()) {
         f_pBSSStart->setValue(f_pBSSStart->value() +
-                              edata->vaddr() +
-                              edata->filesz());
+                              (*edata)->vaddr() +
+                              (*edata)->filesz());
       }
 
       if (NULL != f_pEnd && ResolveInfo::ThreadLocal != f_pEnd->type()) {
         f_pEnd->setValue(f_pEnd->value() +
-                         edata->vaddr() +
-                         edata->memsz());
+                         (*edata)->vaddr() +
+                         (*edata)->memsz());
       }
       if (NULL != f_p_End && ResolveInfo::ThreadLocal != f_p_End->type()) {
         f_p_End->setValue(f_p_End->value() +
-                          edata->vaddr() +
-                          edata->memsz());
+                          (*edata)->vaddr() +
+                          (*edata)->memsz());
       }
     }
     else {
@@ -672,11 +692,12 @@
     return true;
 
   // the value of a TLS symbol is the offset to the TLS segment
-  ELFSegment* tls_seg = m_ELFSegmentTable.find(llvm::ELF::PT_TLS,
-                                               llvm::ELF::PF_R, 0x0);
+  ELFSegmentFactory::iterator tls_seg =
+    elfSegmentTable().find(llvm::ELF::PT_TLS, llvm::ELF::PF_R, 0x0);
+  assert(tls_seg != elfSegmentTable().end());
   uint64_t value = pSymbol.fragRef()->getOutputOffset();
   uint64_t addr  = pSymbol.fragRef()->frag()->getParent()->getSection().addr();
-  pSymbol.setValue(value + addr - tls_seg->vaddr());
+  pSymbol.setValue(value + addr - (*tls_seg)->vaddr());
   return true;
 }
 
@@ -718,6 +739,18 @@
   }
 }
 
+/// sizeShstrtab - compute the size of .shstrtab
+void GNULDBackend::sizeShstrtab(Module& pModule)
+{
+  size_t shstrtab = 0;
+  // compute the size of .shstrtab section.
+  Module::const_iterator sect, sectEnd = pModule.end();
+  for (sect = pModule.begin(); sect != sectEnd; ++sect) {
+    shstrtab += (*sect)->name().size() + 1;
+  } // end of for
+  getOutputFormat()->getShStrTab().setSize(shstrtab);
+}
+
 /// sizeNamePools - compute the size of regular name pools
 /// In ELF executable files, regular name pools are .symtab, .strtab,
 /// .dynsym, .dynstr, .hash and .shstrtab.
@@ -734,7 +767,6 @@
   // first byte
   size_t strtab   = 1;
   size_t dynstr   = config().isCodeStatic()? 0 : 1;
-  size_t shstrtab = 1;
   size_t hash     = 0;
   size_t gnuhash  = 0;
 
@@ -746,21 +778,34 @@
   Module::const_sym_iterator symbol, symEnd;
   /// Compute the size of .symtab, .strtab, and symtab_local_cnt
   /// @{
-  symEnd = symbols.end();
-  for (symbol = symbols.begin(); symbol != symEnd; ++symbol) {
-    ++symtab;
-    if (hasEntryInStrTab(**symbol))
-      strtab += (*symbol)->nameSize() + 1;
-  }
-  symtab_local_cnt = 1 + symbols.numOfFiles() + symbols.numOfLocals() +
-                     symbols.numOfLocalDyns();
+  /* TODO:
+       1. discard locals and temporary locals
+       2. check whether the symbol is used
+   */
+  switch (config().options().getStripSymbolMode()) {
+    case GeneralOptions::StripAllSymbols: {
+      symtab = strtab = 0;
+      break;
+    }
+    default: {
+      symEnd = symbols.end();
+      for (symbol = symbols.begin(); symbol != symEnd; ++symbol) {
+        ++symtab;
+        if (hasEntryInStrTab(**symbol))
+          strtab += (*symbol)->nameSize() + 1;
+      }
+      symtab_local_cnt = 1 + symbols.numOfFiles() + symbols.numOfLocals() +
+                         symbols.numOfLocalDyns();
+      break;
+    }
+  } // end of switch
 
   ELFFileFormat* file_format = getOutputFormat();
 
   switch(config().codeGenType()) {
     case LinkerConfig::DynObj: {
       // soname
-      dynstr += pModule.name().size() + 1;
+      dynstr += config().options().soname().size() + 1;
     }
     /** fall through **/
     case LinkerConfig::Exec:
@@ -857,38 +902,9 @@
       // index of the last local symbol
       file_format->getSymTab().setInfo(symtab_local_cnt);
 
-      // compute the size of .shstrtab section.
-      Module::const_iterator sect, sectEnd = pModule.end();
-      for (sect = pModule.begin(); sect != sectEnd; ++sect) {
-        switch ((*sect)->kind()) {
-        case LDFileFormat::Null:
-          break;
-        // take StackNote directly
-        case LDFileFormat::StackNote:
-          shstrtab += ((*sect)->name().size() + 1);
-          break;
-        case LDFileFormat::EhFrame:
-          if (((*sect)->size() != 0) ||
-              ((*sect)->hasEhFrame() &&
-               config().codeGenType() == LinkerConfig::Object))
-            shstrtab += ((*sect)->name().size() + 1);
-          break;
-        case LDFileFormat::Relocation:
-          if (((*sect)->size() != 0) ||
-              ((*sect)->hasRelocData() &&
-               config().codeGenType() == LinkerConfig::Object))
-            shstrtab += ((*sect)->name().size() + 1);
-          break;
-        default:
-          if (((*sect)->size() != 0) ||
-              ((*sect)->hasSectionData() &&
-               config().codeGenType() == LinkerConfig::Object))
-            shstrtab += ((*sect)->name().size() + 1);
-          break;
-        } // end of switch
-      } // end of for
-      shstrtab += (strlen(".shstrtab") + 1);
-      file_format->getShStrTab().setSize(shstrtab);
+      // The size of .shstrtab should be decided after output sections are all
+      // set, so we just set it to 1 here.
+      file_format->getShStrTab().setSize(0x1);
       break;
     }
     default:
@@ -948,32 +964,34 @@
 /// the size of these tables should be computed before layout
 /// layout should computes the start offset of these tables
 void GNULDBackend::emitRegNamePools(const Module& pModule,
-                                    MemoryArea& pOutput)
+                                    FileOutputBuffer& pOutput)
 {
   ELFFileFormat* file_format = getOutputFormat();
+  if (!file_format->hasSymTab())
+    return;
 
   LDSection& symtab_sect = file_format->getSymTab();
   LDSection& strtab_sect = file_format->getStrTab();
 
-  MemoryRegion* symtab_region = pOutput.request(symtab_sect.offset(),
-                                                symtab_sect.size());
-  MemoryRegion* strtab_region = pOutput.request(strtab_sect.offset(),
-                                                strtab_sect.size());
+  MemoryRegion symtab_region = pOutput.request(symtab_sect.offset(),
+                                               symtab_sect.size());
+  MemoryRegion strtab_region = pOutput.request(strtab_sect.offset(),
+                                               strtab_sect.size());
 
   // set up symtab_region
   llvm::ELF::Elf32_Sym* symtab32 = NULL;
   llvm::ELF::Elf64_Sym* symtab64 = NULL;
   if (config().targets().is32Bits())
-    symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start();
+    symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region.begin();
   else if (config().targets().is64Bits())
-    symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start();
+    symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region.begin();
   else {
     fatal(diag::unsupported_bitclass) << config().targets().triple().str()
                                       << config().targets().bitclass();
   }
 
   // set up strtab_region
-  char* strtab = (char*)strtab_region->start();
+  char* strtab = (char*)strtab_region.begin();
 
   // emit the first ELF symbol
   if (config().targets().is32Bits())
@@ -1014,7 +1032,7 @@
 ///
 /// the size of these tables should be computed before layout
 /// layout should computes the start offset of these tables
-void GNULDBackend::emitDynNamePools(Module& pModule, MemoryArea& pOutput)
+void GNULDBackend::emitDynNamePools(Module& pModule, FileOutputBuffer& pOutput)
 {
   ELFFileFormat* file_format = getOutputFormat();
   if (!file_format->hasDynSymTab() ||
@@ -1029,26 +1047,26 @@
   LDSection& strtab_sect = file_format->getDynStrTab();
   LDSection& dyn_sect    = file_format->getDynamic();
 
-  MemoryRegion* symtab_region = pOutput.request(symtab_sect.offset(),
-                                                symtab_sect.size());
-  MemoryRegion* strtab_region = pOutput.request(strtab_sect.offset(),
-                                                strtab_sect.size());
-  MemoryRegion* dyn_region    = pOutput.request(dyn_sect.offset(),
-                                                dyn_sect.size());
+  MemoryRegion symtab_region = pOutput.request(symtab_sect.offset(),
+                                               symtab_sect.size());
+  MemoryRegion strtab_region = pOutput.request(strtab_sect.offset(),
+                                               strtab_sect.size());
+  MemoryRegion dyn_region = pOutput.request(dyn_sect.offset(),
+                                            dyn_sect.size());
   // set up symtab_region
   llvm::ELF::Elf32_Sym* symtab32 = NULL;
   llvm::ELF::Elf64_Sym* symtab64 = NULL;
   if (config().targets().is32Bits())
-    symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start();
+    symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region.begin();
   else if (config().targets().is64Bits())
-    symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start();
+    symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region.begin();
   else {
     fatal(diag::unsupported_bitclass) << config().targets().triple().str()
                                       << config().targets().bitclass();
   }
 
   // set up strtab_region
-  char* strtab = (char*)strtab_region->start();
+  char* strtab = (char*)strtab_region.begin();
 
   // emit the first ELF symbol
   if (config().targets().is32Bits())
@@ -1121,28 +1139,28 @@
     dynamic().applySoname(strtabsize);
   }
   dynamic().applyEntries(*file_format);
-  dynamic().emit(dyn_sect, *dyn_region);
+  dynamic().emit(dyn_sect, dyn_region);
 
   // emit soname
   if (LinkerConfig::DynObj == config().codeGenType()) {
-    strcpy((strtab + strtabsize), pModule.name().c_str());
-    strtabsize += pModule.name().size() + 1;
+    strcpy((strtab + strtabsize), config().options().soname().c_str());
+    strtabsize += config().options().soname().size() + 1;
   }
 }
 
 /// emitELFHashTab - emit .hash
 void GNULDBackend::emitELFHashTab(const Module::SymbolTable& pSymtab,
-                                  MemoryArea& pOutput)
+                                  FileOutputBuffer& pOutput)
 {
   ELFFileFormat* file_format = getOutputFormat();
   if (!file_format->hasHashTab())
     return;
   LDSection& hash_sect = file_format->getHashTab();
-  MemoryRegion* hash_region = pOutput.request(hash_sect.offset(),
-                                              hash_sect.size());
+  MemoryRegion hash_region = pOutput.request(hash_sect.offset(),
+                                             hash_sect.size());
   // both 32 and 64 bits hash table use 32-bit entry
   // set up hash_region
-  uint32_t* word_array = (uint32_t*)hash_region->start();
+  uint32_t* word_array = (uint32_t*)hash_region.begin();
   uint32_t& nbucket = word_array[0];
   uint32_t& nchain  = word_array[1];
 
@@ -1171,17 +1189,17 @@
 
 /// emitGNUHashTab - emit .gnu.hash
 void GNULDBackend::emitGNUHashTab(Module::SymbolTable& pSymtab,
-                                  MemoryArea& pOutput)
+                                  FileOutputBuffer& pOutput)
 {
   ELFFileFormat* file_format = getOutputFormat();
   if (!file_format->hasGNUHashTab())
     return;
 
-  MemoryRegion* gnuhash_region =
+  MemoryRegion gnuhash_region =
     pOutput.request(file_format->getGNUHashTab().offset(),
                     file_format->getGNUHashTab().size());
 
-  uint32_t* word_array = (uint32_t*)gnuhash_region->start();
+  uint32_t* word_array = (uint32_t*)gnuhash_region.begin();
   // fixed-length fields
   uint32_t& nbucket   = word_array[0];
   uint32_t& symidx    = word_array[1];
@@ -1309,18 +1327,18 @@
 }
 
 /// emitInterp - emit the .interp
-void GNULDBackend::emitInterp(MemoryArea& pOutput)
+void GNULDBackend::emitInterp(FileOutputBuffer& pOutput)
 {
   if (getOutputFormat()->hasInterp()) {
     const LDSection& interp = getOutputFormat()->getInterp();
-    MemoryRegion *region = pOutput.request(interp.offset(), interp.size());
+    MemoryRegion region = pOutput.request(interp.offset(), interp.size());
     const char* dyld_name;
     if (config().options().hasDyld())
       dyld_name = config().options().dyld().c_str();
     else
       dyld_name = m_pInfo->dyld();
 
-    std::memcpy(region->start(), dyld_name, interp.size());
+    std::memcpy(region.begin(), dyld_name, interp.size());
   }
 }
 
@@ -1349,7 +1367,7 @@
 
   // NULL section should be the "1st" section
   if (LDFileFormat::Null == pSectHdr.kind())
-    return 0;
+    return SHO_NULL;
 
   if (&pSectHdr == &file_format->getStrTab())
     return SHO_STRTAB;
@@ -1493,15 +1511,6 @@
   if (pSymbol.resolveInfo()->isUndef() || pSymbol.isDyn())
     return llvm::ELF::SHN_UNDEF;
 
-  if (pSymbol.resolveInfo()->isLocal() &&
-      LinkerConfig::Object != config().codeGenType()) {
-    switch (pSymbol.type()) {
-      case ResolveInfo::NoType:
-      case ResolveInfo::File:
-        return llvm::ELF::SHN_ABS;
-    }
-  }
-
   if (pSymbol.resolveInfo()->isDefine() && !pSymbol.hasFragRef())
     return llvm::ELF::SHN_ABS;
 
@@ -1598,18 +1607,19 @@
       // description here.
       (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
       Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
-      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
 
       if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
         // allocate TLS common symbol in tbss section
         tbss_offset += ObjectBuilder::AppendFragment(*frag,
                                                      *tbss_sect_data,
                                                      (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       }
       else {
         bss_offset += ObjectBuilder::AppendFragment(*frag,
                                                     *bss_sect_data,
                                                     (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       }
     }
   }
@@ -1624,18 +1634,19 @@
     // description here.
     (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
     Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
-    (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
 
     if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
       // allocate TLS common symbol in tbss section
       tbss_offset += ObjectBuilder::AppendFragment(*frag,
                                                    *tbss_sect_data,
                                                    (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
     }
     else {
       bss_offset += ObjectBuilder::AppendFragment(*frag,
                                                   *bss_sect_data,
                                                   (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
     }
   }
 
@@ -1670,35 +1681,177 @@
   return true;
 }
 
+/// readRelocation - read ELF32_Rel entry
+bool GNULDBackend::readRelocation(const llvm::ELF::Elf32_Rel& pRel,
+                                  Relocation::Type& pType,
+                                  uint32_t& pSymIdx,
+                                  uint32_t& pOffset) const
+{
+  uint32_t r_info = 0x0;
+  if (llvm::sys::IsLittleEndianHost) {
+    pOffset = pRel.r_offset;
+    r_info  = pRel.r_info;
+  }
+  else {
+    pOffset = mcld::bswap32(pRel.r_offset);
+    r_info  = mcld::bswap32(pRel.r_info);
+  }
+
+  pType = static_cast<unsigned char>(r_info);
+  pSymIdx = (r_info >> 8);
+  return true;
+}
+
+/// readRelocation - read ELF32_Rela entry
+bool GNULDBackend::readRelocation(const llvm::ELF::Elf32_Rela& pRel,
+                                  Relocation::Type& pType,
+                                  uint32_t& pSymIdx,
+                                  uint32_t& pOffset,
+                                  int32_t& pAddend) const
+{
+  uint32_t r_info   = 0x0;
+  if (llvm::sys::IsLittleEndianHost) {
+    pOffset = pRel.r_offset;
+    r_info  = pRel.r_info;
+    pAddend = pRel.r_addend;
+  }
+  else {
+    pOffset = mcld::bswap32(pRel.r_offset);
+    r_info  = mcld::bswap32(pRel.r_info);
+    pAddend = mcld::bswap32(pRel.r_addend);
+  }
+
+  pType = static_cast<unsigned char>(r_info);
+  pSymIdx = (r_info >> 8);
+  return true;
+}
+
+/// readRelocation - read ELF64_Rel entry
+bool GNULDBackend::readRelocation(const llvm::ELF::Elf64_Rel& pRel,
+                              Relocation::Type& pType,
+                              uint32_t& pSymIdx,
+                              uint64_t& pOffset) const
+{
+  uint64_t r_info = 0x0;
+  if (llvm::sys::IsLittleEndianHost) {
+    pOffset = pRel.r_offset;
+    r_info  = pRel.r_info;
+  }
+  else {
+    pOffset = mcld::bswap64(pRel.r_offset);
+    r_info  = mcld::bswap64(pRel.r_info);
+  }
+
+  pType = static_cast<uint32_t>(r_info);
+  pSymIdx = (r_info >> 32);
+  return true;
+}
+
+/// readRel - read ELF64_Rela entry
+bool GNULDBackend::readRelocation(const llvm::ELF::Elf64_Rela& pRel,
+                              Relocation::Type& pType,
+                              uint32_t& pSymIdx,
+                              uint64_t& pOffset,
+                              int64_t& pAddend) const
+{
+  uint64_t r_info = 0x0;
+  if (llvm::sys::IsLittleEndianHost) {
+    pOffset = pRel.r_offset;
+    r_info  = pRel.r_info;
+    pAddend = pRel.r_addend;
+  }
+  else {
+    pOffset = mcld::bswap64(pRel.r_offset);
+    r_info  = mcld::bswap64(pRel.r_info);
+    pAddend = mcld::bswap64(pRel.r_addend);
+  }
+
+  pType = static_cast<uint32_t>(r_info);
+  pSymIdx = (r_info >> 32);
+  return true;
+}
+
+/// emitRelocation - write data to the ELF32_Rel entry
+void GNULDBackend::emitRelocation(llvm::ELF::Elf32_Rel& pRel,
+                                  Relocation::Type pType,
+                                  uint32_t pSymIdx,
+                                  uint32_t pOffset) const
+{
+  pRel.r_offset = pOffset;
+  pRel.setSymbolAndType(pSymIdx, pType);
+}
+
+/// emitRelocation - write data to the ELF32_Rela entry
+void GNULDBackend::emitRelocation(llvm::ELF::Elf32_Rela& pRel,
+                                  Relocation::Type pType,
+                                  uint32_t pSymIdx,
+                                  uint32_t pOffset,
+                                  int32_t pAddend) const
+{
+  pRel.r_offset = pOffset;
+  pRel.r_addend = pAddend;
+  pRel.setSymbolAndType(pSymIdx, pType);
+}
+
+/// emitRelocation - write data to the ELF64_Rel entry
+void GNULDBackend::emitRelocation(llvm::ELF::Elf64_Rel& pRel,
+                                  Relocation::Type pType,
+                                  uint32_t pSymIdx,
+                                  uint64_t pOffset) const
+{
+  pRel.r_offset = pOffset;
+  pRel.setSymbolAndType(pSymIdx, pType);
+}
+
+/// emitRelocation - write data to the ELF64_Rela entry
+void GNULDBackend::emitRelocation(llvm::ELF::Elf64_Rela& pRel,
+                                  Relocation::Type pType,
+                                  uint32_t pSymIdx,
+                                  uint64_t pOffset,
+                                  int64_t pAddend) const
+{
+  pRel.r_offset = pOffset;
+  pRel.r_addend = pAddend;
+  pRel.setSymbolAndType(pSymIdx, pType);
+}
+
 /// createProgramHdrs - base on output sections to create the program headers
 void GNULDBackend::createProgramHdrs(Module& pModule)
 {
   ELFFileFormat *file_format = getOutputFormat();
 
-  // make PT_PHDR
-  m_ELFSegmentTable.produce(llvm::ELF::PT_PHDR);
-
   // make PT_INTERP
   if (file_format->hasInterp()) {
-    ELFSegment* interp_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_INTERP);
-    interp_seg->addSection(&file_format->getInterp());
+    // make PT_PHDR
+    elfSegmentTable().produce(llvm::ELF::PT_PHDR);
+
+    ELFSegment* interp_seg = elfSegmentTable().produce(llvm::ELF::PT_INTERP);
+    interp_seg->append(&file_format->getInterp());
   }
 
-  uint32_t cur_flag, prev_flag = getSegmentFlag(0);
+  uint32_t cur_flag, prev_flag = 0x0;
   ELFSegment* load_seg = NULL;
   // make possible PT_LOAD segments
-  LinkerScript::AddressMap::iterator addrEnd
-                                      = pModule.getScript().addressMap().end();
-  Module::iterator sect, sect_end = pModule.end();
-  for (sect = pModule.begin(); sect != sect_end; ++sect) {
+  LinkerScript& ldscript = pModule.getScript();
+  LinkerScript::AddressMap::iterator addrEnd= ldscript.addressMap().end();
+  SectionMap::iterator out, prev, outBegin, outEnd;
+  outBegin = ldscript.sectionMap().begin();
+  outEnd = ldscript.sectionMap().end();
+  for (out = outBegin, prev = outEnd; out != outEnd; prev = out, ++out) {
+    LDSection* sect = (*out)->getSection();
 
-    if (0 == ((*sect)->flag() & llvm::ELF::SHF_ALLOC) &&
-        LDFileFormat::Null != (*sect)->kind())
+    if (0 == (sect->flag() & llvm::ELF::SHF_ALLOC) &&
+        LDFileFormat::Null != sect->kind())
+      break;
+
+    // bypass empty sections
+    if (!(*out)->hasContent() &&
+        (*out)->getSection()->kind() != LDFileFormat::Null)
       continue;
 
-    cur_flag = getSegmentFlag((*sect)->flag());
+    cur_flag = getSegmentFlag(sect->flag());
     bool createPT_LOAD = false;
-    if (LDFileFormat::Null == (*sect)->kind()) {
+    if (LDFileFormat::Null == sect->kind()) {
       // 1. create text segment
       createPT_LOAD = true;
     }
@@ -1707,31 +1860,35 @@
       // 2. create data segment if w/o omagic set
       createPT_LOAD = true;
     }
-    else if ((*sect)->kind() == LDFileFormat::BSS &&
+    else if (sect->kind() == LDFileFormat::BSS &&
              load_seg->isDataSegment() &&
-             addrEnd != pModule.getScript().addressMap().find(".bss")) {
+             addrEnd != ldscript.addressMap().find(".bss")) {
       // 3. create bss segment if w/ -Tbss and there is a data segment
       createPT_LOAD = true;
     }
-    else {
-      if ((*sect != &(file_format->getText())) &&
-          (*sect != &(file_format->getData())) &&
-          (*sect != &(file_format->getBSS())) &&
-          (addrEnd != pModule.getScript().addressMap().find((*sect)->name())))
-        // 4. create PT_LOAD for sections in address map except for text, data,
-        // and bss
-        createPT_LOAD = true;
+    else if ((sect != &(file_format->getText())) &&
+             (sect != &(file_format->getData())) &&
+             (sect != &(file_format->getBSS())) &&
+             (addrEnd != ldscript.addressMap().find(sect->name()))) {
+      // 4. create PT_LOAD for sections in address map except for text, data,
+      // and bss
+      createPT_LOAD = true;
+    }
+    else if (LDFileFormat::Null == (*prev)->getSection()->kind() &&
+             !config().options().getScriptList().empty()) {
+      // 5. create PT_LOAD to hold NULL section if there is a default ldscript
+      createPT_LOAD = true;
     }
 
     if (createPT_LOAD) {
       // create new PT_LOAD segment
-      load_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_LOAD, cur_flag);
+      load_seg = elfSegmentTable().produce(llvm::ELF::PT_LOAD, cur_flag);
       if (!config().options().nmagic() && !config().options().omagic())
         load_seg->setAlign(abiPageSize());
     }
 
     assert(NULL != load_seg);
-    load_seg->addSection((*sect));
+    load_seg->append(sect);
     if (cur_flag != prev_flag)
       load_seg->updateFlag(cur_flag);
 
@@ -1740,27 +1897,27 @@
 
   // make PT_DYNAMIC
   if (file_format->hasDynamic()) {
-    ELFSegment* dyn_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_DYNAMIC,
+    ELFSegment* dyn_seg = elfSegmentTable().produce(llvm::ELF::PT_DYNAMIC,
                                                     llvm::ELF::PF_R |
                                                     llvm::ELF::PF_W);
-    dyn_seg->addSection(&file_format->getDynamic());
+    dyn_seg->append(&file_format->getDynamic());
   }
 
   if (config().options().hasRelro()) {
     // make PT_GNU_RELRO
-    ELFSegment* relro_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_GNU_RELRO);
+    ELFSegment* relro_seg = elfSegmentTable().produce(llvm::ELF::PT_GNU_RELRO);
     for (ELFSegmentFactory::iterator seg = elfSegmentTable().begin(),
-         segEnd = elfSegmentTable().end(); seg != segEnd; ++seg) {
-      if (llvm::ELF::PT_LOAD != (*seg).type())
+      segEnd = elfSegmentTable().end(); seg != segEnd; ++seg) {
+      if (llvm::ELF::PT_LOAD != (*seg)->type())
         continue;
 
-      for (ELFSegment::sect_iterator sect = (*seg).begin(),
-             sectEnd = (*seg).end(); sect != sectEnd; ++sect) {
+      for (ELFSegment::iterator sect = (*seg)->begin(),
+        sectEnd = (*seg)->end(); sect != sectEnd; ++sect) {
         unsigned int order = getSectionOrder(**sect);
         if (SHO_RELRO_LOCAL == order ||
             SHO_RELRO == order ||
             SHO_RELRO_LAST == order) {
-          relro_seg->addSection(*sect);
+          relro_seg->append(*sect);
         }
       }
     }
@@ -1768,22 +1925,22 @@
 
   // make PT_GNU_EH_FRAME
   if (file_format->hasEhFrameHdr()) {
-    ELFSegment* eh_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_GNU_EH_FRAME);
-    eh_seg->addSection(&file_format->getEhFrameHdr());
+    ELFSegment* eh_seg = elfSegmentTable().produce(llvm::ELF::PT_GNU_EH_FRAME);
+    eh_seg->append(&file_format->getEhFrameHdr());
   }
 
   // make PT_TLS
   if (file_format->hasTData() || file_format->hasTBSS()) {
-    ELFSegment* tls_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_TLS);
+    ELFSegment* tls_seg = elfSegmentTable().produce(llvm::ELF::PT_TLS);
     if (file_format->hasTData())
-      tls_seg->addSection(&file_format->getTData());
+      tls_seg->append(&file_format->getTData());
     if (file_format->hasTBSS())
-      tls_seg->addSection(&file_format->getTBSS());
+      tls_seg->append(&file_format->getTBSS());
   }
 
   // make PT_GNU_STACK
   if (file_format->hasStackNote()) {
-    m_ELFSegmentTable.produce(llvm::ELF::PT_GNU_STACK,
+    elfSegmentTable().produce(llvm::ELF::PT_GNU_STACK,
                               llvm::ELF::PF_R |
                               llvm::ELF::PF_W |
                               getSegmentFlag(file_format->getStackNote().flag()));
@@ -1791,9 +1948,12 @@
 
   // make PT_NOTE
   ELFSegment *note_seg = NULL;
-  prev_flag = getSegmentFlag(0);
-  for (sect = pModule.begin(); sect != sect_end; ++sect) {
-    if ((*sect)->kind() != LDFileFormat::Note ||
+  prev_flag = 0x0;
+  Module::iterator sect, sectBegin, sectEnd;
+  sectBegin = pModule.begin();
+  sectEnd = pModule.end();
+  for (sect = sectBegin; sect != sectEnd; ++sect) {
+    if ((*sect)->type() != llvm::ELF::SHT_NOTE ||
         ((*sect)->flag() & llvm::ELF::SHF_ALLOC) == 0)
       continue;
 
@@ -1802,9 +1962,9 @@
     // create 2 segments if needed.
     if (note_seg == NULL ||
         (cur_flag & llvm::ELF::PF_W) != (prev_flag & llvm::ELF::PF_W))
-      note_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_NOTE, cur_flag);
+      note_seg = elfSegmentTable().produce(llvm::ELF::PT_NOTE, cur_flag);
 
-    note_seg->addSection(*sect);
+    note_seg->append(*sect);
     prev_flag = cur_flag;
   }
 
@@ -1816,54 +1976,151 @@
 void GNULDBackend::setupProgramHdrs(const LinkerScript& pScript)
 {
   // update segment info
-  uint64_t seg_start_addr = getSegmentStartAddr(pScript);
-  ELFSegmentFactory::iterator seg, seg_end = m_ELFSegmentTable.end();
-  for (seg = m_ELFSegmentTable.begin(); seg != seg_end; ++seg) {
-    ELFSegment& segment = *seg;
+  for (ELFSegmentFactory::iterator seg = elfSegmentTable().begin(),
+    segEnd = elfSegmentTable().end(); seg != segEnd; ++seg) {
 
-    // update PT_PHDR
-    if (llvm::ELF::PT_PHDR == segment.type()) {
-      uint64_t offset = 0, phdr_size = 0;
+    // bypass if there is no section in this segment (e.g., PT_GNU_STACK)
+    if ((*seg)->size() == 0)
+      continue;
+
+    // bypass the PT_LOAD that only has NULL section now
+    if ((*seg)->type() == llvm::ELF::PT_LOAD &&
+        (*seg)->front()->kind() == LDFileFormat::Null &&
+        (*seg)->size() == 1)
+       continue;
+
+    (*seg)->setOffset((*seg)->front()->offset());
+    if ((*seg)->type() == llvm::ELF::PT_LOAD &&
+        (*seg)->front()->kind() == LDFileFormat::Null) {
+      const LDSection* second = *((*seg)->begin() + 1);
+      assert(second != NULL);
+      (*seg)->setVaddr(second->addr() - second->offset());
+    } else {
+      (*seg)->setVaddr((*seg)->front()->addr());
+    }
+    (*seg)->setPaddr((*seg)->vaddr());
+
+    ELFSegment::reverse_iterator sect, sectREnd = (*seg)->rend();
+    for (sect = (*seg)->rbegin(); sect != sectREnd; ++sect) {
+      if ((*sect)->kind() != LDFileFormat::BSS)
+        break;
+    }
+    if (sect != sectREnd) {
+      (*seg)->setFilesz((*sect)->offset() +
+                        (*sect)->size() -
+                        (*seg)->offset());
+    } else {
+      (*seg)->setFilesz(0x0);
+    }
+
+    (*seg)->setMemsz((*seg)->back()->addr() +
+                     (*seg)->back()->size() -
+                     (*seg)->vaddr());
+  } // end of for
+
+  // handle the case if text segment only has NULL section
+  LDSection* null_sect = &getOutputFormat()->getNULLSection();
+  ELFSegmentFactory::iterator null_seg =
+    elfSegmentTable().find(llvm::ELF::PT_LOAD, null_sect);
+
+  if ((*null_seg)->size() == 1) {
+    // find 2nd PT_LOAD
+    ELFSegmentFactory::iterator seg, segEnd = elfSegmentTable().end();
+    for (seg = null_seg + 1; seg != segEnd; ++seg) {
+      if ((*seg)->type() == llvm::ELF::PT_LOAD)
+        break;
+    }
+    if (seg != segEnd) {
+      uint64_t addr = (*seg)->front()->addr() - (*seg)->front()->offset();
+      uint64_t size = sectionStartOffset();
+      if (addr + size == (*seg)->front()->addr()) {
+        // if there is no space between the 2 segments, we can merge them.
+        (*seg)->setOffset(0x0);
+        (*seg)->setVaddr(addr);
+        (*seg)->setPaddr(addr);
+
+        ELFSegment::iterator sect, sectEnd = (*seg)->end();
+        for (sect = (*seg)->begin(); sect != sectEnd; ++sect) {
+          if ((*sect)->kind() == LDFileFormat::BSS) {
+            --sect;
+            break;
+          }
+        }
+        if (sect == sectEnd) {
+          (*seg)->setFilesz((*seg)->back()->offset() +
+                            (*seg)->back()->size() -
+                            (*seg)->offset());
+        } else if (*sect != (*seg)->front()) {
+          --sect;
+          (*seg)->setFilesz((*sect)->offset() +
+                            (*sect)->size() -
+                            (*seg)->offset());
+        } else {
+          (*seg)->setFilesz(0x0);
+        }
+
+        (*seg)->setMemsz((*seg)->back()->addr() +
+                         (*seg)->back()->size() -
+                         (*seg)->vaddr());
+
+        (*seg)->insert((*seg)->begin(), null_sect);
+        elfSegmentTable().erase(null_seg);
+
+      } else if (addr + size < (*seg)->vaddr()) {
+        (*null_seg)->setOffset(0x0);
+        (*null_seg)->setVaddr(addr);
+        (*null_seg)->setPaddr(addr);
+        (*null_seg)->setFilesz(size);
+        (*null_seg)->setMemsz(size);
+      } else {
+        // erase the non valid segment contains NULL.
+        elfSegmentTable().erase(null_seg);
+      }
+    }
+  }
+
+  // set up PT_PHDR
+  ELFSegmentFactory::iterator phdr =
+    elfSegmentTable().find(llvm::ELF::PT_PHDR, llvm::ELF::PF_R, 0x0);
+
+  if (phdr != elfSegmentTable().end()) {
+    ELFSegmentFactory::iterator null_seg =
+      elfSegmentTable().find(llvm::ELF::PT_LOAD, null_sect);
+    if (null_seg != elfSegmentTable().end()) {
+      uint64_t offset = 0x0, phdr_size = 0x0;
       if (config().targets().is32Bits()) {
         offset = sizeof(llvm::ELF::Elf32_Ehdr);
         phdr_size = sizeof(llvm::ELF::Elf32_Phdr);
-      }
-      else {
+      } else {
         offset = sizeof(llvm::ELF::Elf64_Ehdr);
         phdr_size = sizeof(llvm::ELF::Elf64_Phdr);
       }
-      segment.setOffset(offset);
-      segment.setVaddr(seg_start_addr + offset);
-      segment.setPaddr(segment.vaddr());
-      segment.setFilesz(numOfSegments() * phdr_size);
-      segment.setMemsz(numOfSegments() * phdr_size);
-      segment.setAlign(config().targets().bitclass() / 8);
-      continue;
+      (*phdr)->setOffset(offset);
+      (*phdr)->setVaddr((*null_seg)->vaddr() + offset);
+      (*phdr)->setPaddr((*phdr)->vaddr());
+      (*phdr)->setFilesz(elfSegmentTable().size() * phdr_size);
+      (*phdr)->setMemsz(elfSegmentTable().size() * phdr_size);
+      (*phdr)->setAlign(config().targets().bitclass() / 8);
+    } else {
+      elfSegmentTable().erase(phdr);
     }
-
-    // bypass if there is no section in this segment (e.g., PT_GNU_STACK)
-    if (segment.numOfSections() == 0)
-      continue;
-
-    segment.setOffset(segment.front()->offset());
-    if (llvm::ELF::PT_LOAD == segment.type() &&
-        LDFileFormat::Null == segment.front()->kind())
-      segment.setVaddr(seg_start_addr);
-    else
-      segment.setVaddr(segment.front()->addr());
-    segment.setPaddr(segment.vaddr());
-
-    const LDSection* last_sect = segment.back();
-    assert(NULL != last_sect);
-    uint64_t file_size = last_sect->offset() - segment.offset();
-    if (LDFileFormat::BSS != last_sect->kind())
-      file_size += last_sect->size();
-    segment.setFilesz(file_size);
-
-    segment.setMemsz(last_sect->addr() - segment.vaddr() + last_sect->size());
   }
 }
 
+/// getSegmentFlag - give a section flag and return the corresponding segment
+/// flag
+uint32_t GNULDBackend::getSegmentFlag(const uint32_t pSectionFlag)
+{
+  uint32_t flag = 0x0;
+  if ((pSectionFlag & llvm::ELF::SHF_ALLOC) != 0x0)
+    flag |= llvm::ELF::PF_R;
+  if ((pSectionFlag & llvm::ELF::SHF_WRITE) != 0x0)
+    flag |= llvm::ELF::PF_W;
+  if ((pSectionFlag & llvm::ELF::SHF_EXECINSTR) != 0x0)
+    flag |= llvm::ELF::PF_X;
+  return flag;
+}
+
 /// setupGNUStackInfo - setup the section flag of .note.GNU-stack in output
 /// @ref gold linker: layout.cc:2608
 void GNULDBackend::setupGNUStackInfo(Module& pModule)
@@ -1910,203 +2167,249 @@
   }
 }
 
-/// setupRelro - setup the offset constraint of PT_RELRO
-void GNULDBackend::setupRelro(Module& pModule)
+/// setOutputSectionOffset - helper function to set output sections' offset.
+void GNULDBackend::setOutputSectionOffset(Module& pModule)
 {
-  assert(config().options().hasRelro());
-  // if -z relro is given, we need to adjust sections' offset again, and let
-  // PT_GNU_RELRO end on a common page boundary
-
-  Module::iterator sect = pModule.begin();
-  for (Module::iterator sect_end = pModule.end(); sect != sect_end; ++sect) {
-    // find the first non-relro section
-    if (getSectionOrder(**sect) > SHO_RELRO_LAST)
-      break;
-  }
-
-  // align the first non-relro section to page boundary
-  uint64_t offset = (*sect)->offset();
-  alignAddress(offset, commonPageSize());
-  (*sect)->setOffset(offset);
-
-  // It seems that compiler think .got and .got.plt are continuous (w/o any
-  // padding between). If .got is the last section in PT_RELRO and it's not
-  // continuous to its next section (i.e. .got.plt), we need to add padding
-  // in front of .got instead.
-  // FIXME: Maybe we can handle this in a more general way.
-  LDSection& got = getOutputFormat()->getGOT();
-  if ((getSectionOrder(got) == SHO_RELRO_LAST) &&
-      (got.offset() + got.size() != offset)) {
-    got.setOffset(offset - got.size());
-  }
-
-  // set up remaining section's offset
-  setOutputSectionOffset(pModule, ++sect, pModule.end());
-}
-
-/// setOutputSectionOffset - helper function to set a group of output sections'
-/// offset, and set pSectBegin to pStartOffset if pStartOffset is not -1U.
-void GNULDBackend::setOutputSectionOffset(Module& pModule,
-                                          Module::iterator pSectBegin,
-                                          Module::iterator pSectEnd,
-                                          uint64_t pStartOffset)
-{
-  if (pSectBegin == pModule.end())
-    return;
-
-  assert(pSectEnd == pModule.end() ||
-         (pSectEnd != pModule.end() &&
-          (*pSectBegin)->index() <= (*pSectEnd)->index()));
-
-  if (pStartOffset != -1U) {
-    (*pSectBegin)->setOffset(pStartOffset);
-    ++pSectBegin;
-  }
-
-  // set up the "cur" and "prev" iterator
-  Module::iterator cur = pSectBegin;
-  Module::iterator prev = pSectBegin;
-  if (cur != pModule.begin())
-    --prev;
-  else
-    ++cur;
-
-  for (; cur != pSectEnd; ++cur, ++prev) {
-    uint64_t offset = 0x0;
-    switch ((*prev)->kind()) {
-      case LDFileFormat::Null:
-        offset = sectionStartOffset();
-        break;
-      case LDFileFormat::BSS:
-        offset = (*prev)->offset();
-        break;
-      default:
-        offset = (*prev)->offset() + (*prev)->size();
-        break;
-    }
-
-    alignAddress(offset, (*cur)->align());
-    (*cur)->setOffset(offset);
-  }
-}
-
-/// setOutputSectionOffset - helper function to set output sections' address
-void GNULDBackend::setOutputSectionAddress(Module& pModule,
-                                           Module::iterator pSectBegin,
-                                           Module::iterator pSectEnd)
-{
-  if (pSectBegin == pModule.end())
-    return;
-
-  assert(pSectEnd == pModule.end() ||
-         (pSectEnd != pModule.end() &&
-          (*pSectBegin)->index() <= (*pSectEnd)->index()));
-
-  const LinkerScript& script = pModule.getScript();
-  uint64_t seg_start_addr = getSegmentStartAddr(script);
-  for (ELFSegmentFactory::iterator seg = elfSegmentTable().begin(),
-         segEnd = elfSegmentTable().end(), prev = elfSegmentTable().end();
-       seg != segEnd; prev = seg, ++seg) {
-    if (llvm::ELF::PT_LOAD != (*seg).type())
+  LinkerScript& script = pModule.getScript();
+  uint64_t offset = 0x0;
+  LDSection* cur = NULL;
+  LDSection* prev = NULL;
+  SectionMap::iterator out, outBegin, outEnd;
+  outBegin = script.sectionMap().begin();
+  outEnd = script.sectionMap().end();
+  for (out = outBegin; out != outEnd; ++out, prev = cur) {
+    cur = (*out)->getSection();
+    if (cur->kind() == LDFileFormat::Null) {
+      cur->setOffset(0x0);
       continue;
+    }
 
-    uint64_t start_addr = 0x0;
-    LinkerScript::AddressMap::const_iterator mapping;
-    if ((*seg).front()->kind() == LDFileFormat::Null)
-      mapping = script.addressMap().find(".text");
-    else if ((*seg).isDataSegment())
-      mapping = script.addressMap().find(".data");
-    else if ((*seg).isBssSegment())
-      mapping = script.addressMap().find(".bss");
-    else
-      mapping = script.addressMap().find((*seg).front()->name());
+    switch (prev->kind()) {
+    case LDFileFormat::Null:
+      offset = sectionStartOffset();
+      break;
+    case LDFileFormat::BSS:
+      offset = prev->offset();
+      break;
+    default:
+      offset = prev->offset() + prev->size();
+      break;
+    }
+    alignAddress(offset, cur->align());
+    cur->setOffset(offset);
+  }
+}
 
-    if (mapping != script.addressMap().end()) {
+/// setOutputSectionAddress - helper function to set output sections' address.
+void GNULDBackend::setOutputSectionAddress(Module& pModule)
+{
+  RpnEvaluator evaluator(pModule, *this);
+  LinkerScript& script = pModule.getScript();
+  uint64_t vma = 0x0, offset = 0x0;
+  LDSection* cur = NULL;
+  LDSection* prev = NULL;
+  LinkerScript::AddressMap::iterator addr, addrEnd = script.addressMap().end();
+  ELFSegmentFactory::iterator seg, segEnd = elfSegmentTable().end();
+  SectionMap::Output::dot_iterator dot;
+  SectionMap::iterator out, outBegin, outEnd;
+  outBegin = script.sectionMap().begin();
+  outEnd = script.sectionMap().end();
+  for (out = outBegin; out != outEnd; prev = cur, ++out) {
+    cur = (*out)->getSection();
+
+    if (cur->kind() == LDFileFormat::Null) {
+      cur->setOffset(0x0);
+      continue;
+    }
+
+    // process dot assignments between 2 output sections
+    for (SectionMap::Output::dot_iterator it = (*out)->dot_begin(),
+      ie = (*out)->dot_end(); it != ie; ++it) {
+      (*it).assign(evaluator);
+    }
+
+    seg = elfSegmentTable().find(llvm::ELF::PT_LOAD, cur);
+    if (seg != segEnd && cur == (*seg)->front()) {
+      if ((*seg)->isBssSegment())
+        addr = script.addressMap().find(".bss");
+      else if ((*seg)->isDataSegment())
+        addr = script.addressMap().find(".data");
+      else
+        addr = script.addressMap().find(cur->name());
+    } else
+      addr = addrEnd;
+
+    if (addr != addrEnd) {
       // use address mapping in script options
-      start_addr = mapping.getEntry()->value();
-    }
-    else {
-      if ((*seg).front()->kind() == LDFileFormat::Null) {
-        // 1st PT_LOAD
-        start_addr = seg_start_addr;
+      vma = addr.getEntry()->value();
+    } else if ((*out)->prolog().hasVMA()) {
+      // use address from output section description
+      evaluator.eval((*out)->prolog().vma(), vma);
+    } else if ((dot = (*out)->find_last_explicit_dot()) != (*out)->dot_end()) {
+      // assign address based on `.' symbol in ldscript
+      vma = (*dot).symbol().value();
+      alignAddress(vma, cur->align());
+    } else {
+      if ((*out)->prolog().type() == OutputSectDesc::NOLOAD) {
+        vma = prev->addr() + prev->size();
+      } else if ((cur->flag() & llvm::ELF::SHF_ALLOC) != 0) {
+        if (prev->kind() == LDFileFormat::Null) {
+          // Let SECTIONS starts at 0 if we have a default ldscript but don't
+          // have any initial value (VMA or `.').
+          if (!config().options().getScriptList().empty())
+            vma = 0x0;
+          else
+            vma = getSegmentStartAddr(script) + sectionStartOffset();
+        } else {
+          if ((prev->kind() == LDFileFormat::BSS))
+            vma = prev->addr();
+          else
+            vma = prev->addr() + prev->size();
+        }
+        alignAddress(vma, cur->align());
+        if (config().options().getScriptList().empty()) {
+          if (seg != segEnd && cur == (*seg)->front()) {
+            // 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());
+          }
+        }
+      } else {
+        vma = 0x0;
       }
-      else if ((*prev).front()->kind() == LDFileFormat::Null) {
-        // prev segment is 1st PT_LOAD
-        start_addr = seg_start_addr + (*seg).front()->offset();
-      }
-      else {
-        // Others
-        start_addr = (*prev).front()->addr() + (*seg).front()->offset();
-      }
-      // 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(start_addr, (*seg).align());
     }
 
+    if (config().options().hasRelro()) {
+      // if -z relro is given, we need to adjust sections' offset again, and
+      // let PT_GNU_RELRO end on a abi page boundary
+
+      // check if current is the first non-relro section
+      SectionMap::iterator relro_last = out - 1;
+      if (relro_last != outEnd &&
+          (*relro_last)->order() <= SHO_RELRO_LAST &&
+          (*out)->order() > SHO_RELRO_LAST) {
+        // align the first non-relro section to page boundary
+        alignAddress(vma, abiPageSize());
+
+        // It seems that compiler think .got and .got.plt are continuous (w/o
+        // any padding between). If .got is the last section in PT_RELRO and
+        // it's not continuous to its next section (i.e. .got.plt), we need to
+        // add padding in front of .got instead.
+        // FIXME: Maybe we can handle this in a more general way.
+        LDSection& got = getOutputFormat()->getGOT();
+        if ((getSectionOrder(got) == SHO_RELRO_LAST) &&
+            (got.addr() + got.size() < vma)) {
+          uint64_t diff = vma - got.addr() - got.size();
+          got.setAddr(vma - got.size());
+          got.setOffset(got.offset() + diff);
+        }
+      }
+    } // end of if - for relro processing
+
+    cur->setAddr(vma);
+
+    switch (prev->kind()) {
+    case LDFileFormat::Null:
+      offset = sectionStartOffset();
+      break;
+    case LDFileFormat::BSS:
+      offset = prev->offset();
+      break;
+    default:
+      offset = prev->offset() + prev->size();
+      break;
+    }
+    alignAddress(offset, cur->align());
     // in p75, http://www.sco.com/developers/devspecs/gabi41.pdf
     // p_align: As "Program Loading" describes in this chapter of the
     // processor supplement, loadable process segments must have congruent
     // values for p_vaddr and p_offset, modulo the page size.
-    if ((start_addr & ((*seg).align() - 1)) !=
-        ((*seg).front()->offset() & ((*seg).align() - 1))) {
-      uint64_t padding = (*seg).align() +
-                         (start_addr & ((*seg).align() - 1)) -
-                         ((*seg).front()->offset() & ((*seg).align() - 1));
-      setOutputSectionOffset(pModule,
-                             pModule.begin() + (*seg).front()->index(),
-                             pModule.end(),
-                             (*seg).front()->offset() + padding);
-      if (config().options().hasRelro())
-        setupRelro(pModule);
+    // FIXME: Now make all sh_addr and sh_offset are congruent, modulo the page
+    // size. Otherwise, old objcopy (e.g., binutils 2.17) may fail with our
+    // output!
+    if ((cur->flag() & llvm::ELF::SHF_ALLOC) != 0 &&
+        (vma & (abiPageSize() - 1)) != (offset & (abiPageSize() - 1))) {
+      uint64_t padding = abiPageSize() +
+                         (vma & (abiPageSize() - 1)) -
+                         (offset & (abiPageSize() - 1));
+      offset += padding;
     }
 
-    for (ELFSegment::sect_iterator sect = (*seg).begin(),
-           sectEnd = (*seg).end(); sect != sectEnd; ++sect) {
-      if ((*sect)->index() < (*pSectBegin)->index())
-        continue;
+    cur->setOffset(offset);
 
-      if (LDFileFormat::Null == (*sect)->kind())
-        continue;
+    // process dot assignments in the output section
+    bool changed = false;
+    Fragment* invalid = NULL;
+    for (SectionMap::Output::iterator in = (*out)->begin(),
+      inEnd = (*out)->end(); in != inEnd; ++in) {
 
-      if (sect == pSectEnd)
-        return;
+      if (invalid != NULL && !(*in)->dotAssignments().empty()) {
+        while (invalid != (*in)->dotAssignments().front().first) {
+          Fragment* prev = invalid->getPrevNode();
+          invalid->setOffset(prev->getOffset() + prev->size());
+          invalid = invalid->getNextNode();
+        }
+        invalid = NULL;
+      }
 
-      if (sect != (*seg).begin())
-        (*sect)->setAddr(start_addr + (*sect)->offset() -
-                         (*seg).front()->offset());
-      else
-        (*sect)->setAddr(start_addr);
+      for (SectionMap::Input::dot_iterator it = (*in)->dot_begin(),
+        ie = (*in)->dot_end(); it != ie; ++it) {
+        (*it).second.assign(evaluator);
+        if ((*it).first != NULL) {
+          uint64_t new_offset = (*it).second.symbol().value() - vma;
+          if (new_offset != (*it).first->getOffset()) {
+            (*it).first->setOffset(new_offset);
+            invalid = (*it).first->getNextNode();
+            changed = true;
+          }
+        }
+      } // for each dot assignment
+    } // for each input description
+
+    if (changed) {
+      while (invalid != NULL) {
+        Fragment* prev = invalid->getPrevNode();
+        invalid->setOffset(prev->getOffset() + prev->size());
+        invalid = invalid->getNextNode();
+      }
+
+      cur->setSize(cur->getSectionData()->back().getOffset() +
+                   cur->getSectionData()->back().size());
     }
-  }
+
+  } // for each output section description
 }
 
-/// layout - layout method
-void GNULDBackend::layout(Module& pModule)
+/// placeOutputSections - place output sections based on SectionMap
+void GNULDBackend::placeOutputSections(Module& pModule)
 {
-  std::vector<SHOEntry> output_list;
-  // 1. determine what sections will go into final output, and push the needed
-  // sections into output_list for later processing
+  typedef std::vector<LDSection*> Orphans;
+  Orphans orphans;
+  SectionMap& sectionMap = pModule.getScript().sectionMap();
+
   for (Module::iterator it = pModule.begin(), ie = pModule.end(); it != ie;
-       ++it) {
+    ++it) {
+    bool wanted = false;
+
     switch ((*it)->kind()) {
     // take NULL and StackNote directly
     case LDFileFormat::Null:
     case LDFileFormat::StackNote:
-      output_list.push_back(std::make_pair(*it, getSectionOrder(**it)));
+      wanted = true;
       break;
     // ignore if section size is 0
     case LDFileFormat::EhFrame:
       if (((*it)->size() != 0) ||
           ((*it)->hasEhFrame() &&
            config().codeGenType() == LinkerConfig::Object))
-        output_list.push_back(std::make_pair(*it, getSectionOrder(**it)));
+        wanted = true;
       break;
     case LDFileFormat::Relocation:
       if (((*it)->size() != 0) ||
           ((*it)->hasRelocData() &&
            config().codeGenType() == LinkerConfig::Object))
-        output_list.push_back(std::make_pair(*it, getSectionOrder(**it)));
+        wanted = true;
       break;
     case LDFileFormat::Regular:
     case LDFileFormat::Target:
@@ -2120,7 +2423,7 @@
       if (((*it)->size() != 0) ||
           ((*it)->hasSectionData() &&
            config().codeGenType() == LinkerConfig::Object))
-        output_list.push_back(std::make_pair(*it, getSectionOrder(**it)));
+        wanted = true;
       break;
     case LDFileFormat::Group:
       if (LinkerConfig::Object == config().codeGenType()) {
@@ -2129,44 +2432,140 @@
       }
       break;
     case LDFileFormat::Version:
-      if (0 != (*it)->size()) {
-        output_list.push_back(std::make_pair(*it, getSectionOrder(**it)));
+      if ((*it)->size() != 0) {
+        wanted = true;
         warning(diag::warn_unsupported_symbolic_versioning) << (*it)->name();
       }
       break;
     default:
-      if (0 != (*it)->size()) {
+      if ((*it)->size() != 0) {
         error(diag::err_unsupported_section) << (*it)->name() << (*it)->kind();
       }
       break;
+    } // end of switch
+
+    if (wanted) {
+      SectionMap::iterator out, outBegin, outEnd;
+      outBegin = sectionMap.begin();
+      outEnd = sectionMap.end();
+      for (out = outBegin; out != outEnd; ++out) {
+        bool matched = false;
+        if ((*it)->name().compare((*out)->name()) == 0) {
+          switch ((*out)->prolog().constraint()) {
+          case OutputSectDesc::NO_CONSTRAINT:
+            matched = true;
+            break;
+          case OutputSectDesc::ONLY_IF_RO:
+            matched = ((*it)->flag() & llvm::ELF::SHF_WRITE) == 0;
+            break;
+          case OutputSectDesc::ONLY_IF_RW:
+            matched = ((*it)->flag() & llvm::ELF::SHF_WRITE) != 0;
+            break;
+          } // end of switch
+
+          if (matched)
+            break;
+        }
+      } // for each output section description
+
+      if (out != outEnd) {
+        // set up the section
+        (*out)->setSection(*it);
+        (*out)->setOrder(getSectionOrder(**it));
+      } else {
+        orphans.push_back(*it);
+      }
     }
-  } // end of for
+  } // for each section in Module
 
-  // 2. sort output section orders
-  std::stable_sort(output_list.begin(), output_list.end(), SHOCompare());
+  // set up sections in SectionMap but do not exist at all.
+  uint32_t flag = 0x0;
+  unsigned int order = SHO_UNDEFINED;
+  OutputSectDesc::Type type = OutputSectDesc::LOAD;
+  for (SectionMap::reverse_iterator out = sectionMap.rbegin(),
+    outEnd = sectionMap.rend(); out != outEnd; ++out) {
+    if ((*out)->hasContent() ||
+        (*out)->getSection()->kind() == LDFileFormat::Null ||
+        (*out)->getSection()->kind() == LDFileFormat::StackNote) {
+      flag = (*out)->getSection()->flag();
+      order = (*out)->order();
+      type = (*out)->prolog().type();
+    } else {
+      (*out)->getSection()->setFlag(flag);
+      (*out)->setOrder(order);
+      (*out)->prolog().setType(type);
+    }
+  } // for each output section description
 
-  // 3. update output sections in Module
-  pModule.getSectionTable().clear();
-  for(size_t index = 0; index < output_list.size(); ++index) {
-    (output_list[index].first)->setIndex(index);
-    pModule.getSectionTable().push_back(output_list[index].first);
+  // place orphan sections
+  for (Orphans::iterator it = orphans.begin(), ie = orphans.end(); it != ie;
+    ++it) {
+    size_t order = getSectionOrder(**it);
+    SectionMap::iterator out, outBegin, outEnd;
+    outBegin = sectionMap.begin();
+    outEnd = sectionMap.end();
+
+    if ((*it)->kind() == LDFileFormat::Null)
+      out = sectionMap.insert(outBegin, *it);
+    else {
+      for (out = outBegin; out != outEnd; ++out) {
+        if ((*out)->order() > order)
+          break;
+      }
+      out = sectionMap.insert(out, *it);
+    }
+    (*out)->setOrder(order);
+  } // for each orphan section
+
+  // sort output section orders if there is no default ldscript
+  if (config().options().getScriptList().empty()) {
+    std::stable_sort(sectionMap.begin(),
+                     sectionMap.end(),
+                     SectionMap::SHOCompare());
   }
 
+  // when section ordering is fixed, now we can make sure dot assignments are
+  // all set appropriately
+  sectionMap.fixupDotSymbols();
+}
+
+/// layout - layout method
+void GNULDBackend::layout(Module& pModule)
+{
+  // 1. place output sections based on SectionMap from SECTIONS command
+  placeOutputSections(pModule);
+
+  // 2. update output sections in Module
+  SectionMap& sectionMap = pModule.getScript().sectionMap();
+  pModule.getSectionTable().clear();
+  for (SectionMap::iterator out = sectionMap.begin(), outEnd = sectionMap.end();
+    out != outEnd; ++out) {
+    if ((*out)->hasContent() ||
+        (*out)->getSection()->kind() == LDFileFormat::Null ||
+        (*out)->getSection()->kind() == LDFileFormat::StackNote ||
+        config().codeGenType() == LinkerConfig::Object) {
+      (*out)->getSection()->setIndex(pModule.size());
+      pModule.getSectionTable().push_back((*out)->getSection());
+    }
+  } // for each output section description
+
+  // 3. update the size of .shstrtab
+  sizeShstrtab(pModule);
+
   // 4. create program headers
   if (LinkerConfig::Object != config().codeGenType()) {
     createProgramHdrs(pModule);
   }
 
-  // 5. set output section offset
-  setOutputSectionOffset(pModule, pModule.begin(), pModule.end(), 0x0);
+  // 5. set output section address/offset
+  if (LinkerConfig::Object != config().codeGenType())
+    setOutputSectionAddress(pModule);
+  else
+    setOutputSectionOffset(pModule);
 }
 
-/// preLayout - Backend can do any needed modification before layout
-void GNULDBackend::preLayout(Module& pModule, IRBuilder& pBuilder)
+void GNULDBackend::createAndSizeEhFrameHdr(Module& pModule)
 {
-  // prelayout target first
-  doPreLayout(pBuilder);
-
   if (LinkerConfig::Object != config().codeGenType() &&
       config().options().hasEhFrameHdr() && getOutputFormat()->hasEhFrame()) {
     // init EhFrameHdr and size the output section
@@ -2175,6 +2574,13 @@
                                    format->getEhFrame());
     m_pEhFrameHdr->sizeOutput();
   }
+}
+
+/// preLayout - Backend can do any needed modification before layout
+void GNULDBackend::preLayout(Module& pModule, IRBuilder& pBuilder)
+{
+  // prelayout target first
+  doPreLayout(pBuilder);
 
   // change .tbss and .tdata section symbol from Local to LocalDyn category
   if (NULL != f_pTDATA)
@@ -2248,28 +2654,17 @@
 /// postLayout - Backend can do any needed modification after layout
 void GNULDBackend::postLayout(Module& pModule, IRBuilder& pBuilder)
 {
-  // 1. set up section address and segment attributes
   if (LinkerConfig::Object != config().codeGenType()) {
-    if (config().options().hasRelro()) {
-      // 1.1 set up the offset constraint of PT_RELRO
-      setupRelro(pModule);
-    }
-
-    // 1.2 set up the output sections' address
-    setOutputSectionAddress(pModule, pModule.begin(), pModule.end());
-
-    // 1.3 do relaxation
+    // do relaxation
     relax(pModule, pBuilder);
-
-    // 1.4 set up the attributes of program headers
+    // set up the attributes of program headers
     setupProgramHdrs(pModule.getScript());
   }
 
-  // 2. target specific post layout
   doPostLayout(pModule, pBuilder);
 }
 
-void GNULDBackend::postProcessing(MemoryArea& pOutput)
+void GNULDBackend::postProcessing(FileOutputBuffer& pOutput)
 {
   if (LinkerConfig::Object != config().codeGenType() &&
       config().options().hasEhFrameHdr() && getOutputFormat()->hasEhFrame()) {
@@ -2327,7 +2722,7 @@
 
 /// isDynamicSymbol
 /// @ref Google gold linker: symtab.cc:311
-bool GNULDBackend::isDynamicSymbol(const LDSymbol& pSymbol)
+bool GNULDBackend::isDynamicSymbol(const LDSymbol& pSymbol) const
 {
   // If a local symbol is in the LDContext's symbol table, it's a real local
   // symbol. We should not add it
@@ -2348,7 +2743,7 @@
 
 /// isDynamicSymbol
 /// @ref Google gold linker: symtab.cc:311
-bool GNULDBackend::isDynamicSymbol(const ResolveInfo& pResolveInfo)
+bool GNULDBackend::isDynamicSymbol(const ResolveInfo& pResolveInfo) const
 {
   // If a local symbol is in the LDContext's symbol table, it's a real local
   // symbol. We should not add it
@@ -2367,6 +2762,20 @@
   return false;
 }
 
+/// elfSegmentTable - return the reference of the elf segment table
+ELFSegmentFactory& GNULDBackend::elfSegmentTable()
+{
+  assert(m_pELFSegmentTable != NULL && "Do not create ELFSegmentTable!");
+  return *m_pELFSegmentTable;
+}
+
+/// elfSegmentTable - return the reference of the elf segment table
+const ELFSegmentFactory& GNULDBackend::elfSegmentTable() const
+{
+  assert(m_pELFSegmentTable != NULL && "Do not create ELFSegmentTable!");
+  return *m_pELFSegmentTable;
+}
+
 /// commonPageSize - the common page size of the target machine.
 /// @ref gold linker: target.h:135
 uint64_t GNULDBackend::commonPageSize() const
@@ -2553,6 +2962,14 @@
   return *f_pTBSS;
 }
 
+llvm::StringRef GNULDBackend::getEntry(const Module& pModule) const
+{
+  if (pModule.getScript().hasEntry())
+    return pModule.getScript().entry();
+  else
+    return getInfo().entry();
+}
+
 void GNULDBackend::checkAndSetHasTextRel(const LDSection& pSection)
 {
   if (m_bHasTextRel)
@@ -2567,6 +2984,28 @@
   return;
 }
 
+/// sortRelocation - sort the dynamic relocations to let dynamic linker
+/// process relocations more efficiently
+void GNULDBackend::sortRelocation(LDSection& pSection)
+{
+  if (!config().options().hasCombReloc())
+    return;
+
+  assert(pSection.kind() == LDFileFormat::Relocation);
+
+  switch (config().codeGenType()) {
+  case LinkerConfig::DynObj:
+  case LinkerConfig::Exec:
+    if (&pSection == &getOutputFormat()->getRelDyn() ||
+        &pSection == &getOutputFormat()->getRelaDyn()) {
+      if (pSection.hasRelocData())
+        pSection.getRelocData()->sort(RelocCompare(*this));
+    }
+  default:
+    return;
+  }
+}
+
 /// initBRIslandFactory - initialize the branch island factory for relaxation
 bool GNULDBackend::initBRIslandFactory()
 {
@@ -2590,21 +3029,12 @@
   if (!mayRelax())
     return true;
 
+  getBRIslandFactory()->group(pModule);
+
   bool finished = true;
   do {
     if (doRelax(pModule, pBuilder, finished)) {
-      // If the sections (e.g., .text) are relaxed, the layout is also changed
-      // We need to do the following:
-
-      // 1. set up the offset
-      setOutputSectionOffset(pModule, pModule.begin(), pModule.end());
-
-      // 2. set up the offset constraint of PT_RELRO
-      if (config().options().hasRelro())
-        setupRelro(pModule);
-
-      // 3. set up the output sections' address
-      setOutputSectionAddress(pModule, pModule.begin(), pModule.end());
+      setOutputSectionAddress(pModule);
     }
   } while (!finished);
 
@@ -2625,3 +3055,42 @@
   return !needGNUHash(*X) && needGNUHash(*Y);
 }
 
+bool GNULDBackend::RelocCompare::operator()(const Relocation* X,
+                                            const Relocation* Y) const
+{
+  // 1. compare if relocation is relative
+  if (X->symInfo() == NULL) {
+    if (Y->symInfo() != NULL)
+      return true;
+  } else if (Y->symInfo() == NULL) {
+    return false;
+  } else {
+    // 2. compare the symbol index
+    size_t symIdxX = m_Backend.getSymbolIdx(X->symInfo()->outSymbol());
+    size_t symIdxY = m_Backend.getSymbolIdx(Y->symInfo()->outSymbol());
+    if (symIdxX < symIdxY)
+      return true;
+    if (symIdxX > symIdxY)
+      return false;
+  }
+
+  // 3. compare the relocation address
+  if (X->place() < Y->place())
+    return true;
+  if (X->place() > Y->place())
+    return false;
+
+  // 4. compare the relocation type
+  if (X->type() < Y->type())
+    return true;
+  if (X->type() > Y->type())
+    return false;
+
+  // 5. compare the addend
+  if (X->addend() < Y->addend())
+    return true;
+  if (X->addend() > Y->addend())
+    return false;
+
+  return false;
+}
diff --git a/lib/Target/Hexagon/Hexagon.h b/lib/Target/Hexagon/Hexagon.h
index 5a286ef..731a878 100644
--- a/lib/Target/Hexagon/Hexagon.h
+++ b/lib/Target/Hexagon/Hexagon.h
@@ -6,19 +6,17 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_HEXAGON_H
-#define MCLD_HEXAGON_H
+#ifndef MCLD_TARGET_HEXAGON_H
+#define MCLD_TARGET_HEXAGON_H
 #include <string>
-#include <mcld/Target/TargetMachine.h>
 
 namespace llvm {
-
 class Target;
-
 } // namespace of llvm
 
 namespace mcld {
 
+class Target;
 class TargetLDBackend;
 
 extern mcld::Target TheHexagonTarget;
diff --git a/lib/Target/Hexagon/HexagonDiagnostic.cpp b/lib/Target/Hexagon/HexagonDiagnostic.cpp
index 01b8f9b..7fd58c0 100644
--- a/lib/Target/Hexagon/HexagonDiagnostic.cpp
+++ b/lib/Target/Hexagon/HexagonDiagnostic.cpp
@@ -6,18 +6,16 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <llvm/ADT/Triple.h>
 #include <mcld/Support/TargetRegistry.h>
 #include <mcld/LD/DWARFLineInfo.h>
 #include "Hexagon.h"
 
-using namespace mcld;
-
 namespace mcld {
 
+//===----------------------------------------------------------------------===//
 // createHexagonDiagnostic - the help function to create corresponding
 // HexagonDiagnostic
-//
+//===----------------------------------------------------------------------===//
 DiagnosticLineInfo*
 createHexagonDiagLineInfo(const Target& pTarget, const std::string &pTriple)
 {
@@ -26,6 +24,8 @@
 
 } // namespace of mcld
 
+using namespace mcld;
+
 //===----------------------------------------------------------------------===//
 // InitializeHexagonDiagnostic
 //===----------------------------------------------------------------------===//
diff --git a/lib/Target/Hexagon/HexagonELFMCLinker.cpp b/lib/Target/Hexagon/HexagonELFMCLinker.cpp
index 6cc4a01..bf5f7d7 100644
--- a/lib/Target/Hexagon/HexagonELFMCLinker.cpp
+++ b/lib/Target/Hexagon/HexagonELFMCLinker.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 #include "HexagonELFMCLinker.h"
-#include <mcld/LinkerConfig.h>
 
 using namespace mcld;
 
 HexagonELFMCLinker::HexagonELFMCLinker(LinkerConfig& pConfig,
                                        mcld::Module& pModule,
-                                       MemoryArea& pOutput)
-  : ELFMCLinker(pConfig, pModule, pOutput) {
+                                       FileHandle& pFileHandle)
+  : ELFMCLinker(pConfig, pModule, pFileHandle) {
 }
 
 HexagonELFMCLinker::~HexagonELFMCLinker()
diff --git a/lib/Target/Hexagon/HexagonELFMCLinker.h b/lib/Target/Hexagon/HexagonELFMCLinker.h
index c588ddf..6bbfe26 100644
--- a/lib/Target/Hexagon/HexagonELFMCLinker.h
+++ b/lib/Target/Hexagon/HexagonELFMCLinker.h
@@ -16,7 +16,7 @@
 namespace mcld {
 
 class Module;
-class MemoryArea;
+class FileHandle;
 
 /** \class HexagonELFMCLinker
  *  \brief HexagonELFMCLinker sets up the environment for linking.
@@ -28,7 +28,7 @@
 public:
   HexagonELFMCLinker(LinkerConfig& pConfig,
                      mcld::Module& pModule,
-                     MemoryArea& pOutput);
+                     FileHandle& pFileHandle);
 
   ~HexagonELFMCLinker();
 };
diff --git a/lib/Target/Hexagon/HexagonGOT.cpp b/lib/Target/Hexagon/HexagonGOT.cpp
index 551b40f..637b078 100644
--- a/lib/Target/Hexagon/HexagonGOT.cpp
+++ b/lib/Target/Hexagon/HexagonGOT.cpp
@@ -27,22 +27,8 @@
 {
 }
 
-void HexagonGOT::reserve(size_t pNum)
+HexagonGOTEntry* HexagonGOT::create()
 {
-  for (size_t i = 0; i < pNum; i++) {
-    new HexagonGOTEntry(0, m_SectionData);
-  }
-}
-
-HexagonGOTEntry* HexagonGOT::consume()
-{
-  if (NULL == m_pLast) {
-    assert(!empty() && "Consume empty GOT entry!");
-    m_pLast = llvm::cast<HexagonGOTEntry>(&m_SectionData->front());
-    return m_pLast;
-  }
-
-  m_pLast = llvm::cast<HexagonGOTEntry>(m_pLast->getNextNode());
-  return m_pLast;
+  return new HexagonGOTEntry(0, m_SectionData);
 }
 
diff --git a/lib/Target/Hexagon/HexagonGOT.h b/lib/Target/Hexagon/HexagonGOT.h
index 4f9120c..c29239c 100644
--- a/lib/Target/Hexagon/HexagonGOT.h
+++ b/lib/Target/Hexagon/HexagonGOT.h
@@ -41,9 +41,7 @@
 
   ~HexagonGOT();
 
-  void reserve(size_t pNum = 1);
-
-  HexagonGOTEntry* consume();
+  HexagonGOTEntry* create();
 
 private:
   HexagonGOTEntry* m_pLast; ///< the last consumed entry
diff --git a/lib/Target/Hexagon/HexagonGOTPLT.cpp b/lib/Target/Hexagon/HexagonGOTPLT.cpp
index fee852f..cfceff5 100644
--- a/lib/Target/Hexagon/HexagonGOTPLT.cpp
+++ b/lib/Target/Hexagon/HexagonGOTPLT.cpp
@@ -23,12 +23,9 @@
 HexagonGOTPLT::HexagonGOTPLT(LDSection& pSection)
   : HexagonGOT(pSection)
 {
-  // Create GOT0 entries
-  reserve(HexagonGOTPLT0Num);
-
   // Skip GOT0 entries
   for (size_t i = 0; i < HexagonGOTPLT0Num; ++i) {
-    consume();
+    create();
   }
   pSection.setAlign(8);
 }
diff --git a/lib/Target/Hexagon/HexagonGOTPLT.h b/lib/Target/Hexagon/HexagonGOTPLT.h
index ad49992..9fc67cd 100644
--- a/lib/Target/Hexagon/HexagonGOTPLT.h
+++ b/lib/Target/Hexagon/HexagonGOTPLT.h
@@ -14,7 +14,6 @@
 
 #include <llvm/ADT/DenseMap.h>
 #include "HexagonGOT.h"
-#include <mcld/Support/MemoryRegion.h>
 
 namespace mcld {
 
diff --git a/lib/Target/Hexagon/HexagonLDBackend.cpp b/lib/Target/Hexagon/HexagonLDBackend.cpp
index fcf7fb3..5265c4b 100644
--- a/lib/Target/Hexagon/HexagonLDBackend.cpp
+++ b/lib/Target/Hexagon/HexagonLDBackend.cpp
@@ -21,7 +21,6 @@
 #include <mcld/Fragment/AlignFragment.h>
 #include <mcld/Fragment/FillFragment.h>
 #include <mcld/Fragment/RegionFragment.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MemoryArea.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Support/TargetRegistry.h>
@@ -30,7 +29,9 @@
 #include <mcld/LD/BranchIslandFactory.h>
 #include <mcld/LD/StubFactory.h>
 #include <mcld/LD/LDContext.h>
-
+#include <mcld/LD/ELFFileFormat.h>
+#include <mcld/LD/ELFSegmentFactory.h>
+#include <mcld/LD/ELFSegment.h>
 
 #include <cstring>
 
@@ -132,7 +133,7 @@
 }
 
 uint64_t HexagonLDBackend::emitSectionData(const LDSection& pSection,
-                                          MemoryRegion& pRegion) const
+                                           MemoryRegion& pRegion) const
 {
   if (!pRegion.size())
     return 0;
@@ -143,10 +144,9 @@
 
   if ((LinkerConfig::Object != config().codeGenType()) &&
       (!config().isCodeStatic())) {
-    if (&pSection == &(FileFormat->getPLT())) {
-      assert(m_pPLT && "emitSectionData failed, m_pPLT is NULL!");
+    if (FileFormat->hasPLT() && (&pSection == &(FileFormat->getPLT()))) {
 
-      unsigned char* buffer = pRegion.getBuffer();
+      unsigned char* buffer = pRegion.begin();
 
       m_pPLT->applyPLT0();
       m_pPLT->applyPLT1();
@@ -168,11 +168,12 @@
       }
       return RegionSize;
     }
-    else if (&pSection == &(FileFormat->getGOT())) {
+    else if (FileFormat->hasGOT() && (&pSection == &(FileFormat->getGOT()))) {
       RegionSize += emitGOTSectionData(pRegion);
       return RegionSize;
     }
-    else if (&pSection == &(FileFormat->getGOTPLT())) {
+    else if (FileFormat->hasGOTPLT() &&
+             (&pSection == &(FileFormat->getGOTPLT()))) {
       RegionSize += emitGOTPLTSectionData(pRegion, FileFormat);
       return RegionSize;
     }
@@ -180,7 +181,7 @@
 
   const SectionData* sect_data = pSection.getSectionData();
   SectionData::const_iterator frag_iter, frag_end = sect_data->end();
-  uint8_t* out_offset = pRegion.start();
+  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()) {
@@ -197,7 +198,7 @@
       case Fragment::Region: {
         const RegionFragment& region_frag =
           llvm::cast<RegionFragment>(*frag_iter);
-        const uint8_t* start = region_frag.getRegion().start();
+        const char* start = region_frag.getRegion().begin();
         memcpy(out_offset, start, size);
         break;
       }
@@ -318,11 +319,12 @@
     m_pGOT->finalizeSectionSize();
 }
 
-uint64_t HexagonLDBackend::emitGOTSectionData(MemoryRegion& pRegion) const
+uint64_t
+HexagonLDBackend::emitGOTSectionData(MemoryRegion& pRegion) const
 {
   assert(m_pGOT && "emitGOTSectionData failed, m_pGOT is NULL!");
 
-  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
+  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
 
   HexagonGOTEntry* got = 0;
   unsigned int EntrySize = HexagonGOTEntry::EntrySize;
@@ -367,13 +369,13 @@
 }
 
 uint64_t HexagonLDBackend::emitGOTPLTSectionData(MemoryRegion& pRegion,
-                                         const ELFFileFormat* FileFormat) const
+    const ELFFileFormat* FileFormat) const
 {
   assert(m_pGOTPLT && "emitGOTPLTSectionData failed, m_pGOTPLT is NULL!");
   m_pGOTPLT->applyGOT0(FileFormat->getDynamic().addr());
   m_pGOTPLT->applyAllGOTPLT(*m_pPLT);
 
-  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
+  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
 
   HexagonGOTEntry* got = 0;
   unsigned int EntrySize = HexagonGOTEntry::EntrySize;
@@ -395,19 +397,19 @@
   const ELFFileFormat* file_format = getOutputFormat();
 
   if (LinkerConfig::Object != config().codeGenType()) {
-    if (&pSectHdr == &file_format->getGOT()) {
+    if (file_format->hasGOT() && (&pSectHdr == &file_format->getGOT())) {
       if (config().options().hasNow())
         return SHO_RELRO;
       return SHO_RELRO_LAST;
     }
 
-    if (&pSectHdr == &file_format->getGOTPLT()) {
+    if (file_format->hasGOTPLT() && (&pSectHdr == &file_format->getGOTPLT())) {
       if (config().options().hasNow())
         return SHO_RELRO;
       return SHO_NON_RELRO_FIRST;
     }
 
-    if (&pSectHdr == &file_format->getPLT())
+    if (file_format->hasPLT() && (&pSectHdr == &file_format->getPLT()))
       return SHO_PLT;
   }
 
@@ -658,33 +660,37 @@
   if (m_psdabase)
     m_psdabase->setValue(m_psdata->addr());
 
-  ELFSegment *edata = m_ELFSegmentTable.find(llvm::ELF::PT_LOAD,
-                                             llvm::ELF::PF_W, llvm::ELF::PF_X);
-  if (NULL != edata) {
+  ELFSegmentFactory::const_iterator edata =
+    elfSegmentTable().find(llvm::ELF::PT_LOAD,
+                           llvm::ELF::PF_W,
+                           llvm::ELF::PF_X);
+  if (elfSegmentTable().end() != edata) {
     if (NULL != f_pEData && ResolveInfo::ThreadLocal != f_pEData->type()) {
-      f_pEData->setValue(edata->vaddr() + edata->filesz());
+      f_pEData->setValue((*edata)->vaddr() + (*edata)->filesz());
     }
     if (NULL != f_p_EData && ResolveInfo::ThreadLocal != f_p_EData->type()) {
-      f_p_EData->setValue(edata->vaddr() + edata->filesz());
+      f_p_EData->setValue((*edata)->vaddr() + (*edata)->filesz());
     }
     if (NULL != f_pBSSStart &&
         ResolveInfo::ThreadLocal != f_pBSSStart->type()) {
-      f_pBSSStart->setValue(edata->vaddr() + edata->filesz());
+      f_pBSSStart->setValue((*edata)->vaddr() + (*edata)->filesz());
     }
     if (NULL != f_pEnd && ResolveInfo::ThreadLocal != f_pEnd->type()) {
-      f_pEnd->setValue(((edata->vaddr() +
-                       edata->memsz()) + 7) & ~7);
+      f_pEnd->setValue((((*edata)->vaddr() +
+                       (*edata)->memsz()) + 7) & ~7);
     }
     if (NULL != f_p_End && ResolveInfo::ThreadLocal != f_p_End->type()) {
-      f_p_End->setValue(((edata->vaddr() +
-                       edata->memsz()) + 7) & ~7);
+      f_p_End->setValue((((*edata)->vaddr() +
+                        (*edata)->memsz()) + 7) & ~7);
     }
   }
   return true;
 }
 
 /// merge Input Sections
-bool HexagonLDBackend::mergeSection(Module& pModule, LDSection& pInputSection)
+bool HexagonLDBackend::mergeSection(Module& pModule,
+                                    const Input& pInputFile,
+                                    LDSection& pInputSection)
 {
   if ((pInputSection.flag() & llvm::ELF::SHF_HEX_GPREL) ||
       (pInputSection.kind() == LDFileFormat::LinkOnce) ||
@@ -699,7 +705,7 @@
   }
   else {
     ObjectBuilder builder(config(), pModule);
-    return builder.MergeSection(pInputSection);
+    builder.MergeSection(pInputFile, pInputSection);
   }
   return true;
 }
@@ -785,7 +791,6 @@
       // description here.
       (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
       Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
-      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
 
       switch((*com_sym)->size())  {
       case 1:
@@ -794,6 +799,7 @@
         ObjectBuilder::AppendFragment(*frag,
                                       *(m_pscommon_1->getSectionData()),
                                       (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
         continue;
       case 2:
         if (maxGPSize <= 1)
@@ -801,6 +807,7 @@
         ObjectBuilder::AppendFragment(*frag,
                                       *(m_pscommon_2->getSectionData()),
                                       (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
         continue;
       case 4:
         if (maxGPSize <= 3)
@@ -808,6 +815,7 @@
         ObjectBuilder::AppendFragment(*frag,
                                       *(m_pscommon_4->getSectionData()),
                                       (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
         continue;
       case 8:
         if (maxGPSize <= 7)
@@ -815,6 +823,7 @@
         ObjectBuilder::AppendFragment(*frag,
                                       *(m_pscommon_8->getSectionData()),
                                       (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
         continue;
       default:
         break;
@@ -825,12 +834,14 @@
         tbss_offset += ObjectBuilder::AppendFragment(*frag,
                                                      *tbss_sect_data,
                                                      (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       }
       // FIXME: how to identify small and large common symbols?
       else {
         bss_offset += ObjectBuilder::AppendFragment(*frag,
                                                     *bss_sect_data,
                                                     (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       }
     }
   }
@@ -845,7 +856,6 @@
     // description here.
     (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
     Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
-    (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
 
     switch((*com_sym)->size())  {
     case 1:
@@ -854,6 +864,7 @@
       ObjectBuilder::AppendFragment(*frag,
                                     *(m_pscommon_1->getSectionData()),
                                     (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       continue;
     case 2:
       if (maxGPSize <= 1)
@@ -861,6 +872,7 @@
       ObjectBuilder::AppendFragment(*frag,
                                     *(m_pscommon_2->getSectionData()),
                                     (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       continue;
     case 4:
       if (maxGPSize <= 3)
@@ -868,6 +880,7 @@
       ObjectBuilder::AppendFragment(*frag,
                                     *(m_pscommon_4->getSectionData()),
                                     (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       continue;
     case 8:
       if (maxGPSize <= 7)
@@ -875,6 +888,7 @@
       ObjectBuilder::AppendFragment(*frag,
                                     *(m_pscommon_8->getSectionData()),
                                     (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       continue;
     default:
       break;
@@ -885,12 +899,14 @@
       tbss_offset += ObjectBuilder::AppendFragment(*frag,
                                                    *tbss_sect_data,
                                                    (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
     }
     // FIXME: how to identify small and large common symbols?
     else {
       bss_offset += ObjectBuilder::AppendFragment(*frag,
                                                   *bss_sect_data,
                                                   (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
     }
   }
 
@@ -954,14 +970,14 @@
     frag = new FillFragment(0x0, 1, size);
   }
   else {
-    MemoryRegion* region = pInput.memArea()->request(offset, size);
-    if (NULL == region) {
+    llvm::StringRef region = pInput.memArea()->request(offset, size);
+    if (region.size() == 0) {
       // If the input section's size is zero, we got a NULL region.
       // use a virtual fill fragment
       frag = new FillFragment(0x0, 0, 0);
     }
     else {
-      frag = new RegionFragment(*region);
+      frag = new RegionFragment(region);
     }
   }
 
@@ -1040,8 +1056,7 @@
 //===----------------------------------------------------------------------===//
 /// createHexagonLDBackend - the help funtion to create corresponding
 /// HexagonLDBackend
-TargetLDBackend* createHexagonLDBackend(const llvm::Target& pTarget,
-                                    const LinkerConfig& pConfig)
+TargetLDBackend* createHexagonLDBackend(const LinkerConfig& pConfig)
 {
   if (pConfig.targets().triple().isOSDarwin()) {
     assert(0 && "MachO linker is not supported yet");
diff --git a/lib/Target/Hexagon/HexagonLDBackend.h b/lib/Target/Hexagon/HexagonLDBackend.h
index 30a9f35..e2bc2bb 100644
--- a/lib/Target/Hexagon/HexagonLDBackend.h
+++ b/lib/Target/Hexagon/HexagonLDBackend.h
@@ -126,7 +126,7 @@
   bool finalizeTargetSymbols();
 
   /// mergeSection - merge target dependent sections
-  bool mergeSection(Module& pModule, LDSection& pSection);
+  bool mergeSection(Module& pModule, const Input& pInput, LDSection& pSection);
 
   /// readSection - read target dependent sections
   bool readSection(Input& pInput, SectionData& pSD);
diff --git a/lib/Target/Hexagon/HexagonMCLinker.cpp b/lib/Target/Hexagon/HexagonMCLinker.cpp
index 4f4f839..770ae94 100644
--- a/lib/Target/Hexagon/HexagonMCLinker.cpp
+++ b/lib/Target/Hexagon/HexagonMCLinker.cpp
@@ -21,9 +21,9 @@
 MCLinker* createHexagonMCLinker(const std::string &pTriple,
                                 LinkerConfig& pConfig,
                                 mcld::Module& pModule,
-                                MemoryArea& pOutput)
+                                FileHandle& pFileHandle)
 {
-  Triple theTriple(pTriple);
+  llvm::Triple theTriple(pTriple);
   if (theTriple.isOSDarwin()) {
     assert(0 && "MachO linker has not supported yet");
     return NULL;
@@ -34,7 +34,7 @@
   }
 
   if (theTriple.isArch32Bit())
-    return new HexagonELFMCLinker(pConfig, pModule, pOutput);
+    return new HexagonELFMCLinker(pConfig, pModule, pFileHandle);
 
   assert(0 && "Hexagon_64 has not supported yet");
   return NULL;
diff --git a/lib/Target/Hexagon/HexagonPLT.cpp b/lib/Target/Hexagon/HexagonPLT.cpp
index ceb8a58..6309408 100644
--- a/lib/Target/Hexagon/HexagonPLT.cpp
+++ b/lib/Target/Hexagon/HexagonPLT.cpp
@@ -49,7 +49,6 @@
   m_PLT0Size = sizeof (hexagon_plt0);
   // create PLT0
   new HexagonPLT0(*m_SectionData);
-  m_Last = m_SectionData->begin();
   pSection.setAlign(16);
 }
 
@@ -98,25 +97,9 @@
   return (m_SectionData->size() > 1);
 }
 
-void HexagonPLT::reserveEntry(size_t pNum)
+HexagonPLT1* HexagonPLT::create()
 {
-  PLTEntryBase* plt1_entry = NULL;
-
-  for (size_t i = 0; i < pNum; ++i) {
-    plt1_entry = new HexagonPLT1(*m_SectionData);
-
-    if (NULL == plt1_entry)
-      fatal(diag::fail_allocate_memory_plt);
-  }
-}
-
-HexagonPLT1* HexagonPLT::consume()
-{
-  ++m_Last;
-  assert(m_Last != m_SectionData->end() &&
-         "The number of PLT Entries and ResolveInfo doesn't match");
-
-  return llvm::cast<HexagonPLT1>(&(*m_Last));
+  return new HexagonPLT1(*m_SectionData);
 }
 
 void HexagonPLT::applyPLT0()
@@ -200,7 +183,7 @@
   uint64_t result = 0x0;
   iterator it = begin();
 
-  unsigned char* buffer = pRegion.getBuffer();
+  unsigned char* buffer = pRegion.begin();
   memcpy(buffer, llvm::cast<HexagonPLT0>((*it)).getValue(), HexagonPLT0::EntrySize);
   result += HexagonPLT0::EntrySize;
   ++it;
diff --git a/lib/Target/Hexagon/HexagonPLT.h b/lib/Target/Hexagon/HexagonPLT.h
index 8cf7e47..abdb4ea 100644
--- a/lib/Target/Hexagon/HexagonPLT.h
+++ b/lib/Target/Hexagon/HexagonPLT.h
@@ -13,6 +13,7 @@
 #include "HexagonGOTPLT.h"
 #include <mcld/Target/GOT.h>
 #include <mcld/Target/PLT.h>
+#include <mcld/Support/MemoryRegion.h>
 
 namespace {
 
@@ -44,7 +45,6 @@
 
 class GOTEntry;
 class LinkerConfig;
-class MemoryRegion;
 class HexagonPLT1;
 
 //===----------------------------------------------------------------------===//
@@ -76,9 +76,7 @@
   // hasPLT1 - return if this PLT has any PLT1 entry
   bool hasPLT1() const;
 
-  void reserveEntry(size_t pNum = 1) ;
-
-  HexagonPLT1* consume();
+  HexagonPLT1* create();
 
   void applyPLT0();
 
@@ -91,9 +89,6 @@
 private:
   HexagonGOTPLT& m_GOTPLT;
 
-  // the last consumed entry.
-  SectionData::iterator m_Last;
-
   const uint8_t *m_PLT0;
   unsigned int m_PLT0Size;
 
diff --git a/lib/Target/Hexagon/HexagonRelocationFunctions.h b/lib/Target/Hexagon/HexagonRelocationFunctions.h
index a5e6b87..6f9acad 100644
--- a/lib/Target/Hexagon/HexagonRelocationFunctions.h
+++ b/lib/Target/Hexagon/HexagonRelocationFunctions.h
@@ -39,84 +39,59 @@
 
 #define DECL_HEXAGON_APPLY_RELOC_FUNCS \
 DECL_HEXAGON_APPLY_RELOC_FUNC(none)             \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB22PCREL)     \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB15PCREL)     \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB7PCREL)      \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocLO16)         \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocHI16)        \
-DECL_HEXAGON_APPLY_RELOC_FUNC(reloc32)         \
-DECL_HEXAGON_APPLY_RELOC_FUNC(reloc16)         \
-DECL_HEXAGON_APPLY_RELOC_FUNC(reloc8)         \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocGPREL16_0)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocGPREL16_1)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocGPREL16_2)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocGPREL16_3)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB13PCREL)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB9PCREL)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB32PCRELX)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(reloc32_6_X)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB22PCRELX)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB15PCRELX)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB13PCRELX)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB9PCRELX)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocB7PCRELX)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(reloc32PCREL)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocHexNX)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocHexGOTRELLO16)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocHexGOTRELHI16)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocHexGOTREL32)  \
+DECL_HEXAGON_APPLY_RELOC_FUNC(relocPCREL)     \
+DECL_HEXAGON_APPLY_RELOC_FUNC(relocGPREL)     \
+DECL_HEXAGON_APPLY_RELOC_FUNC(relocAbs)     \
 DECL_HEXAGON_APPLY_RELOC_FUNC(relocPLTB22PCREL)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocHex6PCRELX)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocHexGOT326X)  \
-DECL_HEXAGON_APPLY_RELOC_FUNC(relocHexGOT1611X)  \
+DECL_HEXAGON_APPLY_RELOC_FUNC(relocGOTREL)  \
+DECL_HEXAGON_APPLY_RELOC_FUNC(relocGOT)  \
 DECL_HEXAGON_APPLY_RELOC_FUNC(unsupport)
 
-
 #define DECL_HEXAGON_APPLY_RELOC_FUNC_PTRS \
   { &none,                0, "R_HEX_NONE"                        }, \
-  { &relocB22PCREL,       1, "R_HEX_B22_PCREL"                   }, \
-  { &relocB15PCREL,       2, "R_HEX_B15_PCREL"                   }, \
-  { &relocB7PCREL,        3, "R_HEX_B7_PCREL"                    }, \
-  { &relocLO16,           4, "R_HEX_LO16"                        }, \
-  { &relocHI16,           5, "R_HEX_HI16"                        }, \
-  { &reloc32,             6, "R_HEX_32"                          }, \
-  { &reloc16,             7, "R_HEX_16"                          }, \
-  { &reloc8,              8, "R_HEX_8"                           }, \
-  { &relocGPREL16_0,      9, "R_HEX_GPREL16_0"                   }, \
-  { &relocGPREL16_1,      10, "R_HEX_GPREL16_1"                  }, \
-  { &relocGPREL16_2,      11, "R_HEX_GPREL16_2"                  }, \
-  { &relocGPREL16_3,      12, "R_HEX_GPREL16_3"                  }, \
+  { &relocPCREL,          1, "R_HEX_B22_PCREL"                   }, \
+  { &relocPCREL,          2, "R_HEX_B15_PCREL"                   }, \
+  { &relocPCREL,          3, "R_HEX_B7_PCREL"                    }, \
+  { &relocAbs,            4, "R_HEX_LO16"                        }, \
+  { &relocAbs,            5, "R_HEX_HI16"                        }, \
+  { &relocAbs,            6, "R_HEX_32"                          }, \
+  { &relocAbs,            7, "R_HEX_16"                          }, \
+  { &relocAbs,            8, "R_HEX_8"                           }, \
+  { &relocGPREL,          9, "R_HEX_GPREL16_0"                   }, \
+  { &relocGPREL,          10, "R_HEX_GPREL16_1"                  }, \
+  { &relocGPREL,          11, "R_HEX_GPREL16_2"                  }, \
+  { &relocGPREL,          12, "R_HEX_GPREL16_3"                  }, \
   { &unsupport,           13, "R_HEX_HL16"                       }, \
-  { &relocB13PCREL,       14, "R_HEX_B13_PCREL"                  }, \
-  { &relocB9PCREL,        15, "R_HEX_B9_PCREL"                   }, \
-  { &relocB32PCRELX,      16, "R_HEX_B32_PCREL_X"                }, \
-  { &reloc32_6_X,         17, "R_HEX_32_6_X"                     }, \
-  { &relocB22PCRELX,      18, "R_HEX_B22_PCREL_X"                }, \
-  { &relocB15PCRELX,      19, "R_HEX_B15_PCREL_X"                }, \
-  { &relocB13PCRELX,      20, "R_HEX_B13_PCREL_X"                }, \
-  { &relocB9PCRELX,       21, "R_HEX_B9_PCREL_X"                 }, \
-  { &relocB7PCRELX,       22, "R_HEX_B7_PCREL_X"                 }, \
-  { &relocHexNX,          23, "R_HEX_16_X"                       }, \
-  { &relocHexNX,          24, "R_HEX_12_X"                       }, \
-  { &relocHexNX,          25, "R_HEX_11_X"                       }, \
-  { &relocHexNX,          26, "R_HEX_10_X"                       }, \
-  { &relocHexNX,          27, "R_HEX_9_X"                        }, \
-  { &relocHexNX,          28, "R_HEX_8_X"                        }, \
-  { &relocHexNX,          29, "R_HEX_7_X"                        }, \
-  { &relocHexNX,          30, "R_HEX_6_X"                        }, \
-  { &reloc32PCREL,        31, "R_HEX_32_PCREL"                   }, \
-  { &unsupport,           32, "R_HEX_COPY"                       }, \
-  { &unsupport,           33, "R_HEX_GLOB_DAT"                   }, \
-  { &unsupport,           34, "R_HEX_JMP_SLOT"                   }, \
-  { &unsupport,           35, "R_HEX_RELATIVE"                   }, \
+  { &relocPCREL,          14, "R_HEX_B13_PCREL"                  }, \
+  { &relocPCREL,          15, "R_HEX_B9_PCREL"                   }, \
+  { &relocPCREL,          16, "R_HEX_B32_PCREL_X"                }, \
+  { &relocAbs,            17, "R_HEX_32_6_X"                     }, \
+  { &relocPCREL,          18, "R_HEX_B22_PCREL_X"                }, \
+  { &relocPCREL,          19, "R_HEX_B15_PCREL_X"                }, \
+  { &relocPCREL,          20, "R_HEX_B13_PCREL_X"                }, \
+  { &relocPCREL,          21, "R_HEX_B9_PCREL_X"                 }, \
+  { &relocPCREL,          22, "R_HEX_B7_PCREL_X"                 }, \
+  { &relocAbs,            23, "R_HEX_16_X"                       }, \
+  { &relocAbs,            24, "R_HEX_12_X"                       }, \
+  { &relocAbs,            25, "R_HEX_11_X"                       }, \
+  { &relocAbs,            26, "R_HEX_10_X"                       }, \
+  { &relocAbs,            27, "R_HEX_9_X"                        }, \
+  { &relocAbs,            28, "R_HEX_8_X"                        }, \
+  { &relocAbs,            29, "R_HEX_7_X"                        }, \
+  { &relocAbs,            30, "R_HEX_6_X"                        }, \
+  { &relocPCREL,          31, "R_HEX_32_PCREL"                   }, \
+  { &none,                32, "R_HEX_COPY"                       }, \
+  { &none,                33, "R_HEX_GLOB_DAT"                   }, \
+  { &none,                34, "R_HEX_JMP_SLOT"                   }, \
+  { &none,                35, "R_HEX_RELATIVE"                   }, \
   { &relocPLTB22PCREL,    36, "R_HEX_PLT_B22_PCREL"              }, \
-  { &relocHexGOTRELLO16,  37, "R_HEX_GOTREL_LO16"                }, \
-  { &relocHexGOTRELHI16,  38, "R_HEX_GOTREL_HI16"                }, \
-  { &relocHexGOTREL32,    39, "R_HEX_GOTREL_32"                  }, \
-  { &unsupport,           40, "R_HEX_GOT_LO16"                   }, \
-  { &unsupport,           41, "R_HEX_GOT_HI16"                   }, \
-  { &unsupport,           42, "R_HEX_GOT_32"                     }, \
-  { &unsupport,           43, "R_HEX_GOT_16"                     }, \
+  { &relocGOTREL,         37, "R_HEX_GOTREL_LO16"                }, \
+  { &relocGOTREL,         38, "R_HEX_GOTREL_HI16"                }, \
+  { &relocGOTREL,         39, "R_HEX_GOTREL_32"                  }, \
+  { &relocGOT,            40, "R_HEX_GOT_LO16"                   }, \
+  { &relocGOT,            41, "R_HEX_GOT_HI16"                   }, \
+  { &relocGOT,            42, "R_HEX_GOT_32"                     }, \
+  { &relocGOT,            43, "R_HEX_GOT_16"                     }, \
   { &unsupport,           44, "R_HEX_DTPMOD_32"                  }, \
   { &unsupport,           45, "R_HEX_DTPREL_LO16"                }, \
   { &unsupport,           46, "R_HEX_DTPREL_HI16"                }, \
@@ -138,13 +113,13 @@
   { &unsupport,           62, "R_HEX_TPREL_HI16"                 }, \
   { &unsupport,           63, "R_HEX_TPREL_32"                   }, \
   { &unsupport,           64, "R_HEX_TPREL_16"                   }, \
-  { &relocHex6PCRELX,     65, "R_HEX_6_PCREL_X"                  }, \
-  { &unsupport,           66, "R_HEX_GOTREL_32_6_X"              }, \
-  { &unsupport,           67, "R_HEX_GOTREL_16_X"                }, \
-  { &unsupport,           68, "R_HEX_GOTREL_11_X"                }, \
-  { &relocHexGOT326X,     69, "R_HEX_GOT_32_6_X"                 }, \
-  { &relocHexGOT1611X,    70, "R_HEX_GOT_16_X"                   }, \
-  { &relocHexGOT1611X,    71, "R_HEX_GOT_11_X"                   }, \
+  { &relocPCREL,          65, "R_HEX_6_PCREL_X"                  }, \
+  { &relocGOTREL,         66, "R_HEX_GOTREL_32_6_X"              }, \
+  { &relocGOTREL,         67, "R_HEX_GOTREL_16_X"                }, \
+  { &relocGOTREL,         68, "R_HEX_GOTREL_11_X"                }, \
+  { &relocGOT,            69, "R_HEX_GOT_32_6_X"                 }, \
+  { &relocGOT,            70, "R_HEX_GOT_16_X"                   }, \
+  { &relocGOT,            71, "R_HEX_GOT_11_X"                   }, \
   { &unsupport,           72, "R_HEX_DTPREL_32_6_X"              }, \
   { &unsupport,           73, "R_HEX_DTPREL_16_X"                }, \
   { &unsupport,           74, "R_HEX_DTPREL_11_X"                }, \
diff --git a/lib/Target/Hexagon/HexagonRelocator.cpp b/lib/Target/Hexagon/HexagonRelocator.cpp
index ba387cf..b82bbcd 100644
--- a/lib/Target/Hexagon/HexagonRelocator.cpp
+++ b/lib/Target/Hexagon/HexagonRelocator.cpp
@@ -6,34 +6,133 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
-#include <llvm/ADT/Twine.h>
-#include <mcld/LD/LDSymbol.h>
-#include <llvm/Support/DataTypes.h>
-#include <llvm/Support/ELF.h>
-#include <mcld/Support/MsgHandling.h>
-
 #include "HexagonRelocator.h"
 #include "HexagonRelocationFunctions.h"
 #include "HexagonEncodings.h"
+#include <llvm/ADT/Twine.h>
+#include <llvm/Support/DataTypes.h>
+#include <llvm/Support/ELF.h>
+
+#include <mcld/LD/ELFFileFormat.h>
+#include <mcld/LD/LDSymbol.h>
+#include <mcld/Support/MsgHandling.h>
 
 using namespace mcld;
 
 //===--------------------------------------------------------------------===//
+// Relocation Helper Functions
+//===--------------------------------------------------------------------===//
+/// helper_DynRel - Get an relocation entry in .rela.dyn
+static Relocation &helper_DynRel_init(ResolveInfo *pSym,
+                                      Fragment &pFrag,
+                                      uint64_t pOffset,
+                                      HexagonRelocator::Type pType,
+                                      HexagonRelocator &pParent) {
+  HexagonLDBackend &ld_backend = pParent.getTarget();
+  Relocation &rela_entry = *ld_backend.getRelaDyn().create();
+  rela_entry.setType(pType);
+  rela_entry.targetRef().assign(pFrag, pOffset);
+  if (pType == llvm::ELF::R_HEX_RELATIVE || NULL == pSym)
+    rela_entry.setSymInfo(0);
+  else
+    rela_entry.setSymInfo(pSym);
+
+  return rela_entry;
+}
+
+/// helper_use_relative_reloc - Check if symbol can use relocation
+/// R_HEX_RELATIVE
+static bool helper_use_relative_reloc(const ResolveInfo &pSym,
+                                      const HexagonRelocator &pFactory) {
+  // if symbol is dynamic or undefine or preemptible
+  if (pSym.isDyn() || pSym.isUndef() ||
+      pFactory.getTarget().isSymbolPreemptible(pSym))
+    return false;
+  return true;
+}
+
+static HexagonGOTEntry &helper_GOT_init(Relocation &pReloc,
+                                        bool pHasRel,
+                                        HexagonRelocator &pParent) {
+  // rsym - The relocation target symbol
+  ResolveInfo *rsym = pReloc.symInfo();
+  HexagonLDBackend &ld_backend = pParent.getTarget();
+  assert(NULL == pParent.getSymGOTMap().lookUp(*rsym));
+
+  HexagonGOTEntry *got_entry = ld_backend.getGOT().create();
+  pParent.getSymGOTMap().record(*rsym, *got_entry);
+
+  if (!pHasRel) {
+    // No corresponding dynamic relocation, initialize to the symbol value.
+    got_entry->setValue(HexagonRelocator::SymVal);
+  }
+  else {
+    // Initialize got_entry content and the corresponding dynamic relocation.
+    if (helper_use_relative_reloc(*rsym, pParent)) {
+      helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_HEX_RELATIVE,
+                                                                       pParent);
+      got_entry->setValue(HexagonRelocator::SymVal);
+    }
+    else {
+      helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_HEX_GLOB_DAT,
+                                                                       pParent);
+      got_entry->setValue(0);
+    }
+  }
+  return *got_entry;
+}
+
+static HexagonRelocator::Address helper_get_GOT_address(ResolveInfo &pSym,
+                                                    HexagonRelocator &pParent) {
+  HexagonGOTEntry *got_entry = pParent.getSymGOTMap().lookUp(pSym);
+  assert(NULL != got_entry);
+  return pParent.getTarget().getGOT().addr() + got_entry->getOffset();
+}
+
+static PLTEntryBase &helper_PLT_init(Relocation &pReloc,
+                                     HexagonRelocator &pParent) {
+  // rsym - The relocation target symbol
+  ResolveInfo *rsym = pReloc.symInfo();
+  HexagonLDBackend &ld_backend = pParent.getTarget();
+  assert(NULL == pParent.getSymPLTMap().lookUp(*rsym));
+
+  PLTEntryBase *plt_entry = ld_backend.getPLT().create();
+  pParent.getSymPLTMap().record(*rsym, *plt_entry);
+
+  assert(NULL == pParent.getSymGOTPLTMap().lookUp(*rsym) &&
+         "PLT entry not exist, but DynRel entry exist!");
+  HexagonGOTEntry *gotplt_entry = ld_backend.getGOTPLT().create();
+  pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
+  // init the corresponding rel entry in .rela.plt
+  Relocation &rela_entry = *ld_backend.getRelaPLT().create();
+  rela_entry.setType(llvm::ELF::R_HEX_JMP_SLOT);
+  rela_entry.targetRef().assign(*gotplt_entry);
+  rela_entry.setSymInfo(rsym);
+
+  return *plt_entry;
+}
+
+static HexagonRelocator::Address helper_get_PLT_address(ResolveInfo& pSym,
+                                                    HexagonRelocator &pParent) {
+  PLTEntryBase *plt_entry = pParent.getSymPLTMap().lookUp(pSym);
+  assert(NULL != plt_entry);
+  return pParent.getTarget().getPLT().addr() + plt_entry->getOffset();
+}
+
+//===--------------------------------------------------------------------===//
 // Relocation Functions and Tables
 //===--------------------------------------------------------------------===//
 DECL_HEXAGON_APPLY_RELOC_FUNCS
 
-/// the prototype of applying function
-typedef Relocator::Result (*ApplyFunctionType)(Relocation& pReloc,
-                                               HexagonRelocator& pParent);
+    /// the prototype of applying function
+    typedef Relocator::Result (*ApplyFunctionType)(Relocation &pReloc,
+                                                   HexagonRelocator &pParent);
 
 // the table entry of applying functions
-struct ApplyFunctionTriple
-{
+struct ApplyFunctionTriple {
   ApplyFunctionType func;
   unsigned int type;
-  const char* name;
+  const char *name;
 };
 
 // declare the table of applying functions
@@ -41,8 +140,9 @@
   DECL_HEXAGON_APPLY_RELOC_FUNC_PTRS
 };
 
-static uint32_t findBitMask(uint32_t insn, Instruction *encodings, int32_t numInsns) {
-  for (int32_t i = 0; i < numInsns ; i++) {
+static uint32_t findBitMask(uint32_t insn, Instruction *encodings,
+                            int32_t numInsns) {
+  for (int32_t i = 0; i < numInsns; i++) {
     if (((insn & 0xc000) == 0) && !(encodings[i].isDuplex))
       continue;
 
@@ -53,30 +153,25 @@
       return encodings[i].insnBitMask;
   }
   assert(0);
+  // Should not be here, but add a return for -Werror=return-type
+  // error: control reaches end of non-void function
+  return -1;
 }
 
-
-#define FINDBITMASK(INSN) \
-  findBitMask((uint32_t)INSN,\
-              insn_encodings,\
+#define FINDBITMASK(INSN)                                                      \
+  findBitMask((uint32_t) INSN, insn_encodings,                                 \
               sizeof(insn_encodings) / sizeof(Instruction))
 
 //===--------------------------------------------------------------------===//
 // HexagonRelocator
 //===--------------------------------------------------------------------===//
-HexagonRelocator::HexagonRelocator(HexagonLDBackend& pParent,
-                                   const LinkerConfig& pConfig)
-  : Relocator(pConfig),
-    m_Target(pParent) {
-}
+HexagonRelocator::HexagonRelocator(HexagonLDBackend &pParent,
+                                   const LinkerConfig &pConfig)
+    : Relocator(pConfig), m_Target(pParent) {}
 
-HexagonRelocator::~HexagonRelocator()
-{
-}
+HexagonRelocator::~HexagonRelocator() {}
 
-Relocator::Result
-HexagonRelocator::applyRelocation(Relocation& pRelocation)
-{
+Relocator::Result HexagonRelocator::applyRelocation(Relocation &pRelocation) {
   Relocation::Type type = pRelocation.type();
 
   if (type > 85) { // 86-255 relocs do not exists for Hexagon
@@ -87,30 +182,27 @@
   return ApplyFunctions[type].func(pRelocation, *this);
 }
 
-const char* HexagonRelocator::getName(Relocation::Type pType) const
-{
+const char *HexagonRelocator::getName(Relocation::Type pType) const {
   return ApplyFunctions[pType].name;
 }
 
-Relocator::Size HexagonRelocator::getSize(Relocation::Type pType) const
-{
+Relocator::Size HexagonRelocator::getSize(Relocation::Type pType) const {
   return 32;
 }
 
-void HexagonRelocator::scanRelocation(Relocation& pReloc,
-                                      IRBuilder& pLinker,
-                                      Module& pModule,
-                                      LDSection& pSection)
-{
+void HexagonRelocator::scanRelocation(Relocation &pReloc, IRBuilder &pLinker,
+                                      Module &pModule, LDSection &pSection, Input &pInput) {
   if (LinkerConfig::Object == config().codeGenType())
     return;
 
-  pReloc.updateAddend();
   // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
+  ResolveInfo *rsym = pReloc.symInfo();
   assert(NULL != rsym &&
          "ResolveInfo of relocation not set while scanRelocation");
 
+  if (config().isCodeStatic())
+    return;
+
   assert(NULL != pSection.getLink());
   if (0 == (pSection.getLink()->flag() & llvm::ELF::SHF_ALLOC))
     return;
@@ -123,106 +215,179 @@
   // check if we should issue undefined reference for the relocation target
   // symbol
   if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
-    fatal(diag::undefined_reference) << rsym->name();
+    issueUndefRef(pReloc, pSection, pInput);
 }
 
-void HexagonRelocator::addCopyReloc(ResolveInfo& pSym,
-                                    HexagonLDBackend& pTarget)
-{
-  Relocation& rel_entry = *pTarget.getRelaDyn().consumeEntry();
+void HexagonRelocator::addCopyReloc(ResolveInfo &pSym,
+                                    HexagonLDBackend &pTarget) {
+  Relocation &rel_entry = *pTarget.getRelaDyn().create();
   rel_entry.setType(pTarget.getCopyRelType());
   assert(pSym.outSymbol()->hasFragRef());
   rel_entry.targetRef().assign(*pSym.outSymbol()->fragRef());
   rel_entry.setSymInfo(&pSym);
 }
 
-void HexagonRelocator::scanLocalReloc(Relocation& pReloc,
-                                     IRBuilder& pBuilder,
-                                     Module& pModule,
-                                     LDSection& pSection)
-{
+void HexagonRelocator::scanLocalReloc(Relocation &pReloc, IRBuilder &pBuilder,
+                                      Module &pModule, LDSection &pSection) {
   // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
+  ResolveInfo *rsym = pReloc.symInfo();
 
-  switch(pReloc.type()){
+  switch (pReloc.type()) {
 
-    case llvm::ELF::R_HEX_32:
-    case llvm::ELF::R_HEX_16:
-    case llvm::ELF::R_HEX_8:
-      // If buiding PIC object (shared library or PIC executable),
-      // a dynamic relocations with RELATIVE type to this location is needed.
-      // Reserve an entry in .rel.dyn
-      if (config().isCodeIndep()) {
-        getTarget().getRelaDyn().reserveEntry();
-        // set Rel bit
-        rsym->setReserved(rsym->reserved() | ReserveRel);
-        getTarget().checkAndSetHasTextRel(*pSection.getLink());
-      }
-      return;
+  case llvm::ELF::R_HEX_LO16:
+  case llvm::ELF::R_HEX_HI16:
+  case llvm::ELF::R_HEX_16:
+  case llvm::ELF::R_HEX_8:
+  case llvm::ELF::R_HEX_32_6_X:
+  case llvm::ELF::R_HEX_16_X:
+  case llvm::ELF::R_HEX_12_X:
+  case llvm::ELF::R_HEX_11_X:
+  case llvm::ELF::R_HEX_10_X:
+  case llvm::ELF::R_HEX_9_X:
+  case llvm::ELF::R_HEX_8_X:
+  case llvm::ELF::R_HEX_7_X:
+  case llvm::ELF::R_HEX_6_X:
+    assert(!(rsym->reserved() & ReserveRel) &&
+           "Cannot apply this relocation for read only section");
+    return;
 
-    default:
-      break;
+  case llvm::ELF::R_HEX_32:
+    // If buiding PIC object (shared library or PIC executable),
+    // a dynamic relocations with RELATIVE type to this location is needed.
+    // Reserve an entry in .rel.dyn
+    if (config().isCodeIndep()) {
+      Relocation &reloc = helper_DynRel_init(rsym,
+                                             *pReloc.targetRef().frag(),
+                                             pReloc.targetRef().offset(),
+                                             llvm::ELF::R_HEX_RELATIVE,
+                                             *this);
+      // we need to set up the relocation addend at apply relocation, record the
+      // relocation
+      getRelRelMap().record(pReloc, reloc);
+
+      // set Rel bit
+      rsym->setReserved(rsym->reserved() | ReserveRel);
+      getTarget().checkAndSetHasTextRel(*pSection.getLink());
+    }
+    return;
+
+  default:
+    return;
   }
 }
 
-void HexagonRelocator::scanGlobalReloc(Relocation& pReloc,
-                                       IRBuilder& pBuilder,
-                                       Module& pModule,
-                                       LDSection& pSection)
-{
+void HexagonRelocator::scanGlobalReloc(Relocation &pReloc, IRBuilder &pBuilder,
+                                       Module &pModule, LDSection &pSection) {
   // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
+  ResolveInfo *rsym = pReloc.symInfo();
+  HexagonLDBackend &ld_backend = getTarget();
 
-  switch(pReloc.type()) {
-    case llvm::ELF::R_HEX_PLT_B22_PCREL:
-      // return if we already create plt for this symbol
-      if (rsym->reserved() & ReservePLT)
-        return;
+  switch (pReloc.type()) {
+  case llvm::ELF::R_HEX_LO16:
+  case llvm::ELF::R_HEX_HI16:
+  case llvm::ELF::R_HEX_16:
+  case llvm::ELF::R_HEX_8:
+  case llvm::ELF::R_HEX_32_6_X:
+  case llvm::ELF::R_HEX_16_X:
+  case llvm::ELF::R_HEX_12_X:
+  case llvm::ELF::R_HEX_11_X:
+  case llvm::ELF::R_HEX_10_X:
+  case llvm::ELF::R_HEX_9_X:
+  case llvm::ELF::R_HEX_8_X:
+  case llvm::ELF::R_HEX_7_X:
+  case llvm::ELF::R_HEX_6_X:
+    assert(!(rsym->reserved() & ReserveRel) &&
+           "Cannot apply this relocation for read only section");
+    return;
 
-      // Symbol needs PLT entry, we need to reserve a PLT entry
-      // and the corresponding GOT and dynamic relocation entry
-      // in .got.plt and .rela.plt.
-      getTarget().getPLT().reserveEntry();
-      getTarget().getGOTPLT().reserve();
-      getTarget().getRelaPLT().reserveEntry();
-      // set PLT bit
-      rsym->setReserved(rsym->reserved() | ReservePLT);
-      return;
-
-    case llvm::ELF::R_HEX_GOT_32_6_X:
-    case llvm::ELF::R_HEX_GOT_16_X:
-    case llvm::ELF::R_HEX_GOT_11_X:
-      // Symbol needs GOT entry, reserve entry in .got
-      // return if we already create GOT for this symbol
-      if (rsym->reserved() & (ReserveGOT | GOTRel))
-        return;
-      // FIXME: check STT_GNU_IFUNC symbol
-      getTarget().getGOT().reserve();
-
-      // If the GOT is used in statically linked binaries,
-      // the GOT entry is enough and no relocation is needed.
-      if (config().isCodeStatic()) {
-        rsym->setReserved(rsym->reserved() | ReserveGOT);
-        return;
+  case llvm::ELF::R_HEX_32:
+    if (ld_backend.symbolNeedsPLT(*rsym)) {
+      //create PLT for this symbol if it does not have.
+      if (!(rsym->reserved() & ReservePLT)) {
+        helper_PLT_init(pReloc, *this);
+        rsym->setReserved(rsym->reserved() | ReservePLT);
       }
-      // If building shared object or the symbol is undefined, a dynamic
-      // relocation is needed to relocate this GOT entry. Reserve an
-      // entry in .rel.dyn
-      if (LinkerConfig::DynObj ==
-                   config().codeGenType() || rsym->isUndef() || rsym->isDyn()) {
-        getTarget().getRelaDyn().reserveEntry();
-        // set GOTRel bit
-        rsym->setReserved(rsym->reserved() | GOTRel);
-        return;
-      }
-      // set GOT bit
-      rsym->setReserved(rsym->reserved() | ReserveGOT);
-      return;
-
-    default: {
-      break;
     }
-  } // end switch
+
+    if (ld_backend.symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT),
+                                     true)) {
+      if (ld_backend.symbolNeedsCopyReloc(pReloc, *rsym)) {
+        LDSymbol &cpy_sym =
+            defineSymbolforCopyReloc(pBuilder, *rsym, ld_backend);
+        addCopyReloc(*cpy_sym.resolveInfo(), ld_backend);
+      }
+      else {
+        Relocation &reloc = helper_DynRel_init(rsym,
+                                               *pReloc.targetRef().frag(),
+                                               pReloc.targetRef().offset(),
+                                               llvm::ELF::R_HEX_RELATIVE,
+                                               *this);
+        // we need to set up the relocation addend at apply relocation, record the
+        // relocation
+        getRelRelMap().record(pReloc, reloc);
+        rsym->setReserved(rsym->reserved() | ReserveRel);
+        ld_backend.checkAndSetHasTextRel(*pSection.getLink());
+      }
+    }
+    return;
+
+  case llvm::ELF::R_HEX_GOTREL_LO16:
+  case llvm::ELF::R_HEX_GOTREL_HI16:
+  case llvm::ELF::R_HEX_GOTREL_32:
+  case llvm::ELF::R_HEX_GOTREL_32_6_X:
+  case llvm::ELF::R_HEX_GOTREL_16_X:
+  case llvm::ELF::R_HEX_GOTREL_11_X:
+    // This assumes that GOT exists
+    return;
+
+  case llvm::ELF::R_HEX_GOT_LO16:
+  case llvm::ELF::R_HEX_GOT_HI16:
+  case llvm::ELF::R_HEX_GOT_32:
+  case llvm::ELF::R_HEX_GOT_16:
+  case llvm::ELF::R_HEX_GOT_32_6_X:
+  case llvm::ELF::R_HEX_GOT_16_X:
+  case llvm::ELF::R_HEX_GOT_11_X:
+    // Symbol needs GOT entry, reserve entry in .got
+    // return if we already create GOT for this symbol
+    if (rsym->reserved() & ReserveGOT)
+      return;
+    // If the GOT is used in statically linked binaries,
+    // the GOT entry is enough and no relocation is needed.
+    if (config().isCodeStatic())
+      helper_GOT_init(pReloc, false, *this);
+    else
+      helper_GOT_init(pReloc, true, *this);
+    // set GOT bit
+    rsym->setReserved(rsym->reserved() | ReserveGOT);
+    return;
+
+  case llvm::ELF::R_HEX_B22_PCREL:
+  case llvm::ELF::R_HEX_B15_PCREL:
+  case llvm::ELF::R_HEX_B7_PCREL:
+  case llvm::ELF::R_HEX_B13_PCREL:
+  case llvm::ELF::R_HEX_B9_PCREL:
+  case llvm::ELF::R_HEX_B32_PCREL_X:
+  case llvm::ELF::R_HEX_B22_PCREL_X:
+  case llvm::ELF::R_HEX_B15_PCREL_X:
+  case llvm::ELF::R_HEX_B13_PCREL_X:
+  case llvm::ELF::R_HEX_B9_PCREL_X:
+  case llvm::ELF::R_HEX_B7_PCREL_X:
+  case llvm::ELF::R_HEX_32_PCREL:
+  case llvm::ELF::R_HEX_6_PCREL_X:
+  case llvm::ELF::R_HEX_PLT_B22_PCREL:
+    if (rsym->reserved() & ReservePLT)
+      return;
+    if (ld_backend.symbolNeedsPLT(*rsym) ||
+        pReloc.type() == llvm::ELF::R_HEX_PLT_B22_PCREL) {
+      helper_PLT_init(pReloc, *this);
+      rsym->setReserved(rsym->reserved() | ReservePLT);
+    }
+    return;
+
+  default:
+    break;
+
+  } // end of switch
 }
 
 /// defineSymbolforCopyReloc
@@ -230,13 +395,11 @@
 /// section and all other reference to this symbol should refer to this
 /// copy.
 /// @note This is executed at `scan relocation' stage.
-LDSymbol& HexagonRelocator::defineSymbolforCopyReloc(IRBuilder& pBuilder,
-                                                 const ResolveInfo& pSym,
-                                                 HexagonLDBackend& pTarget)
-{
+LDSymbol &HexagonRelocator::defineSymbolforCopyReloc(
+    IRBuilder &pBuilder, const ResolveInfo &pSym, HexagonLDBackend &pTarget) {
   // get or create corresponding BSS LDSection
-  LDSection* bss_sect_hdr = NULL;
-  ELFFileFormat* file_format = pTarget.getOutputFormat();
+  LDSection *bss_sect_hdr = NULL;
+  ELFFileFormat *file_format = pTarget.getOutputFormat();
   if (ResolveInfo::ThreadLocal == pSym.type())
     bss_sect_hdr = &file_format->getTBSS();
   else
@@ -244,7 +407,7 @@
 
   // get or create corresponding BSS SectionData
   assert(NULL != bss_sect_hdr);
-  SectionData* bss_section = NULL;
+  SectionData *bss_section = NULL;
   if (bss_sect_hdr->hasSectionData())
     bss_section = bss_sect_hdr->getSectionData();
   else
@@ -255,45 +418,36 @@
   uint32_t addralign = config().targets().bitclass() / 8;
 
   // allocate space in BSS for the copy symbol
-  Fragment* frag = new FillFragment(0x0, 1, pSym.size());
-  uint64_t size = ObjectBuilder::AppendFragment(*frag,
-                                                *bss_section,
-                                                addralign);
+  Fragment *frag = new FillFragment(0x0, 1, pSym.size());
+  uint64_t size = ObjectBuilder::AppendFragment(*frag, *bss_section, addralign);
   bss_sect_hdr->setSize(bss_sect_hdr->size() + size);
 
   // change symbol binding to Global if it's a weak symbol
-  ResolveInfo::Binding binding = (ResolveInfo::Binding)pSym.binding();
+  ResolveInfo::Binding binding = (ResolveInfo::Binding) pSym.binding();
   if (binding == ResolveInfo::Weak)
     binding = ResolveInfo::Global;
 
   // Define the copy symbol in the bss section and resolve it
-  LDSymbol* cpy_sym = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
-                      pSym.name(),
-                      (ResolveInfo::Type)pSym.type(),
-                      ResolveInfo::Define,
-                      binding,
-                      pSym.size(),  // size
-                      0x0,          // value
-                      FragmentRef::Create(*frag, 0x0),
-                      (ResolveInfo::Visibility)pSym.other());
+  LDSymbol *cpy_sym = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
+      pSym.name(), (ResolveInfo::Type) pSym.type(), ResolveInfo::Define,
+      binding, pSym.size(), // size
+      0x0,                  // value
+      FragmentRef::Create(*frag, 0x0), (ResolveInfo::Visibility) pSym.other());
 
   // output all other alias symbols if any
   Module &pModule = pBuilder.getModule();
-  Module::AliasList* alias_list = pModule.getAliasList(pSym);
-  if (NULL!=alias_list) {
-    Module::alias_iterator it, it_e=alias_list->end();
-    for (it=alias_list->begin(); it!=it_e; ++it) {
-      const ResolveInfo* alias = *it;
-      if (alias!=&pSym && alias->isDyn()) {
+  Module::AliasList *alias_list = pModule.getAliasList(pSym);
+  if (NULL != alias_list) {
+    Module::alias_iterator it, it_e = alias_list->end();
+    for (it = alias_list->begin(); it != it_e; ++it) {
+      const ResolveInfo *alias = *it;
+      if (alias != &pSym && alias->isDyn()) {
         pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
-                           alias->name(),
-                           (ResolveInfo::Type)alias->type(),
-                           ResolveInfo::Define,
-                           binding,
-                           alias->size(),  // size
-                           0x0,          // value
-                           FragmentRef::Create(*frag, 0x0),
-                           (ResolveInfo::Visibility)alias->other());
+            alias->name(), (ResolveInfo::Type) alias->type(),
+            ResolveInfo::Define, binding, alias->size(), // size
+            0x0,                                         // value
+            FragmentRef::Create(*frag, 0x0),
+            (ResolveInfo::Visibility) alias->other());
       }
     }
   }
@@ -301,587 +455,359 @@
   return *cpy_sym;
 }
 
-void HexagonRelocator::partialScanRelocation(Relocation& pReloc,
-                                      Module& pModule,
-                                      const LDSection& pSection)
-{
+void HexagonRelocator::partialScanRelocation(Relocation &pReloc,
+                                             Module &pModule,
+                                             const LDSection &pSection) {
   pReloc.updateAddend();
   // if we meet a section symbol
   if (pReloc.symInfo()->type() == ResolveInfo::Section) {
-    LDSymbol* input_sym = pReloc.symInfo()->outSymbol();
+    LDSymbol *input_sym = pReloc.symInfo()->outSymbol();
 
     // 1. update the relocation target offset
     assert(input_sym->hasFragRef());
     // 2. get the output LDSection which the symbol defined in
-    const LDSection& out_sect =
-                        input_sym->fragRef()->frag()->getParent()->getSection();
-    ResolveInfo* sym_info =
-                     pModule.getSectionSymbolSet().get(out_sect)->resolveInfo();
+    const LDSection &out_sect =
+        input_sym->fragRef()->frag()->getParent()->getSection();
+    ResolveInfo *sym_info =
+        pModule.getSectionSymbolSet().get(out_sect)->resolveInfo();
     // set relocation target symbol to the output section symbol's resolveInfo
     pReloc.setSymInfo(sym_info);
   }
 }
 
-/// helper_DynRel - Get an relocation entry in .rela.dyn
-static
-Relocation& helper_DynRel(ResolveInfo* pSym,
-                          Fragment& pFrag,
-                          uint64_t pOffset,
-                          HexagonRelocator::Type pType,
-                          HexagonRelocator& pParent)
-{
-  HexagonLDBackend& ld_backend = pParent.getTarget();
-  Relocation& rela_entry = *ld_backend.getRelaDyn().consumeEntry();
-  rela_entry.setType(pType);
-  rela_entry.targetRef().assign(pFrag, pOffset);
-  if (pType == llvm::ELF::R_HEX_RELATIVE || NULL == pSym)
-    rela_entry.setSymInfo(0);
-  else
-    rela_entry.setSymInfo(pSym);
-
-  return rela_entry;
-}
-
-
-/// helper_use_relative_reloc - Check if symbol can use relocation
-/// R_HEX_RELATIVE
-static bool
-helper_use_relative_reloc(const ResolveInfo& pSym,
-                          const HexagonRelocator& pFactory)
-
-{
-  // if symbol is dynamic or undefine or preemptible
-  if (pSym.isDyn() ||
-      pSym.isUndef() ||
-      pFactory.getTarget().isSymbolPreemptible(pSym))
-    return false;
-  return true;
-}
-
-static
-HexagonGOTEntry& helper_get_GOT_and_init(Relocation& pReloc,
-					HexagonRelocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  HexagonLDBackend& ld_backend = pParent.getTarget();
-
-  HexagonGOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
-  if (NULL != got_entry)
-    return *got_entry;
-
-  // not found
-  got_entry = ld_backend.getGOT().consume();
-  pParent.getSymGOTMap().record(*rsym, *got_entry);
-
-  // If we first get this GOT entry, we should initialize it.
-  if (rsym->reserved() & HexagonRelocator::ReserveGOT) {
-    // No corresponding dynamic relocation, initialize to the symbol value.
-    got_entry->setValue(pReloc.symValue());
-  }
-  else if (rsym->reserved() & HexagonRelocator::GOTRel) {
-    // Initialize got_entry content and the corresponding dynamic relocation.
-    if (helper_use_relative_reloc(*rsym, pParent)) {
-      helper_DynRel(rsym, *got_entry, 0x0, llvm::ELF::R_HEX_RELATIVE, pParent);
-      got_entry->setValue(pReloc.symValue());
-    }
-    else {
-      helper_DynRel(rsym, *got_entry, 0x0, llvm::ELF::R_HEX_GLOB_DAT, pParent);
-      got_entry->setValue(0);
-    }
-  }
-  else {
-    fatal(diag::reserve_entry_number_mismatch_got);
-  }
-  return *got_entry;
-}
-
-static
-HexagonRelocator::Address helper_GOT_ORG(HexagonRelocator& pParent)
-{
-  return pParent.getTarget().getGOT().addr();
-}
-
-static
-HexagonRelocator::Address helper_GOT(Relocation& pReloc, HexagonRelocator& pParent)
-{
-  HexagonGOTEntry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
-  return helper_GOT_ORG(pParent) + got_entry.getOffset();
-}
-
-static
-PLTEntryBase& helper_get_PLT_and_init(Relocation& pReloc,
-				      HexagonRelocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  HexagonLDBackend& ld_backend = pParent.getTarget();
-
-  PLTEntryBase* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
-  if (NULL != plt_entry)
-    return *plt_entry;
-
-  // not found
-  plt_entry = ld_backend.getPLT().consume();
-  pParent.getSymPLTMap().record(*rsym, *plt_entry);
-  // If we first get this PLT entry, we should initialize it.
-  if (rsym->reserved() & HexagonRelocator::ReservePLT) {
-    HexagonGOTEntry* gotplt_entry = pParent.getSymGOTPLTMap().lookUp(*rsym);
-    assert(NULL == gotplt_entry && "PLT entry not exist, but DynRel entry exist!");
-    gotplt_entry = ld_backend.getGOTPLT().consume();
-    pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
-    // init the corresponding rel entry in .rel.plt
-    Relocation& rela_entry = *ld_backend.getRelaPLT().consumeEntry();
-    rela_entry.setType(llvm::ELF::R_HEX_JMP_SLOT);
-    rela_entry.targetRef().assign(*gotplt_entry);
-    rela_entry.setSymInfo(rsym);
-  }
-  else {
-    fatal(diag::reserve_entry_number_mismatch_plt);
-  }
-
-  return *plt_entry;
-}
-
-static
-HexagonRelocator::Address helper_PLT_ORG(HexagonRelocator& pParent)
-{
-  return pParent.getTarget().getPLT().addr();
-}
-
-static
-HexagonRelocator::Address helper_PLT(Relocation& pReloc,
-                                     HexagonRelocator& pParent)
-{
-  PLTEntryBase& plt_entry = helper_get_PLT_and_init(pReloc, pParent);
-  return helper_PLT_ORG(pParent) + plt_entry.getOffset();
-}
-
 //=========================================//
 // Each relocation function implementation //
 //=========================================//
 
 // R_HEX_NONE
-HexagonRelocator::Result none(Relocation& pReloc, HexagonRelocator& pParent)
-{
+HexagonRelocator::Result none(Relocation &pReloc, HexagonRelocator &pParent) {
   return HexagonRelocator::OK;
 }
 
-// R_HEX_B15_PCREL: Word32_B15 : 0x00df20fe  (S + A - P) >> 2 : Signed Verify
-HexagonRelocator::Result relocB15PCREL(Relocation& pReloc,
-                                       HexagonRelocator& pParent)
-{
+//R_HEX_32 and its class of relocations use only addend and symbol value
+// S + A : result is unsigned truncate.
+// Exception: R_HEX_32_6_X : unsigned verify
+HexagonRelocator::Result applyAbs(Relocation &pReloc) {
   HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = (int32_t) ((S + A - P) >> 2);
-  int32_t range =  1 << 14;
-  if ( (result < range) && (result > -range)) {
-    pReloc.target() = pReloc.target() | ApplyMask<int32_t>(0x00df20fe,result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B22_PCREL: Word32_B22 : 0x01ff3ffe  (S + A - P) >> 2 : Signed Verify
-HexagonRelocator::Result relocB22PCREL(Relocation& pReloc,
-                                       HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = (int32_t) ((S + A - P) >> 2);
-  int32_t range = 1 << 21;
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  if ( (result < range) && (result > -range)) {
-    pReloc.target() = pReloc.target() | ApplyMask<int32_t>(bitMask, result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B7_PCREL: Word32_B7 : 0x0001f18  (S + A - P) >> 2 : Signed Verify
-HexagonRelocator::Result relocB7PCREL(Relocation& pReloc,
-                                      HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = (int32_t) ((S + A - P) >> 2);
-  int32_t range = 1 << 6;
-  if ( (result < range) && (result > -range)) {
-    pReloc.target() = pReloc.target() | ApplyMask<int32_t>(0x00001f18, result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_32: Word32 : 0xffffffff : (S + A) : Unsigned Truncate
-HexagonRelocator::Result reloc32(Relocation& pReloc,
-                                 HexagonRelocator& pParent)
-{
   HexagonRelocator::DWord A = pReloc.addend();
-  HexagonRelocator::DWord S = pReloc.symValue();
-  ResolveInfo* rsym = pReloc.symInfo();
-  bool has_dyn_rel = pParent.getTarget().symbolNeedsDynRel(
-                              *rsym,
-                              (rsym->reserved() & HexagonRelocator::ReservePLT),
-                              true);
+  uint32_t result = (uint32_t)(S + A);
+  uint32_t bitMask = 0;
+  uint32_t effectiveBits = 0;
+  uint32_t alignment = 1;
+  uint32_t shift = 0;
 
-  // A local symbol may need REL Type dynamic relocation
+  switch (pReloc.type()) {
+  case llvm::ELF::R_HEX_LO16:
+    bitMask = 0x00c03fff;
+    break;
+
+  case llvm::ELF::R_HEX_HI16:
+    shift = 16;
+    bitMask = 0x00c03fff;
+    break;
+
+  case llvm::ELF::R_HEX_32:
+    bitMask = 0xffffffff;
+    break;
+
+  case llvm::ELF::R_HEX_16:
+    bitMask = 0x0000ffff;
+    alignment = 2;
+    break;
+
+  case llvm::ELF::R_HEX_8:
+    bitMask = 0x000000ff;
+    alignment = 1;
+    break;
+
+  case llvm::ELF::R_HEX_12_X:
+    bitMask = 0x000007e0;
+    break;
+
+  case llvm::ELF::R_HEX_32_6_X:
+    bitMask = 0xfff3fff;
+    shift = 6;
+    effectiveBits = 26;
+    break;
+
+  case llvm::ELF::R_HEX_16_X:
+  case llvm::ELF::R_HEX_11_X:
+  case llvm::ELF::R_HEX_10_X:
+  case llvm::ELF::R_HEX_9_X:
+  case llvm::ELF::R_HEX_8_X:
+  case llvm::ELF::R_HEX_7_X:
+  case llvm::ELF::R_HEX_6_X:
+    bitMask = FINDBITMASK(pReloc.target());
+    break;
+
+  default:
+    // show proper error
+    fatal(diag::unsupported_relocation) << (int)
+        pReloc.type() << "mclinker@googlegroups.com";
+
+  }
+
+  if ((shift != 0) && (result % alignment != 0))
+    return HexagonRelocator::BadReloc;
+
+  result >>= shift;
+
+  if (effectiveBits) {
+    uint32_t range = 1 << effectiveBits;
+    if (result > (range - 1))
+      return HexagonRelocator::Overflow;
+  }
+
+  pReloc.target() |= ApplyMask<uint32_t>(bitMask, result);
+  return HexagonRelocator::OK;
+}
+
+//R_HEX_B22_PCREL and its class of relocations, use
+// S + A - P : result is signed verify.
+// Exception: R_HEX_B32_PCREL_X : signed truncate
+// Another Exception: R_HEX_6_PCREL_X is unsigned truncate
+HexagonRelocator::Result applyRel(Relocation &pReloc, int64_t pResult) {
+  uint32_t bitMask = 0;
+  uint32_t effectiveBits = 0;
+  uint32_t alignment = 1;
+  uint32_t result;
+  uint32_t shift = 0;
+
+  switch (pReloc.type()) {
+  case llvm::ELF::R_HEX_B22_PCREL:
+    bitMask = 0x01ff3ffe;
+    effectiveBits = 22;
+    alignment = 4;
+    shift = 2;
+    break;
+
+  case llvm::ELF::R_HEX_B15_PCREL:
+    bitMask = 0x00df20fe;
+    effectiveBits = 15;
+    alignment = 4;
+    shift = 2;
+    break;
+
+  case llvm::ELF::R_HEX_B7_PCREL:
+    bitMask = 0x00001f18;
+    effectiveBits = 7;
+    alignment = 4;
+    shift = 2;
+    break;
+
+  case llvm::ELF::R_HEX_B13_PCREL:
+    bitMask = 0x00202ffe;
+    effectiveBits = 13;
+    alignment = 4;
+    shift = 2;
+    break;
+
+  case llvm::ELF::R_HEX_B9_PCREL:
+    bitMask = 0x003000fe;
+    effectiveBits = 9;
+    alignment = 4;
+    shift = 2;
+    break;
+
+  case llvm::ELF::R_HEX_B32_PCREL_X:
+    bitMask = 0xfff3fff;
+    shift = 6;
+    break;
+
+  case llvm::ELF::R_HEX_B22_PCREL_X:
+    bitMask = 0x01ff3ffe;
+    effectiveBits = 22;
+    pResult &= 0x3f;
+    break;
+
+  case llvm::ELF::R_HEX_B15_PCREL_X:
+    bitMask = 0x00df20fe;
+    effectiveBits = 15;
+    pResult &= 0x3f;
+    break;
+
+  case llvm::ELF::R_HEX_B13_PCREL_X:
+    bitMask = 0x00202ffe;
+    effectiveBits = 13;
+    pResult &= 0x3f;
+    break;
+
+  case llvm::ELF::R_HEX_B9_PCREL_X:
+    bitMask = 0x003000fe;
+    effectiveBits = 9;
+    pResult &= 0x3f;
+    break;
+
+  case llvm::ELF::R_HEX_B7_PCREL_X:
+    bitMask = 0x00001f18;
+    effectiveBits = 7;
+    pResult &= 0x3f;
+    break;
+
+  case llvm::ELF::R_HEX_32_PCREL:
+    bitMask = 0xffffffff;
+    effectiveBits = 32;
+    break;
+
+  case llvm::ELF::R_HEX_6_PCREL_X:
+    // This is unique since it has a unsigned operand and its truncated
+    bitMask = FINDBITMASK(pReloc.target());
+    result = pReloc.addend() + pReloc.symValue() - pReloc.place();
+    pReloc.target() |= ApplyMask<uint32_t>(bitMask, result);
+    return HexagonRelocator::OK;
+
+  default:
+    // show proper error
+    fatal(diag::unsupported_relocation) << (int)
+        pReloc.type() << "mclinker@googlegroups.com";
+  }
+
+  if ((shift != 0) && (pResult % alignment != 0))
+    return HexagonRelocator::BadReloc;
+
+  pResult >>= shift;
+
+  if (effectiveBits) {
+    int64_t range = 1LL << (effectiveBits - 1);
+    if ((pResult > (range - 1)) || (pResult < -range))
+      return HexagonRelocator::Overflow;
+  }
+
+  pReloc.target() |= (uint32_t) ApplyMask<int32_t>(bitMask, pResult);
+  return HexagonRelocator::OK;
+}
+
+HexagonRelocator::Result relocAbs(Relocation &pReloc,
+                                  HexagonRelocator &pParent) {
+  ResolveInfo *rsym = pReloc.symInfo();
+  HexagonRelocator::Address S = pReloc.symValue();
+  HexagonRelocator::DWord A = pReloc.addend();
+
+  Relocation* rel_entry = pParent.getRelRelMap().lookUp(pReloc);
+  bool has_dyn_rel = (NULL != rel_entry);
+
+  // if the flag of target section is not ALLOC, we eprform only static
+  // relocation.
+  if (0 == (llvm::ELF::SHF_ALLOC &
+            pReloc.targetRef().frag()->getParent()->getSection().flag())) {
+    return applyAbs(pReloc);
+  }
+
+  // a local symbol with .rela type relocation
   if (rsym->isLocal() && has_dyn_rel) {
-    FragmentRef &target_fragref = pReloc.targetRef();
-    Fragment *target_frag = target_fragref.frag();
-    HexagonRelocator::Type pType = llvm::ELF::R_HEX_RELATIVE;
-    Relocation& rel_entry = helper_DynRel(rsym, *target_frag,
-        target_fragref.offset(), pType, pParent);
-    rel_entry.setAddend(S + A);
+    rel_entry->setAddend(S + A);
+    return HexagonRelocator::OK;
   }
 
-  uint32_t result = (uint32_t) (S + A);
+  if (!rsym->isLocal()) {
+    if (rsym->reserved() & HexagonRelocator::ReservePLT) {
+      S = helper_get_PLT_address(*rsym, pParent);
+    }
 
-  pReloc.target() = result | pReloc.target();
-  return HexagonRelocator::OK;
+    if (has_dyn_rel) {
+      if (llvm::ELF::R_HEX_32 == pReloc.type() &&
+          helper_use_relative_reloc(*rsym, pParent)) {
+        rel_entry->setAddend(S + A);
+      } else {
+        rel_entry->setAddend(A);
+        return HexagonRelocator::OK;
+      }
+    }
+  }
+
+  return applyAbs(pReloc);
 }
 
-// R_HEX_16: Word32 : 0xffff : (S + A) : Unsigned Truncate
-HexagonRelocator::Result reloc16(Relocation& pReloc,
-                                 HexagonRelocator& pParent)
-{
+HexagonRelocator::Result relocPCREL(Relocation &pReloc,
+                                    HexagonRelocator &pParent) {
+  ResolveInfo *rsym = pReloc.symInfo();
+  int64_t result;
+
+  HexagonRelocator::Address S = pReloc.symValue();
   HexagonRelocator::DWord A = pReloc.addend();
-  HexagonRelocator::DWord S = pReloc.symValue();
+  HexagonRelocator::DWord P = pReloc.place();
 
-  uint32_t result = (uint32_t) (S + A);
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0x0000ffff, result);
+  FragmentRef &target_fragref = pReloc.targetRef();
+  Fragment *target_frag = target_fragref.frag();
+  LDSection &target_sect = target_frag->getParent()->getSection();
 
-  return HexagonRelocator::OK;
+  result = (int64_t)(S + A - P);
+
+  // for relocs inside non ALLOC, just apply
+  if (0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
+    return applyRel(pReloc, result);
+  }
+
+  if (!rsym->isLocal()) {
+    if (rsym->reserved() & HexagonRelocator::ReservePLT) {
+      S = helper_get_PLT_address(*rsym, pParent);
+      result = (int64_t)(S + A - P);
+      applyRel(pReloc, result);
+      return HexagonRelocator::OK;
+    }
+  }
+
+  return applyRel(pReloc, result);
 }
 
-// R_HEX_8: Word32 : 0xff : (S + A) : Unsigned Truncate
-HexagonRelocator::Result reloc8(Relocation& pReloc,
-                                HexagonRelocator& pParent)
-{
+// R_HEX_GPREL16_0 and its class : Unsigned Verify
+HexagonRelocator::Result relocGPREL(Relocation &pReloc,
+                                    HexagonRelocator &pParent) {
+  HexagonRelocator::Address S = pReloc.symValue();
   HexagonRelocator::DWord A = pReloc.addend();
-  HexagonRelocator::DWord S = pReloc.symValue();
+  HexagonRelocator::DWord GP = pParent.getTarget().getGP();
 
-  uint32_t result = (uint32_t) (S + A);
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0x000000ff, result);
+  uint32_t result = (uint32_t)(S + A - GP);
+  uint32_t shift = 0;
+  uint32_t alignment = 1;
 
-  return HexagonRelocator::OK;
-}
+  switch (pReloc.type()) {
+  case llvm::ELF::R_HEX_GPREL16_0:
+    break;
 
-// R_HEX_LO16: Word32_LO : 0x00c03fff  (S + A) : Unsigned Truncate
-HexagonRelocator::Result relocLO16(Relocation& pReloc,
-                                   HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
+  case llvm::ELF::R_HEX_GPREL16_1:
+    shift = 1;
+    alignment = 2;
+    break;
 
-  uint32_t result = (uint32_t) (S + A);
-//  result = ((result & 0x3fff) | ((result << 6) & 0x00c00000));
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0x00c03fff, result);
-  return HexagonRelocator::OK;
-}
+  case llvm::ELF::R_HEX_GPREL16_2:
+    shift = 2;
+    alignment = 4;
+    break;
 
-// R_HEX_HI16: Word32_LO : 0x00c03fff  (S + A) >> 16 : Unsigned Truncate
-HexagonRelocator::Result relocHI16(Relocation& pReloc,
-                                   HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
+  case llvm::ELF::R_HEX_GPREL16_3:
+    shift = 3;
+    alignment = 8;
+    break;
 
-  uint32_t result = (uint32_t) ((S + A) >> 16);
-//  result = ((result & 0x3fff) | ((result << 6) & 0x00c00000));
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0x00c03fff, result);
-  return HexagonRelocator::OK;
-}
-
-// R_HEX_GPREL16_0 : Word32_GP : 0x061f2ff  (S + A - GP) : Unsigned Verify
-HexagonRelocator::Result relocGPREL16_0(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonLDBackend& ld_backend = pParent.getTarget();
-  HexagonRelocator::DWord   GP = ld_backend.getGP();
-
-  int64_t result = (int64_t) (S + A - GP);
-  int64_t range = 1ULL << 32;
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  if (result <= range) {
-    pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_GPREL16_1 : Word32_GP : 0x061f2ff  (S + A - GP)>>1 : Unsigned Verify
-HexagonRelocator::Result relocGPREL16_1(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonLDBackend& ld_backend = pParent.getTarget();
-  HexagonRelocator::DWord   GP = ld_backend.getGP();
-
-  int64_t result = (int64_t) ((S + A - GP) >> 1);
-  int64_t range = 1LL << 32;
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  if (result <= range) {
-    pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_GPREL16_2 : Word32_GP : 0x061f2ff  (S + A - GP)>>2 : Unsigned Verify
-HexagonRelocator::Result relocGPREL16_2(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonLDBackend& ld_backend = pParent.getTarget();
-  HexagonRelocator::DWord   GP = ld_backend.getGP();
-
-  int64_t result = (int64_t) ((S + A - GP) >> 2);
-  int64_t range = 1LL << 32;
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  if (result <= range) {
-    pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_GPREL16_3 : Word32_GP : 0x061f2ff  (S + A - GP)>>3 : Unsigned Verify
-HexagonRelocator::Result relocGPREL16_3(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonLDBackend& ld_backend = pParent.getTarget();
-  HexagonRelocator::DWord   GP = ld_backend.getGP();
-
-  int64_t result = (int64_t) ((S + A - GP) >> 3);
-  int64_t range = 1LL << 32;
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  if (result <= range) {
-    pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B13_PCREL : Word32_B13 : 0x00202ffe  (S + A - P)>>2 : Signed Verify
-HexagonRelocator::Result relocB13PCREL(Relocation& pReloc,
-                                       HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = ((S + A - P) >> 2);
-  int32_t range = 1L << 12;
-  if (result < range && result > -range) {
-    pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0x00202ffe, result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B9_PCREL : Word32_B9 : 0x00300ffe  (S + A - P)>>2 : Signed Verify
-HexagonRelocator::Result relocB9PCREL(Relocation& pReloc,
-                                      HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = ((S + A - P) >> 2);
-  int32_t range = 1L << 8;
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  if (result < range && result > -range) {
-    pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
-    return HexagonRelocator::OK;
-  }
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B32_PCREL_X : Word32_X26 : 0x0fff3fff  (S + A - P)>>6 : Truncate
-HexagonRelocator::Result relocB32PCRELX(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = ((S + A - P) >> 6);
-  pReloc.target() = pReloc.target() | ApplyMask<int32_t>(0xfff3fff, result);
-
-  return HexagonRelocator::OK;
-}
-
-// R_HEX_32_6_X : Word32_X26 : 0x0fff3fff  (S + A)>>6 : Unsigned Verify
-HexagonRelocator::Result reloc32_6_X(Relocation& pReloc,
-                                     HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-
-  int64_t result = ((S + A) >> 6);
-  int64_t range = 1LL << 32;
-
-  if (result > range)
-    return HexagonRelocator::Overflow;
-
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0xfff3fff, result);
-
-  return HexagonRelocator::OK;
-}
-
-// R_HEX_B22_PCREL_X : Word32_B22 : 0x01ff3ffe
-// ((S + A - P) & 0x3f)>>2 : Signed Verify
-HexagonRelocator::Result relocB22PCRELX(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = ((S + A - P) & 0x3f);
-  int32_t range = 1 << 21;
-
-  if (result < range && result > -range)  {
-    pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0x01ff3ffe, result);
-    return HexagonRelocator::OK;
+  default:
+    // show proper error
+    fatal(diag::unsupported_relocation) << (int)
+        pReloc.type() << "mclinker@googlegroups.com";
   }
 
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B15_PCREL_X : Word32_B15 : 0x00df20fe
-// ((S + A - P) & 0x3f)>>2 : Signed Verify
-HexagonRelocator::Result relocB15PCRELX(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = ((S + A - P) & 0x3f);
-  int32_t range = 1 << 14;
-
-  if (result < range && result > -range)  {
-    pReloc.target() = pReloc.target() | ApplyMask<int32_t>(0x00df20fe, result);
-    return HexagonRelocator::OK;
-  }
-
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B13_PCREL_X : Word32_B13 : 0x00202ffe
-// ((S + A - P) & 0x3f)>>2 : Signed Verify
-HexagonRelocator::Result relocB13PCRELX(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = ((S + A - P) & 0x3f);
-  int32_t range = 1 << 12;
-
-  if (result < range && result > -range)  {
-    pReloc.target() = pReloc.target() | ApplyMask<int32_t>(0x00202ffe, result);
-    return HexagonRelocator::OK;
-  }
-
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B9_PCREL_X : Word32_B9 : 0x003000fe
-// ((S + A - P) & 0x3f)>>2 : Signed Verify
-HexagonRelocator::Result relocB9PCRELX(Relocation& pReloc,
-                                       HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = ((S + A - P) & 0x3f);
-  int32_t range = 1 << 8;
-
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  if (result < range && result > -range)  {
-    pReloc.target() = pReloc.target() | ApplyMask<int32_t>(bitMask, result);
-    return HexagonRelocator::OK;
-  }
-
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_B7_PCREL_X : Word32_B7 : 0x00001f18
-// ((S + A - P) & 0x3f)>>2 : Signed Verify
-HexagonRelocator::Result relocB7PCRELX(Relocation& pReloc,
-                                       HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = ((S + A - P) & 0x3f);
-  int32_t range = 1 << 6;
-
-  if (result < range && result > -range)  {
-    pReloc.target() = pReloc.target() | ApplyMask<int32_t>(0x00001f18, result);
-    return HexagonRelocator::OK;
-  }
-
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_32_PCREL : Word32 : 0xffffffff  (S + A - P) : Signed Verify
-HexagonRelocator::Result reloc32PCREL(Relocation& pReloc,
-                                      HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int64_t result = S + A - P;
-  int32_t range = 1 << 31;
-
-  if (result < range && result > -range)  {
-    pReloc.target() = pReloc.target() | ApplyMask<int32_t>(0xffffffff, result);
-    return HexagonRelocator::OK;
-  }
-
-  return HexagonRelocator::Overflow;
-}
-
-// R_HEX_N_X : Word32_U6 : (S + A) : Unsigned Truncate
-HexagonRelocator::Result relocHexNX(Relocation& pReloc,
-                                    HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  uint32_t result = (S + A);
+  uint32_t range = 1 << 16;
   uint32_t bitMask = FINDBITMASK(pReloc.target());
 
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
-  return HexagonRelocator::OK;
+  if ((shift != 0) && (result % alignment != 0))
+    return HexagonRelocator::BadReloc;
+
+  result >>= shift;
+
+  if (result < range - 1) {
+    pReloc.target() |= ApplyMask<uint32_t>(bitMask, result);
+    return HexagonRelocator::OK;
+  }
+  return HexagonRelocator::Overflow;
 }
 
 // R_HEX_PLT_B22_PCREL: PLT(S) + A - P
-HexagonRelocator::Result relocPLTB22PCREL(Relocation& pReloc, HexagonRelocator& pParent)
-{
+HexagonRelocator::Result relocPLTB22PCREL(Relocation &pReloc,
+                                          HexagonRelocator &pParent) {
   // PLT_S depends on if there is a PLT entry.
   HexagonRelocator::Address PLT_S;
   if ((pReloc.symInfo()->reserved() & HexagonRelocator::ReservePLT))
-    PLT_S = helper_PLT(pReloc, pParent);
+    PLT_S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
   else
     PLT_S = pReloc.symValue();
   HexagonRelocator::Address P = pReloc.place();
@@ -891,97 +817,142 @@
   return HexagonRelocator::OK;
 }
 
-// R_HEX_GOTREL_LO16: Word32_LO : 0x00c03fff  (S + A - GOT) : Unsigned Truncate
-HexagonRelocator::Result relocHexGOTRELLO16(Relocation& pReloc,
-                                            HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::Address GOT = pParent.getTarget().getGOTSymbolAddr();
-
-  uint32_t result = (uint32_t) (S + A - GOT);
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0x00c03fff, result);
-  return HexagonRelocator::OK;
-}
-
-// R_HEX_GOTREL_HI16 : Word32_LO : 0x00c03fff  (S + A - GOT) >> 16 : Unsigned Truncate
-HexagonRelocator::Result relocHexGOTRELHI16(Relocation& pReloc,
-                                   HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::Address GOT = pParent.getTarget().getGOTSymbolAddr();
-
-  uint32_t result = (uint32_t) ((S + A - GOT) >> 16);
-
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(0x00c03fff, result);
-  return HexagonRelocator::OK;
-}
-
-// R_HEX_GOTREL_32 : Word32  (S + A - GOT) : Unsigned Truncate
-HexagonRelocator::Result relocHexGOTREL32(Relocation& pReloc,
-                                   HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::Address GOT = pParent.getTarget().getGOTSymbolAddr();
-
-  uint32_t result = (uint32_t) (S + A - GOT);
-
-  pReloc.target() = pReloc.target() | result;
-  return HexagonRelocator::OK;
-}
-
-// R_HEX_6_PCREL_X : (S + A - P)
-HexagonRelocator::Result relocHex6PCRELX(Relocation& pReloc,
-                                        HexagonRelocator& pParent)
-{
-  HexagonRelocator::Address S = pReloc.symValue();
-  HexagonRelocator::DWord   A = pReloc.addend();
-  HexagonRelocator::DWord   P = pReloc.place();
-
-  int32_t result = (S + A - P);
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
-  return HexagonRelocator::OK;
-}
-
-// R_HEX_GOT_32_6_X : (G) >> 6
-HexagonRelocator::Result relocHexGOT326X(Relocation& pReloc,
-                                         HexagonRelocator& pParent)
-{
-  if (!(pReloc.symInfo()->reserved()
-       & (HexagonRelocator::ReserveGOT | HexagonRelocator::GOTRel))) {
+//R_HEX_GOT_LO16 and its class : (G) Signed Truncate
+//Exception: R_HEX_GOT_16(_X): signed verify
+// Exception: R_HEX_GOT_11_X : unsigned truncate
+HexagonRelocator::Result relocGOT(Relocation &pReloc,
+                                  HexagonRelocator &pParent) {
+  if (!(pReloc.symInfo()->reserved() & HexagonRelocator::ReserveGOT)) {
     return HexagonRelocator::BadReloc;
   }
-  HexagonRelocator::Address GOT_S   = helper_GOT(pReloc, pParent);
-  HexagonRelocator::Address GOT = pParent.getTarget().getGOTSymbolAddr();
-  int32_t result = (GOT_S - GOT) >> 6;
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
-  return HexagonRelocator::OK;
-}
 
-// R_HEX_GOT_16_X : (G)
-// R_HEX_GOT_11_X : (G)
-HexagonRelocator::Result relocHexGOT1611X(Relocation& pReloc,
-                                         HexagonRelocator& pParent)
-{
-  if (!(pReloc.symInfo()->reserved()
-       & (HexagonRelocator::ReserveGOT | HexagonRelocator::GOTRel))) {
-    return HexagonRelocator::BadReloc;
+  // set got entry value if needed
+  HexagonGOTEntry *got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
+  assert(NULL != got_entry);
+  if (HexagonRelocator::SymVal == got_entry->getValue())
+    got_entry->setValue(pReloc.symValue());
+
+  HexagonRelocator::Address GOT_S =
+                             helper_get_GOT_address(*pReloc.symInfo(), pParent);
+  HexagonRelocator::Address GOT = pParent.getTarget().getGOTSymbolAddr();
+  int32_t result = (int32_t)(GOT_S - GOT);
+  uint32_t effectiveBits = 0;
+  uint32_t alignment = 1;
+  uint32_t bitMask = 0;
+  uint32_t result_u;
+  uint32_t shift = 0;
+
+  switch (pReloc.type()) {
+  case llvm::ELF::R_HEX_GOT_LO16:
+    bitMask = 0x00c03fff;
+    break;
+
+  case llvm::ELF::R_HEX_GOT_HI16:
+    bitMask = 0x00c03fff;
+    shift = 16;
+    alignment = 4;
+    break;
+
+  case llvm::ELF::R_HEX_GOT_32:
+    bitMask = 0xffffffff;
+    break;
+
+  case llvm::ELF::R_HEX_GOT_16:
+    bitMask = FINDBITMASK(pReloc.target());
+    effectiveBits = 16;
+    break;
+
+  case llvm::ELF::R_HEX_GOT_32_6_X:
+    bitMask = 0xfff3fff;
+    shift = 6;
+    break;
+
+  case llvm::ELF::R_HEX_GOT_16_X:
+    bitMask = FINDBITMASK(pReloc.target());
+    effectiveBits = 6;
+    break;
+
+  case llvm::ELF::R_HEX_GOT_11_X:
+    bitMask = FINDBITMASK(pReloc.target());
+    result_u = GOT_S - GOT;
+    pReloc.target() |= ApplyMask<uint32_t>(bitMask, result_u);
+    return HexagonRelocator::OK;
+
+  default:
+    // show proper error
+    fatal(diag::unsupported_relocation) << (int)
+        pReloc.type() << "mclinker@googlegroups.com";
   }
-  HexagonRelocator::Address GOT_S   = helper_GOT(pReloc, pParent);
-  HexagonRelocator::Address GOT = pParent.getTarget().getGOTSymbolAddr();
-  int32_t result = (GOT_S - GOT);
-  uint32_t bitMask = FINDBITMASK(pReloc.target());
-  pReloc.target() = pReloc.target() | ApplyMask<uint32_t>(bitMask, result);
+
+  if ((shift != 0) && (result % alignment != 0))
+    return HexagonRelocator::BadReloc;
+
+  result >>= shift;
+
+  if (effectiveBits) {
+    int32_t range = 1 << (effectiveBits - 1);
+    if ((result > range - 1) || (result < -range))
+      return HexagonRelocator::Overflow;
+  }
+  pReloc.target() |= ApplyMask<int32_t>(bitMask, result);
   return HexagonRelocator::OK;
 }
 
-HexagonRelocator::Result unsupport(Relocation& pReloc,
-                                   HexagonRelocator& pParent)
-{
+// R_HEX_GOTREL_LO16: and its class of relocs
+// (S + A - GOT) : Signed Truncate
+HexagonRelocator::Result relocGOTREL(Relocation &pReloc,
+                                     HexagonRelocator &pParent) {
+  HexagonRelocator::Address S = pReloc.symValue();
+  HexagonRelocator::DWord A = pReloc.addend();
+  HexagonRelocator::Address GOT = pParent.getTarget().getGOTSymbolAddr();
+
+  uint32_t bitMask = 0;
+  uint32_t alignment = 1;
+  uint32_t shift = 0;
+
+  uint32_t result = (uint32_t)(S + A - GOT);
+
+  switch (pReloc.type()) {
+  case llvm::ELF::R_HEX_GOTREL_LO16:
+    bitMask = 0x00c03fff;
+    break;
+
+  case llvm::ELF::R_HEX_GOTREL_HI16:
+    bitMask = 0x00c03fff;
+    shift = 16;
+    alignment = 4;
+    break;
+
+  case llvm::ELF::R_HEX_GOTREL_32:
+    bitMask = 0xffffffff;
+    break;
+
+  case llvm::ELF::R_HEX_GOTREL_32_6_X:
+    bitMask = 0x0fff3fff;
+    shift = 6;
+    break;
+
+  case llvm::ELF::R_HEX_GOTREL_16_X:
+  case llvm::ELF::R_HEX_GOTREL_11_X:
+    bitMask = FINDBITMASK(pReloc.target());
+    break;
+
+  default:
+    // show proper error
+    fatal(diag::unsupported_relocation) << (int)
+        pReloc.type() << "mclinker@googlegroups.com";
+  }
+
+  if (result % alignment != 0)
+    return HexagonRelocator::BadReloc;
+
+  result >>= shift;
+
+  pReloc.target() |= ApplyMask<uint32_t>(bitMask, result);
+  return HexagonRelocator::OK;
+}
+
+HexagonRelocator::Result unsupport(Relocation &pReloc,
+                                   HexagonRelocator &pParent) {
   return HexagonRelocator::Unsupport;
 }
diff --git a/lib/Target/Hexagon/HexagonRelocator.h b/lib/Target/Hexagon/HexagonRelocator.h
index e65be9f..02e99c9 100644
--- a/lib/Target/Hexagon/HexagonRelocator.h
+++ b/lib/Target/Hexagon/HexagonRelocator.h
@@ -15,7 +15,7 @@
 #include <mcld/LD/Relocator.h>
 #include <mcld/Target/GOT.h>
 #include <mcld/Target/PLT.h>
-#include <mcld/Target/SymbolEntryMap.h>
+#include <mcld/Target/KeyEntryMap.h>
 #include "HexagonLDBackend.h"
 
 namespace mcld {
@@ -30,55 +30,45 @@
 class HexagonRelocator : public Relocator
 {
 public:
-  typedef SymbolEntryMap<PLTEntryBase> SymPLTMap;
-  typedef SymbolEntryMap<HexagonGOTEntry> SymGOTMap;
-  typedef SymbolEntryMap<HexagonGOTEntry> SymGOTPLTMap;
-
+  typedef KeyEntryMap<ResolveInfo, PLTEntryBase> SymPLTMap;
+  typedef KeyEntryMap<ResolveInfo, HexagonGOTEntry> SymGOTMap;
+  typedef KeyEntryMap<ResolveInfo, HexagonGOTEntry> SymGOTPLTMap;
+  typedef KeyEntryMap<Relocation, Relocation> RelRelMap;
 
 public:
   /** \enum ReservedEntryType
    *  \brief The reserved entry type of reserved space in ResolveInfo.
    *
    *  This is used for sacnRelocation to record what kinds of entries are
-   *  reserved for this resolved symbol
+   *  reserved for this resolved symbol. In Hexagon, there are three kinds
+   *  of entries, GOT, PLT, and dynamic relocation.
    *
-   *  In Hexagon, there are three kinds of entries, GOT, PLT, and dynamic
-   *  relocation.
-   *
-   *  GOT may needs a corresponding relocation to relocate itself, so we
-   *  separate GOT to two situations: GOT and GOTRel. Besides, for the same
-   *  symbol, there might be two kinds of entries reserved for different location.
-   *  For example, reference to the same symbol, one may use GOT and the other may
-   *  use dynamic relocation.
-   *
-   *  bit:  3       2      1     0
-   *   | PLT | GOTRel | GOT | Rel |
+   *  bit:  3     2     1     0
+   *   |    | PLT | GOT | Rel |
    *
    *  value    Name         - Description
    *
    *  0000     None         - no reserved entry
    *  0001     ReserveRel   - reserve an dynamic relocation entry
    *  0010     ReserveGOT   - reserve an GOT entry
-   *  0011     GOTandRel    - For different relocation, we've reserved GOT and
-   *                          Rel for different location.
-   *  0100     GOTRel       - reserve an GOT entry and the corresponding Dyncamic
-   *                          relocation entry which relocate this GOT entry
-   *  0101     GOTRelandRel - For different relocation, we've reserved GOTRel
-   *                          and relocation entry for different location.
-   *  1000     ReservePLT   - reserve an PLT entry and the corresponding GOT,
-   *                          Dynamic relocation entries
-   *  1001     PLTandRel    - For different relocation, we've reserved PLT and
-   *                          Rel for different location.
+   *  0100     ReservePLT   - reserve an PLT entry and the corresponding GOT,
+   *
    */
   enum ReservedEntryType {
     None         = 0,
     ReserveRel   = 1,
     ReserveGOT   = 2,
-    GOTandRel    = 3,
-    GOTRel       = 4,
-    GOTRelandRel = 5,
-    ReservePLT   = 8,
-    PLTandRel    = 9
+    ReservePLT   = 4,
+  };
+
+  /** \enum EntryValue
+   *  \brief The value of the entries. The symbol value will be decided at after
+   *  layout, so we mark the entry during scanRelocation and fill up the actual
+   *  value when applying relocations.
+   */
+  enum EntryValue {
+    Default = 0,
+    SymVal  = 1
   };
 
   HexagonRelocator(HexagonLDBackend& pParent, const LinkerConfig& pConfig);
@@ -95,7 +85,8 @@
   void scanRelocation(Relocation& pReloc,
                       IRBuilder& pBuilder,
                       Module& pModule,
-                      LDSection& pSection);
+                      LDSection& pSection,
+                      Input& pInput);
 
   // Handle partial linking
   void partialScanRelocation(Relocation& pReloc,
@@ -121,6 +112,9 @@
   const SymGOTPLTMap& getSymGOTPLTMap() const { return m_SymGOTPLTMap; }
   SymGOTPLTMap&       getSymGOTPLTMap()       { return m_SymGOTPLTMap; }
 
+  const RelRelMap& getRelRelMap() const { return m_RelRelMap; }
+  RelRelMap&       getRelRelMap()       { return m_RelRelMap; }
+
 protected:
   /// addCopyReloc - add a copy relocation into .rela.dyn for pSym
   /// @param pSym - A resolved copy symbol that defined in BSS section
@@ -148,6 +142,7 @@
   SymPLTMap m_SymPLTMap;
   SymGOTMap m_SymGOTMap;
   SymGOTPLTMap m_SymGOTPLTMap;
+  RelRelMap m_RelRelMap;
 };
 
 } // namespace of mcld
diff --git a/lib/Target/Hexagon/HexagonTargetMachine.cpp b/lib/Target/Hexagon/HexagonTargetMachine.cpp
index 4e4f1c2..33067b9 100644
--- a/lib/Target/Hexagon/HexagonTargetMachine.cpp
+++ b/lib/Target/Hexagon/HexagonTargetMachine.cpp
@@ -8,7 +8,6 @@
 //===----------------------------------------------------------------------===//
 #include "HexagonTargetMachine.h"
 #include "Hexagon.h"
-#include <mcld/Target/TargetMachine.h>
 #include <mcld/Support/TargetRegistry.h>
 
 extern "C" void MCLDInitializeHexagonLDTarget() {
@@ -17,13 +16,14 @@
      X(mcld::TheHexagonTarget);
 }
 
-mcld::HexagonTargetMachine::HexagonTargetMachine(llvm::TargetMachine& pPM,
-                                                 const mcld::Target &pTarget,
-                                                 const std::string& pTriple)
-  : mcld::MCLDTargetMachine(pPM, pTarget, pTriple) {
-}
+using namespace mcld;
 
-mcld::HexagonTargetMachine::~HexagonTargetMachine()
-{
+//===----------------------------------------------------------------------===//
+// HexagonTargetMachine
+//===----------------------------------------------------------------------===//
+HexagonTargetMachine::HexagonTargetMachine(llvm::TargetMachine& pPM,
+                                           const llvm::Target& pLLVMTarget,
+                                           const mcld::Target& pMCLDTarget,
+                                           const std::string& pTriple)
+  : MCLDTargetMachine(pPM, pLLVMTarget, pMCLDTarget, pTriple) {
 }
-
diff --git a/lib/Target/Hexagon/HexagonTargetMachine.h b/lib/Target/Hexagon/HexagonTargetMachine.h
index a374475..9b131c1 100644
--- a/lib/Target/Hexagon/HexagonTargetMachine.h
+++ b/lib/Target/Hexagon/HexagonTargetMachine.h
@@ -9,7 +9,7 @@
 #ifndef MCLD_HEXAGON_TARGET_MACHINE_H
 #define MCLD_HEXAGON_TARGET_MACHINE_H
 #include "Hexagon.h"
-#include <mcld/Target/TargetMachine.h>
+#include <mcld/CodeGen/TargetMachine.h>
 
 namespace mcld {
 
@@ -17,10 +17,9 @@
 {
 public:
   HexagonTargetMachine(llvm::TargetMachine &pTM,
-                       const mcld::Target &pTarget,
+                       const llvm::Target &pLLVMTarget,
+                       const mcld::Target &pMCLDTarget,
                        const std::string &pTriple);
-
-  virtual ~HexagonTargetMachine();
 };
 
 } // namespace of mcld
diff --git a/lib/Target/Hexagon/TargetInfo/HexagonTargetInfo.cpp b/lib/Target/Hexagon/TargetInfo/HexagonTargetInfo.cpp
index 0b113aa..e0d660b 100644
--- a/lib/Target/Hexagon/TargetInfo/HexagonTargetInfo.cpp
+++ b/lib/Target/Hexagon/TargetInfo/HexagonTargetInfo.cpp
@@ -6,7 +6,7 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <mcld/Target/TargetMachine.h>
+#include <mcld/Support/Target.h>
 #include <mcld/Support/TargetRegistry.h>
 
 namespace mcld {
@@ -15,7 +15,7 @@
 
 extern "C" void MCLDInitializeHexagonLDTargetInfo() {
   // register into mcld::TargetRegistry
-  mcld::RegisterTarget X(TheHexagonTarget, "hexagon");
+  mcld::RegisterTarget<llvm::Triple::hexagon> X(TheHexagonTarget, "hexagon");
 }
 
 } // namespace of mcld
diff --git a/lib/Target/Mips/Mips.h b/lib/Target/Mips/Mips.h
index a63be45..35be4b4 100644
--- a/lib/Target/Mips/Mips.h
+++ b/lib/Target/Mips/Mips.h
@@ -9,11 +9,12 @@
 #ifndef MCLD_MIPS_H
 #define MCLD_MIPS_H
 
-#include "mcld/Support/TargetRegistry.h"
-
 namespace mcld {
 
-extern mcld::Target TheMipselTarget;
+class Target;
+
+extern Target TheMipselTarget;
+extern Target TheMips64elTarget;
 
 } // namespace of mcld
 
diff --git a/lib/Target/Mips/MipsDiagnostic.cpp b/lib/Target/Mips/MipsDiagnostic.cpp
index 2d5b7d9..e03ea3c 100644
--- a/lib/Target/Mips/MipsDiagnostic.cpp
+++ b/lib/Target/Mips/MipsDiagnostic.cpp
@@ -6,30 +6,30 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <llvm/ADT/Triple.h>
 #include <mcld/Support/TargetRegistry.h>
 #include <mcld/LD/DWARFLineInfo.h>
 #include "Mips.h"
 
-using namespace mcld;
+namespace {
 
-
-namespace mcld {
 //===----------------------------------------------------------------------===//
 // createMipsDiagnostic - the help function to create corresponding
 // MipsDiagnostic
-DiagnosticLineInfo* createMipsDiagLineInfo(const mcld::Target& pTarget,
-                                           const std::string &pTriple)
+//===----------------------------------------------------------------------===//
+mcld::DiagnosticLineInfo* createMipsDiagLineInfo(const mcld::Target& pTarget,
+                                                 const std::string &pTriple)
 {
-  return new DWARFLineInfo();
+  return new mcld::DWARFLineInfo();
 }
 
 } // namespace of mcld
 
-//==========================
+//===----------------------------------------------------------------------===//
 // InitializeMipsDiagnostic
+//===----------------------------------------------------------------------===//
 extern "C" void MCLDInitializeMipsDiagnosticLineInfo() {
-  // Register the linker frontend
-  mcld::TargetRegistry::RegisterDiagnosticLineInfo(TheMipselTarget, createMipsDiagLineInfo);
+  mcld::TargetRegistry::RegisterDiagnosticLineInfo(mcld::TheMipselTarget,
+                                                   createMipsDiagLineInfo);
+  mcld::TargetRegistry::RegisterDiagnosticLineInfo(mcld::TheMips64elTarget,
+                                                   createMipsDiagLineInfo);
 }
-
diff --git a/lib/Target/Mips/MipsELFDynamic.cpp b/lib/Target/Mips/MipsELFDynamic.cpp
index e34d698..b532b03 100644
--- a/lib/Target/Mips/MipsELFDynamic.cpp
+++ b/lib/Target/Mips/MipsELFDynamic.cpp
@@ -6,61 +6,55 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "MipsELFDynamic.h"
-
-#include "MipsLDBackend.h"
+#include <llvm/Support/ELF.h>
+#include <mcld/LinkerConfig.h>
 #include <mcld/LD/ELFFileFormat.h>
+#include <mcld/LD/ELFSegment.h>
+#include <mcld/LD/ELFSegmentFactory.h>
 #include <mcld/Target/GNULDBackend.h>
+#include "MipsELFDynamic.h"
+#include "MipsLDBackend.h"
 
 using namespace mcld;
 
-// MIPS mandatory dynamic section entries
-enum {
-  MIPS_RLD_VERSION  = 0x70000001,
-  MIPS_FLAGS        = 0x70000005,
-  MIPS_BASE_ADDRESS = 0x70000006,
-  MIPS_LOCAL_GOTNO  = 0x7000000a,
-  MIPS_SYMTABNO     = 0x70000011,
-  MIPS_GOTSYM       = 0x70000013
-};
-
 MipsELFDynamic::MipsELFDynamic(const MipsGNULDBackend& pParent,
                                const LinkerConfig& pConfig)
   : ELFDynamic(pParent, pConfig),
-    m_pParent(pParent)
-{
-}
-
-MipsELFDynamic::~MipsELFDynamic()
+    m_pParent(pParent),
+    m_pConfig(pConfig)
 {
 }
 
 void MipsELFDynamic::reserveTargetEntries(const ELFFileFormat& pFormat)
 {
-  // reservePLTGOT
   if (pFormat.hasGOT())
     reserveOne(llvm::ELF::DT_PLTGOT);
 
-  reserveOne(MIPS_RLD_VERSION);
-  reserveOne(MIPS_FLAGS);
-  reserveOne(MIPS_BASE_ADDRESS);
-  reserveOne(MIPS_LOCAL_GOTNO);
-  reserveOne(MIPS_SYMTABNO);
-  reserveOne(MIPS_GOTSYM);
+  reserveOne(llvm::ELF::DT_MIPS_RLD_VERSION);
+  reserveOne(llvm::ELF::DT_MIPS_FLAGS);
+  reserveOne(llvm::ELF::DT_MIPS_BASE_ADDRESS);
+  reserveOne(llvm::ELF::DT_MIPS_LOCAL_GOTNO);
+  reserveOne(llvm::ELF::DT_MIPS_SYMTABNO);
+  reserveOne(llvm::ELF::DT_MIPS_GOTSYM);
+
+  if (pFormat.hasGOTPLT())
+    reserveOne(llvm::ELF::DT_MIPS_PLTGOT);
 }
 
 void MipsELFDynamic::applyTargetEntries(const ELFFileFormat& pFormat)
 {
-  // applyPLTGOT
   if (pFormat.hasGOT())
     applyOne(llvm::ELF::DT_PLTGOT, pFormat.getGOT().addr());
 
-  applyOne(MIPS_RLD_VERSION, 1);
-  applyOne(MIPS_FLAGS, 0);
-  applyOne(MIPS_BASE_ADDRESS, 0);
-  applyOne(MIPS_LOCAL_GOTNO, getLocalGotNum(pFormat));
-  applyOne(MIPS_SYMTABNO, getSymTabNum(pFormat));
-  applyOne(MIPS_GOTSYM, getGotSym(pFormat));
+  applyOne(llvm::ELF::DT_MIPS_RLD_VERSION, 1);
+  applyOne(llvm::ELF::DT_MIPS_FLAGS, llvm::ELF::RHF_NOTPOT);
+  applyOne(llvm::ELF::DT_MIPS_BASE_ADDRESS, getBaseAddress());
+  applyOne(llvm::ELF::DT_MIPS_LOCAL_GOTNO, getLocalGotNum(pFormat));
+  applyOne(llvm::ELF::DT_MIPS_SYMTABNO, getSymTabNum(pFormat));
+  applyOne(llvm::ELF::DT_MIPS_GOTSYM, getGotSym(pFormat));
+
+  if (pFormat.hasGOTPLT())
+    applyOne(llvm::ELF::DT_MIPS_PLTGOT, pFormat.getGOTPLT().addr());
 }
 
 size_t MipsELFDynamic::getSymTabNum(const ELFFileFormat& pFormat) const
@@ -87,3 +81,14 @@
 
   return m_pParent.getGOT().getLocalNum();
 }
+
+uint64_t MipsELFDynamic::getBaseAddress()
+{
+  if (LinkerConfig::Exec != m_pConfig.codeGenType())
+    return 0;
+
+  ELFSegmentFactory::const_iterator baseSeg =
+    m_pParent.elfSegmentTable().find(llvm::ELF::PT_LOAD, 0x0, 0x0);
+
+  return m_pParent.elfSegmentTable().end() == baseSeg ? 0 : (*baseSeg)->vaddr();
+}
diff --git a/lib/Target/Mips/MipsELFDynamic.h b/lib/Target/Mips/MipsELFDynamic.h
index 6efbf71..bb7e579 100644
--- a/lib/Target/Mips/MipsELFDynamic.h
+++ b/lib/Target/Mips/MipsELFDynamic.h
@@ -22,10 +22,10 @@
 {
 public:
   MipsELFDynamic(const MipsGNULDBackend& pParent, const LinkerConfig& pConfig);
-  ~MipsELFDynamic();
 
 private:
   const MipsGNULDBackend& m_pParent;
+  const LinkerConfig& m_pConfig;
 
 private:
   void reserveTargetEntries(const ELFFileFormat& pFormat);
@@ -34,6 +34,7 @@
   size_t getSymTabNum(const ELFFileFormat& pFormat) const;
   size_t getGotSym(const ELFFileFormat& pFormat) const;
   size_t getLocalGotNum(const ELFFileFormat& pFormat) const;
+  uint64_t getBaseAddress();
 };
 
 } // namespace of mcld
diff --git a/lib/Target/Mips/MipsELFMCLinker.cpp b/lib/Target/Mips/MipsELFMCLinker.cpp
index 3964ee8..077177a 100644
--- a/lib/Target/Mips/MipsELFMCLinker.cpp
+++ b/lib/Target/Mips/MipsELFMCLinker.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 #include "MipsELFMCLinker.h"
-#include <mcld/LinkerConfig.h>
 
 using namespace mcld;
 
 MipsELFMCLinker::MipsELFMCLinker(LinkerConfig& pConfig,
                                  mcld::Module& pModule,
-                                 MemoryArea& pOutput)
-  : ELFMCLinker(pConfig, pModule, pOutput) {
+                                 FileHandle& pFileHandle)
+  : ELFMCLinker(pConfig, pModule, pFileHandle) {
 }
 
 MipsELFMCLinker::~MipsELFMCLinker()
diff --git a/lib/Target/Mips/MipsELFMCLinker.h b/lib/Target/Mips/MipsELFMCLinker.h
index 2c240ad..cdffdd5 100644
--- a/lib/Target/Mips/MipsELFMCLinker.h
+++ b/lib/Target/Mips/MipsELFMCLinker.h
@@ -16,7 +16,7 @@
 namespace mcld {
 
 class Module;
-class MemoryArea;
+class FileHandle;
 
 /** \class MipsELFMCLinker
  *  \brief MipsELFMCLinker sets up the environment for linking.
@@ -26,7 +26,7 @@
 public:
   MipsELFMCLinker(LinkerConfig& pConfig,
                   mcld::Module& pModule,
-                  MemoryArea& pOutput);
+                  FileHandle& pFileHandle);
 
   ~MipsELFMCLinker();
 };
diff --git a/lib/Target/Mips/MipsEmulation.cpp b/lib/Target/Mips/MipsEmulation.cpp
index bdb1783..5e5d192 100644
--- a/lib/Target/Mips/MipsEmulation.cpp
+++ b/lib/Target/Mips/MipsEmulation.cpp
@@ -21,7 +21,11 @@
 
   // set up bitclass and endian
   pConfig.targets().setEndian(TargetOptions::Little);
-  pConfig.targets().setBitClass(32);
+
+  llvm::Triple::ArchType arch = pConfig.targets().triple().getArch();
+  assert(arch == llvm::Triple::mipsel || arch == llvm::Triple::mips64el);
+  unsigned bitclass = arch == llvm::Triple::mipsel ? 32 : 64;
+  pConfig.targets().setBitClass(bitclass);
 
   // set up target-dependent constraints of attributes
   pConfig.attribute().constraint().enableWholeArchive();
@@ -58,7 +62,8 @@
 // MipsEmulation
 //===----------------------------------------------------------------------===//
 extern "C" void MCLDInitializeMipsEmulation() {
-  // Register the emulation
-  mcld::TargetRegistry::RegisterEmulation(mcld::TheMipselTarget, mcld::emulateMipsLD);
+  mcld::TargetRegistry::RegisterEmulation(mcld::TheMipselTarget,
+                                          mcld::emulateMipsLD);
+  mcld::TargetRegistry::RegisterEmulation(mcld::TheMips64elTarget,
+                                          mcld::emulateMipsLD);
 }
-
diff --git a/lib/Target/Mips/MipsGNUInfo.cpp b/lib/Target/Mips/MipsGNUInfo.cpp
new file mode 100644
index 0000000..521a800
--- /dev/null
+++ b/lib/Target/Mips/MipsGNUInfo.cpp
@@ -0,0 +1,77 @@
+//===- MipsGNUInfo.cpp ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "MipsGNUInfo.h"
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// MipsGNUInfo
+//===----------------------------------------------------------------------===//
+MipsGNUInfo::MipsGNUInfo(const llvm::Triple& pTriple)
+  : GNUInfo(pTriple),
+    m_ABIVersion(0),
+    m_PICFlags(0)
+{}
+
+void MipsGNUInfo::setABIVersion(uint8_t ver)
+{
+  m_ABIVersion = ver;
+}
+
+void MipsGNUInfo::setPICFlags(uint64_t flags)
+{
+  m_PICFlags = flags;
+}
+
+uint32_t MipsGNUInfo::machine() const
+{
+  return llvm::ELF::EM_MIPS;
+}
+
+uint8_t MipsGNUInfo::ABIVersion() const
+{
+  return m_ABIVersion;
+}
+
+uint64_t MipsGNUInfo::defaultTextSegmentAddr() const
+{
+  if (m_Triple.isArch32Bit())
+    return 0x400000;
+  else
+    return 0x120000000ull;
+}
+
+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;
+}
+
+const char* MipsGNUInfo::entry() const
+{
+  return "__start";
+}
+
+const char* MipsGNUInfo::dyld() const
+{
+  return m_Triple.isArch32Bit() ? "/lib/ld.so.1" : "/lib64/ld.so.1";
+}
+
+uint64_t MipsGNUInfo::abiPageSize() const
+{
+  return 0x10000;
+}
+
+} // end mcld namespace
diff --git a/lib/Target/Mips/MipsGNUInfo.h b/lib/Target/Mips/MipsGNUInfo.h
index 9c829d5..2e43d80 100644
--- a/lib/Target/Mips/MipsGNUInfo.h
+++ b/lib/Target/Mips/MipsGNUInfo.h
@@ -8,52 +8,33 @@
 //===----------------------------------------------------------------------===//
 #ifndef MCLD_TARGET_MIPS_GNU_INFO_H
 #define MCLD_TARGET_MIPS_GNU_INFO_H
-#include <mcld/Target/GNUInfo.h>
-
 #include <llvm/Support/ELF.h>
+#include <mcld/Target/GNUInfo.h>
 
 namespace mcld {
 
 class MipsGNUInfo : public GNUInfo
 {
 public:
-  enum {
-    // The original o32 abi.
-    E_MIPS_ABI_O32    = 0x00001000,
-    // O32 extended to work on 64 bit architectures.
-    E_MIPS_ABI_O64    = 0x00002000,
-    // EABI in 32 bit mode.
-    E_MIPS_ABI_EABI32 = 0x00003000,
-    // EABI in 64 bit mode.
-    E_MIPS_ABI_EABI64 = 0x00004000
-  };
+  MipsGNUInfo(const llvm::Triple& pTriple);
 
-public:
-  MipsGNUInfo(const llvm::Triple& pTriple) : GNUInfo(pTriple) { }
+  void setABIVersion(uint8_t ver);
+  void setPICFlags(uint64_t flags);
 
-  uint32_t machine() const { return llvm::ELF::EM_MIPS; }
+  // GNUInfo
+  uint32_t machine() const;
+  uint8_t ABIVersion() const;
+  uint64_t defaultTextSegmentAddr() const;
+  uint64_t flags() const;
+  const char* entry() const;
+  const char* dyld() const;
+  uint64_t abiPageSize() const;
 
-  uint64_t defaultTextSegmentAddr() const { return 0x80000; }
-
-  uint64_t flags() const
-  {
-    // TODO: (simon) The correct flag's set depend on command line
-    // arguments and flags from input .o files.
-    return llvm::ELF::EF_MIPS_ARCH_32R2 |
-           llvm::ELF::EF_MIPS_NOREORDER |
-           llvm::ELF::EF_MIPS_PIC |
-           llvm::ELF::EF_MIPS_CPIC |
-           E_MIPS_ABI_O32;
-  }
-
-  const char* entry() const { return "__start"; }
-
-  const char* dyld() const { return "/lib/ld.so.1"; }
-
-  uint64_t abiPageSize() const { return 0x10000; }
+private:
+  uint8_t m_ABIVersion;
+  uint64_t m_PICFlags;
 };
 
 } // namespace of mcld
 
 #endif
-
diff --git a/lib/Target/Mips/MipsGOT.cpp b/lib/Target/Mips/MipsGOT.cpp
index 037e75a..dddf12b 100644
--- a/lib/Target/Mips/MipsGOT.cpp
+++ b/lib/Target/Mips/MipsGOT.cpp
@@ -11,7 +11,6 @@
 #include <llvm/Support/ELF.h>
 
 #include <mcld/LD/ResolveInfo.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Target/OutputRelocSection.h>
 
@@ -19,7 +18,9 @@
 #include "MipsRelocator.h"
 
 namespace {
-  const size_t MipsGOT0Num = 1;
+  const uint32_t Mips32ModulePtr = 1 << 31;
+  const uint64_t Mips64ModulePtr = 1ull << 63;
+  const size_t MipsGOT0Num = 2;
   const size_t MipsGOTGpOffset = 0x7FF0;
   const size_t MipsGOTSize = MipsGOTGpOffset + 0x7FFF;
 }
@@ -27,13 +28,6 @@
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
-// MipsGOTEntry
-//===----------------------------------------------------------------------===//
-MipsGOTEntry::MipsGOTEntry(uint64_t pContent, SectionData* pParent)
-   : GOT::Entry<4>(pContent, pParent)
-{}
-
-//===----------------------------------------------------------------------===//
 // MipsGOT::GOTMultipart
 //===----------------------------------------------------------------------===//
 MipsGOT::GOTMultipart::GOTMultipart(size_t local, size_t global)
@@ -57,7 +51,7 @@
   assert(m_ConsumedLocal < m_LocalNum &&
          "Consumed too many local GOT entries");
   ++m_ConsumedLocal;
-  m_pLastLocal = llvm::cast<MipsGOTEntry>(m_pLastLocal->getNextNode());
+  m_pLastLocal = m_pLastLocal->getNextNode();
 }
 
 void MipsGOT::GOTMultipart::consumeGlobal()
@@ -65,7 +59,29 @@
   assert(m_ConsumedGlobal < m_GlobalNum &&
          "Consumed too many global GOT entries");
   ++m_ConsumedGlobal;
-  m_pLastGlobal = llvm::cast<MipsGOTEntry>(m_pLastGlobal->getNextNode());
+  m_pLastGlobal = m_pLastGlobal->getNextNode();
+}
+
+//===----------------------------------------------------------------------===//
+// MipsGOT::LocalEntry
+//===----------------------------------------------------------------------===//
+MipsGOT::LocalEntry::LocalEntry(const ResolveInfo* pInfo,
+                                Relocation::DWord addend, bool isGot16)
+  : m_pInfo(pInfo),
+    m_Addend(addend),
+    m_IsGot16(isGot16)
+{
+}
+
+bool MipsGOT::LocalEntry::operator<(const LocalEntry &O) const
+{
+  if (m_pInfo != O.m_pInfo)
+    return m_pInfo < O.m_pInfo;
+
+  if (m_Addend != O.m_Addend)
+    return m_Addend < O.m_Addend;
+
+  return m_IsGot16 < O.m_IsGot16;
 }
 
 //===----------------------------------------------------------------------===//
@@ -78,16 +94,15 @@
 {
 }
 
-SizeTraits<32>::Address MipsGOT::getGPDispAddress() const
+uint64_t MipsGOT::getGPDispAddress() const
 {
   return addr() + MipsGOTGpOffset;
 }
 
 void MipsGOT::reserve(size_t pNum)
 {
-  for (size_t i = 0; i < pNum; i++) {
-    new MipsGOTEntry(0, m_SectionData);
-  }
+  for (size_t i = 0; i < pNum; i++)
+    createEntry(0, m_SectionData);
 }
 
 bool MipsGOT::hasGOT1() const
@@ -104,10 +119,10 @@
 {
   for (MultipartListType::iterator it = m_MultipartList.begin();
        it != m_MultipartList.end(); ++it) {
-    reserve(MipsGOT0Num);
-    it->m_pLastLocal = llvm::cast<MipsGOTEntry>(&m_SectionData->back());
+    reserveHeader();
+    it->m_pLastLocal = &m_SectionData->back();
     reserve(it->m_LocalNum);
-    it->m_pLastGlobal = llvm::cast<MipsGOTEntry>(&m_SectionData->back());
+    it->m_pLastGlobal = &m_SectionData->back();
     reserve(it->m_GlobalNum);
 
     if (it == m_MultipartList.begin())
@@ -137,20 +152,6 @@
   return itX == m_SymbolOrderMap.end() && itY != m_SymbolOrderMap.end();
 }
 
-uint64_t MipsGOT::emit(MemoryRegion& pRegion)
-{
-  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
-
-  uint64_t result = 0;
-  for (iterator it = begin(), ie = end();
-       it != ie; ++it, ++buffer) {
-    MipsGOTEntry* got = &(llvm::cast<MipsGOTEntry>((*it)));
-    *buffer = static_cast<uint32_t>(got->getValue());
-    result += got->size();
-  }
-  return result;
-}
-
 void MipsGOT::initGOTList()
 {
   m_SymbolOrderMap.clear();
@@ -170,8 +171,8 @@
 {
   m_MultipartList.back().m_Inputs.insert(m_pInput);
 
-  for (SymbolSetType::iterator it = m_InputLocalSymbols.begin(),
-                               end = m_InputLocalSymbols.end();
+  for (LocalSymbolSetType::iterator it = m_InputLocalSymbols.begin(),
+                                    end = m_InputLocalSymbols.end();
        it != end; ++it)
     m_MergedLocalSymbols.insert(*it);
 
@@ -193,7 +194,7 @@
 
   gotCount += 1;
 
-  return (gotCount * mcld::MipsGOTEntry::EntrySize) > MipsGOTSize;
+  return gotCount * getEntrySize() > MipsGOTSize;
 }
 
 void MipsGOT::split()
@@ -234,23 +235,27 @@
 {
 }
 
-bool MipsGOT::reserveLocalEntry(ResolveInfo& pInfo)
+bool MipsGOT::reserveLocalEntry(ResolveInfo& pInfo, int reloc,
+                                Relocation::DWord pAddend)
 {
-  if (pInfo.type() != ResolveInfo::Section) {
-    if (m_InputLocalSymbols.count(&pInfo))
-      return false;
+  LocalEntry entry(&pInfo, pAddend, reloc == llvm::ELF::R_MIPS_GOT16);
 
-    if (m_MergedLocalSymbols.count(&pInfo)) {
-      m_InputLocalSymbols.insert(&pInfo);
-      return false;
-    }
+  if (m_InputLocalSymbols.count(entry))
+    // Do nothing, if we have seen this symbol
+    // in the current input already.
+    return false;
+
+  if (m_MergedLocalSymbols.count(entry)) {
+    // We have seen this symbol in previous inputs.
+    // Remember that it exists in the current input too.
+    m_InputLocalSymbols.insert(entry);
+    return false;
   }
 
   if (isGOTFull())
     split();
 
-  if (pInfo.type() != ResolveInfo::Section)
-    m_InputLocalSymbols.insert(&pInfo);
+  m_InputLocalSymbols.insert(entry);
 
   ++m_MultipartList.back().m_LocalNum;
   return true;
@@ -285,7 +290,7 @@
   return m_CurrentGOTPart > 0;
 }
 
-MipsGOTEntry* MipsGOT::consumeLocal()
+Fragment* MipsGOT::consumeLocal()
 {
   assert(m_CurrentGOTPart < m_MultipartList.size() && "GOT number is out of range!");
 
@@ -297,7 +302,7 @@
   return m_MultipartList[m_CurrentGOTPart].m_pLastLocal;
 }
 
-MipsGOTEntry* MipsGOT::consumeGlobal()
+Fragment* MipsGOT::consumeGlobal()
 {
   assert(m_CurrentGOTPart < m_MultipartList.size() && "GOT number is out of range!");
 
@@ -309,7 +314,7 @@
   return m_MultipartList[m_CurrentGOTPart].m_pLastGlobal;
 }
 
-SizeTraits<32>::Address MipsGOT::getGPAddr(const Input& pInput) const
+uint64_t MipsGOT::getGPAddr(const Input& pInput) const
 {
   uint64_t gotSize = 0;
   for (MultipartListType::const_iterator it = m_MultipartList.begin();
@@ -322,32 +327,59 @@
       gotSize += getGlobalNum() - it->m_GlobalNum;
   }
 
-  return addr() + gotSize * MipsGOTEntry::EntrySize + MipsGOTGpOffset;
+  return addr() + gotSize * getEntrySize() + MipsGOTGpOffset;
 }
 
-SizeTraits<32>::Offset MipsGOT::getGPRelOffset(const Input& pInput,
-                                               const MipsGOTEntry& pEntry) const
+uint64_t MipsGOT::getGPRelOffset(const Input& pInput,
+                                 const Fragment& pEntry) const
 {
-  SizeTraits<32>::Address gpAddr = getGPAddr(pInput);
-  return addr() + pEntry.getOffset() - gpAddr;
+  return addr() + pEntry.getOffset() - getGPAddr(pInput);
 }
 
-void MipsGOT::recordEntry(const ResolveInfo* pInfo, MipsGOTEntry* pEntry)
+void MipsGOT::recordGlobalEntry(const ResolveInfo* pInfo, Fragment* pEntry)
 {
   GotEntryKey key;
   key.m_GOTPage = m_CurrentGOTPart;
   key.m_pInfo = pInfo;
-  m_GotEntriesMap[key] = pEntry;
+  key.m_Addend = 0;
+  m_GotGlobalEntriesMap[key] = pEntry;
 }
 
-MipsGOTEntry* MipsGOT::lookupEntry(const ResolveInfo* pInfo)
+Fragment* MipsGOT::lookupGlobalEntry(const ResolveInfo* pInfo)
 {
   GotEntryKey key;
   key.m_GOTPage= m_CurrentGOTPart;
   key.m_pInfo = pInfo;
-  GotEntryMapType::iterator it = m_GotEntriesMap.find(key);
+  key.m_Addend = 0;
+  GotEntryMapType::iterator it = m_GotGlobalEntriesMap.find(key);
 
-  if (it == m_GotEntriesMap.end())
+  if (it == m_GotGlobalEntriesMap.end())
+    return NULL;
+
+  return it->second;
+}
+
+void MipsGOT::recordLocalEntry(const ResolveInfo* pInfo,
+                               Relocation::DWord pAddend,
+                               Fragment* pEntry)
+{
+  GotEntryKey key;
+  key.m_GOTPage = m_CurrentGOTPart;
+  key.m_pInfo = pInfo;
+  key.m_Addend = pAddend;
+  m_GotLocalEntriesMap[key] = pEntry;
+}
+
+Fragment* MipsGOT::lookupLocalEntry(const ResolveInfo* pInfo,
+                                    Relocation::DWord pAddend)
+{
+  GotEntryKey key;
+  key.m_GOTPage= m_CurrentGOTPart;
+  key.m_pInfo = pInfo;
+  key.m_Addend = pAddend;
+  GotEntryMapType::iterator it = m_GotLocalEntriesMap.find(key);
+
+  if (it == m_GotLocalEntriesMap.end())
     return NULL;
 
   return it->second;
@@ -363,3 +395,85 @@
 {
   return m_SymbolOrderMap.size();
 }
+
+//===----------------------------------------------------------------------===//
+// Mips32GOT
+//===----------------------------------------------------------------------===//
+Mips32GOT::Mips32GOT(LDSection& pSection)
+  : MipsGOT(pSection)
+{}
+
+void Mips32GOT::setEntryValue(Fragment* entry, uint64_t pValue)
+{
+  llvm::cast<Mips32GOTEntry>(entry)->setValue(pValue);
+}
+
+uint64_t Mips32GOT::emit(MemoryRegion& pRegion)
+{
+  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
+
+  uint64_t result = 0;
+  for (iterator it = begin(), ie = end(); it != ie; ++it, ++buffer) {
+    Mips32GOTEntry* got = &(llvm::cast<Mips32GOTEntry>((*it)));
+    *buffer = static_cast<uint32_t>(got->getValue());
+    result += got->size();
+  }
+  return result;
+}
+
+Fragment* Mips32GOT::createEntry(uint64_t pValue, SectionData* pParent)
+{
+  return new Mips32GOTEntry(pValue, pParent);
+}
+
+size_t Mips32GOT::getEntrySize() const
+{
+  return Mips32GOTEntry::EntrySize;
+}
+
+void Mips32GOT::reserveHeader()
+{
+  createEntry(0, m_SectionData);
+  createEntry(Mips32ModulePtr, m_SectionData);
+}
+
+//===----------------------------------------------------------------------===//
+// Mips64GOT
+//===----------------------------------------------------------------------===//
+Mips64GOT::Mips64GOT(LDSection& pSection)
+  : MipsGOT(pSection)
+{}
+
+void Mips64GOT::setEntryValue(Fragment* entry, uint64_t pValue)
+{
+  llvm::cast<Mips64GOTEntry>(entry)->setValue(pValue);
+}
+
+uint64_t Mips64GOT::emit(MemoryRegion& pRegion)
+{
+  uint64_t* buffer = reinterpret_cast<uint64_t*>(pRegion.begin());
+
+  uint64_t result = 0;
+  for (iterator it = begin(), ie = end(); it != ie; ++it, ++buffer) {
+    Mips64GOTEntry* got = &(llvm::cast<Mips64GOTEntry>((*it)));
+    *buffer = static_cast<uint64_t>(got->getValue());
+    result += got->size();
+  }
+  return result;
+}
+
+Fragment* Mips64GOT::createEntry(uint64_t pValue, SectionData* pParent)
+{
+  return new Mips64GOTEntry(pValue, pParent);
+}
+
+size_t Mips64GOT::getEntrySize() const
+{
+  return Mips64GOTEntry::EntrySize;
+}
+
+void Mips64GOT::reserveHeader()
+{
+  createEntry(0, m_SectionData);
+  createEntry(Mips64ModulePtr, m_SectionData);
+}
diff --git a/lib/Target/Mips/MipsGOT.h b/lib/Target/Mips/MipsGOT.h
index 7f3051d..e3a9b9e 100644
--- a/lib/Target/Mips/MipsGOT.h
+++ b/lib/Target/Mips/MipsGOT.h
@@ -15,29 +15,21 @@
 #include <gtest.h>
 #endif
 
-#include <llvm/ADT/DenseMap.h>
-#include <llvm/ADT/DenseSet.h>
-
 #include <mcld/ADT/SizeTraits.h>
 #include <mcld/Target/GOT.h>
+#include <mcld/Fragment/Relocation.h>
+#include <mcld/Support/MemoryRegion.h>
+#include <llvm/ADT/DenseMap.h>
+#include <llvm/ADT/DenseSet.h>
+#include <set>
 
-namespace mcld
-{
+namespace mcld {
+
 class Input;
 class LDSection;
 class LDSymbol;
-class MemoryRegion;
 class OutputRelocSection;
 
-/** \class MipsGOTEntry
- *  \brief GOT Entry with size of 4 bytes
- */
-class MipsGOTEntry : public GOT::Entry<4>
-{
-public:
-  MipsGOTEntry(uint64_t pContent, SectionData* pParent);
-};
-
 /** \class MipsGOT
  *  \brief Mips Global Offset Table.
  */
@@ -46,15 +38,20 @@
 public:
   MipsGOT(LDSection& pSection);
 
-  /// Address of _gp_disp symbol.
-  SizeTraits<32>::Address getGPDispAddress() const;
+  /// Assign value to the GOT entry.
+  virtual void setEntryValue(Fragment* entry, uint64_t pValue) = 0;
 
-  uint64_t emit(MemoryRegion& pRegion);
+  /// Emit the global offset table.
+  virtual uint64_t emit(MemoryRegion& pRegion) = 0;
+
+  /// Address of _gp_disp symbol.
+  uint64_t getGPDispAddress() const;
 
   void initializeScan(const Input& pInput);
   void finalizeScan(const Input& pInput);
 
-  bool reserveLocalEntry(ResolveInfo& pInfo);
+  bool reserveLocalEntry(ResolveInfo& pInfo, int reloc,
+                         Relocation::DWord pAddend);
   bool reserveGlobalEntry(ResolveInfo& pInfo);
 
   size_t getLocalNum() const;   ///< number of local symbols in primary GOT
@@ -62,31 +59,20 @@
 
   bool isPrimaryGOTConsumed();
 
-  MipsGOTEntry* consumeLocal();
-  MipsGOTEntry* consumeGlobal();
+  Fragment* consumeLocal();
+  Fragment* consumeGlobal();
 
-  SizeTraits<32>::Address getGPAddr(const Input& pInput) const;
-  SizeTraits<32>::Offset getGPRelOffset(const Input& pInput,
-                                        const MipsGOTEntry& pEntry) const;
+  uint64_t getGPAddr(const Input& pInput) const;
+  uint64_t getGPRelOffset(const Input& pInput, const Fragment& pEntry) const;
 
-  void recordEntry(const ResolveInfo* pInfo, MipsGOTEntry* pEntry);
-  MipsGOTEntry* lookupEntry(const ResolveInfo* pInfo);
+  void recordGlobalEntry(const ResolveInfo* pInfo, Fragment* pEntry);
+  Fragment* lookupGlobalEntry(const ResolveInfo* pInfo);
 
-  void setLocal(const ResolveInfo* pInfo) {
-    m_GOTTypeMap[pInfo] = false;
-  }
-
-  void setGlobal(const ResolveInfo* pInfo) {
-    m_GOTTypeMap[pInfo] = true;
-  }
-
-  bool isLocal(const ResolveInfo* pInfo) {
-    return m_GOTTypeMap[pInfo] == false;
-  }
-
-  bool isGlobal(const ResolveInfo* pInfo) {
-    return m_GOTTypeMap[pInfo] == true;
-  }
+  void recordLocalEntry(const ResolveInfo* pInfo,
+                        Relocation::DWord pAddend,
+                        Fragment* pEntry);
+  Fragment* lookupLocalEntry(const ResolveInfo* pInfo,
+                             Relocation::DWord pAddend);
 
   /// hasGOT1 - return if this got section has any GOT1 entry
   bool hasGOT1() const;
@@ -99,6 +85,16 @@
   /// Compare two symbols to define order in the .dynsym.
   bool dynSymOrderCompare(const LDSymbol* pX, const LDSymbol* pY) const;
 
+protected:
+  /// Create GOT entry.
+  virtual Fragment* createEntry(uint64_t pValue, SectionData* pParent) = 0;
+
+  /// Size of GOT entry.
+  virtual size_t getEntrySize() const = 0;
+
+  /// Reserve GOT header entries.
+  virtual void reserveHeader() = 0;
+
 private:
   /** \class GOTMultipart
    *  \brief GOTMultipart counts local and global entries in the GOT.
@@ -115,8 +111,8 @@
     size_t m_ConsumedLocal;       ///< consumed local entries
     size_t m_ConsumedGlobal;      ///< consumed global entries
 
-    MipsGOTEntry* m_pLastLocal;   ///< the last consumed local entry
-    MipsGOTEntry* m_pLastGlobal;  ///< the last consumed global entry
+    Fragment* m_pLastLocal;   ///< the last consumed local entry
+    Fragment* m_pLastGlobal;  ///< the last consumed global entry
 
     InputSetType m_Inputs;
 
@@ -126,17 +122,46 @@
     void consumeGlobal();
   };
 
+  /** \class LocalEntry
+   *  \brief LocalEntry local GOT entry descriptor.
+   */
+  struct LocalEntry
+  {
+    const ResolveInfo* m_pInfo;
+    Relocation::DWord  m_Addend;
+    bool               m_IsGot16;
+
+    LocalEntry(const ResolveInfo* pInfo,
+               Relocation::DWord addend, bool isGot16);
+
+    bool operator<(const LocalEntry &O) const;
+  };
+
   typedef std::vector<GOTMultipart> MultipartListType;
 
+  // Set of global symbols.
   typedef llvm::DenseSet<const ResolveInfo*> SymbolSetType;
+  // Map of symbols. If value is true, the symbol is referenced
+  // in the current input only. If value is false, the symbol
+  // is referenced in the other modules merged to the current GOT.
   typedef llvm::DenseMap<const ResolveInfo*, bool> SymbolUniqueMapType;
 
+  // Set of local symbols.
+  typedef std::set<LocalEntry> LocalSymbolSetType;
+
   MultipartListType m_MultipartList;  ///< list of GOT's descriptors
   const Input* m_pInput;              ///< current input
-  SymbolSetType m_MergedGlobalSymbols; ///< merged global symbols from
-  SymbolUniqueMapType m_InputGlobalSymbols; ///< input global symbols
-  SymbolSetType m_MergedLocalSymbols;
-  SymbolSetType m_InputLocalSymbols;
+
+  // Global symbols merged to the current GOT
+  // except symbols from the current input.
+  SymbolSetType m_MergedGlobalSymbols;
+  // Global symbols from the current input.
+  SymbolUniqueMapType m_InputGlobalSymbols;
+  // Local symbols merged to the current GOT
+  // except symbols from the current input.
+  LocalSymbolSetType m_MergedLocalSymbols;
+  // Local symbols from the current input.
+  LocalSymbolSetType m_InputLocalSymbols;
 
   size_t m_CurrentGOTPart;
 
@@ -144,33 +169,72 @@
   SymbolOrderMapType m_SymbolOrderMap;
 
   void initGOTList();
+
   void changeInput();
   bool isGOTFull() const;
   void split();
   void reserve(size_t pNum);
 
 private:
-  typedef llvm::DenseMap<const ResolveInfo*, bool> SymbolTypeMapType;
-
-  SymbolTypeMapType m_GOTTypeMap;
-
-private:
   struct GotEntryKey
   {
     size_t m_GOTPage;
     const ResolveInfo* m_pInfo;
+    Relocation::DWord m_Addend;
 
     bool operator<(const GotEntryKey& key) const
     {
-      if (m_GOTPage == key.m_GOTPage)
-        return m_pInfo < key.m_pInfo;
-      else
+      if (m_GOTPage != key.m_GOTPage)
         return m_GOTPage < key.m_GOTPage;
+
+      if (m_pInfo != key.m_pInfo)
+        return m_pInfo < key.m_pInfo;
+
+      return m_Addend < key.m_Addend;
     }
   };
 
-  typedef std::map<GotEntryKey, MipsGOTEntry*> GotEntryMapType;
-  GotEntryMapType m_GotEntriesMap;
+  typedef std::map<GotEntryKey, Fragment*> GotEntryMapType;
+  GotEntryMapType m_GotLocalEntriesMap;
+  GotEntryMapType m_GotGlobalEntriesMap;
+};
+
+/** \class Mips32GOT
+ *  \brief Mips 32-bit Global Offset Table.
+ */
+class Mips32GOT : public MipsGOT
+{
+public:
+  Mips32GOT(LDSection& pSection);
+
+private:
+  typedef GOT::Entry<4> Mips32GOTEntry;
+
+  // MipsGOT
+  virtual void setEntryValue(Fragment* entry, uint64_t pValue);
+  virtual uint64_t emit(MemoryRegion& pRegion);
+  virtual Fragment* createEntry(uint64_t pValue, SectionData* pParent);
+  virtual size_t getEntrySize() const;
+  virtual void reserveHeader();
+};
+
+/** \class Mips64GOT
+ *  \brief Mips 64-bit Global Offset Table.
+ */
+class Mips64GOT : public MipsGOT
+{
+public:
+  Mips64GOT(LDSection& pSection);
+
+private:
+  typedef GOT::Entry<8> Mips64GOTEntry;
+
+  // MipsGOT
+  virtual void setEntryValue(Fragment* entry, uint64_t pValue);
+  virtual uint64_t emit(MemoryRegion& pRegion);
+  virtual Fragment* createEntry(uint64_t pValue, SectionData* pParent);
+  virtual size_t getEntrySize() const;
+  virtual void reserveHeader();
 };
 
 } // namespace of mcld
diff --git a/lib/Target/Mips/MipsGOTPLT.cpp b/lib/Target/Mips/MipsGOTPLT.cpp
new file mode 100644
index 0000000..1f65490
--- /dev/null
+++ b/lib/Target/Mips/MipsGOTPLT.cpp
@@ -0,0 +1,79 @@
+//===- MipsGOTPLT.cpp -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <llvm/Support/Casting.h>
+#include "MipsGOTPLT.h"
+
+namespace {
+  typedef mcld::GOT::Entry<4> GOTPLTEntry;
+
+  const size_t MipsGOTPLT0Num = 2;
+}
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// MipsGOTPLT
+//===----------------------------------------------------------------------===//
+MipsGOTPLT::MipsGOTPLT(LDSection& pSection)
+  : GOT(pSection)
+{
+  // 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)
+{
+  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
+
+  uint64_t result = 0;
+  for (iterator it = begin(), ie = end(); it != ie; ++it, ++buffer) {
+    GOTPLTEntry* got = &(llvm::cast<GOTPLTEntry>((*it)));
+    *buffer = static_cast<uint32_t>(got->getValue());
+    result += got->size();
+  }
+  return result;
+}
+
+Fragment* MipsGOTPLT::consume()
+{
+  ++m_Last;
+  assert(m_Last != m_SectionData->end() &&
+         "There is no reserved GOTPLT entries");
+  return &(*m_Last);
+}
+
+bool MipsGOTPLT::hasGOT1() const
+{
+  return m_SectionData->size() > MipsGOTPLT0Num;
+}
+
+uint64_t MipsGOTPLT::getEntryAddr(size_t num) const
+{
+  return addr() + (MipsGOTPLT0Num + num) * GOTPLTEntry::EntrySize;
+}
+
+void MipsGOTPLT::applyAllGOTPLT(uint64_t pltAddr)
+{
+  iterator it = begin();
+  llvm::cast<GOTPLTEntry>(*it++).setValue(0); // PLT lazy resolver
+  llvm::cast<GOTPLTEntry>(*it++).setValue(0); // Module pointer
+
+  for (; it != end(); ++it)
+    llvm::cast<GOTPLTEntry>(*it).setValue(pltAddr);
+}
+
+} //end mcld namespace
diff --git a/lib/Target/Mips/MipsGOTPLT.h b/lib/Target/Mips/MipsGOTPLT.h
new file mode 100644
index 0000000..ccf521e
--- /dev/null
+++ b/lib/Target/Mips/MipsGOTPLT.h
@@ -0,0 +1,53 @@
+//===- MipsGOTPLT.h -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_MIPS_GOTPLT_H
+#define MCLD_MIPS_GOTPLT_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Target/GOT.h>
+#include <mcld/Support/MemoryRegion.h>
+#include <llvm/ADT/DenseMap.h>
+
+namespace mcld {
+
+class LDSection;
+
+/** \class MipsGOTPLT
+ *  \brief Mips .got.plt section.
+ */
+class MipsGOTPLT : public GOT
+{
+public:
+  MipsGOTPLT(LDSection &pSection);
+
+  // hasGOT1 - return if this section has any GOT1 entry
+  bool hasGOT1() const;
+
+  uint64_t getEntryAddr(size_t num) const;
+
+  uint64_t emit(MemoryRegion& pRegion);
+
+  Fragment* consume();
+
+  void applyAllGOTPLT(uint64_t pltAddr);
+
+public:
+  // GOT
+  void reserve(size_t pNum = 1);
+
+private:
+  // the last consumed entry.
+  SectionData::iterator m_Last;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/lib/Target/Mips/MipsLA25Stub.cpp b/lib/Target/Mips/MipsLA25Stub.cpp
new file mode 100644
index 0000000..fcbc011
--- /dev/null
+++ b/lib/Target/Mips/MipsLA25Stub.cpp
@@ -0,0 +1,109 @@
+//===- MipsLA25Stub.cpp ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/LD/ResolveInfo.h>
+#include "MipsLA25Stub.h"
+#include "MipsLDBackend.h"
+
+namespace {
+
+const uint32_t STUB[] = {
+  0x3c190000,   // lui $25,%hi(func)
+  0x08000000,   // j func
+  0x27390000,   // add $25,$25,%lo(func)
+  0x00000000    // nop
+};
+
+enum {
+  // Fake relocations for patching LA25 stubs.
+  R_MIPS_LA25_LUI = 200,
+  R_MIPS_LA25_J   = 201,
+  R_MIPS_LA25_ADD = 202
+};
+
+}
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// MipsLA25Stub
+//===----------------------------------------------------------------------===//
+
+MipsLA25Stub::MipsLA25Stub(const MipsGNULDBackend& pTarget)
+ : m_Target(pTarget),
+   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);
+}
+
+MipsLA25Stub::MipsLA25Stub(const MipsGNULDBackend& pTarget,
+                           const uint32_t* pData,
+                           size_t pSize,
+                           const_fixup_iterator pBegin,
+                           const_fixup_iterator pEnd)
+ : m_Target(pTarget),
+   m_Name("pic"),
+   m_pData(pData),
+   m_Size(pSize)
+{
+  for (const_fixup_iterator it = pBegin, ie = pEnd; it != ie; ++it)
+    addFixup(**it);
+}
+
+bool MipsLA25Stub::isMyDuty(const Relocation& pReloc,
+                            uint64_t pSource,
+                            uint64_t pTargetSymValue) const
+{
+  if (llvm::ELF::R_MIPS_26 != pReloc.type())
+    return false;
+
+  const ResolveInfo* rsym = pReloc.symInfo();
+
+  if (!rsym->isDefine())
+    return false;
+
+  if (rsym->isDyn() || rsym->isUndef())
+    return false;
+
+  if (!m_Target.hasNonPICBranch(rsym))
+    return false;
+
+  return true;
+}
+
+const std::string& MipsLA25Stub::name() const
+{
+  return m_Name;
+}
+
+const uint8_t* MipsLA25Stub::getContent() const
+{
+  return reinterpret_cast<const uint8_t*>(m_pData);
+}
+
+size_t MipsLA25Stub::size() const
+{
+  return m_Size;
+}
+
+size_t MipsLA25Stub::alignment() const
+{
+  return 4;
+}
+
+Stub* MipsLA25Stub::doClone()
+{
+  return new MipsLA25Stub(m_Target, m_pData, m_Size,
+                          fixup_begin(), fixup_end());
+}
+
+} //end mcld namespace
diff --git a/lib/Target/Mips/MipsLA25Stub.h b/lib/Target/Mips/MipsLA25Stub.h
new file mode 100644
index 0000000..126cfd7
--- /dev/null
+++ b/lib/Target/Mips/MipsLA25Stub.h
@@ -0,0 +1,64 @@
+//===- MipsLA25Stub.h -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_MIPS_LA25_STUB_H
+#define MCLD_MIPS_LA25_STUB_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Fragment/Stub.h>
+
+namespace mcld
+{
+
+class MipsGNULDBackend;
+class Relocation;
+
+//===----------------------------------------------------------------------===//
+// MipsLA25Stub
+//===----------------------------------------------------------------------===//
+/** \class MipsLA25Stub
+ *  \brief Mips stub for a non-PIC interface to a PIC function.
+ */
+class MipsLA25Stub : public Stub
+{
+public:
+  MipsLA25Stub(const MipsGNULDBackend& pTarget);
+
+private:
+  // Stub
+  Stub* doClone();
+  bool isMyDuty(const Relocation& pReloc,
+                uint64_t pSource,
+                uint64_t pTargetSymValue) const;
+  const std::string& name() const;
+  const uint8_t* getContent() const;
+  size_t size() const;
+  size_t alignment() const;
+
+private:
+  MipsLA25Stub(const MipsLA25Stub&);
+  MipsLA25Stub& operator=(const MipsLA25Stub&);
+
+  MipsLA25Stub(const MipsGNULDBackend& pTarget,
+               const uint32_t* pData,
+               size_t pSize,
+               const_fixup_iterator pBegin,
+               const_fixup_iterator pEnd);
+
+private:
+  const MipsGNULDBackend& m_Target;
+  const std::string m_Name;
+  const uint32_t* m_pData;
+  const size_t m_Size;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/lib/Target/Mips/MipsLDBackend.cpp b/lib/Target/Mips/MipsLDBackend.cpp
index e26a89e..a6fd40b 100644
--- a/lib/Target/Mips/MipsLDBackend.cpp
+++ b/lib/Target/Mips/MipsLDBackend.cpp
@@ -9,15 +9,22 @@
 #include "Mips.h"
 #include "MipsGNUInfo.h"
 #include "MipsELFDynamic.h"
+#include "MipsLA25Stub.h"
 #include "MipsLDBackend.h"
 #include "MipsRelocator.h"
 
 #include <llvm/ADT/Triple.h>
+#include <llvm/Support/Casting.h>
 #include <llvm/Support/ELF.h>
+#include <llvm/Support/Host.h>
 
 #include <mcld/Module.h>
 #include <mcld/LinkerConfig.h>
 #include <mcld/IRBuilder.h>
+#include <mcld/LD/BranchIslandFactory.h>
+#include <mcld/LD/LDContext.h>
+#include <mcld/LD/StubFactory.h>
+#include <mcld/LD/ELFFileFormat.h>
 #include <mcld/MC/Attribute.h>
 #include <mcld/Fragment/FillFragment.h>
 #include <mcld/Support/MemoryRegion.h>
@@ -37,9 +44,14 @@
   : GNULDBackend(pConfig, pInfo),
     m_pRelocator(NULL),
     m_pGOT(NULL),
+    m_pPLT(NULL),
+    m_pGOTPLT(NULL),
+    m_pInfo(*pInfo),
+    m_pRelPlt(NULL),
     m_pRelDyn(NULL),
     m_pDynamic(NULL),
     m_pGOTSymbol(NULL),
+    m_pPLTSymbol(NULL),
     m_pGpDispSymbol(NULL)
 {
 }
@@ -47,24 +59,52 @@
 MipsGNULDBackend::~MipsGNULDBackend()
 {
   delete m_pRelocator;
-  delete m_pGOT;
+  delete m_pPLT;
+  delete m_pRelPlt;
   delete m_pRelDyn;
   delete m_pDynamic;
 }
 
-void MipsGNULDBackend::initTargetSections(Module& pModule, ObjectBuilder& pBuilder)
+bool MipsGNULDBackend::needsLA25Stub(Relocation::Type pType,
+                                     const mcld::ResolveInfo* pSym)
 {
-  if (LinkerConfig::Object != config().codeGenType()) {
-    ELFFileFormat* file_format = getOutputFormat();
+  if (config().isCodeIndep())
+    return false;
 
-    // initialize .got
-    LDSection& got = file_format->getGOT();
-    m_pGOT = new MipsGOT(got);
+  if (llvm::ELF::R_MIPS_26 != pType)
+    return false;
 
-    // initialize .rel.dyn
-    LDSection& reldyn = file_format->getRelDyn();
-    m_pRelDyn = new OutputRelocSection(pModule, reldyn);
-  }
+  if (pSym->isLocal())
+    return false;
+
+  return true;
+}
+
+void MipsGNULDBackend::addNonPICBranchSym(ResolveInfo* rsym)
+{
+  m_HasNonPICBranchSyms.insert(rsym);
+}
+
+bool MipsGNULDBackend::hasNonPICBranch(const ResolveInfo* rsym) const
+{
+  return m_HasNonPICBranchSyms.count(rsym);
+}
+
+void MipsGNULDBackend::initTargetSections(Module& pModule,
+                                            ObjectBuilder& pBuilder)
+{
+  if (LinkerConfig::Object == config().codeGenType())
+    return;
+
+  ELFFileFormat* file_format = getOutputFormat();
+
+  // initialize .rel.plt
+  LDSection& relplt = file_format->getRelPlt();
+  m_pRelPlt = new OutputRelocSection(pModule, relplt);
+
+  // initialize .rel.dyn
+  LDSection& reldyn = file_format->getRelDyn();
+  m_pRelDyn = new OutputRelocSection(pModule, reldyn);
 }
 
 void MipsGNULDBackend::initTargetSymbols(IRBuilder& pBuilder, Module& pModule)
@@ -81,6 +121,19 @@
                    FragmentRef::Null(), // FragRef
                    ResolveInfo::Hidden);
 
+  // Define the symbol _PROCEDURE_LINKAGE_TABLE_ if there is a symbol with the
+  // same name in input
+  m_pPLTSymbol =
+    pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
+                   "_PROCEDURE_LINKAGE_TABLE_",
+                   ResolveInfo::Object,
+                   ResolveInfo::Define,
+                   ResolveInfo::Local,
+                   0x0,  // size
+                   0x0,  // value
+                   FragmentRef::Null(), // FragRef
+                   ResolveInfo::Hidden);
+
   m_pGpDispSymbol = pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
                    "_gp_disp",
                    ResolveInfo::Section,
@@ -90,18 +143,6 @@
                    0x0,  // value
                    FragmentRef::Null(), // FragRef
                    ResolveInfo::Default);
-
-  if (NULL != m_pGpDispSymbol) {
-    m_pGpDispSymbol->resolveInfo()->setReserved(MipsRelocator::ReserveGpDisp);
-  }
-}
-
-bool MipsGNULDBackend::initRelocator()
-{
-  if (NULL == m_pRelocator) {
-    m_pRelocator = new MipsRelocator(*this, config());
-  }
-  return true;
 }
 
 Relocator* MipsGNULDBackend::getRelocator()
@@ -128,7 +169,25 @@
       defineGOTSymbol(pBuilder);
     }
 
+    if (m_pGOTPLT->hasGOT1()) {
+      m_pGOTPLT->finalizeSectionSize();
+
+      defineGOTPLTSymbol(pBuilder);
+    }
+
+    if (m_pPLT->hasPLT1())
+      m_pPLT->finalizeSectionSize();
+
     ELFFileFormat* file_format = getOutputFormat();
+
+    // set .rel.plt size
+    if (!m_pRelPlt->empty()) {
+      assert(!config().isCodeStatic() &&
+            "static linkage should not result in a dynamic relocation section");
+      file_format->getRelPlt().setSize(
+                                  m_pRelPlt->numOfRelocs() * getRelEntrySize());
+    }
+
     // set .rel.dyn size
     if (!m_pRelDyn->empty()) {
       assert(!config().isCodeStatic() &&
@@ -141,6 +200,32 @@
 
 void MipsGNULDBackend::doPostLayout(Module& pModule, IRBuilder& pBuilder)
 {
+  const ELFFileFormat *format = getOutputFormat();
+
+  if (format->hasGOTPLT()) {
+    assert(m_pGOTPLT && "doPostLayout failed, m_pGOTPLT is NULL!");
+    m_pGOTPLT->applyAllGOTPLT(m_pPLT->addr());
+  }
+
+  if (format->hasPLT()) {
+    assert(m_pPLT && "doPostLayout failed, m_pPLT is NULL!");
+    m_pPLT->applyAllPLT(*m_pGOTPLT);
+  }
+
+  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.
@@ -166,10 +251,16 @@
 
   const ELFFileFormat* file_format = getOutputFormat();
 
-  if (&pSection == &(file_format->getGOT())) {
-    assert(NULL != m_pGOT && "emitSectionData failed, m_pGOT is NULL!");
-    uint64_t result = m_pGOT->emit(pRegion);
-    return result;
+  if (file_format->hasGOT() && (&pSection == &(file_format->getGOT()))) {
+    return m_pGOT->emit(pRegion);
+  }
+
+  if (file_format->hasPLT() && (&pSection == &(file_format->getPLT()))) {
+    return m_pPLT->emit(pRegion);
+  }
+
+  if (file_format->hasGOTPLT() && (&pSection == &(file_format->getGOTPLT()))) {
+    return m_pGOTPLT->emit(pRegion);
   }
 
   fatal(diag::unrecognized_output_sectoin)
@@ -218,6 +309,102 @@
                    DynsymGOTCompare(*m_pGOT));
 }
 
+namespace llvm {
+namespace ELF {
+// SHT_MIPS_OPTIONS section's block descriptor.
+struct Elf_Options {
+  unsigned char kind;     // Determines interpretation of variable
+                          // part of descriptor. See ODK_xxx enumeration.
+  unsigned char size;     // Byte size of descriptor, including this header.
+  Elf64_Half    section;  // Section header index of section affected,
+                          // or 0 for global options.
+  Elf64_Word    info;     // Kind-speciﬁc information.
+};
+
+// Type of SHT_MIPS_OPTIONS section's block.
+enum {
+  ODK_NULL       = 0, // Undefined.
+  ODK_REGINFO    = 1, // Register usage and GP value.
+  ODK_EXCEPTIONS = 2, // Exception processing information.
+  ODK_PAD        = 3, // Section padding information.
+  ODK_HWPATCH    = 4, // Hardware workarounds performed.
+  ODK_FILL       = 5, // Fill value used by the linker.
+  ODK_TAGS       = 6, // Reserved space for desktop tools.
+  ODK_HWAND      = 7, // Hardware workarounds, AND bits when merging.
+  ODK_HWOR       = 8, // Hardware workarounds, OR bits when merging.
+  ODK_GP_GROUP   = 9, // GP group to use for text/data sections.
+  ODK_IDENT      = 10 // ID information.
+};
+
+// Content of ODK_REGINFO block in SHT_MIPS_OPTIONS section on 32 bit ABI.
+struct Elf32_RegInfo {
+  Elf32_Word ri_gprmask;    // Mask of general purpose registers used.
+  Elf32_Word ri_cprmask[4]; // Mask of co-processor registers used.
+  Elf32_Addr ri_gp_value;   // GP register value for this object file.
+};
+
+// Content of ODK_REGINFO block in SHT_MIPS_OPTIONS section on 64 bit ABI.
+struct Elf64_RegInfo {
+  Elf32_Word ri_gprmask;    // Mask of general purpose registers used.
+  Elf32_Word ri_pad;        // Padding.
+  Elf32_Word ri_cprmask[4]; // Mask of co-processor registers used.
+  Elf64_Addr ri_gp_value;   // GP register value for this object file.
+};
+
+}
+}
+
+bool MipsGNULDBackend::readSection(Input& pInput, SectionData& pSD)
+{
+  llvm::StringRef name(pSD.getSection().name());
+
+  if (name.startswith(".sdata")) {
+    uint64_t offset = pInput.fileOffset() + pSD.getSection().offset();
+    uint64_t size = pSD.getSection().size();
+
+    Fragment* frag = IRBuilder::CreateRegion(pInput, offset, size);
+    ObjectBuilder::AppendFragment(*frag, pSD);
+    return true;
+  }
+
+  if (pSD.getSection().type() == llvm::ELF::SHT_MIPS_OPTIONS) {
+    uint32_t offset = pInput.fileOffset() + pSD.getSection().offset();
+    uint32_t size = pSD.getSection().size();
+
+    llvm::StringRef region = pInput.memArea()->request(offset, size);
+    if (region.size() > 0) {
+      const llvm::ELF::Elf_Options* optb =
+        reinterpret_cast<const llvm::ELF::Elf_Options*>(region.begin());
+      const llvm::ELF::Elf_Options* opte =
+        reinterpret_cast<const llvm::ELF::Elf_Options*>(region.begin() + size);
+
+      for (const llvm::ELF::Elf_Options* opt = optb; opt < opte; opt += opt->size) {
+        switch (opt->kind) {
+          default:
+            // Nothing to do.
+            break;
+          case llvm::ELF::ODK_REGINFO:
+            if (config().targets().triple().isArch32Bit()) {
+              const llvm::ELF::Elf32_RegInfo* reg =
+                reinterpret_cast<const llvm::ELF::Elf32_RegInfo*>(opt + 1);
+              m_GP0Map[&pInput] = reg->ri_gp_value;
+            }
+            else {
+              const llvm::ELF::Elf64_RegInfo* reg =
+                reinterpret_cast<const llvm::ELF::Elf64_RegInfo*>(opt + 1);
+              m_GP0Map[&pInput] = reg->ri_gp_value;
+            }
+            break;
+        }
+      }
+    }
+
+    return true;
+  }
+
+  return GNULDBackend::readSection(pInput, pSD);
+}
+
 MipsGOT& MipsGNULDBackend::getGOT()
 {
   assert(NULL != m_pGOT);
@@ -230,6 +417,42 @@
   return *m_pGOT;
 }
 
+MipsPLT& MipsGNULDBackend::getPLT()
+{
+  assert(NULL != m_pPLT);
+  return *m_pPLT;
+}
+
+const MipsPLT& MipsGNULDBackend::getPLT() const
+{
+  assert(NULL != m_pPLT);
+  return *m_pPLT;
+}
+
+MipsGOTPLT& MipsGNULDBackend::getGOTPLT()
+{
+  assert(NULL != m_pGOTPLT);
+  return *m_pGOTPLT;
+}
+
+const MipsGOTPLT& MipsGNULDBackend::getGOTPLT() const
+{
+  assert(NULL != m_pGOTPLT);
+  return *m_pGOTPLT;
+}
+
+OutputRelocSection& MipsGNULDBackend::getRelPLT()
+{
+  assert(NULL != m_pRelPlt);
+  return *m_pRelPlt;
+}
+
+const OutputRelocSection& MipsGNULDBackend::getRelPLT() const
+{
+  assert(NULL != m_pRelPlt);
+  return *m_pRelPlt;
+}
+
 OutputRelocSection& MipsGNULDBackend::getRelDyn()
 {
   assert(NULL != m_pRelDyn);
@@ -247,9 +470,15 @@
 {
   const ELFFileFormat* file_format = getOutputFormat();
 
-  if (&pSectHdr == &file_format->getGOT())
+  if (file_format->hasGOT() && (&pSectHdr == &file_format->getGOT()))
     return SHO_DATA;
 
+  if (file_format->hasGOTPLT() && (&pSectHdr == &file_format->getGOTPLT()))
+    return SHO_DATA;
+
+  if (file_format->hasPLT() && (&pSectHdr == &file_format->getPLT()))
+    return SHO_PLT;
+
   return SHO_UNDEFINED;
 }
 
@@ -313,19 +542,20 @@
       // description here.
       (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
       Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
-      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
 
       if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
         // allocate TLS common symbol in tbss section
         tbss_offset += ObjectBuilder::AppendFragment(*frag,
                                                      *tbss_sect_data,
                                                      (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       }
       // FIXME: how to identify small and large common symbols?
       else {
         bss_offset += ObjectBuilder::AppendFragment(*frag,
                                                     *bss_sect_data,
                                                     (*com_sym)->value());
+        (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
       }
     }
   }
@@ -340,19 +570,20 @@
     // description here.
     (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
     Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
-    (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
 
     if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
       // allocate TLS common symbol in tbss section
       tbss_offset += ObjectBuilder::AppendFragment(*frag,
                                                    *tbss_sect_data,
                                                    (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
     }
     // FIXME: how to identify small and large common symbols?
     else {
       bss_offset += ObjectBuilder::AppendFragment(*frag,
                                                   *bss_sect_data,
                                                   (*com_sym)->value());
+      (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
     }
   }
 
@@ -362,6 +593,11 @@
   return true;
 }
 
+uint64_t MipsGNULDBackend::getGP0(const Input& pInput) const
+{
+  return m_GP0Map.lookup(&pInput);
+}
+
 void MipsGNULDBackend::defineGOTSymbol(IRBuilder& pBuilder)
 {
   // If we do not reserve any GOT entries, we do not need to re-define GOT
@@ -394,6 +630,33 @@
   }
 }
 
+void MipsGNULDBackend::defineGOTPLTSymbol(IRBuilder& pBuilder)
+{
+  // define symbol _PROCEDURE_LINKAGE_TABLE_
+  if ( m_pPLTSymbol != NULL ) {
+    pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
+                     "_PROCEDURE_LINKAGE_TABLE_",
+                     ResolveInfo::Object,
+                     ResolveInfo::Define,
+                     ResolveInfo::Local,
+                     0x0, // size
+                     0x0, // value
+                     FragmentRef::Create(*(m_pPLT->begin()), 0x0),
+                     ResolveInfo::Hidden);
+  }
+  else {
+    m_pPLTSymbol = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
+                     "_PROCEDURE_LINKAGE_TABLE_",
+                     ResolveInfo::Object,
+                     ResolveInfo::Define,
+                     ResolveInfo::Local,
+                     0x0, // size
+                     0x0, // value
+                     FragmentRef::Create(*(m_pPLT->begin()), 0x0),
+                     ResolveInfo::Hidden);
+  }
+}
+
 /// doCreateProgramHdrs - backend can implement this function to create the
 /// target-dependent segments
 void MipsGNULDBackend::doCreateProgramHdrs(Module& pModule)
@@ -401,27 +664,343 @@
   // TODO
 }
 
+bool MipsGNULDBackend::relaxRelocation(IRBuilder& pBuilder, Relocation& pRel)
+{
+  uint64_t sym_value = 0x0;
+
+  LDSymbol* symbol = pRel.symInfo()->outSymbol();
+  if (symbol->hasFragRef()) {
+    uint64_t value = symbol->fragRef()->getOutputOffset();
+    uint64_t addr = symbol->fragRef()->frag()->getParent()->getSection().addr();
+    sym_value = addr + value;
+  }
+
+  Stub* stub =
+    getStubFactory()->create(pRel, sym_value, pBuilder, *getBRIslandFactory());
+
+  if (NULL == stub)
+    return false;
+
+  assert(NULL != stub->symInfo());
+  // increase the size of .symtab and .strtab
+  LDSection& symtab = getOutputFormat()->getSymTab();
+  LDSection& strtab = getOutputFormat()->getStrTab();
+  symtab.setSize(symtab.size() + sizeof(llvm::ELF::Elf32_Sym));
+  strtab.setSize(strtab.size() + stub->symInfo()->nameSize() + 1);
+
+  return true;
+}
+
+bool MipsGNULDBackend::doRelax(Module& pModule, IRBuilder& pBuilder,
+                               bool& pFinished)
+{
+  assert(NULL != getStubFactory() && NULL != getBRIslandFactory());
+
+  bool isRelaxed = false;
+
+  for (Module::obj_iterator input = pModule.obj_begin();
+       input != pModule.obj_end(); ++input) {
+    LDContext* context = (*input)->context();
+
+    for (LDContext::sect_iterator rs = context->relocSectBegin();
+         rs != context->relocSectEnd(); ++rs) {
+      LDSection* sec = *rs;
+
+      if (LDFileFormat::Ignore == sec->kind() || !sec->hasRelocData())
+        continue;
+
+      for (RelocData::iterator reloc = sec->getRelocData()->begin();
+           reloc != sec->getRelocData()->end(); ++reloc) {
+        if (llvm::ELF::R_MIPS_26 != reloc->type())
+          continue;
+
+        if (relaxRelocation(pBuilder, *llvm::cast<Relocation>(reloc)))
+          isRelaxed = true;
+      }
+    }
+  }
+
+  SectionData* textData = getOutputFormat()->getText().getSectionData();
+
+  // find the first fragment w/ invalid offset due to stub insertion
+  Fragment* invalid = NULL;
+  pFinished = true;
+  for (BranchIslandFactory::iterator ii = getBRIslandFactory()->begin(),
+                                     ie = getBRIslandFactory()->end();
+       ii != ie; ++ii)
+  {
+    BranchIsland& island = *ii;
+    if (island.end() == textData->end())
+      break;
+
+    Fragment* exit = island.end();
+    if ((island.offset() + island.size()) > exit->getOffset()) {
+      invalid = exit;
+      pFinished = false;
+      break;
+    }
+  }
+
+  // reset the offset of invalid fragments
+  while (NULL != invalid) {
+    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());
+
+  return isRelaxed;
+}
+
+bool MipsGNULDBackend::initTargetStubs()
+{
+  if (NULL == getStubFactory())
+    return false;
+
+  getStubFactory()->addPrototype(new MipsLA25Stub(*this));
+  return true;
+}
+
+bool MipsGNULDBackend::readRelocation(const llvm::ELF::Elf32_Rel& pRel,
+                                      Relocation::Type& pType,
+                                      uint32_t& pSymIdx,
+                                      uint32_t& pOffset) const
+{
+  return GNULDBackend::readRelocation(pRel, pType, pSymIdx, pOffset);
+}
+
+bool MipsGNULDBackend::readRelocation(const llvm::ELF::Elf32_Rela& pRel,
+                                      Relocation::Type& pType,
+                                      uint32_t& pSymIdx,
+                                      uint32_t& pOffset,
+                                      int32_t& pAddend) const
+{
+  return GNULDBackend::readRelocation(pRel, pType, pSymIdx, pOffset, pAddend);
+}
+
+bool MipsGNULDBackend::readRelocation(const llvm::ELF::Elf64_Rel& pRel,
+                                      Relocation::Type& pType,
+                                      uint32_t& pSymIdx,
+                                      uint64_t& pOffset) const
+{
+  uint64_t r_info = 0x0;
+  if (llvm::sys::IsLittleEndianHost) {
+    pOffset = pRel.r_offset;
+    r_info  = pRel.r_info;
+  }
+  else {
+    pOffset = mcld::bswap64(pRel.r_offset);
+    r_info  = mcld::bswap64(pRel.r_info);
+  }
+
+  // MIPS 64 little endian (we do not support big endian now)
+  // has a "special" encoding of r_info relocation
+  // field. Instead of one 64 bit little endian number, it is a little
+  // endian 32 bit number followed by a 32 bit big endian number.
+  pType = mcld::bswap32(r_info >> 32);
+  pSymIdx = r_info & 0xffffffff;
+  return true;
+}
+
+bool MipsGNULDBackend::readRelocation(const llvm::ELF::Elf64_Rela& pRel,
+                                      Relocation::Type& pType,
+                                      uint32_t& pSymIdx,
+                                      uint64_t& pOffset,
+                                      int64_t& pAddend) const
+{
+  uint64_t r_info = 0x0;
+  if (llvm::sys::IsLittleEndianHost) {
+    pOffset = pRel.r_offset;
+    r_info  = pRel.r_info;
+    pAddend = pRel.r_addend;
+  }
+  else {
+    pOffset = mcld::bswap64(pRel.r_offset);
+    r_info  = mcld::bswap64(pRel.r_info);
+    pAddend = mcld::bswap64(pRel.r_addend);
+  }
+
+  pType = mcld::bswap32(r_info >> 32);
+  pSymIdx = r_info & 0xffffffff;
+  return true;
+}
+
+void MipsGNULDBackend::emitRelocation(llvm::ELF::Elf32_Rel& pRel,
+                                      Relocation::Type pType,
+                                      uint32_t pSymIdx,
+                                      uint32_t pOffset) const
+{
+  GNULDBackend::emitRelocation(pRel, pType, pSymIdx, pOffset);
+}
+
+void MipsGNULDBackend::emitRelocation(llvm::ELF::Elf32_Rela& pRel,
+                                      Relocation::Type pType,
+                                      uint32_t pSymIdx,
+                                      uint32_t pOffset,
+                                      int32_t pAddend) const
+{
+  GNULDBackend::emitRelocation(pRel, pType, pSymIdx, pOffset, pAddend);
+}
+
+void MipsGNULDBackend::emitRelocation(llvm::ELF::Elf64_Rel& pRel,
+                                      Relocation::Type pType,
+                                      uint32_t pSymIdx,
+                                      uint64_t pOffset) const
+{
+  uint64_t r_info = mcld::bswap32(pType);
+  r_info <<= 32;
+  r_info |= pSymIdx;
+
+  pRel.r_info = r_info;
+  pRel.r_offset = pOffset;
+}
+
+void MipsGNULDBackend::emitRelocation(llvm::ELF::Elf64_Rela& pRel,
+                                      Relocation::Type pType,
+                                      uint32_t pSymIdx,
+                                      uint64_t pOffset,
+                                      int64_t pAddend) const
+{
+  uint64_t r_info = mcld::bswap32(pType);
+  r_info <<= 32;
+  r_info |= pSymIdx;
+
+  pRel.r_info = r_info;
+  pRel.r_offset = pOffset;
+  pRel.r_addend = pAddend;
+}
+
+//===----------------------------------------------------------------------===//
+// Mips32GNULDBackend
+//===----------------------------------------------------------------------===//
+Mips32GNULDBackend::Mips32GNULDBackend(const LinkerConfig& pConfig,
+                                       MipsGNUInfo* pInfo)
+  : MipsGNULDBackend(pConfig, pInfo)
+{}
+
+bool Mips32GNULDBackend::initRelocator()
+{
+  if (NULL == m_pRelocator)
+    m_pRelocator = new Mips32Relocator(*this, config());
+
+  return true;
+}
+
+void Mips32GNULDBackend::initTargetSections(Module& pModule,
+                                            ObjectBuilder& pBuilder)
+{
+  MipsGNULDBackend::initTargetSections(pModule, pBuilder);
+
+  if (LinkerConfig::Object == config().codeGenType())
+    return;
+
+  ELFFileFormat* fileFormat = getOutputFormat();
+
+  // initialize .got
+  LDSection& got = fileFormat->getGOT();
+  m_pGOT = new Mips32GOT(got);
+
+  // initialize .got.plt
+  LDSection& gotplt = fileFormat->getGOTPLT();
+  m_pGOTPLT = new MipsGOTPLT(gotplt);
+
+  // initialize .plt
+  LDSection& plt = fileFormat->getPLT();
+  m_pPLT = new MipsPLT(plt);
+}
+
+size_t Mips32GNULDBackend::getRelEntrySize()
+{
+  return 8;
+}
+
+size_t Mips32GNULDBackend::getRelaEntrySize()
+{
+  return 12;
+}
+
+//===----------------------------------------------------------------------===//
+// Mips64GNULDBackend
+//===----------------------------------------------------------------------===//
+Mips64GNULDBackend::Mips64GNULDBackend(const LinkerConfig& pConfig,
+                                       MipsGNUInfo* pInfo)
+  : MipsGNULDBackend(pConfig, pInfo)
+{}
+
+bool Mips64GNULDBackend::initRelocator()
+{
+  if (NULL == m_pRelocator)
+    m_pRelocator = new Mips64Relocator(*this, config());
+
+  return true;
+}
+
+void Mips64GNULDBackend::initTargetSections(Module& pModule,
+                                            ObjectBuilder& pBuilder)
+{
+  MipsGNULDBackend::initTargetSections(pModule, pBuilder);
+
+  if (LinkerConfig::Object == config().codeGenType())
+    return;
+
+  ELFFileFormat* fileFormat = getOutputFormat();
+
+  // initialize .got
+  LDSection& got = fileFormat->getGOT();
+  m_pGOT = new Mips64GOT(got);
+
+  // initialize .got.plt
+  LDSection& gotplt = fileFormat->getGOTPLT();
+  m_pGOTPLT = new MipsGOTPLT(gotplt);
+
+  // initialize .plt
+  LDSection& plt = fileFormat->getPLT();
+  m_pPLT = new MipsPLT(plt);
+}
+
+size_t Mips64GNULDBackend::getRelEntrySize()
+{
+  return 16;
+}
+
+size_t Mips64GNULDBackend::getRelaEntrySize()
+{
+  return 24;
+}
+
 //===----------------------------------------------------------------------===//
 /// createMipsLDBackend - the help funtion to create corresponding MipsLDBackend
 ///
-static TargetLDBackend* createMipsLDBackend(const llvm::Target& pTarget,
-                                            const LinkerConfig& pConfig)
+static TargetLDBackend* createMipsLDBackend(const LinkerConfig& pConfig)
 {
-  if (pConfig.targets().triple().isOSDarwin()) {
+  const llvm::Triple& triple = pConfig.targets().triple();
+
+  if (triple.isOSDarwin()) {
     assert(0 && "MachO linker is not supported yet");
   }
-  if (pConfig.targets().triple().isOSWindows()) {
+  if (triple.isOSWindows()) {
     assert(0 && "COFF linker is not supported yet");
   }
-  return new MipsGNULDBackend(pConfig, new MipsGNUInfo(pConfig.targets().triple()));
+
+  llvm::Triple::ArchType arch = triple.getArch();
+
+  if (llvm::Triple::mips64el == arch)
+    return new Mips64GNULDBackend(pConfig, new MipsGNUInfo(triple));
+
+  assert (arch == llvm::Triple::mipsel);
+  return new Mips32GNULDBackend(pConfig, new MipsGNUInfo(triple));
 }
 
 //===----------------------------------------------------------------------===//
 // Force static initialization.
 //===----------------------------------------------------------------------===//
 extern "C" void MCLDInitializeMipsLDBackend() {
-  // Register the linker backend
   mcld::TargetRegistry::RegisterTargetLDBackend(mcld::TheMipselTarget,
                                                 createMipsLDBackend);
+  mcld::TargetRegistry::RegisterTargetLDBackend(mcld::TheMips64elTarget,
+                                                createMipsLDBackend);
 }
-
diff --git a/lib/Target/Mips/MipsLDBackend.h b/lib/Target/Mips/MipsLDBackend.h
index 831d830..5c4d12b 100644
--- a/lib/Target/Mips/MipsLDBackend.h
+++ b/lib/Target/Mips/MipsLDBackend.h
@@ -11,6 +11,8 @@
 #include <mcld/Target/GNULDBackend.h>
 #include "MipsELFDynamic.h"
 #include "MipsGOT.h"
+#include "MipsGOTPLT.h"
+#include "MipsPLT.h"
 
 namespace mcld {
 
@@ -20,9 +22,9 @@
 class MemoryArea;
 class MipsGNUInfo;
 
-//===----------------------------------------------------------------------===//
-/// MipsGNULDBackend - linker backend of Mips target of GNU ELF format
-///
+/** \class MipsGNULDBackend
+ *  \brief Base linker backend of Mips target of GNU ELF format.
+ */
 class MipsGNULDBackend : public GNULDBackend
 {
 public:
@@ -32,6 +34,11 @@
   MipsGNULDBackend(const LinkerConfig& pConfig, MipsGNUInfo* pInfo);
   ~MipsGNULDBackend();
 
+  bool needsLA25Stub(Relocation::Type pType, const mcld::ResolveInfo* pSym);
+
+  void addNonPICBranchSym(ResolveInfo* rsym);
+  bool hasNonPICBranch(const ResolveInfo* rsym) const;
+
 public:
   /// initTargetSections - initialize target dependent sections in output
   void initTargetSections(Module& pModule, ObjectBuilder& pBuilder);
@@ -39,9 +46,6 @@
   /// initTargetSymbols - initialize target dependent symbols in output.
   void initTargetSymbols(IRBuilder& pBuilder, Module& pModule);
 
-  /// initRelocator - create and initialize Relocator.
-  bool initRelocator();
-
   /// getRelocator - return relocator.
   Relocator* getRelocator();
 
@@ -82,14 +86,26 @@
   /// orderSymbolTable - order symbol table before emitting
   void orderSymbolTable(Module& pModule);
 
+  /// readSection - read a target dependent section.
+  bool readSection(Input& pInput, SectionData& pSD);
+
   MipsGOT& getGOT();
   const MipsGOT& getGOT() const;
 
+  MipsPLT& getPLT();
+  const MipsPLT& getPLT() const;
+
+  MipsGOTPLT& getGOTPLT();
+  const MipsGOTPLT& getGOTPLT() const;
+
+  OutputRelocSection& getRelPLT();
+  const OutputRelocSection& getRelPLT() const;
+
   OutputRelocSection& getRelDyn();
   const OutputRelocSection& getRelDyn() const;
 
-  LDSymbol*             getGOTSymbo()            { return m_pGOTSymbol;    }
-  const LDSymbol*       getGOTSymbo() const      { return m_pGOTSymbol;    }
+  LDSymbol*             getGOTSymbol()           { return m_pGOTSymbol;    }
+  const LDSymbol*       getGOTSymbol() const     { return m_pGOTSymbol;    }
 
   LDSymbol*             getGpDispSymbol()        { return m_pGpDispSymbol; }
   const LDSymbol*       getGpDispSymbol() const  { return m_pGpDispSymbol; }
@@ -107,8 +123,15 @@
   /// sections.
   bool allocateCommonSymbols(Module& pModule);
 
+  /// getGP0 - the gp value used to create the relocatable objects
+  /// in the specified input.
+  uint64_t getGP0(const Input& pInput) const;
+
 private:
   void defineGOTSymbol(IRBuilder& pBuilder);
+  void defineGOTPLTSymbol(IRBuilder& pBuilder);
+
+  bool relaxRelocation(IRBuilder& pBuilder, Relocation& pRel);
 
   /// emitSymbol32 - emit an ELF32 symbol, override parent's function
   void emitSymbol32(llvm::ELF::Elf32_Sym& pSym32,
@@ -117,32 +140,134 @@
                     size_t pStrtabsize,
                     size_t pSymtabIdx);
 
-  /// getRelEntrySize - the size in BYTE of rel type relocation
-  size_t getRelEntrySize()
-  { return 8; }
-
-  /// getRelEntrySize - the size in BYTE of rela type relocation
-  size_t getRelaEntrySize()
-  { return 12; }
-
   /// doCreateProgramHdrs - backend can implement this function to create the
   /// target-dependent segments
   void doCreateProgramHdrs(Module& pModule);
 
-private:
-  Relocator* m_pRelocator;
+  /// mayRelax - Backends should override this function if they need relaxation
+  bool mayRelax() { return true; }
 
+  /// doRelax - Backend can orevride this function to add its relaxation
+  /// implementation. Return true if the output (e.g., .text) is "relaxed"
+  /// (i.e. layout is changed), and set pFinished to true if everything is fit,
+  /// otherwise set it to false.
+  bool doRelax(Module& pModule, IRBuilder& pBuilder, bool& pFinished);
+
+  /// initTargetStubs
+  bool initTargetStubs();
+
+  /// readRelocation - read ELF32_Rel entry
+  bool readRelocation(const llvm::ELF::Elf32_Rel& pRel,
+                      Relocation::Type& pType,
+                      uint32_t& pSymIdx,
+                      uint32_t& pOffset) const;
+
+  /// readRelocation - read ELF32_Rela entry
+  bool readRelocation(const llvm::ELF::Elf32_Rela& pRel,
+                      Relocation::Type& pType,
+                      uint32_t& pSymIdx,
+                      uint32_t& pOffset,
+                      int32_t& pAddend) const;
+
+  /// readRelocation - read ELF64_Rel entry
+  bool readRelocation(const llvm::ELF::Elf64_Rel& pRel,
+                      Relocation::Type& pType,
+                      uint32_t& pSymIdx,
+                      uint64_t& pOffset) const;
+
+  /// readRel - read ELF64_Rela entry
+  bool readRelocation(const llvm::ELF::Elf64_Rela& pRel,
+                      Relocation::Type& pType,
+                      uint32_t& pSymIdx,
+                      uint64_t& pOffset,
+                      int64_t& pAddend) const;
+
+  /// emitRelocation - write data to the ELF32_Rel entry
+  void emitRelocation(llvm::ELF::Elf32_Rel& pRel,
+                      Relocation::Type pType,
+                      uint32_t pSymIdx,
+                      uint32_t pOffset) const;
+
+  /// emitRelocation - write data to the ELF32_Rela entry
+  void emitRelocation(llvm::ELF::Elf32_Rela& pRel,
+                      Relocation::Type pType,
+                      uint32_t pSymIdx,
+                      uint32_t pOffset,
+                      int32_t pAddend) const;
+
+  /// emitRelocation - write data to the ELF64_Rel entry
+  void emitRelocation(llvm::ELF::Elf64_Rel& pRel,
+                      Relocation::Type pType,
+                      uint32_t pSymIdx,
+                      uint64_t pOffset) const;
+
+  /// emitRelocation - write data to the ELF64_Rela entry
+  void emitRelocation(llvm::ELF::Elf64_Rela& pRel,
+                      Relocation::Type pType,
+                      uint32_t pSymIdx,
+                      uint64_t pOffset,
+                      int64_t pAddend) const;
+
+private:
+  typedef llvm::DenseSet<const ResolveInfo*> ResolveInfoSetType;
+  typedef llvm::DenseMap<const Input*, llvm::ELF::Elf64_Addr> GP0MapType;
+
+protected:
+  Relocator* m_pRelocator;
   MipsGOT* m_pGOT;                      // .got
+  MipsPLT* m_pPLT;                      // .plt
+  MipsGOTPLT* m_pGOTPLT;                // .got.plt
+
+private:
+  MipsGNUInfo& m_pInfo;
+
+  OutputRelocSection* m_pRelPlt;        // .rel.plt
   OutputRelocSection* m_pRelDyn;        // .rel.dyn
 
   MipsELFDynamic* m_pDynamic;
   LDSymbol* m_pGOTSymbol;
+  LDSymbol* m_pPLTSymbol;
   LDSymbol* m_pGpDispSymbol;
 
   SymbolListType m_GlobalGOTSyms;
+  ResolveInfoSetType m_HasNonPICBranchSyms;
+  GP0MapType m_GP0Map;
+};
+
+/** \class Mips32GNULDBackend
+ *  \brief Base linker backend of Mips 32-bit target of GNU ELF format.
+ */
+class Mips32GNULDBackend : public MipsGNULDBackend
+{
+public:
+  Mips32GNULDBackend(const LinkerConfig& pConfig, MipsGNUInfo* pInfo);
+
+private:
+  // MipsGNULDBackend
+
+  bool initRelocator();
+  void initTargetSections(Module& pModule, ObjectBuilder& pBuilder);
+  size_t getRelEntrySize();
+  size_t getRelaEntrySize();
+};
+
+/** \class Mips64GNULDBackend
+ *  \brief Base linker backend of Mips 64-bit target of GNU ELF format.
+ */
+class Mips64GNULDBackend : public MipsGNULDBackend
+{
+public:
+  Mips64GNULDBackend(const LinkerConfig& pConfig, MipsGNUInfo* pInfo);
+
+private:
+  // MipsGNULDBackend
+
+  bool initRelocator();
+  void initTargetSections(Module& pModule, ObjectBuilder& pBuilder);
+  size_t getRelEntrySize();
+  size_t getRelaEntrySize();
 };
 
 } // namespace of mcld
 
 #endif
-
diff --git a/lib/Target/Mips/MipsMCLinker.cpp b/lib/Target/Mips/MipsMCLinker.cpp
index 5805f12..49940b7 100644
--- a/lib/Target/Mips/MipsMCLinker.cpp
+++ b/lib/Target/Mips/MipsMCLinker.cpp
@@ -6,25 +6,21 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "MipsELFMCLinker.h"
-
 #include "Mips.h"
+#include "MipsELFMCLinker.h"
 #include <llvm/ADT/Triple.h>
 #include <mcld/Module.h>
 #include <mcld/Support/TargetRegistry.h>
 
-using namespace mcld;
+namespace {
 
-namespace mcld {
 //===----------------------------------------------------------------------===//
-/// createMipsMCLinker - the help funtion to create
+/// createMipsMCLinker - the help funtion to create corresponding MipsMCLinker
 //===----------------------------------------------------------------------===//
-/// corresponding MipsMCLinker
-///
-MCLinker* createMipsMCLinker(const std::string &pTriple,
-                             LinkerConfig& pConfig,
-                             mcld::Module& pModule,
-                             MemoryArea& pOutput)
+mcld::MCLinker* createMipsMCLinker(const std::string &pTriple,
+                                   mcld::LinkerConfig& pConfig,
+                                   mcld::Module& pModule,
+                                   mcld::FileHandle& pFileHandle)
 {
   llvm::Triple theTriple(pTriple);
   if (theTriple.isOSDarwin()) {
@@ -36,7 +32,7 @@
     return NULL;
   }
 
-  return new MipsELFMCLinker(pConfig, pModule, pOutput);
+  return new mcld::MipsELFMCLinker(pConfig, pModule, pFileHandle);
 }
 
 } // namespace of mcld
@@ -45,6 +41,8 @@
 // MipsMCLinker
 //===----------------------------------------------------------------------===//
 extern "C" void MCLDInitializeMipsMCLinker() {
-  // Register the linker frontend
-  mcld::TargetRegistry::RegisterMCLinker(TheMipselTarget, createMipsMCLinker);
+  mcld::TargetRegistry::RegisterMCLinker(mcld::TheMipselTarget,
+                                         createMipsMCLinker);
+  mcld::TargetRegistry::RegisterMCLinker(mcld::TheMips64elTarget,
+                                         createMipsMCLinker);
 }
diff --git a/lib/Target/Mips/MipsPLT.cpp b/lib/Target/Mips/MipsPLT.cpp
new file mode 100644
index 0000000..a00b7c8
--- /dev/null
+++ b/lib/Target/Mips/MipsPLT.cpp
@@ -0,0 +1,169 @@
+//===- MipsPLT.cpp --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <llvm/Support/Casting.h>
+#include <llvm/Support/ELF.h>
+#include <mcld/Support/MsgHandling.h>
+#include "MipsGOTPLT.h"
+#include "MipsPLT.h"
+
+namespace {
+
+const uint32_t PLT0[] = {
+  0x3c1c0000,         // lui $28, %hi(&GOTPLT[0])
+  0x8f990000,         // lw $25, %lo(&GOTPLT[0])($28)
+  0x279c0000,         // addiu $28, $28, %lo(&GOTPLT[0])
+  0x031cc023,         // subu $24, $24, $28
+  0x03e07821,         // move $15, $31
+  0x0018c082,         // srl $24, $24, 2
+  0x0320f809,         // jalr $25
+  0x2718fffe          // subu $24, $24, 2
+};
+
+const uint32_t PLTA[] = {
+  0x3c0f0000,         // lui $15, %hi(.got.plt entry)
+  0x8df90000,         // l[wd] $25, %lo(.got.plt entry)($15)
+  0x03200008,         // jr $25
+  0x25f80000          // addiu $24, $15, %lo(.got.plt entry)
+};
+
+}
+
+namespace mcld {
+
+//===----------------------------------------------------------------------===//
+// MipsPLT0 Entry
+//===----------------------------------------------------------------------===//
+class MipsPLT0 : public PLT::Entry<sizeof(PLT0)>
+{
+public:
+  MipsPLT0(SectionData& pParent)
+    : PLT::Entry<sizeof(PLT0)>(pParent)
+  {}
+};
+
+//===----------------------------------------------------------------------===//
+// MipsPLTA Entry
+//===----------------------------------------------------------------------===//
+class MipsPLTA : public PLT::Entry<sizeof(PLTA)>
+{
+public:
+  MipsPLTA(SectionData& pParent)
+    : PLT::Entry<sizeof(PLTA)>(pParent)
+  {}
+};
+
+//===----------------------------------------------------------------------===//
+// MipsPLT
+//===----------------------------------------------------------------------===//
+MipsPLT::MipsPLT(LDSection& pSection)
+  : PLT(pSection)
+{
+  new MipsPLT0(*m_SectionData);
+  m_Last = m_SectionData->begin();
+}
+
+void MipsPLT::finalizeSectionSize()
+{
+  uint64_t size = sizeof(PLT0) +
+                  (m_SectionData->size() - 1) * sizeof(PLTA);
+  m_Section.setSize(size);
+
+  uint32_t offset = 0;
+  SectionData::iterator frag, fragEnd = m_SectionData->end();
+  for (frag = m_SectionData->begin(); frag != fragEnd; ++frag) {
+    frag->setOffset(offset);
+    offset += frag->size();
+  }
+}
+
+bool MipsPLT::hasPLT1() const
+{
+  return m_SectionData->size() > 1;
+}
+
+uint64_t MipsPLT::emit(MemoryRegion& pRegion)
+{
+  uint64_t result = 0x0;
+  iterator it = begin();
+
+  unsigned char* buffer = pRegion.begin();
+  memcpy(buffer, llvm::cast<MipsPLT0>((*it)).getValue(), MipsPLT0::EntrySize);
+  result += MipsPLT0::EntrySize;
+  ++it;
+
+  MipsPLTA* plta = 0;
+  for (iterator ie = end(); it != ie; ++it) {
+    plta = &(llvm::cast<MipsPLTA>(*it));
+    memcpy(buffer + result, plta->getValue(), MipsPLTA::EntrySize);
+    result += MipsPLTA::EntrySize;
+  }
+  return result;
+}
+
+void MipsPLT::reserveEntry(size_t pNum)
+{
+  for (size_t i = 0; i < pNum; ++i) {
+    Fragment* entry = new (std::nothrow) MipsPLTA(*m_SectionData);
+
+    if (NULL == entry)
+      fatal(diag::fail_allocate_memory_plt);
+  }
+}
+
+Fragment* MipsPLT::consume()
+{
+  ++m_Last;
+  assert(m_Last != m_SectionData->end() &&
+         "The number of PLT Entries and ResolveInfo doesn't match");
+  return &(*m_Last);
+}
+
+void MipsPLT::applyAllPLT(MipsGOTPLT& pGOTPLT)
+{
+  assert(m_Section.addr() && ".plt base address is NULL!");
+
+  size_t count = 0;
+  for (iterator it = m_SectionData->begin(); it != m_SectionData->end(); ++it) {
+    PLTEntryBase* plt = &(llvm::cast<PLTEntryBase>(*it));
+
+    if (it == m_SectionData->begin()) {
+      uint32_t* data = static_cast<uint32_t*>(malloc(plt->size()));
+
+      if (!data)
+        fatal(diag::fail_allocate_memory_plt);
+
+      memcpy(data, PLT0, plt->size());
+
+      uint64_t gotAddr = pGOTPLT.addr();
+
+      data[0] |= ((gotAddr + 0x8000) >> 16) & 0xffff;
+      data[1] |= gotAddr & 0xffff;
+      data[2] |= gotAddr & 0xffff;
+
+      plt->setValue(reinterpret_cast<unsigned char*>(data));
+    } else {
+      uint32_t* data = static_cast<uint32_t*>(malloc(plt->size()));
+
+      if (!data)
+        fatal(diag::fail_allocate_memory_plt);
+
+      memcpy(data, PLTA, plt->size());
+
+      uint64_t gotEntryAddr = pGOTPLT.getEntryAddr(count++);
+
+      data[0] |= ((gotEntryAddr + 0x8000) >> 16) & 0xffff;
+      data[1] |= gotEntryAddr & 0xffff;
+      data[3] |= gotEntryAddr & 0xffff;
+
+      plt->setValue(reinterpret_cast<unsigned char*>(data));
+    }
+  }
+}
+
+} //end mcld namespace
diff --git a/lib/Target/Mips/MipsPLT.h b/lib/Target/Mips/MipsPLT.h
new file mode 100644
index 0000000..f2ad0c8
--- /dev/null
+++ b/lib/Target/Mips/MipsPLT.h
@@ -0,0 +1,51 @@
+//===- MipsPLT.h ----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_MIPS_PLT_H
+#define MCLD_TARGET_MIPS_PLT_H
+
+#include <mcld/Target/PLT.h>
+#include <mcld/Support/MemoryRegion.h>
+
+namespace mcld {
+
+class MipsGOTPLT;
+
+//===----------------------------------------------------------------------===//
+// MipsPLT
+//===----------------------------------------------------------------------===//
+/** \class MipsPLT
+ *  \brief Mips Procedure Linkage Table
+ */
+class MipsPLT : public PLT
+{
+public:
+  MipsPLT(LDSection& pSection);
+
+  // hasPLT1 - return if this PLT has any PLTA/PLTB entries
+  bool hasPLT1() const;
+
+  uint64_t emit(MemoryRegion& pRegion);
+
+  Fragment* consume();
+
+  void applyAllPLT(MipsGOTPLT& pGOTPLT);
+
+public:
+  // PLT
+  void reserveEntry(size_t pNum = 1);
+  void finalizeSectionSize();
+
+private:
+  // the last consumed entry.
+  SectionData::iterator m_Last;
+};
+
+} // namespace of mcld
+
+#endif
diff --git a/lib/Target/Mips/MipsRelocationFunctions.h b/lib/Target/Mips/MipsRelocationFunctions.h
index f1461a0..3634686 100644
--- a/lib/Target/Mips/MipsRelocationFunctions.h
+++ b/lib/Target/Mips/MipsRelocationFunctions.h
@@ -8,70 +8,285 @@
 //===----------------------------------------------------------------------===//
 
 #define DECL_MIPS_APPLY_RELOC_FUNC(Name) \
-static MipsRelocator::Result Name(Relocation& pEntry, \
+static MipsRelocator::Result Name(MipsRelocationInfo& pReloc, \
                                   MipsRelocator& pParent);
 
 #define DECL_MIPS_APPLY_RELOC_FUNCS \
 DECL_MIPS_APPLY_RELOC_FUNC(none) \
 DECL_MIPS_APPLY_RELOC_FUNC(abs32) \
+DECL_MIPS_APPLY_RELOC_FUNC(rel26) \
 DECL_MIPS_APPLY_RELOC_FUNC(hi16) \
 DECL_MIPS_APPLY_RELOC_FUNC(lo16) \
+DECL_MIPS_APPLY_RELOC_FUNC(gprel16) \
 DECL_MIPS_APPLY_RELOC_FUNC(got16) \
 DECL_MIPS_APPLY_RELOC_FUNC(call16) \
 DECL_MIPS_APPLY_RELOC_FUNC(gprel32) \
+DECL_MIPS_APPLY_RELOC_FUNC(abs64) \
+DECL_MIPS_APPLY_RELOC_FUNC(gotdisp) \
+DECL_MIPS_APPLY_RELOC_FUNC(gotoff) \
 DECL_MIPS_APPLY_RELOC_FUNC(gothi16) \
-DECL_MIPS_APPLY_RELOC_FUNC(gotlo16)
+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(unsupport)
 
 #define DECL_MIPS_APPLY_RELOC_FUNC_PTRS \
-  { &none,     0, "R_MIPS_NONE",             0}, \
-  { &none,     1, "R_MIPS_16",              16}, \
-  { &abs32,    2, "R_MIPS_32",              32}, \
-  { &none,     3, "R_MIPS_REL32",           32}, \
-  { &none,     4, "R_MIPS_26",              64}, \
-  { &hi16,     5, "R_MIPS_HI16",            16}, \
-  { &lo16,     6, "R_MIPS_LO16",            16}, \
-  { &none,     7, "R_MIPS_GPREL16",         16}, \
-  { &none,     8, "R_MIPS_LITERAL",         16}, \
-  { &got16,    9, "R_MIPS_GOT16",           16}, \
-  { &none,    10, "R_MIPS_PC16",            16}, \
-  { &call16,  11, "R_MIPS_CALL16",          16}, \
-  { &gprel32, 12, "R_MIPS_GPREL32",         32}, \
-  { &none,    13, "R_MIPS_UNUSED1",          0}, \
-  { &none,    14, "R_MIPS_UNUSED2",          0}, \
-  { &none,    15, "R_MIPS_UNUSED3",          0}, \
-  { &none,    16, "R_MIPS_SHIFT5",          32}, \
-  { &none,    17, "R_MIPS_SHIFT6",          32}, \
-  { &none,    18, "R_MIPS_64",              64}, \
-  { &none,    19, "R_MIPS_GOT_DISP",        16}, \
-  { &none,    20, "R_MIPS_GOT_PAGE",        16}, \
-  { &none,    21, "R_MIPS_GOT_OFST",        16}, \
-  { &gothi16, 22, "R_MIPS_GOT_HI16",        16}, \
-  { &gotlo16, 23, "R_MIPS_GOT_LO16",        16}, \
-  { &none,    24, "R_MIPS_SUB",             64}, \
-  { &none,    25, "R_MIPS_INSERT_A",         0}, \
-  { &none,    26, "R_MIPS_INSERT_B",         0}, \
-  { &none,    27, "R_MIPS_DELETE",           0}, \
-  { &none,    28, "R_MIPS_HIGHER",          16}, \
-  { &none,    29, "R_MIPS_HIGHEST",         16}, \
-  { &gothi16, 30, "R_MIPS_CALL_HI16",       16}, \
-  { &gotlo16, 31, "R_MIPS_CALL_LO16",       16}, \
-  { &none,    32, "R_MIPS_SCN_DISP",        32}, \
-  { &none,    33, "R_MIPS_REL16",            0}, \
-  { &none,    34, "R_MIPS_ADD_IMMEDIATE",    0}, \
-  { &none,    35, "R_MIPS_PJUMP",            0}, \
-  { &none,    36, "R_MIPS_RELGOT",           0}, \
-  { &none,    37, "R_MIPS_JALR",            32}, \
-  { &none,    38, "R_MIPS_TLS_DTPMOD32",    32}, \
-  { &none,    39, "R_MIPS_TLS_DTPREL32",    32}, \
-  { &none,    40, "R_MIPS_TLS_DTPMOD64",     0}, \
-  { &none,    41, "R_MIPS_TLS_DTPREL64",     0}, \
-  { &none,    42, "R_MIPS_TLS_GD",          16}, \
-  { &none,    43, "R_MIPS_TLS_LDM",         16}, \
-  { &none,    44, "R_MIPS_TLS_DTPREL_HI16", 16}, \
-  { &none,    45, "R_MIPS_TLS_DTPREL_LO16", 16}, \
-  { &none,    46, "R_MIPS_TLS_GOTTPREL",    16}, \
-  { &none,    47, "R_MIPS_TLS_TPREL32",     32}, \
-  { &none,    48, "R_MIPS_TLS_TPREL64",      0}, \
-  { &none,    49, "R_MIPS_TLS_TPREL_HI16",  16}, \
-  { &none,    50, "R_MIPS_TLS_TPREL_LO16",  16}, \
-  { &none,    51, "R_MIPS_GLOB_DAT",         0}
+  { &none,         0, "R_MIPS_NONE",                  0}, \
+  { &unsupport,    1, "R_MIPS_16",                   16}, \
+  { &abs32,        2, "R_MIPS_32",                   32}, \
+  { &unsupport,    3, "R_MIPS_REL32",                32}, \
+  { &rel26,        4, "R_MIPS_26",                   26}, \
+  { &hi16,         5, "R_MIPS_HI16",                 16}, \
+  { &lo16,         6, "R_MIPS_LO16",                 16}, \
+  { &gprel16,      7, "R_MIPS_GPREL16",              16}, \
+  { &unsupport,    8, "R_MIPS_LITERAL",              16}, \
+  { &got16,        9, "R_MIPS_GOT16",                16}, \
+  { &unsupport,   10, "R_MIPS_PC16",                 16}, \
+  { &call16,      11, "R_MIPS_CALL16",               16}, \
+  { &gprel32,     12, "R_MIPS_GPREL32",              32}, \
+  { &none,        13, "R_MIPS_UNUSED1",               0}, \
+  { &none,        14, "R_MIPS_UNUSED2",               0}, \
+  { &none,        15, "R_MIPS_UNUSED3",               0}, \
+  { &unsupport,   16, "R_MIPS_SHIFT5",               32}, \
+  { &unsupport,   17, "R_MIPS_SHIFT6",               32}, \
+  { &abs64,       18, "R_MIPS_64",                   64}, \
+  { &gotdisp,     19, "R_MIPS_GOT_DISP",             16}, \
+  { &gotdisp,     20, "R_MIPS_GOT_PAGE",             16}, \
+  { &gotoff,      21, "R_MIPS_GOT_OFST",             16}, \
+  { &gothi16,     22, "R_MIPS_GOT_HI16",             16}, \
+  { &gotlo16,     23, "R_MIPS_GOT_LO16",             16}, \
+  { &sub,         24, "R_MIPS_SUB",                  64}, \
+  { &unsupport,   25, "R_MIPS_INSERT_A",              0}, \
+  { &unsupport,   26, "R_MIPS_INSERT_B",              0}, \
+  { &unsupport,   27, "R_MIPS_DELETE",                0}, \
+  { &unsupport,   28, "R_MIPS_HIGHER",               16}, \
+  { &unsupport,   29, "R_MIPS_HIGHEST",              16}, \
+  { &gothi16,     30, "R_MIPS_CALL_HI16",            16}, \
+  { &gotlo16,     31, "R_MIPS_CALL_LO16",            16}, \
+  { &unsupport,   32, "R_MIPS_SCN_DISP",             32}, \
+  { &unsupport,   33, "R_MIPS_REL16",                 0}, \
+  { &unsupport,   34, "R_MIPS_ADD_IMMEDIATE",         0}, \
+  { &unsupport,   35, "R_MIPS_PJUMP",                 0}, \
+  { &unsupport,   36, "R_MIPS_RELGOT",                0}, \
+  { &jalr,        37, "R_MIPS_JALR",                 32}, \
+  { &unsupport,   38, "R_MIPS_TLS_DTPMOD32",         32}, \
+  { &unsupport,   39, "R_MIPS_TLS_DTPREL32",         32}, \
+  { &unsupport,   40, "R_MIPS_TLS_DTPMOD64",          0}, \
+  { &unsupport,   41, "R_MIPS_TLS_DTPREL64",          0}, \
+  { &unsupport,   42, "R_MIPS_TLS_GD",               16}, \
+  { &unsupport,   43, "R_MIPS_TLS_LDM",              16}, \
+  { &unsupport,   44, "R_MIPS_TLS_DTPREL_HI16",      16}, \
+  { &unsupport,   45, "R_MIPS_TLS_DTPREL_LO16",      16}, \
+  { &unsupport,   46, "R_MIPS_TLS_GOTTPREL",         16}, \
+  { &unsupport,   47, "R_MIPS_TLS_TPREL32",          32}, \
+  { &unsupport,   48, "R_MIPS_TLS_TPREL64",           0}, \
+  { &unsupport,   49, "R_MIPS_TLS_TPREL_HI16",       16}, \
+  { &unsupport,   50, "R_MIPS_TLS_TPREL_LO16",       16}, \
+  { &unsupport,   51, "R_MIPS_GLOB_DAT",              0}, \
+  { &unsupport,   52, "",                             0}, \
+  { &unsupport,   53, "",                             0}, \
+  { &unsupport,   54, "",                             0}, \
+  { &unsupport,   55, "",                             0}, \
+  { &unsupport,   56, "",                             0}, \
+  { &unsupport,   57, "",                             0}, \
+  { &unsupport,   58, "",                             0}, \
+  { &unsupport,   59, "",                             0}, \
+  { &unsupport,   60, "",                             0}, \
+  { &unsupport,   61, "",                             0}, \
+  { &unsupport,   62, "",                             0}, \
+  { &unsupport,   63, "",                             0}, \
+  { &unsupport,   64, "",                             0}, \
+  { &unsupport,   65, "",                             0}, \
+  { &unsupport,   66, "",                             0}, \
+  { &unsupport,   67, "",                             0}, \
+  { &unsupport,   68, "",                             0}, \
+  { &unsupport,   69, "",                             0}, \
+  { &unsupport,   70, "",                             0}, \
+  { &unsupport,   71, "",                             0}, \
+  { &unsupport,   72, "",                             0}, \
+  { &unsupport,   73, "",                             0}, \
+  { &unsupport,   74, "",                             0}, \
+  { &unsupport,   75, "",                             0}, \
+  { &unsupport,   76, "",                             0}, \
+  { &unsupport,   77, "",                             0}, \
+  { &unsupport,   78, "",                             0}, \
+  { &unsupport,   79, "",                             0}, \
+  { &unsupport,   80, "",                             0}, \
+  { &unsupport,   81, "",                             0}, \
+  { &unsupport,   82, "",                             0}, \
+  { &unsupport,   83, "",                             0}, \
+  { &unsupport,   84, "",                             0}, \
+  { &unsupport,   85, "",                             0}, \
+  { &unsupport,   86, "",                             0}, \
+  { &unsupport,   87, "",                             0}, \
+  { &unsupport,   88, "",                             0}, \
+  { &unsupport,   89, "",                             0}, \
+  { &unsupport,   90, "",                             0}, \
+  { &unsupport,   91, "",                             0}, \
+  { &unsupport,   92, "",                             0}, \
+  { &unsupport,   93, "",                             0}, \
+  { &unsupport,   94, "",                             0}, \
+  { &unsupport,   95, "",                             0}, \
+  { &unsupport,   96, "",                             0}, \
+  { &unsupport,   97, "",                             0}, \
+  { &unsupport,   98, "",                             0}, \
+  { &unsupport,   99, "",                             0}, \
+  { &unsupport,  100, "R_MIPS16_26",                  0}, \
+  { &unsupport,  101, "R_MIPS16_GPREL",               0}, \
+  { &unsupport,  102, "R_MIPS16_GOT16",               0}, \
+  { &unsupport,  103, "R_MIPS16_CALL16",              0}, \
+  { &unsupport,  104, "R_MIPS16_HI16",                0}, \
+  { &unsupport,  105, "R_MIPS16_LO16",                0}, \
+  { &unsupport,  106, "R_MIPS16_TLS_GD",              0}, \
+  { &unsupport,  107, "R_MIPS16_TLS_LDM",             0}, \
+  { &unsupport,  108, "R_MIPS16_TLS_DTPREL_HI16",     0}, \
+  { &unsupport,  109, "R_MIPS16_TLS_DTPREL_LO16",     0}, \
+  { &unsupport,  110, "R_MIPS16_TLS_GOTTPREL",        0}, \
+  { &unsupport,  111, "R_MIPS16_TLS_TPREL_HI16",      0}, \
+  { &unsupport,  112, "R_MIPS16_TLS_TPREL_LO16",      0}, \
+  { &unsupport,  113, "",                             0}, \
+  { &unsupport,  114, "",                             0}, \
+  { &unsupport,  115, "",                             0}, \
+  { &unsupport,  116, "",                             0}, \
+  { &unsupport,  117, "",                             0}, \
+  { &unsupport,  118, "",                             0}, \
+  { &unsupport,  119, "",                             0}, \
+  { &unsupport,  120, "",                             0}, \
+  { &unsupport,  121, "",                             0}, \
+  { &unsupport,  122, "",                             0}, \
+  { &unsupport,  123, "",                             0}, \
+  { &unsupport,  124, "",                             0}, \
+  { &unsupport,  125, "",                             0}, \
+  { &unsupport,  126, "R_MIPS_COPY",                  0}, \
+  { &unsupport,  127, "R_MIPS_JUMP_SLOT",             0}, \
+  { &unsupport,  128, "",                             0}, \
+  { &unsupport,  129, "",                             0}, \
+  { &unsupport,  130, "",                             0}, \
+  { &unsupport,  131, "",                             0}, \
+  { &unsupport,  132, "",                             0}, \
+  { &unsupport,  133, "R_MICROMIPS_26_S1",            0}, \
+  { &unsupport,  134, "R_MICROMIPS_HI16",             0}, \
+  { &unsupport,  135, "R_MICROMIPS_LO16",             0}, \
+  { &unsupport,  136, "R_MICROMIPS_GPREL16",          0}, \
+  { &unsupport,  137, "R_MICROMIPS_LITERAL",          0}, \
+  { &unsupport,  138, "R_MICROMIPS_GOT16",            0}, \
+  { &unsupport,  139, "R_MICROMIPS_PC7_S1",           0}, \
+  { &unsupport,  140, "R_MICROMIPS_PC10_S1",          0}, \
+  { &unsupport,  141, "R_MICROMIPS_PC16_S1",          0}, \
+  { &unsupport,  142, "R_MICROMIPS_CALL16",           0}, \
+  { &unsupport,  143, "R_MICROMIPS_GOT_DISP",         0}, \
+  { &unsupport,  144, "R_MICROMIPS_GOT_PAGE",         0}, \
+  { &unsupport,  145, "R_MICROMIPS_GOT_OFST",         0}, \
+  { &unsupport,  146, "R_MICROMIPS_GOT_HI16",         0}, \
+  { &unsupport,  147, "R_MICROMIPS_GOT_LO16",         0}, \
+  { &unsupport,  148, "R_MICROMIPS_SUB",              0}, \
+  { &unsupport,  149, "R_MICROMIPS_HIGHER",           0}, \
+  { &unsupport,  150, "R_MICROMIPS_HIGHEST",          0}, \
+  { &unsupport,  151, "R_MICROMIPS_CALL_HI16",        0}, \
+  { &unsupport,  152, "R_MICROMIPS_CALL_LO16",        0}, \
+  { &unsupport,  153, "R_MICROMIPS_SCN_DISP",         0}, \
+  { &unsupport,  154, "R_MICROMIPS_JALR",             0}, \
+  { &unsupport,  155, "R_MICROMIPS_HI0_LO16",         0}, \
+  { &unsupport,  156, "",                             0}, \
+  { &unsupport,  157, "",                             0}, \
+  { &unsupport,  158, "",                             0}, \
+  { &unsupport,  159, "",                             0}, \
+  { &unsupport,  160, "",                             0}, \
+  { &unsupport,  161, "",                             0}, \
+  { &unsupport,  162, "R_MICROMIPS_TLS_GD",           0}, \
+  { &unsupport,  163, "R_MICROMIPS_TLS_LDM",          0}, \
+  { &unsupport,  164, "R_MICROMIPS_TLS_DTPREL_HI16",  0}, \
+  { &unsupport,  165, "R_MICROMIPS_TLS_DTPREL_LO16",  0}, \
+  { &unsupport,  166, "R_MICROMIPS_TLS_GOTTPREL",     0}, \
+  { &unsupport,  167, "",                             0}, \
+  { &unsupport,  168, "",                             0}, \
+  { &unsupport,  169, "R_MICROMIPS_TLS_TPREL_HI16",   0}, \
+  { &unsupport,  170, "R_MICROMIPS_TLS_TPREL_LO16",   0}, \
+  { &unsupport,  171, "",                             0}, \
+  { &unsupport,  172, "R_MICROMIPS_GPREL7_S2",        0}, \
+  { &unsupport,  173, "R_MICROMIPS_PC23_S2",          0}, \
+  { &unsupport,  174, "",                             0}, \
+  { &unsupport,  175, "",                             0}, \
+  { &unsupport,  176, "",                             0}, \
+  { &unsupport,  177, "",                             0}, \
+  { &unsupport,  178, "",                             0}, \
+  { &unsupport,  179, "",                             0}, \
+  { &unsupport,  180, "",                             0}, \
+  { &unsupport,  181, "",                             0}, \
+  { &unsupport,  182, "",                             0}, \
+  { &unsupport,  183, "",                             0}, \
+  { &unsupport,  184, "",                             0}, \
+  { &unsupport,  185, "",                             0}, \
+  { &unsupport,  186, "",                             0}, \
+  { &unsupport,  187, "",                             0}, \
+  { &unsupport,  188, "",                             0}, \
+  { &unsupport,  189, "",                             0}, \
+  { &unsupport,  190, "",                             0}, \
+  { &unsupport,  191, "",                             0}, \
+  { &unsupport,  192, "",                             0}, \
+  { &unsupport,  193, "",                             0}, \
+  { &unsupport,  194, "",                             0}, \
+  { &unsupport,  195, "",                             0}, \
+  { &unsupport,  196, "",                             0}, \
+  { &unsupport,  197, "",                             0}, \
+  { &unsupport,  198, "",                             0}, \
+  { &unsupport,  199, "",                             0}, \
+  { &la25lui,    200, "R_MIPS_LA25_LUI",             16}, \
+  { &la25j,      201, "R_MIPS_LA25_J",               26}, \
+  { &la25add,    202, "R_MIPS_LA25_ADD",             16}, \
+  { &unsupport,  203, "",                             0}, \
+  { &unsupport,  204, "",                             0}, \
+  { &unsupport,  205, "",                             0}, \
+  { &unsupport,  206, "",                             0}, \
+  { &unsupport,  207, "",                             0}, \
+  { &unsupport,  208, "",                             0}, \
+  { &unsupport,  209, "",                             0}, \
+  { &unsupport,  210, "",                             0}, \
+  { &unsupport,  211, "",                             0}, \
+  { &unsupport,  212, "",                             0}, \
+  { &unsupport,  213, "",                             0}, \
+  { &unsupport,  214, "",                             0}, \
+  { &unsupport,  215, "",                             0}, \
+  { &unsupport,  216, "",                             0}, \
+  { &unsupport,  217, "",                             0}, \
+  { &unsupport,  218, "",                             0}, \
+  { &unsupport,  219, "",                             0}, \
+  { &unsupport,  220, "",                             0}, \
+  { &unsupport,  221, "",                             0}, \
+  { &unsupport,  222, "",                             0}, \
+  { &unsupport,  223, "",                             0}, \
+  { &unsupport,  224, "",                             0}, \
+  { &unsupport,  225, "",                             0}, \
+  { &unsupport,  226, "",                             0}, \
+  { &unsupport,  227, "",                             0}, \
+  { &unsupport,  228, "",                             0}, \
+  { &unsupport,  229, "",                             0}, \
+  { &unsupport,  230, "",                             0}, \
+  { &unsupport,  231, "",                             0}, \
+  { &unsupport,  232, "",                             0}, \
+  { &unsupport,  233, "",                             0}, \
+  { &unsupport,  234, "",                             0}, \
+  { &unsupport,  235, "",                             0}, \
+  { &unsupport,  236, "",                             0}, \
+  { &unsupport,  237, "",                             0}, \
+  { &unsupport,  238, "",                             0}, \
+  { &unsupport,  239, "",                             0}, \
+  { &unsupport,  240, "",                             0}, \
+  { &unsupport,  241, "",                             0}, \
+  { &unsupport,  242, "",                             0}, \
+  { &unsupport,  243, "",                             0}, \
+  { &unsupport,  244, "",                             0}, \
+  { &unsupport,  245, "",                             0}, \
+  { &unsupport,  246, "",                             0}, \
+  { &unsupport,  247, "",                             0}, \
+  { &pc32,       248, "R_MIPS_PC32",                  0}, \
+  { &unsupport,  249, "",                             0}, \
+  { &unsupport,  250, "R_MIPS_GNU_REL16_S2",          0}, \
+  { &unsupport,  251, "",                             0}, \
+  { &unsupport,  252, "",                             0}, \
+  { &unsupport,  253, "R_MIPS_GNU_VTINHERIT",         0}, \
+  { &unsupport,  254, "R_MIPS_GNU_VTENTRY",           0}
diff --git a/lib/Target/Mips/MipsRelocator.cpp b/lib/Target/Mips/MipsRelocator.cpp
index 8f08862..314a6ad 100644
--- a/lib/Target/Mips/MipsRelocator.cpp
+++ b/lib/Target/Mips/MipsRelocator.cpp
@@ -6,26 +6,155 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
-#include <llvm/ADT/Twine.h>
-#include <llvm/Support/ELF.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Target/OutputRelocSection.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/IRBuilder.h>
-
 #include "MipsRelocator.h"
 #include "MipsRelocationFunctions.h"
 
+#include <mcld/IRBuilder.h>
+#include <mcld/LinkerConfig.h>
+#include <mcld/Object/ObjectBuilder.h>
+#include <mcld/Support/MsgHandling.h>
+#include <mcld/Target/OutputRelocSection.h>
+#include <mcld/LD/ELFFileFormat.h>
+
+#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,
+  R_MIPS_PC32     = 248,
+};
+
+} // end namespace ELF
+} // end namespace llvm
+
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
+// MipsRelocationInfo
+//===----------------------------------------------------------------------===//
+class mcld::MipsRelocationInfo
+{
+public:
+  static bool HasSubType(const Relocation& pParent, Relocation::Type pType)
+  {
+    if (llvm::ELF::R_MIPS_NONE == pType)
+      return true;
+
+    for (Relocation::Type type = pParent.type();
+         llvm::ELF::R_MIPS_NONE != (type & 0xff); type >>= 8) {
+      if ((type & 0xff) == pType)
+        return true;
+    }
+
+    return false;
+  }
+
+  MipsRelocationInfo(Relocation& pParent, bool pIsRel)
+    : m_Parent(&pParent),
+      m_Type(pParent.type()),
+      m_Addend(0),
+      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();
+  }
+
+  bool isNone() const
+  {
+    return llvm::ELF::R_MIPS_NONE == type();
+  }
+
+  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);
+  }
+
+  const Relocation& parent() const
+  {
+    return *m_Parent;
+  }
+
+  Relocation& parent()
+  {
+    return *m_Parent;
+  }
+
+  Relocation::Type type() const
+  {
+    return m_Type & 0xff;
+  }
+
+  Relocation::DWord A() const
+  {
+    return m_Addend;
+  }
+
+  Relocation::DWord S() const
+  {
+    return m_Symbol;
+  }
+
+  Relocation::DWord P() const
+  {
+    return parent().place();
+  }
+
+  Relocation::DWord result() const
+  {
+    return m_Result;
+  }
+
+  Relocation::DWord& result()
+  {
+    return m_Result;
+  }
+
+private:
+  Relocation* m_Parent;
+  Relocation::Type m_Type;
+  Relocation::DWord m_Addend;
+  Relocation::DWord m_Symbol;
+  Relocation::DWord m_Result;
+
+  MipsRelocationInfo(Relocation& pParent, Relocation::Type pType,
+                     Relocation::DWord pResult,
+                     Relocation::DWord pAddend, Relocation::DWord pSymbol)
+    : m_Parent(&pParent),
+      m_Type(pType),
+      m_Addend(pAddend),
+      m_Symbol(pSymbol),
+      m_Result(pResult)
+  {}
+
+  bool isFirst() const {
+    return m_Type == parent().type();
+  }
+};
+
+//===----------------------------------------------------------------------===//
 // Relocation Functions and Tables
 //===----------------------------------------------------------------------===//
 DECL_MIPS_APPLY_RELOC_FUNCS
 
 /// the prototype of applying function
-typedef Relocator::Result (*ApplyFunctionType)(Relocation&, MipsRelocator&);
+typedef Relocator::Result (*ApplyFunctionType)(MipsRelocationInfo&,
+                                               MipsRelocator& pParent);
+
 
 // the table entry of applying functions
 struct ApplyFunctionTriple
@@ -49,78 +178,102 @@
   : Relocator(pConfig),
     m_Target(pParent),
     m_pApplyingInput(NULL),
-    m_AHL(0)
+    m_CurrentLo16Reloc(NULL)
 {
 }
 
 Relocator::Result
-MipsRelocator::applyRelocation(Relocation& pRelocation)
+MipsRelocator::applyRelocation(Relocation& pReloc)
 {
-  Relocation::Type type = pRelocation.type();
-
-  if (type >= sizeof(ApplyFunctions) / sizeof(ApplyFunctions[0])) {
-    return Unknown;
+  // If m_CurrentLo16Reloc is not NULL we are processing
+  // postponed relocation. Otherwise check relocation type
+  // and postpone it for later handling.
+  if (NULL == m_CurrentLo16Reloc && isPostponed(pReloc)) {
+    postponeRelocation(pReloc);
+    return OK;
   }
 
-  // apply the relocation
-  return ApplyFunctions[type].func(pRelocation, *this);
+  for (MipsRelocationInfo info(pReloc, isRel());
+       !info.isNone(); info = info.next()) {
+    if (info.type() >= sizeof(ApplyFunctions) / sizeof(ApplyFunctions[0]))
+      return Unknown;
+
+    const ApplyFunctionTriple & triple = ApplyFunctions[info.type()];
+
+    Result res = triple.func(info, *this);
+    if (OK != res)
+      return res;
+
+    if (info.isLast()) {
+      uint64_t mask = 0xFFFFFFFFFFFFFFFFULL >> (64 - triple.size);
+      pReloc.target() &= ~mask;
+      pReloc.target() |= info.result() & mask;
+    }
+  }
+
+  return OK;
 }
 
 const char* MipsRelocator::getName(Relocation::Type pType) const
 {
-  return ApplyFunctions[pType].name;
+  return ApplyFunctions[pType & 0xff].name;
 }
 
 Relocator::Size MipsRelocator::getSize(Relocation::Type pType) const
 {
-  return ApplyFunctions[pType].size;
+  return ApplyFunctions[pType & 0xff].size;
 }
 
 void MipsRelocator::scanRelocation(Relocation& pReloc,
                                    IRBuilder& pBuilder,
                                    Module& pModule,
-                                   LDSection& pSection)
+                                   LDSection& pSection,
+                                   Input& pInput)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
   assert(NULL != rsym && "ResolveInfo of relocation not set while scanRelocation");
 
   // Skip relocation against _gp_disp
-  if (NULL != getTarget().getGpDispSymbol()) {
-    if (pReloc.symInfo() == getTarget().getGpDispSymbol()->resolveInfo())
-      return;
-  }
-
-  pReloc.updateAddend();
+  if (NULL != getTarget().getGpDispSymbol() &&
+      rsym == getTarget().getGpDispSymbol()->resolveInfo())
+    return;
 
   assert(NULL != pSection.getLink());
   if (0 == (pSection.getLink()->flag() & llvm::ELF::SHF_ALLOC))
     return;
 
-  // We test isLocal or if pInputSym is not a dynamic symbol
-  // We assume -Bsymbolic to bind all symbols internaly via !rsym->isDyn()
-  // Don't put undef symbols into local entries.
-  if ((rsym->isLocal() || !getTarget().isDynamicSymbol(*rsym) ||
-      !rsym->isDyn()) && !rsym->isUndef())
-    scanLocalReloc(pReloc, pBuilder, pSection);
-  else
-    scanGlobalReloc(pReloc, pBuilder, pSection);
+  for (MipsRelocationInfo info(pReloc, isRel());
+       !info.isNone(); info = info.next()) {
+    // We test isLocal or if pInputSym is not a dynamic symbol
+    // We assume -Bsymbolic to bind all symbols internaly via !rsym->isDyn()
+    // Don't put undef symbols into local entries.
+    if (isLocalReloc(*rsym))
+      scanLocalReloc(info, pBuilder, pSection);
+    else
+      scanGlobalReloc(info, pBuilder, pSection);
 
-  // check if we shoule issue undefined reference for the relocation target
-  // symbol
+    if (getTarget().needsLA25Stub(info.type(), info.parent().symInfo()))
+      getTarget().addNonPICBranchSym(pReloc.symInfo());
+  }
+
+  // Check if we should issue undefined reference
+  // for the relocation target symbol.
   if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
-    fatal(diag::undefined_reference) << rsym->name();
+    issueUndefRef(pReloc, pSection, pInput);
 }
 
 bool MipsRelocator::initializeScan(Input& pInput)
 {
-  getTarget().getGOT().initializeScan(pInput);
+  if (LinkerConfig::Object != config().codeGenType())
+    getTarget().getGOT().initializeScan(pInput);
   return true;
 }
 
 bool MipsRelocator::finalizeScan(Input& pInput)
 {
-  getTarget().getGOT().finalizeScan(pInput);
+  if (LinkerConfig::Object != config().codeGenType())
+    getTarget().getGOT().finalizeScan(pInput);
   return true;
 }
 
@@ -136,17 +289,18 @@
   return true;
 }
 
-void MipsRelocator::scanLocalReloc(Relocation& pReloc,
+void MipsRelocator::scanLocalReloc(MipsRelocationInfo& pReloc,
                                    IRBuilder& pBuilder,
                                    const LDSection& pSection)
 {
-  ResolveInfo* rsym = pReloc.symInfo();
+  ResolveInfo* rsym = pReloc.parent().symInfo();
 
   switch (pReloc.type()){
     case llvm::ELF::R_MIPS_NONE:
     case llvm::ELF::R_MIPS_16:
       break;
     case llvm::ELF::R_MIPS_32:
+    case llvm::ELF::R_MIPS_64:
       if (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.
@@ -155,10 +309,6 @@
         getTarget().getRelDyn().reserveEntry();
         rsym->setReserved(rsym->reserved() | ReserveRel);
         getTarget().checkAndSetHasTextRel(*pSection.getLink());
-
-        // Remeber this rsym is a local GOT entry (as if it needs an entry).
-        // Actually we don't allocate an GOT entry.
-        getTarget().getGOT().setLocal(rsym);
       }
       break;
     case llvm::ELF::R_MIPS_REL32:
@@ -168,9 +318,6 @@
     case llvm::ELF::R_MIPS_PC16:
     case llvm::ELF::R_MIPS_SHIFT5:
     case llvm::ELF::R_MIPS_SHIFT6:
-    case llvm::ELF::R_MIPS_64:
-    case llvm::ELF::R_MIPS_GOT_PAGE:
-    case llvm::ELF::R_MIPS_GOT_OFST:
     case llvm::ELF::R_MIPS_SUB:
     case llvm::ELF::R_MIPS_INSERT_A:
     case llvm::ELF::R_MIPS_INSERT_B:
@@ -193,17 +340,18 @@
     case llvm::ELF::R_MIPS_CALL_HI16:
     case llvm::ELF::R_MIPS_GOT_LO16:
     case llvm::ELF::R_MIPS_CALL_LO16:
-      if (getTarget().getGOT().reserveLocalEntry(*rsym)) {
+    case llvm::ELF::R_MIPS_GOT_DISP:
+    case llvm::ELF::R_MIPS_GOT_PAGE:
+    case llvm::ELF::R_MIPS_GOT_OFST:
+      if (getTarget().getGOT().reserveLocalEntry(*rsym,
+                                                 pReloc.type(), pReloc.A())) {
         if (getTarget().getGOT().hasMultipleGOT())
           getTarget().checkAndSetHasTextRel(*pSection.getLink());
-        // Remeber this rsym is a local GOT entry
-        getTarget().getGOT().setLocal(rsym);
       }
       break;
     case llvm::ELF::R_MIPS_GPREL32:
     case llvm::ELF::R_MIPS_GPREL16:
     case llvm::ELF::R_MIPS_LITERAL:
-    case llvm::ELF::R_MIPS_GOT_DISP:
       break;
     case llvm::ELF::R_MIPS_TLS_DTPMOD32:
     case llvm::ELF::R_MIPS_TLS_DTPREL32:
@@ -219,17 +367,18 @@
     case llvm::ELF::R_MIPS_TLS_TPREL_HI16:
     case llvm::ELF::R_MIPS_TLS_TPREL_LO16:
       break;
+    case llvm::ELF::R_MIPS_PC32:
+      break;
     default:
-      fatal(diag::unknown_relocation) << (int)pReloc.type()
-                                      << pReloc.symInfo()->name();
+      fatal(diag::unknown_relocation) << (int)pReloc.type() << rsym->name();
   }
 }
 
-void MipsRelocator::scanGlobalReloc(Relocation& pReloc,
+void MipsRelocator::scanGlobalReloc(MipsRelocationInfo& pReloc,
                                     IRBuilder& pBuilder,
                                     const LDSection& pSection)
 {
-  ResolveInfo* rsym = pReloc.symInfo();
+  ResolveInfo* rsym = pReloc.parent().symInfo();
 
   switch (pReloc.type()){
     case llvm::ELF::R_MIPS_NONE:
@@ -250,12 +399,15 @@
     case llvm::ELF::R_MIPS_LO16:
       if (getTarget().symbolNeedsDynRel(*rsym, false, true)) {
         getTarget().getRelDyn().reserveEntry();
-        rsym->setReserved(rsym->reserved() | ReserveRel);
-        getTarget().checkAndSetHasTextRel(*pSection.getLink());
-
-        // Remeber this rsym is a global GOT entry (as if it needs an entry).
-        // Actually we don't allocate an GOT entry.
-        getTarget().getGOT().setGlobal(rsym);
+        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());
+        }
       }
       break;
     case llvm::ELF::R_MIPS_GOT16:
@@ -270,18 +422,25 @@
       if (getTarget().getGOT().reserveGlobalEntry(*rsym)) {
         if (getTarget().getGOT().hasMultipleGOT())
           getTarget().checkAndSetHasTextRel(*pSection.getLink());
-        // Remeber this rsym is a global GOT entry
-        getTarget().getGOT().setGlobal(rsym);
       }
       break;
     case llvm::ELF::R_MIPS_LITERAL:
     case llvm::ELF::R_MIPS_GPREL32:
       fatal(diag::invalid_global_relocation) << (int)pReloc.type()
-                                             << pReloc.symInfo()->name();
+                                             << rsym->name();
       break;
     case llvm::ELF::R_MIPS_GPREL16:
       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();
+        rsym->setReserved(rsym->reserved() | ReservePLT);
+      }
+      break;
     case llvm::ELF::R_MIPS_PC16:
       break;
     case llvm::ELF::R_MIPS_16:
@@ -303,8 +462,8 @@
     case llvm::ELF::R_MIPS_TLS_TPREL_LO16:
       break;
     case llvm::ELF::R_MIPS_REL32:
-      break;
     case llvm::ELF::R_MIPS_JALR:
+    case llvm::ELF::R_MIPS_PC32:
       break;
     case llvm::ELF::R_MIPS_COPY:
     case llvm::ELF::R_MIPS_GLOB_DAT:
@@ -312,156 +471,320 @@
       fatal(diag::dynamic_relocation) << (int)pReloc.type();
       break;
     default:
-      fatal(diag::unknown_relocation) << (int)pReloc.type()
-                                      << pReloc.symInfo()->name();
+      fatal(diag::unknown_relocation) << (int)pReloc.type() << rsym->name();
   }
 }
 
-//===----------------------------------------------------------------------===//
-// Relocation helper function
-//===----------------------------------------------------------------------===//
-static const char * const GP_DISP_NAME = "_gp_disp";
-
-// Find next R_MIPS_LO16 relocation paired to pReloc.
-static
-Relocation* helper_FindLo16Reloc(Relocation& pReloc)
+bool MipsRelocator::isPostponed(const Relocation& pReloc) const
 {
-  Relocation* reloc = static_cast<Relocation*>(pReloc.getNextNode());
-  while (NULL != reloc)
-  {
-    if (llvm::ELF::R_MIPS_LO16 == reloc->type() &&
-        reloc->symInfo() == pReloc.symInfo())
-      return reloc;
+  if (MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_HI16))
+    return true;
 
-    reloc = static_cast<Relocation*>(reloc->getNextNode());
+  if (MipsRelocationInfo::HasSubType(pReloc, llvm::ELF::R_MIPS_GOT16) &&
+      pReloc.symInfo()->isLocal())
+    return true;
+
+  return false;
+}
+
+void MipsRelocator::addCopyReloc(ResolveInfo& pSym)
+{
+  Relocation& relEntry = *getTarget().getRelDyn().consumeEntry();
+  relEntry.setType(llvm::ELF::R_MIPS_COPY);
+  assert(pSym.outSymbol()->hasFragRef());
+  relEntry.targetRef().assign(*pSym.outSymbol()->fragRef());
+  relEntry.setSymInfo(&pSym);
+}
+
+LDSymbol& MipsRelocator::defineSymbolforCopyReloc(IRBuilder& pBuilder,
+                                                  const ResolveInfo& pSym)
+{
+  // Get or create corresponding BSS LDSection
+  ELFFileFormat* fileFormat = getTarget().getOutputFormat();
+  LDSection* bssSectHdr =
+    ResolveInfo::ThreadLocal == pSym.type() ? &fileFormat->getTBSS()
+                                            : &fileFormat->getBSS();
+
+  // Get or create corresponding BSS SectionData
+  SectionData* bssData =
+    bssSectHdr->hasSectionData() ? bssSectHdr->getSectionData()
+                                 : IRBuilder::CreateSectionData(*bssSectHdr);
+
+  // Determine the alignment by the symbol value
+  // FIXME: here we use the largest alignment
+  uint32_t addrAlign = config().targets().bitclass() / 8;
+
+  // Allocate space in BSS for the copy symbol
+  Fragment* frag = new FillFragment(0x0, 1, pSym.size());
+  uint64_t size = ObjectBuilder::AppendFragment(*frag, *bssData, addrAlign);
+  bssSectHdr->setSize(bssSectHdr->size() + size);
+
+  // Change symbol binding to Global if it's a weak symbol
+  ResolveInfo::Binding binding = (ResolveInfo::Binding)pSym.binding();
+  if (binding == ResolveInfo::Weak)
+    binding = ResolveInfo::Global;
+
+  // Define the copy symbol in the bss section and resolve it
+  LDSymbol* cpySym = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
+                      pSym.name(),
+                      (ResolveInfo::Type)pSym.type(),
+                      ResolveInfo::Define,
+                      binding,
+                      pSym.size(),  // size
+                      0x0,          // value
+                      FragmentRef::Create(*frag, 0x0),
+                      (ResolveInfo::Visibility)pSym.other());
+
+  // Output all other alias symbols if any
+  Module::AliasList* alias_list = pBuilder.getModule().getAliasList(pSym);
+  if (NULL == alias_list)
+    return *cpySym;
+
+  for (Module::alias_iterator it = alias_list->begin(), ie = alias_list->end();
+       it != ie; ++it) {
+    const ResolveInfo* alias = *it;
+    if (alias == &pSym || !alias->isDyn())
+      continue;
+
+    pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
+        alias->name(),
+        (ResolveInfo::Type)alias->type(),
+        ResolveInfo::Define,
+        binding,
+        alias->size(),  // size
+        0x0,            // value
+        FragmentRef::Create(*frag, 0x0),
+        (ResolveInfo::Visibility)alias->other());
   }
-  return NULL;
+
+  return *cpySym;
 }
 
-// Check the symbol is _gp_disp.
-static
-bool helper_isGpDisp(const Relocation& pReloc)
+void MipsRelocator::postponeRelocation(Relocation& pReloc)
 {
-  const ResolveInfo* rsym = pReloc.symInfo();
-  return 0 == strcmp(GP_DISP_NAME, rsym->name());
+  ResolveInfo* rsym = pReloc.symInfo();
+  m_PostponedRelocs[rsym].insert(&pReloc);
 }
 
-static
-Relocator::Address helper_GetGP(MipsRelocator& pParent)
+void MipsRelocator::applyPostponedRelocations(MipsRelocationInfo& pLo16Reloc)
 {
-  return pParent.getTarget().getGOT().getGPAddr(pParent.getApplyingInput());
+  m_CurrentLo16Reloc = &pLo16Reloc;
+
+  ResolveInfo* rsym = pLo16Reloc.parent().symInfo();
+
+  RelocationSet & relocs = m_PostponedRelocs[rsym];
+  for (RelocationSet::iterator it = relocs.begin(); it != relocs.end(); ++it)
+    (*it)->apply(*this);
+
+  m_PostponedRelocs.erase(rsym);
+
+  m_CurrentLo16Reloc = NULL;
 }
 
-static
-void helper_SetupRelDynForGOTEntry(MipsGOTEntry& got_entry,
-                                   Relocation& pReloc,
-                                   ResolveInfo* rsym,
-                                   MipsRelocator& pParent)
+bool MipsRelocator::isGpDisp(const Relocation& pReloc) const
 {
-  MipsGNULDBackend& ld_backend = pParent.getTarget();
-
-  Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
-  rel_entry.setType(llvm::ELF::R_MIPS_REL32);
-  rel_entry.targetRef() = *FragmentRef::Create(got_entry, 0);
-  rel_entry.setSymInfo(rsym);
+  return 0 == strcmp("_gp_disp", pReloc.symInfo()->name());
 }
 
-static
-MipsGOTEntry& helper_GetGOTEntry(Relocation& pReloc, MipsRelocator& pParent)
+bool MipsRelocator::isRel() const
+{
+  return config().targets().is32Bits();
+}
+
+bool MipsRelocator::isLocalReloc(ResolveInfo& pSym) const
+{
+  if (pSym.isUndef())
+    return false;
+
+  return pSym.isLocal() ||
+         !getTarget().isDynamicSymbol(pSym) ||
+         !pSym.isDyn();
+}
+
+Relocator::Address MipsRelocator::getGPAddress()
+{
+  return getTarget().getGOT().getGPAddr(getApplyingInput());
+}
+
+Relocator::Address MipsRelocator::getGP0()
+{
+  return getTarget().getGP0(getApplyingInput());
+}
+
+Fragment& MipsRelocator::getLocalGOTEntry(MipsRelocationInfo& pReloc,
+                                          Relocation::DWord entryValue)
 {
   // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  MipsGNULDBackend& ld_backend = pParent.getTarget();
-  MipsGOT& got = ld_backend.getGOT();
-  MipsGOTEntry* got_entry;
+  ResolveInfo* rsym = pReloc.parent().symInfo();
+  MipsGOT& got = getTarget().getGOT();
 
-  if (got.isLocal(rsym) && ResolveInfo::Section == rsym->type()) {
-    // Local section symbols consume local got entries.
-    got_entry = got.consumeLocal();
-    if (got.isPrimaryGOTConsumed())
-      helper_SetupRelDynForGOTEntry(*got_entry, pReloc, NULL, pParent);
+  assert(isLocalReloc(*rsym) &&
+         "Attempt to get a global GOT entry for the local relocation");
+
+  Fragment* got_entry = got.lookupLocalEntry(rsym, entryValue);
+
+  // Found a mapping, then return the mapped entry immediately.
+  if (NULL != got_entry)
     return *got_entry;
-  }
 
-  got_entry = got.lookupEntry(rsym);
-  if (NULL != got_entry) {
-    // found a mapping, then return the mapped entry immediately
-    return *got_entry;
-  }
-
-  // not found
-  if (got.isLocal(rsym))
-    got_entry = got.consumeLocal();
-  else
-    got_entry = got.consumeGlobal();
-
-  got.recordEntry(rsym, got_entry);
-
-  // If we first get this GOT entry, we should initialize it.
-  if (!got.isLocal(rsym) || ResolveInfo::Section != rsym->type()) {
-    if (!got.isPrimaryGOTConsumed())
-      got_entry->setValue(pReloc.symValue());
-  }
+  // Not found.
+  got_entry = got.consumeLocal();
 
   if (got.isPrimaryGOTConsumed())
-    helper_SetupRelDynForGOTEntry(*got_entry, pReloc,
-                                  got.isLocal(rsym) ? NULL : rsym, pParent);
+    setupRelDynEntry(*FragmentRef::Create(*got_entry, 0), NULL);
+  else
+    got.setEntryValue(got_entry, entryValue);
+
+  got.recordLocalEntry(rsym, entryValue, got_entry);
 
   return *got_entry;
 }
 
-static
-Relocator::Address helper_GetGOTOffset(Relocation& pReloc,
-                                       MipsRelocator& pParent)
+Fragment& MipsRelocator::getGlobalGOTEntry(MipsRelocationInfo& pReloc)
 {
-  MipsGNULDBackend& ld_backend = pParent.getTarget();
-  MipsGOT& got = ld_backend.getGOT();
-  MipsGOTEntry& got_entry = helper_GetGOTEntry(pReloc, pParent);
-  return got.getGPRelOffset(pParent.getApplyingInput(), got_entry);
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.parent().symInfo();
+  MipsGOT& got = getTarget().getGOT();
+
+  assert(!isLocalReloc(*rsym) &&
+         "Attempt to get a local GOT entry for the global relocation");
+
+  Fragment* got_entry = got.lookupGlobalEntry(rsym);
+
+  // Found a mapping, then return the mapped entry immediately.
+  if (NULL != got_entry)
+    return *got_entry;
+
+  // Not found.
+  got_entry = got.consumeGlobal();
+
+  if (got.isPrimaryGOTConsumed())
+    setupRelDynEntry(*FragmentRef::Create(*got_entry, 0), rsym);
+  else
+    got.setEntryValue(got_entry, pReloc.parent().symValue());
+
+  got.recordGlobalEntry(rsym, got_entry);
+
+  return *got_entry;
 }
 
-static
-int32_t helper_CalcAHL(const Relocation& pHiReloc, const Relocation& pLoReloc)
+Relocator::Address MipsRelocator::getGOTOffset(MipsRelocationInfo& pReloc)
 {
-  assert((pHiReloc.type() == llvm::ELF::R_MIPS_HI16 ||
-          pHiReloc.type() == llvm::ELF::R_MIPS_GOT16) &&
-         pLoReloc.type() == llvm::ELF::R_MIPS_LO16 &&
-         "Incorrect type of relocation for AHL calculation");
+  ResolveInfo* rsym = pReloc.parent().symInfo();
+  MipsGOT& got = getTarget().getGOT();
 
-  // Note the addend is section symbol offset here
-  assert (pHiReloc.addend() == pLoReloc.addend());
+  if (isLocalReloc(*rsym)) {
+    uint64_t value = pReloc.S();
 
-  int32_t AHI = pHiReloc.target();
-  int32_t ALO = pLoReloc.target();
-  int32_t AHL = ((AHI & 0xFFFF) << 16) + (int16_t)(ALO & 0xFFFF) +
-                 pLoReloc.addend();
+    if (ResolveInfo::Section == rsym->type())
+      value += pReloc.A();
+
+    return got.getGPRelOffset(getApplyingInput(),
+                              getLocalGOTEntry(pReloc, value));
+  }
+  else {
+    return got.getGPRelOffset(getApplyingInput(), getGlobalGOTEntry(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);
+    // Don't add symbol value that will be resolved by the dynamic linker.
+    pReloc.result() = A;
+  }
+}
+
+uint64_t MipsRelocator::calcAHL(const MipsRelocationInfo& pHiReloc)
+{
+  assert(NULL != m_CurrentLo16Reloc &&
+         "There is no saved R_MIPS_LO16 relocation");
+
+  uint64_t AHI = pHiReloc.A() & 0xFFFF;
+  uint64_t ALO = m_CurrentLo16Reloc->A() & 0xFFFF;
+  uint64_t AHL = (AHI << 16) + int16_t(ALO);
+
   return AHL;
 }
 
-static
-void helper_DynRel(Relocation& pReloc, MipsRelocator& pParent)
+bool MipsRelocator::isN64ABI() const
 {
-  ResolveInfo* rsym = pReloc.symInfo();
-  MipsGNULDBackend& ld_backend = pParent.getTarget();
-  MipsGOT& got = ld_backend.getGOT();
+  return config().targets().is64Bits();
+}
 
-  Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
+uint64_t MipsRelocator::getPLTAddress(ResolveInfo& rsym)
+{
+  assert((rsym.reserved() & MipsRelocator::ReservePLT) &&
+         "Symbol does not require a PLT entry");
 
-  rel_entry.setType(llvm::ELF::R_MIPS_REL32);
-  rel_entry.targetRef() = pReloc.targetRef();
+  SymPLTMap::const_iterator it = m_SymPLTMap.find(&rsym);
 
-  Relocator::DWord A = pReloc.target() + pReloc.addend();
-  Relocator::DWord S = pReloc.symValue();
+  Fragment* plt;
 
-  if (got.isLocal(rsym)) {
-    rel_entry.setSymInfo(NULL);
-    pReloc.target() = A + S;
+  if (it != m_SymPLTMap.end()) {
+    plt = it->second.first;
   }
   else {
-    rel_entry.setSymInfo(rsym);
-    // Don't add symbol value that will be resolved by the dynamic linker
-    pReloc.target() = A;
+    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();
+}
+
+//===----------------------------------------------------------------------===//
+// Mips32Relocator
+//===----------------------------------------------------------------------===//
+Mips32Relocator::Mips32Relocator(Mips32GNULDBackend& pParent,
+                                 const LinkerConfig& pConfig)
+  : 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);
+}
+
+//===----------------------------------------------------------------------===//
+// Mips64Relocator
+//===----------------------------------------------------------------------===//
+Mips64Relocator::Mips64Relocator(Mips64GNULDBackend& pParent,
+                                 const LinkerConfig& pConfig)
+  : MipsRelocator(pParent, pConfig)
+{}
+
+void Mips64Relocator::setupRelDynEntry(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;
+
+  Relocation& relEntry = *getTarget().getRelDyn().consumeEntry();
+  relEntry.setType(type);
+  relEntry.targetRef() = pFragRef;
+  relEntry.setSymInfo(pSym);
 }
 
 //=========================================//
@@ -470,35 +793,60 @@
 
 // R_MIPS_NONE and those unsupported/deprecated relocation type
 static
-MipsRelocator::Result none(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result none(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
   return MipsRelocator::OK;
 }
 
 // R_MIPS_32: S + A
 static
-MipsRelocator::Result abs32(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result abs32(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
-  ResolveInfo* rsym = pReloc.symInfo();
+  ResolveInfo* rsym = pReloc.parent().symInfo();
 
-  Relocator::DWord A = pReloc.target() + pReloc.addend();
-  Relocator::DWord S = pReloc.symValue();
+  Relocator::DWord A = pReloc.A();
+  Relocator::DWord S = pReloc.S();
 
-  LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
+  LDSection& target_sect =
+    pReloc.parent().targetRef().frag()->getParent()->getSection();
+
   // If the flag of target section is not ALLOC, we will not scan this relocation
   // but perform static relocation. (e.g., applying .debug section)
   if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
-    pReloc.target() = S + A;
+    pReloc.result() = S + A;
     return MipsRelocator::OK;
   }
 
   if (rsym->reserved() & MipsRelocator::ReserveRel) {
-    helper_DynRel(pReloc, pParent);
-
+    pParent.createDynRel(pReloc);
     return MipsRelocator::OK;
   }
 
-  pReloc.target() = (S + A);
+  pReloc.result() = S + A;
+
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_26:
+//   local   : ((A | ((P + 4) & 0x3F000000)) + S) >> 2
+//   external: (sign–extend(A) + S) >> 2
+static
+MipsRelocator::Result rel26(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  ResolveInfo* rsym = pReloc.parent().symInfo();
+
+  int32_t A = ((pReloc.parent().target() & 0x03FFFFFF) << 2);
+  int32_t P = pReloc.P();
+  int32_t S = rsym->reserved() & MipsRelocator::ReservePLT
+                  ? pParent.getPLTAddress(*rsym)
+                  : pReloc.S();
+
+  if (rsym->isLocal())
+    pReloc.result() = A | ((P + 4) & 0x3F000000);
+  else
+    pReloc.result() = mcld::signExtend<28>(A);
+
+  pReloc.result() = (pReloc.result() + S) >> 2;
 
   return MipsRelocator::OK;
 }
@@ -507,29 +855,23 @@
 //   local/external: ((AHL + S) - (short)(AHL + S)) >> 16
 //   _gp_disp      : ((AHL + GP - P) - (short)(AHL + GP - P)) >> 16
 static
-MipsRelocator::Result hi16(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result hi16(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
-  Relocation* lo_reloc = helper_FindLo16Reloc(pReloc);
-  assert(NULL != lo_reloc && "There is no paired R_MIPS_LO16 for R_MIPS_HI16");
+  uint64_t AHL = pParent.calcAHL(pReloc);
 
-  int32_t AHL = helper_CalcAHL(pReloc, *lo_reloc);
-  int32_t res = 0;
-
-  pParent.setAHL(AHL);
-
-  if (helper_isGpDisp(pReloc)) {
-    int32_t P = pReloc.place();
-    int32_t GP = helper_GetGP(pParent);
-    res = ((AHL + GP - P) - (int16_t)(AHL + GP - P)) >> 16;
+  if (pParent.isGpDisp(pReloc.parent())) {
+    int32_t P = pReloc.P();
+    int32_t GP = pParent.getGPAddress();
+    pReloc.result() = ((AHL + GP - P) - (int16_t)(AHL + GP - P)) >> 16;
   }
   else {
-    int32_t S = pReloc.symValue();
-    res = ((AHL + S) - (int16_t)(AHL + S)) >> 16;
+    int32_t S = pReloc.S();
+    if (pParent.isN64ABI())
+      pReloc.result() = (pReloc.A() + S + 0x8000ull) >> 16;
+    else
+      pReloc.result() = ((AHL + S) - (int16_t)(AHL + S)) >> 16;
   }
 
-  pReloc.target() &= 0xFFFF0000;
-  pReloc.target() |= (res & 0xFFFF);
-
   return MipsRelocator::OK;
 }
 
@@ -537,27 +879,45 @@
 //   local/external: AHL + S
 //   _gp_disp      : AHL + GP - P + 4
 static
-MipsRelocator::Result lo16(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result lo16(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
-  int32_t res = 0;
+  // AHL is a combination of HI16 and LO16 addends. But R_MIPS_LO16
+  // uses low 16 bits of the AHL. That is why we do not need R_MIPS_HI16
+  // addend here.
+  int32_t AHL = (pReloc.A() & 0xFFFF);
 
-  if (helper_isGpDisp(pReloc)) {
-    int32_t P = pReloc.place();
-    int32_t GP = helper_GetGP(pParent);
-    int32_t AHL = pParent.getAHL();
-    res = AHL + GP - P + 4;
+  if (pParent.isGpDisp(pReloc.parent())) {
+    int32_t P = pReloc.P();
+    int32_t GP = pParent.getGPAddress();
+    pReloc.result() = AHL + GP - P + 4;
   }
   else {
-    int32_t S = pReloc.symValue();
-    // The previous AHL may be for other hi/lo pairs.
-    // We need to calcuate the lo part now.  It is easy.
-    // Remember to add the section offset to ALO.
-    int32_t ALO = (pReloc.target() & 0xFFFF) + pReloc.addend();
-    res = ALO + S;
+    int32_t S = pReloc.S();
+    pReloc.result() = AHL + S;
   }
 
-  pReloc.target() &= 0xFFFF0000;
-  pReloc.target() |= (res & 0xFFFF);
+  pParent.applyPostponedRelocations(pReloc);
+
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_GPREL16:
+//   external: sign–extend(A) + S - GP
+//   local   : sign–extend(A) + S + GP0 – GP
+static
+MipsRelocator::Result gprel16(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  // Remember to add the section offset to A.
+  uint64_t A = pReloc.A();
+  uint64_t S = pReloc.S();
+  uint64_t GP0 = pParent.getGP0();
+  uint64_t GP = pParent.getGPAddress();
+
+  ResolveInfo* rsym = pReloc.parent().symInfo();
+  if (rsym->isLocal())
+    pReloc.result() = A + S + GP0 - GP;
+  else
+    pReloc.result() = A + S - GP;
 
   return MipsRelocator::OK;
 }
@@ -566,52 +926,35 @@
 //   local   : G (calculate AHL and put high 16 bit to GOT)
 //   external: G
 static
-MipsRelocator::Result got16(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result got16(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
-  MipsGNULDBackend& ld_backend = pParent.getTarget();
-  MipsGOT& got = ld_backend.getGOT();
-  ResolveInfo* rsym = pReloc.symInfo();
-  Relocator::Address G = 0;
-
-  if (rsym->isLocal()) {
-    Relocation* lo_reloc = helper_FindLo16Reloc(pReloc);
-    assert(NULL != lo_reloc && "There is no paired R_MIPS_LO16 for R_MIPS_GOT16");
-
-    int32_t AHL = helper_CalcAHL(pReloc, *lo_reloc);
-    int32_t S = pReloc.symValue();
-
-    pParent.setAHL(AHL);
-
+  if (pReloc.parent().symInfo()->isLocal()) {
+    int32_t AHL = pParent.calcAHL(pReloc);
+    int32_t S = pReloc.S();
     int32_t res = (AHL + S + 0x8000) & 0xFFFF0000;
-    MipsGOTEntry& got_entry = helper_GetGOTEntry(pReloc, pParent);
 
-    got_entry.setValue(res);
-    G = got.getGPRelOffset(pParent.getApplyingInput(), got_entry);
+    MipsGOT& got = pParent.getTarget().getGOT();
+
+    Fragment& got_entry = pParent.getLocalGOTEntry(pReloc, res);
+
+    pReloc.result() = got.getGPRelOffset(pParent.getApplyingInput(), got_entry);
   }
   else {
-    G = helper_GetGOTOffset(pReloc, pParent);
+    pReloc.result() = pParent.getGOTOffset(pReloc);
   }
 
-  pReloc.target() &= 0xFFFF0000;
-  pReloc.target() |= (G & 0xFFFF);
-
   return MipsRelocator::OK;
 }
 
 // R_MIPS_GOTHI16:
 //   external: (G - (short)G) >> 16 + A
 static
-MipsRelocator::Result gothi16(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result gothi16(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
-  int32_t res = 0;
+  Relocator::Address G = pParent.getGOTOffset(pReloc);
+  int32_t A = pReloc.A();
 
-  Relocator::Address G = helper_GetGOTOffset(pReloc, pParent);
-  int32_t A = pReloc.target() + pReloc.addend();
-
-  res = (G - (int16_t)G) >> (16 + A);
-
-  pReloc.target() &= 0xFFFF0000;
-  pReloc.target() |= (res & 0xFFFF);
+  pReloc.result() = (G - (int16_t)G) >> (16 + A);
 
   return MipsRelocator::OK;
 }
@@ -619,41 +962,145 @@
 // R_MIPS_GOTLO16:
 //   external: G & 0xffff
 static
-MipsRelocator::Result gotlo16(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result gotlo16(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
-  Relocator::Address G = helper_GetGOTOffset(pReloc, pParent);
+  pReloc.result() = pParent.getGOTOffset(pReloc) & 0xffff;
 
-  pReloc.target() &= 0xFFFF0000;
-  pReloc.target() |= (G & 0xFFFF);
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_SUB:
+//   external/local: S - A
+static
+MipsRelocator::Result sub(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  uint64_t S = pReloc.S();
+  uint64_t A = pReloc.A();
+
+  pReloc.result() = S - A;
 
   return MipsRelocator::OK;
 }
 
 // R_MIPS_CALL16: G
 static
-MipsRelocator::Result call16(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result call16(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
-  Relocator::Address G = helper_GetGOTOffset(pReloc, pParent);
-
-  pReloc.target() &= 0xFFFF0000;
-  pReloc.target() |= (G & 0xFFFF);
+  pReloc.result() = pParent.getGOTOffset(pReloc);
 
   return MipsRelocator::OK;
 }
 
 // R_MIPS_GPREL32: A + S + GP0 - GP
 static
-MipsRelocator::Result gprel32(Relocation& pReloc, MipsRelocator& pParent)
+MipsRelocator::Result gprel32(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
 {
   // Remember to add the section offset to A.
-  int32_t A = pReloc.target() + pReloc.addend();
-  int32_t S = pReloc.symValue();
-  int32_t GP = helper_GetGP(pParent);
+  uint64_t A = pReloc.A();
+  uint64_t S = pReloc.S();
+  uint64_t GP0 = pParent.getGP0();
+  uint64_t GP = pParent.getGPAddress();
 
-  // llvm does not emits SHT_MIPS_REGINFO section.
-  // Assume that GP0 is zero.
-  pReloc.target() = (A + S - GP) & 0xFFFFFFFF;
+  pReloc.result() = A + S + GP0 - GP;
 
   return MipsRelocator::OK;
 }
 
+// R_MIPS_64: S + A
+static
+MipsRelocator::Result abs64(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  // FIXME (simon): Consider to merge with abs32() or use the same function
+  // but with another mask size.
+  ResolveInfo* rsym = pReloc.parent().symInfo();
+
+  Relocator::DWord A = pReloc.A();
+  Relocator::DWord S = pReloc.S();
+
+  LDSection& target_sect =
+    pReloc.parent().targetRef().frag()->getParent()->getSection();
+
+  // If the flag of target section is not ALLOC, we will not scan this relocation
+  // but perform static relocation. (e.g., applying .debug section)
+  if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
+    pReloc.result() = S + A;
+    return MipsRelocator::OK;
+  }
+
+  if (rsym->reserved() & MipsRelocator::ReserveRel) {
+    pParent.createDynRel(pReloc);
+    return MipsRelocator::OK;
+  }
+
+  pReloc.result() = S + A;
+
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_GOT_DISP / R_MIPS_GOT_PAGE: G
+static
+MipsRelocator::Result gotdisp(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  pReloc.result() = pParent.getGOTOffset(pReloc);
+
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_GOT_OFST:
+static
+MipsRelocator::Result gotoff(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  // FIXME (simon): Needs to be implemented.
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_JALR:
+static
+MipsRelocator::Result jalr(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_LA25_LUI
+static
+MipsRelocator::Result la25lui(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  int32_t S = pReloc.S();
+
+  pReloc.result() = (S + 0x8000) >> 16;
+
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_LA25_J
+static
+MipsRelocator::Result la25j(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  int32_t S = pReloc.S();
+
+  pReloc.result() = S >> 2;
+
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_LA25_ADD
+static
+MipsRelocator::Result la25add(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  pReloc.result() = pReloc.S();
+
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_PC32:
+static
+MipsRelocator::Result pc32(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  return MipsRelocator::OK;
+}
+
+static
+MipsRelocator::Result unsupport(MipsRelocationInfo& pReloc, MipsRelocator& pParent)
+{
+  return MipsRelocator::Unsupport;
+}
diff --git a/lib/Target/Mips/MipsRelocator.h b/lib/Target/Mips/MipsRelocator.h
index 96e73e2..4e24329 100644
--- a/lib/Target/Mips/MipsRelocator.h
+++ b/lib/Target/Mips/MipsRelocator.h
@@ -12,12 +12,15 @@
 #include <gtest.h>
 #endif
 
+#include <llvm/ADT/DenseMapInfo.h>
 #include <mcld/LD/Relocator.h>
 #include <mcld/Support/GCFactory.h>
 #include "MipsLDBackend.h"
 
 namespace mcld {
 
+class MipsRelocationInfo;
+
 /** \class MipsRelocator
  *  \brief MipsRelocator creates and destroys the Mips relocations.
  */
@@ -28,7 +31,7 @@
     None          = 0,  // no reserved entry
     ReserveRel    = 1,  // reserve a dynamic relocation entry
     ReserveGot    = 2,  // reserve a GOT entry
-    ReserveGpDisp = 8   // reserve _gp_disp symbol
+    ReservePLT    = 4   // reserve a PLT entry
   };
 
 public:
@@ -40,7 +43,8 @@
   void scanRelocation(Relocation& pReloc,
                       IRBuilder& pBuilder,
                       Module& pModule,
-                      LDSection& pSection);
+                      LDSection& pSection,
+                      Input& pInput);
 
   /// initializeScan - do initialization before scan relocations in pInput
   /// @return - return true for initialization success
@@ -58,7 +62,7 @@
   /// @return - return true for finalization success
   bool finalizeApply(Input& pInput);
 
-  Result applyRelocation(Relocation& pRelocation);
+  Result applyRelocation(Relocation& pReloc);
 
   const Input& getApplyingInput() const
   { return *m_pApplyingInput; }
@@ -69,31 +73,124 @@
   const MipsGNULDBackend& getTarget() const
   { return m_Target; }
 
-  // Get last calculated AHL.
-  int32_t getAHL() const
-  { return m_AHL; }
+  /// postponeRelocation - save R_MIPS_LO16 paired relocations
+  /// like R_MISP_HI16 and R_MIPS_GOT16 for a future processing.
+  void postponeRelocation(Relocation& pReloc);
 
-  // Set last calculated AHL.
-  void setAHL(int32_t pAHL)
-  { m_AHL = pAHL; }
+  /// applyPostponedRelocations - apply all postponed relocations
+  /// paired with the R_MIPS_LO16 one.
+  void applyPostponedRelocations(MipsRelocationInfo& pLo16Reloc);
+
+  /// isGpDisp - return true if relocation is against _gp_disp symbol.
+  bool isGpDisp(const Relocation& pReloc) const;
+
+  /// getGPAddress - return address of _gp symbol.
+  Address getGPAddress();
+
+  /// getGP0 - the gp value used to create the relocatable objects
+  /// in the processing input.
+  Address getGP0();
+
+  /// getLocalGOTEntry - initialize and return a local GOT entry
+  /// for this relocation.
+  Fragment& getLocalGOTEntry(MipsRelocationInfo& pReloc,
+                             Relocation::DWord entryValue);
+
+  /// getGlobalGOTEntry - initialize and return a global GOT entry
+  /// for this relocation.
+  Fragment& getGlobalGOTEntry(MipsRelocationInfo& pReloc);
+
+  /// getGOTOffset - return offset of corresponded GOT entry.
+  Address getGOTOffset(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);
+
+  /// isN64ABI - check current ABI
+  bool isN64ABI() const;
 
   const char* getName(Relocation::Type pType) const;
 
   Size getSize(Relocation::Type pType) const;
 
-private:
-  void scanLocalReloc(Relocation& pReloc,
-                      IRBuilder& pBuilder,
-                      const LDSection& pSection);
+protected:
+  /// setupRelDynEntry - create dynamic relocation entry.
+  virtual void setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym) = 0;
 
-  void scanGlobalReloc(Relocation& pReloc,
-                       IRBuilder& pBuilder,
-                       const LDSection& pSection);
+  /// isLocalReloc - handle relocation as a local symbol
+  bool isLocalReloc(ResolveInfo& pSym) const;
+
+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;
   Input* m_pApplyingInput;
-  int32_t m_AHL;
+  SymRelocSetMap m_PostponedRelocs;
+  MipsRelocationInfo* m_CurrentLo16Reloc;
+
+private:
+  void scanLocalReloc(MipsRelocationInfo& pReloc,
+                      IRBuilder& pBuilder,
+                      const LDSection& pSection);
+
+  void scanGlobalReloc(MipsRelocationInfo& pReloc,
+                       IRBuilder& pBuilder,
+                       const LDSection& pSection);
+
+  /// isPostponed - relocation applying needs to be postponed.
+  bool isPostponed(const Relocation& pReloc) const;
+
+  /// addCopyReloc - add a copy relocation into .rel.dyn for pSym
+  /// @param pSym - A resolved copy symbol that defined in BSS section
+  void addCopyReloc(ResolveInfo& pSym);
+
+  /// defineSymbolforCopyReloc - allocate a space in BSS section and
+  /// and force define the copy of pSym to BSS section
+  /// @return the output LDSymbol of the copy symbol
+  LDSymbol& defineSymbolforCopyReloc(IRBuilder& pBuilder,
+                                     const ResolveInfo& pSym);
+
+  /// isRel - returns true if REL relocation record format is expected
+  bool isRel() const;
+};
+
+/** \class Mips32Relocator
+ *  \brief Mips32Relocator creates and destroys the Mips 32-bit relocations.
+ */
+class Mips32Relocator : public MipsRelocator
+{
+public:
+  Mips32Relocator(Mips32GNULDBackend& pParent, const LinkerConfig& pConfig);
+
+private:
+  // MipsRelocator
+  void setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym);
+};
+
+/** \class Mips64Relocator
+ *  \brief Mips64Relocator creates and destroys the Mips 64-bit relocations.
+ */
+class Mips64Relocator : public MipsRelocator
+{
+public:
+  Mips64Relocator(Mips64GNULDBackend& pParent, const LinkerConfig& pConfig);
+
+private:
+  // MipsRelocator
+  void setupRelDynEntry(FragmentRef& pFragRef, ResolveInfo* pSym);
 };
 
 } // namespace of mcld
diff --git a/lib/Target/Mips/MipsTargetMachine.cpp b/lib/Target/Mips/MipsTargetMachine.cpp
index 03db780..2e57868 100644
--- a/lib/Target/Mips/MipsTargetMachine.cpp
+++ b/lib/Target/Mips/MipsTargetMachine.cpp
@@ -7,23 +7,24 @@
 //
 //===----------------------------------------------------------------------===//
 #include "MipsTargetMachine.h"
-
 #include "Mips.h"
-#include <mcld/Target/TargetMachine.h>
 #include <mcld/Support/TargetRegistry.h>
 
+typedef mcld::RegisterTargetMachine<mcld::MipsBaseTargetMachine> RegMipsTarget;
+
 extern "C" void MCLDInitializeMipsLDTarget() {
-  // Register createTargetMachine function pointer to mcld::Target
-  mcld::RegisterTargetMachine<mcld::MipsBaseTargetMachine>
-        X(mcld::TheMipselTarget);
+  RegMipsTarget X1(mcld::TheMipselTarget);
+  RegMipsTarget X2(mcld::TheMips64elTarget);
 }
 
-mcld::MipsBaseTargetMachine::MipsBaseTargetMachine(llvm::TargetMachine& pPM,
-                                                   const mcld::Target &pTarget,
-                                                   const std::string& pTriple)
-  : mcld::MCLDTargetMachine(pPM, pTarget, pTriple) {
-}
+using namespace mcld;
 
-mcld::MipsBaseTargetMachine::~MipsBaseTargetMachine()
-{
+//===----------------------------------------------------------------------===//
+// MipsBaseTargetMachine
+//===----------------------------------------------------------------------===//
+MipsBaseTargetMachine::MipsBaseTargetMachine(llvm::TargetMachine& pPM,
+                                             const llvm::Target &pLLVMTarget,
+                                             const mcld::Target &pMCLDTarget,
+                                             const std::string& pTriple)
+  : MCLDTargetMachine(pPM, pLLVMTarget, pMCLDTarget, pTriple) {
 }
diff --git a/lib/Target/Mips/MipsTargetMachine.h b/lib/Target/Mips/MipsTargetMachine.h
index 6cfae73..964a6d1 100644
--- a/lib/Target/Mips/MipsTargetMachine.h
+++ b/lib/Target/Mips/MipsTargetMachine.h
@@ -9,8 +9,7 @@
 #ifndef MIPS_TARGET_MACHINE_H
 #define MIPS_TARGET_MACHINE_H
 
-#include "Mips.h"
-#include <mcld/Target/TargetMachine.h>
+#include <mcld/CodeGen/TargetMachine.h>
 
 namespace mcld {
 
@@ -18,10 +17,9 @@
 {
 public:
   MipsBaseTargetMachine(llvm::TargetMachine &pTM,
-                        const mcld::Target &pTarget,
+                        const llvm::Target &pLLVMTarget,
+                        const mcld::Target &pMCLDTarget,
                         const std::string &pTriple);
-
-  virtual ~MipsBaseTargetMachine();
 };
 
 } // namespace of mcld
diff --git a/lib/Target/Mips/TargetInfo/MipsTargetInfo.cpp b/lib/Target/Mips/TargetInfo/MipsTargetInfo.cpp
index 3991c45..4ae7a61 100644
--- a/lib/Target/Mips/TargetInfo/MipsTargetInfo.cpp
+++ b/lib/Target/Mips/TargetInfo/MipsTargetInfo.cpp
@@ -6,16 +6,19 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "mcld/Target/TargetMachine.h"
-#include "mcld/Support/TargetRegistry.h"
+#include <mcld/Support/Target.h>
+#include <mcld/Support/TargetRegistry.h>
 
 namespace mcld {
 
 mcld::Target TheMipselTarget;
+mcld::Target TheMips64elTarget;
 
 extern "C" void MCLDInitializeMipsLDTargetInfo() {
-  // register into mcld::TargetRegistry
-  mcld::RegisterTarget X(TheMipselTarget, "mipsel");
+  mcld::RegisterTarget<llvm::Triple::mipsel>
+                       X1(TheMipselTarget, "mipsel");
+  mcld::RegisterTarget<llvm::Triple::mips64el>
+                       X2(TheMips64elTarget, "mips64el");
 }
 
 } // namespace of mcld
diff --git a/lib/Target/OutputRelocSection.cpp b/lib/Target/OutputRelocSection.cpp
index 603350b..07670a3 100644
--- a/lib/Target/OutputRelocSection.cpp
+++ b/lib/Target/OutputRelocSection.cpp
@@ -34,6 +34,13 @@
 {
 }
 
+Relocation* OutputRelocSection::create()
+{
+  Relocation* reloc = Relocation::Create();
+  m_pRelocData->append(*reloc);
+  return reloc;
+}
+
 void OutputRelocSection::reserveEntry(size_t pNum)
 {
   for(size_t i=0; i<pNum; i++)
diff --git a/lib/Target/Target.cpp b/lib/Target/Target.cpp
deleted file mode 100644
index ba69e03..0000000
--- a/lib/Target/Target.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===- Target.cpp ---------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Support/TargetRegistry.h>
-#include <mcld/Target/TargetMachine.h>
-#include <llvm/Support/TargetRegistry.h>
-#include <llvm/Target/TargetMachine.h>
-
-using namespace llvm;
-
-mcld::Target::Target()
-  : TargetMachineCtorFn(NULL),
-    MCLinkerCtorFn(NULL),
-    TargetLDBackendCtorFn(NULL),
-    DiagnosticLineInfoCtorFn(NULL),
-    m_pT(NULL)
-{
-}
-
diff --git a/lib/Target/X86/TargetInfo/X86TargetInfo.cpp b/lib/Target/X86/TargetInfo/X86TargetInfo.cpp
index 3c02314..8e3a7c0 100644
--- a/lib/Target/X86/TargetInfo/X86TargetInfo.cpp
+++ b/lib/Target/X86/TargetInfo/X86TargetInfo.cpp
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "mcld/Target/TargetMachine.h"
-#include "mcld/Support/TargetRegistry.h"
+#include <mcld/Support/Target.h>
+#include <mcld/Support/TargetRegistry.h>
 
 namespace mcld {
 
@@ -16,8 +16,10 @@
 
 extern "C" void MCLDInitializeX86LDTargetInfo() {
   // register into mcld::TargetRegistry
-  mcld::RegisterTarget X(TheX86_32Target, "x86");
-  mcld::RegisterTarget Y(TheX86_64Target, "x86-64");
+  mcld::RegisterTarget<llvm::Triple::x86>
+                       X(TheX86_32Target, "x86");
+  mcld::RegisterTarget<llvm::Triple::x86_64>
+                       Y(TheX86_64Target, "x86-64");
 }
 
 } // namespace of mcld
diff --git a/lib/Target/X86/X86.h b/lib/Target/X86/X86.h
index 0f7d65d..5927f44 100644
--- a/lib/Target/X86/X86.h
+++ b/lib/Target/X86/X86.h
@@ -6,12 +6,17 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#ifndef MCLD_X86_H
-#define MCLD_X86_H
+#ifndef MCLD_TARGET_X86_H
+#define MCLD_TARGET_X86_H
 #include <string>
-#include "mcld/Target/TargetMachine.h"
+
+namespace llvm {
+class Target;
+} // namespace of llvm
 
 namespace mcld {
+
+class Target;
 class TargetLDBackend;
 
 extern mcld::Target TheX86_32Target;
diff --git a/lib/Target/X86/X86Diagnostic.cpp b/lib/Target/X86/X86Diagnostic.cpp
index 9287ca7..9dab719 100644
--- a/lib/Target/X86/X86Diagnostic.cpp
+++ b/lib/Target/X86/X86Diagnostic.cpp
@@ -6,21 +6,16 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <llvm/ADT/Triple.h>
 #include <mcld/Support/TargetRegistry.h>
 #include <mcld/LD/DWARFLineInfo.h>
 #include "X86.h"
 
 using namespace mcld;
 
-//===----------------------------------------------------------------------===//
-// X86Diagnostic
-
-
 namespace mcld {
 //===----------------------------------------------------------------------===//
 // createX86Diagnostic - the help function to create corresponding X86Diagnostic
-//
+//===----------------------------------------------------------------------===//
 DiagnosticLineInfo* createX86DiagLineInfo(const mcld::Target& pTarget,
                                           const std::string &pTriple)
 {
@@ -29,8 +24,9 @@
 
 } // namespace of mcld
 
-//==========================
+//===----------------------------------------------------------------------===//
 // InitializeX86Diagnostic
+//===----------------------------------------------------------------------===//
 extern "C" void MCLDInitializeX86DiagnosticLineInfo() {
   // Register the linker frontend
   mcld::TargetRegistry::RegisterDiagnosticLineInfo(TheX86_32Target, createX86DiagLineInfo);
diff --git a/lib/Target/X86/X86ELFMCLinker.cpp b/lib/Target/X86/X86ELFMCLinker.cpp
index 868d61c..a57fe37 100644
--- a/lib/Target/X86/X86ELFMCLinker.cpp
+++ b/lib/Target/X86/X86ELFMCLinker.cpp
@@ -7,14 +7,13 @@
 //
 //===----------------------------------------------------------------------===//
 #include "X86ELFMCLinker.h"
-#include <mcld/LinkerConfig.h>
 
 using namespace mcld;
 
 X86ELFMCLinker::X86ELFMCLinker(LinkerConfig& pConfig,
                                mcld::Module& pModule,
-                               MemoryArea& pOutput)
-  : ELFMCLinker(pConfig, pModule, pOutput) {
+                               FileHandle& pFileHandle)
+  : ELFMCLinker(pConfig, pModule, pFileHandle) {
 }
 
 X86ELFMCLinker::~X86ELFMCLinker()
diff --git a/lib/Target/X86/X86ELFMCLinker.h b/lib/Target/X86/X86ELFMCLinker.h
index 173f7dc..4b64d28 100644
--- a/lib/Target/X86/X86ELFMCLinker.h
+++ b/lib/Target/X86/X86ELFMCLinker.h
@@ -16,7 +16,7 @@
 namespace mcld {
 
 class Module;
-class MemoryArea;
+class FileHandle;
 
 /** \class X86ELFMCLinker
  *  \brief X86ELFMCLinker sets up the environment for linking.
@@ -28,7 +28,7 @@
 public:
   X86ELFMCLinker(LinkerConfig& pConfig,
                  mcld::Module& pModule,
-                 MemoryArea& pOutput);
+                 FileHandle& pFileHandle);
 
   ~X86ELFMCLinker();
 };
diff --git a/lib/Target/X86/X86Emulation.cpp b/lib/Target/X86/X86Emulation.cpp
index 99e15da..d91d46d 100644
--- a/lib/Target/X86/X86Emulation.cpp
+++ b/lib/Target/X86/X86Emulation.cpp
@@ -22,10 +22,10 @@
   // set up bitclass and endian
   pConfig.targets().setEndian(TargetOptions::Little);
   unsigned int bitclass;
-  Triple::ArchType arch = pConfig.targets().triple().getArch();
-  assert (arch == Triple::x86 || arch == Triple::x86_64);
-  if (arch == Triple::x86 ||
-      pConfig.targets().triple().getEnvironment() == Triple::GNUX32) {
+  llvm::Triple::ArchType arch = pConfig.targets().triple().getArch();
+  assert (arch == llvm::Triple::x86 || arch == llvm::Triple::x86_64);
+  if (arch == llvm::Triple::x86 ||
+      pConfig.targets().triple().getEnvironment() == llvm::Triple::GNUX32) {
     bitclass = 32;
   }
   else {
diff --git a/lib/Target/X86/X86GOT.cpp b/lib/Target/X86/X86GOT.cpp
index b77cfd3..bac4bee 100644
--- a/lib/Target/X86/X86GOT.cpp
+++ b/lib/Target/X86/X86GOT.cpp
@@ -19,7 +19,7 @@
 // X86_32GOT
 //===----------------------------------------------------------------------===//
 X86_32GOT::X86_32GOT(LDSection& pSection)
-  : GOT(pSection), m_pLast(NULL)
+  : GOT(pSection)
 {
 }
 
@@ -27,23 +27,9 @@
 {
 }
 
-void X86_32GOT::reserve(size_t pNum)
+X86_32GOTEntry* X86_32GOT::create()
 {
-  for (size_t i = 0; i < pNum; i++) {
-    new X86_32GOTEntry(0, m_SectionData);
-  }
-}
-
-X86_32GOTEntry* X86_32GOT::consume()
-{
-  if (NULL == m_pLast) {
-    assert(!empty() && "Consume empty GOT entry!");
-    m_pLast = llvm::cast<X86_32GOTEntry>(&m_SectionData->front());
-    return m_pLast;
-  }
-
-  m_pLast = llvm::cast<X86_32GOTEntry>(m_pLast->getNextNode());
-  return m_pLast;
+  return new X86_32GOTEntry(0, m_SectionData);
 }
 
 //===----------------------------------------------------------------------===//
@@ -58,22 +44,8 @@
 {
 }
 
-void X86_64GOT::reserve(size_t pNum)
+X86_64GOTEntry* X86_64GOT::create()
 {
-  for (size_t i = 0; i < pNum; i++) {
-    new X86_64GOTEntry(0, m_SectionData);
-  }
-}
-
-X86_64GOTEntry* X86_64GOT::consume()
-{
-  if (NULL == m_pLast) {
-    assert(!empty() && "Consume empty GOT entry!");
-    m_pLast = llvm::cast<X86_64GOTEntry>(&m_SectionData->front());
-    return m_pLast;
-  }
-
-  m_pLast = llvm::cast<X86_64GOTEntry>(m_pLast->getNextNode());
-  return m_pLast;
+  return new X86_64GOTEntry(0, m_SectionData);
 }
 
diff --git a/lib/Target/X86/X86GOT.h b/lib/Target/X86/X86GOT.h
index df557f3..67c3163 100644
--- a/lib/Target/X86/X86GOT.h
+++ b/lib/Target/X86/X86GOT.h
@@ -41,12 +41,7 @@
 
   ~X86_32GOT();
 
-  void reserve(size_t pNum = 1);
-
-  X86_32GOTEntry* consume();
-
-private:
-  X86_32GOTEntry* m_pLast; ///< the last consumed entry
+  X86_32GOTEntry* create();
 };
 
 /** \class X86_64GOTEntry
@@ -71,9 +66,7 @@
 
   ~X86_64GOT();
 
-  void reserve(size_t pNum = 1);
-
-  X86_64GOTEntry* consume();
+  X86_64GOTEntry* create();
 
 private:
   X86_64GOTEntry* m_pLast; ///< the last consumed entry
diff --git a/lib/Target/X86/X86GOTPLT.cpp b/lib/Target/X86/X86GOTPLT.cpp
index 961e0dc..7baa5cb 100644
--- a/lib/Target/X86/X86GOTPLT.cpp
+++ b/lib/Target/X86/X86GOTPLT.cpp
@@ -23,13 +23,9 @@
 X86_32GOTPLT::X86_32GOTPLT(LDSection& pSection)
   : X86_32GOT(pSection)
 {
-  // Create GOT0 entries
-  reserve(X86GOTPLT0Num);
-
-  // Skip GOT0 entries
-  for (size_t i = 0; i < X86GOTPLT0Num; ++i) {
-    consume();
-  }
+  // create GOT0 entries
+  for (size_t i = 0; i < X86GOTPLT0Num; ++i)
+    create();
 }
 
 X86_32GOTPLT::~X86_32GOTPLT()
@@ -67,13 +63,8 @@
 X86_64GOTPLT::X86_64GOTPLT(LDSection& pSection)
   : X86_64GOT(pSection)
 {
-  // Create GOT0 entries
-  reserve(X86GOTPLT0Num);
-
-  // Skip GOT0 entries
-  for (size_t i = 0; i < X86GOTPLT0Num; ++i) {
-    consume();
-  }
+  for (size_t i = 0; i < X86GOTPLT0Num; ++i)
+    create();
 }
 
 X86_64GOTPLT::~X86_64GOTPLT()
diff --git a/lib/Target/X86/X86LDBackend.cpp b/lib/Target/X86/X86LDBackend.cpp
index 87c1192..04e858c 100644
--- a/lib/Target/X86/X86LDBackend.cpp
+++ b/lib/Target/X86/X86LDBackend.cpp
@@ -12,18 +12,19 @@
 #include "X86Relocator.h"
 #include "X86GNUInfo.h"
 
+#include <llvm/ADT/StringRef.h>
 #include <llvm/ADT/Triple.h>
 #include <llvm/Support/Casting.h>
 
 #include <mcld/LinkerConfig.h>
 #include <mcld/IRBuilder.h>
+#include <mcld/LD/ELFFileFormat.h>
 #include <mcld/Fragment/FillFragment.h>
 #include <mcld/Fragment/RegionFragment.h>
-#include <mcld/Fragment/FragmentLinker.h>
-#include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Support/TargetRegistry.h>
 #include <mcld/Object/ObjectBuilder.h>
+#include <llvm/Support/Dwarf.h>
 
 #include <cstring>
 
@@ -44,13 +45,13 @@
     m_pGOTSymbol(NULL),
     m_CopyRel(pCopyRel)
 {
-  Triple::ArchType arch = pConfig.targets().triple().getArch();
-  assert (arch == Triple::x86 || arch == Triple::x86_64);
-  if (arch == Triple::x86 ||
-      pConfig.targets().triple().getEnvironment() == Triple::GNUX32) {
+  llvm::Triple::ArchType arch = pConfig.targets().triple().getArch();
+  assert (arch == llvm::Triple::x86 || arch == llvm::Triple::x86_64);
+  if (arch == llvm::Triple::x86 ||
+      pConfig.targets().triple().getEnvironment() == llvm::Triple::GNUX32) {
     m_RelEntrySize = 8;
     m_RelaEntrySize = 12;
-    if (arch == Triple::x86)
+    if (arch == llvm::Triple::x86)
       m_PointerRel = llvm::ELF::R_386_32;
     else
       m_PointerRel = llvm::ELF::R_X86_64_32;
@@ -105,6 +106,9 @@
       setRelPLTSize();
     }
   }
+
+  if (config().options().genUnwindInfo())
+    addEhFrameForPLT(pBuilder.getModule());
 }
 
 void X86GNULDBackend::doPostLayout(Module& pModule,
@@ -168,10 +172,8 @@
   unsigned int EntrySize = 0;
   uint64_t RegionSize = 0;
 
-  if (&pSection == &(FileFormat->getPLT())) {
-    assert(m_pPLT && "emitSectionData failed, m_pPLT is NULL!");
-
-    unsigned char* buffer = pRegion.getBuffer();
+  if (FileFormat->hasPLT() && (&pSection == &(FileFormat->getPLT()))) {
+    unsigned char* buffer = pRegion.begin();
 
     m_pPLT->applyPLT0();
     m_pPLT->applyPLT1();
@@ -192,15 +194,13 @@
       ++it;
     }
   }
-
-  else if (&pSection == &(FileFormat->getGOT())) {
+  else if (FileFormat->hasGOT() && (&pSection == &(FileFormat->getGOT()))) {
     RegionSize += emitGOTSectionData(pRegion);
   }
-
-  else if (&pSection == &(FileFormat->getGOTPLT())) {
+  else if (FileFormat->hasGOTPLT() &&
+           (&pSection == &(FileFormat->getGOTPLT()))) {
     RegionSize += emitGOTPLTSectionData(pRegion, FileFormat);
   }
-
   else {
     fatal(diag::unrecognized_output_sectoin)
             << pSection.name()
@@ -250,19 +250,19 @@
 {
   const ELFFileFormat* file_format = getOutputFormat();
 
-  if (&pSectHdr == &file_format->getGOT()) {
+  if (file_format->hasGOT() && (&pSectHdr == &file_format->getGOT())) {
     if (config().options().hasNow())
       return SHO_RELRO;
     return SHO_RELRO_LAST;
   }
 
-  if (&pSectHdr == &file_format->getGOTPLT()) {
+  if (file_format->hasGOTPLT() && (&pSectHdr == &file_format->getGOTPLT())) {
     if (config().options().hasNow())
       return SHO_RELRO;
     return SHO_NON_RELRO_FIRST;
   }
 
-  if (&pSectHdr == &file_format->getPLT())
+  if (file_format->hasPLT() && (&pSectHdr == &file_format->getPLT()))
     return SHO_PLT;
 
   return SHO_UNDEFINED;
@@ -286,6 +286,51 @@
   }
 }
 
+void X86GNULDBackend::addEhFrameForPLT(Module& pModule)
+{
+  LDSection* plt_sect = pModule.getSection(".plt");
+  if (!plt_sect || plt_sect->size() == 0u)
+    return;
+
+  LDSection* eh_sect = pModule.getSection(".eh_frame");
+  if (!eh_sect || !eh_sect->hasEhFrame())
+    return;
+
+  EhFrame* eh_frame = eh_sect->getEhFrame();
+  SectionData::FragmentListType& frag_list =
+      eh_frame->getSectionData()->getFragmentList();
+  llvm::StringRef cie_region = createCIERegionForPLT();
+  llvm::StringRef fde_region = createFDERegionForPLT();
+  EhFrame::CIE* cie = new EhFrame::GeneratedCIE(cie_region);
+  EhFrame::FDE* fde = new EhFrame::GeneratedFDE(fde_region, *cie);
+  // Augmentation data only contains FDE encoding.
+  uint8_t aug_data = (uint8_t)(llvm::dwarf::DW_EH_PE_pcrel |
+                               llvm::dwarf::DW_EH_PE_sdata4);
+  cie->setFDEEncode(aug_data);
+  cie->setAugmentationData(std::string(1, aug_data));
+
+  EhFrame::cie_iterator i = eh_frame->cie_begin();
+  for (EhFrame::cie_iterator e = eh_frame->cie_end(); i != e; ++i) {
+    EhFrame::CIE& exist_cie = **i;
+    if (exist_cie == *cie) {
+      // Insert the FDE fragment
+      SectionData::iterator cur_iter(exist_cie);
+      frag_list.insertAfter(cur_iter, fde);
+      fde->setCIE(exist_cie);
+
+      // Cleanup the CIE we created
+      cie->clearFDEs();
+      delete cie;
+      break;
+    }
+  }
+  if (i == eh_frame->cie_end()) {
+    // Newly insert
+    eh_frame->addCIE(*cie);
+    eh_frame->addFDE(*fde);
+  }
+}
+
 /// finalizeSymbol - finalize the symbol value
 bool X86GNULDBackend::finalizeTargetSymbols()
 {
@@ -335,6 +380,7 @@
 
     // initialize .plt
     LDSection& plt = file_format->getPLT();
+    plt.setAlign(16u);
     m_pPLT = new X86_32PLT(plt,
 			   *m_pGOTPLT,
 			   config());
@@ -375,6 +421,59 @@
   return *m_pGOTPLT;
 }
 
+llvm::StringRef X86_32GNULDBackend::createCIERegionForPLT()
+{
+  using namespace llvm::dwarf;
+  static const uint8_t data[4+4+16] = {
+    0x14, 0, 0, 0, // length
+    0, 0, 0, 0, // ID
+    1,  // version
+    'z', 'R', '\0', // augmentation string
+    1,  // code alignment factor
+    0x7c, // data alignment factor
+    8,  // return address column
+    1,  // augmentation data size
+    DW_EH_PE_pcrel | DW_EH_PE_sdata4, // FDE encoding
+    DW_CFA_def_cfa, 4, 4,
+    DW_CFA_offset + 8, 1,
+    DW_CFA_nop,
+    DW_CFA_nop
+  };
+  return llvm::StringRef((const char*)data, 4+4+16);
+}
+
+llvm::StringRef X86_32GNULDBackend::createFDERegionForPLT()
+{
+  using namespace llvm::dwarf;
+  static const uint8_t data[4+4+32] = {
+    0x24, 0, 0, 0,  // length
+    0, 0, 0, 0,   // offset to CIE
+    0, 0, 0, 0,   // offset to PLT
+    0, 0, 0, 0,   // size of PLT
+    0,            // augmentation data size
+    DW_CFA_def_cfa_offset, 8,
+    DW_CFA_advance_loc + 6,
+    DW_CFA_def_cfa_offset, 12,
+    DW_CFA_advance_loc + 10,
+    DW_CFA_def_cfa_expression,
+    11,
+    DW_OP_breg4, 4,
+    DW_OP_breg8, 0,
+    DW_OP_lit15,
+    DW_OP_and,
+    DW_OP_lit11,
+    DW_OP_ge,
+    DW_OP_lit2,
+    DW_OP_shl,
+    DW_OP_plus,
+    DW_CFA_nop,
+    DW_CFA_nop,
+    DW_CFA_nop,
+    DW_CFA_nop
+  };
+  return llvm::StringRef((const char*)data, 4+4+32);
+}
+
 void X86_32GNULDBackend::setRelDynSize()
 {
   ELFFileFormat* file_format = getOutputFormat();
@@ -408,7 +507,7 @@
 {
   assert(m_pGOT && "emitGOTSectionData failed, m_pGOT is NULL!");
 
-  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
+  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
 
   X86_32GOTEntry* got = 0;
   unsigned int EntrySize = X86_32GOTEntry::EntrySize;
@@ -431,7 +530,7 @@
   m_pGOTPLT->applyGOT0(FileFormat->getDynamic().addr());
   m_pGOTPLT->applyAllGOTPLT(*m_pPLT);
 
-  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
+  uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
 
   X86_32GOTEntry* got = 0;
   unsigned int EntrySize = X86_32GOTEntry::EntrySize;
@@ -492,6 +591,59 @@
   return *m_pGOTPLT;
 }
 
+llvm::StringRef X86_64GNULDBackend::createCIERegionForPLT()
+{
+  using namespace llvm::dwarf;
+  static const uint8_t data[4+4+16] = {
+    0x14, 0, 0, 0,  // length
+    0, 0, 0, 0,   // ID
+    1,          // CIE version
+    'z', 'R', '\0', // augmentation string
+    1,          // code alignment factor
+    0x78,       // data alignment factor
+    16,         // return address column
+    1,          // augmentation data size
+    DW_EH_PE_pcrel | DW_EH_PE_sdata4, // FDE encoding
+    DW_CFA_def_cfa, 7, 8,
+    DW_CFA_offset + 16, 1,
+    DW_CFA_nop,
+    DW_CFA_nop
+  };
+  return llvm::StringRef((const char*)data, 4+4+16);
+}
+
+llvm::StringRef X86_64GNULDBackend::createFDERegionForPLT()
+{
+  using namespace llvm::dwarf;
+  static const uint8_t data[4+4+32] = {
+    0x24, 0, 0, 0,  // length
+    0, 0, 0, 0,   // ID
+    0, 0, 0, 0,   // offset to PLT
+    0, 0, 0, 0,   // size of PLT
+    0,            // augmentation data size
+    DW_CFA_def_cfa_offset, 16,
+    DW_CFA_advance_loc + 6,
+    DW_CFA_def_cfa_offset, 24,
+    DW_CFA_advance_loc + 10,
+    DW_CFA_def_cfa_expression,
+    11,
+    DW_OP_breg7, 8,
+    DW_OP_breg16, 0,
+    DW_OP_lit15,
+    DW_OP_and,
+    DW_OP_lit11,
+    DW_OP_ge,
+    DW_OP_lit3,
+    DW_OP_shl,
+    DW_OP_plus,
+    DW_CFA_nop,
+    DW_CFA_nop,
+    DW_CFA_nop,
+    DW_CFA_nop
+  };
+  return llvm::StringRef((const char*)data, 4+4+32);
+}
+
 void X86_64GNULDBackend::setRelDynSize()
 {
   ELFFileFormat* file_format = getOutputFormat();
@@ -521,6 +673,7 @@
 
     // initialize .plt
     LDSection& plt = file_format->getPLT();
+    plt.setAlign(16u);
     m_pPLT = new X86_64PLT(plt,
 			   *m_pGOTPLT,
 			   config());
@@ -556,7 +709,7 @@
 {
   assert(m_pGOT && "emitGOTSectionData failed, m_pGOT is NULL!");
 
-  uint64_t* buffer = reinterpret_cast<uint64_t*>(pRegion.getBuffer());
+  uint64_t* buffer = reinterpret_cast<uint64_t*>(pRegion.begin());
 
   X86_64GOTEntry* got = 0;
   unsigned int EntrySize = X86_64GOTEntry::EntrySize;
@@ -579,7 +732,7 @@
   m_pGOTPLT->applyGOT0(FileFormat->getDynamic().addr());
   m_pGOTPLT->applyAllGOTPLT(*m_pPLT);
 
-  uint64_t* buffer = reinterpret_cast<uint64_t*>(pRegion.getBuffer());
+  uint64_t* buffer = reinterpret_cast<uint64_t*>(pRegion.begin());
 
   X86_64GOTEntry* got = 0;
   unsigned int EntrySize = X86_64GOTEntry::EntrySize;
@@ -600,8 +753,7 @@
 //===----------------------------------------------------------------------===//
 /// createX86LDBackend - the help funtion to create corresponding X86LDBackend
 ///
-TargetLDBackend* createX86LDBackend(const llvm::Target& pTarget,
-                                    const LinkerConfig& pConfig)
+TargetLDBackend* createX86LDBackend(const LinkerConfig& pConfig)
 {
   if (pConfig.targets().triple().isOSDarwin()) {
     assert(0 && "MachO linker is not supported yet");
@@ -619,11 +771,11 @@
                                createX86COFFObjectWriter);
     **/
   }
-  Triple::ArchType arch = pConfig.targets().triple().getArch();
-  if (arch == Triple::x86)
+  llvm::Triple::ArchType arch = pConfig.targets().triple().getArch();
+  if (arch == llvm::Triple::x86)
     return new X86_32GNULDBackend(pConfig,
 				  new X86_32GNUInfo(pConfig.targets().triple()));
-  assert (arch == Triple::x86_64);
+  assert (arch == llvm::Triple::x86_64);
   return new X86_64GNULDBackend(pConfig,
 				new X86_64GNUInfo(pConfig.targets().triple()));
 }
diff --git a/lib/Target/X86/X86LDBackend.h b/lib/Target/X86/X86LDBackend.h
index a3e8635..4ef5311 100644
--- a/lib/Target/X86/X86LDBackend.h
+++ b/lib/Target/X86/X86LDBackend.h
@@ -130,6 +130,10 @@
   virtual void setRelDynSize() = 0;
   virtual void setRelPLTSize() = 0;
 
+  void addEhFrameForPLT(Module& pModule);
+  virtual llvm::StringRef createCIERegionForPLT() = 0;
+  virtual llvm::StringRef createFDERegionForPLT() = 0;
+
 protected:
   Relocator* m_pRelocator;
   X86PLT* m_pPLT;
@@ -183,6 +187,9 @@
   void setRelDynSize();
   void setRelPLTSize();
 
+  llvm::StringRef createCIERegionForPLT();
+  llvm::StringRef createFDERegionForPLT();
+
 private:
   X86_32GOT* m_pGOT;
   X86_32GOTPLT* m_pGOTPLT;
@@ -223,6 +230,9 @@
   void setRelDynSize();
   void setRelPLTSize();
 
+  llvm::StringRef createCIERegionForPLT();
+  llvm::StringRef createFDERegionForPLT();
+
 private:
   X86_64GOT* m_pGOT;
   X86_64GOTPLT* m_pGOTPLT;
diff --git a/lib/Target/X86/X86MCLinker.cpp b/lib/Target/X86/X86MCLinker.cpp
index bad20a9..46d7bb5 100644
--- a/lib/Target/X86/X86MCLinker.cpp
+++ b/lib/Target/X86/X86MCLinker.cpp
@@ -22,9 +22,9 @@
 MCLinker* createX86MCLinker(const std::string &pTriple,
                             LinkerConfig& pConfig,
                             mcld::Module& pModule,
-                            MemoryArea& pOutput)
+                            FileHandle& pFileHandle)
 {
-  Triple theTriple(pTriple);
+  llvm::Triple theTriple(pTriple);
   if (theTriple.isOSDarwin()) {
     assert(0 && "MachO linker has not supported yet");
     return NULL;
@@ -34,7 +34,7 @@
     return NULL;
   }
 
-  return new X86ELFMCLinker(pConfig, pModule, pOutput);
+  return new X86ELFMCLinker(pConfig, pModule, pFileHandle);
 }
 
 } // namespace of mcld
diff --git a/lib/Target/X86/X86PLT.cpp b/lib/Target/X86/X86PLT.cpp
index 669a047..d73693b 100644
--- a/lib/Target/X86/X86PLT.cpp
+++ b/lib/Target/X86/X86PLT.cpp
@@ -90,9 +90,7 @@
     m_PLT1Size = sizeof (x86_64_plt1);
     // create PLT0
     new X86_64PLT0(*m_SectionData);
-    m_Last = m_SectionData->begin();
   }
-  m_Last = m_SectionData->begin();
 }
 
 X86PLT::~X86PLT()
@@ -128,29 +126,12 @@
   return (m_SectionData->size() > 1);
 }
 
-void X86PLT::reserveEntry(size_t pNum)
+PLTEntryBase* X86PLT::create()
 {
-  PLTEntryBase* plt1_entry = NULL;
-
-  for (size_t i = 0; i < pNum; ++i) {
-
-    if (LinkerConfig::DynObj == m_Config.codeGenType())
-      plt1_entry = new X86_32DynPLT1(*m_SectionData);
-    else
-      plt1_entry = new X86_32ExecPLT1(*m_SectionData);
-
-    if (NULL == plt1_entry)
-      fatal(diag::fail_allocate_memory_plt);
-  }
-}
-
-PLTEntryBase* X86PLT::consume()
-{
-  // This will skip PLT0.
-  ++m_Last;
-  assert(m_Last != m_SectionData->end() &&
-         "The number of PLT Entries and ResolveInfo doesn't match");
-  return llvm::cast<PLTEntryBase>(&(*m_Last));
+  if (LinkerConfig::DynObj == m_Config.codeGenType())
+    return new X86_32DynPLT1(*m_SectionData);
+  else
+    return new X86_32ExecPLT1(*m_SectionData);
 }
 
 PLTEntryBase* X86PLT::getPLT0() const
diff --git a/lib/Target/X86/X86PLT.h b/lib/Target/X86/X86PLT.h
index 2f4176c..2578d67 100644
--- a/lib/Target/X86/X86PLT.h
+++ b/lib/Target/X86/X86PLT.h
@@ -119,9 +119,7 @@
   // hasPLT1 - return if this PLT has any PLT1 entry
   bool hasPLT1() const;
 
-  void reserveEntry(size_t pNum = 1) ;
-
-  PLTEntryBase* consume();
+  PLTEntryBase* create();
 
   virtual void applyPLT0() = 0;
 
@@ -134,9 +132,6 @@
   PLTEntryBase* getPLT0() const;
 
 protected:
-  // the last consumed entry.
-  SectionData::iterator m_Last;
-
   const uint8_t *m_PLT0;
   const uint8_t *m_PLT1;
   unsigned int m_PLT0Size;
diff --git a/lib/Target/X86/X86RelocationFunctions.h b/lib/Target/X86/X86RelocationFunctions.h
index 9209242..a4568bb 100644
--- a/lib/Target/X86/X86RelocationFunctions.h
+++ b/lib/Target/X86/X86RelocationFunctions.h
@@ -43,11 +43,11 @@
   { &unsupport,         12, "",                       0  },  \
   { &unsupport,         13, "",                       0  },  \
   { &unsupport,         14, "R_386_TLS_TPOFF",        0  },  \
-  { &tls_ie,            15, "R_386_TLS_IE",           0  },  \
-  { &tls_gotie,         16, "R_386_TLS_GOTIE",        0  },  \
-  { &tls_le,            17, "R_386_TLS_LE",           0  },  \
-  { &tls_gd,            18, "R_386_TLS_GD",           0  },  \
-  { &tls_ldm,           19, "R_386_TLS_LDM",          0  },  \
+  { &tls_ie,            15, "R_386_TLS_IE",           32 },  \
+  { &tls_gotie,         16, "R_386_TLS_GOTIE",        32 },  \
+  { &tls_le,            17, "R_386_TLS_LE",           32 },  \
+  { &tls_gd,            18, "R_386_TLS_GD",           32 },  \
+  { &tls_ldm,           19, "R_386_TLS_LDM",          32 },  \
   { &abs,               20, "R_386_16",               16 },  \
   { &rel,               21, "R_386_PC16",             16 },  \
   { &abs,               22, "R_386_8",                8  },  \
@@ -60,7 +60,7 @@
   { &unsupport,         29, "R_386_TLS_LDM_PUSH",     0  },  \
   { &unsupport,         30, "R_386_TLS_LDM_CALL",     0  },  \
   { &unsupport,         31, "R_386_TLS_LDM_POP",      0  },  \
-  { &tls_ldo_32,        32, "R_386_TLS_LDO_32",       0  },  \
+  { &tls_ldo_32,        32, "R_386_TLS_LDO_32",       32 },  \
   { &unsupport,         33, "R_386_TLS_IE_32",        0  },  \
   { &unsupport,         34, "R_386_TLS_LE_32",        0  },  \
   { &unsupport,         35, "R_386_TLS_DTPMOD32",     0  },  \
@@ -72,7 +72,7 @@
   { &unsupport,         41, "R_386_TLS_DESC",         0  },  \
   { &unsupport,         42, "R_386_IRELATIVE",        0  },  \
   { &unsupport,         43, "R_386_NUM",              0  },  \
-  { &none,              44, "R_386_TLS_OPT",          0  }
+  { &none,              44, "R_386_TLS_OPT",          32 }
 
 #define DECL_X86_64_APPLY_RELOC_FUNC(Name) \
 static X86Relocator::Result Name(Relocation& pEntry, X86_64Relocator& pParent);
diff --git a/lib/Target/X86/X86Relocator.cpp b/lib/Target/X86/X86Relocator.cpp
index af8c932..6e3234f 100644
--- a/lib/Target/X86/X86Relocator.cpp
+++ b/lib/Target/X86/X86Relocator.cpp
@@ -13,6 +13,9 @@
 #include <mcld/IRBuilder.h>
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/LD/LDSymbol.h>
+#include <mcld/LD/ELFFileFormat.h>
+#include <mcld/LD/ELFSegmentFactory.h>
+#include <mcld/LD/ELFSegment.h>
 #include <mcld/Object/ObjectBuilder.h>
 
 #include <llvm/ADT/Twine.h>
@@ -22,7 +25,126 @@
 using namespace mcld;
 
 //===--------------------------------------------------------------------===//
-// Relocation Functions and Tables
+// X86_32 Relocation helper function
+//===--------------------------------------------------------------------===//
+/// helper_DynRel - Get an relocation entry in .rel.dyn
+static
+Relocation& helper_DynRel_init(ResolveInfo* pSym,
+                               Fragment& pFrag,
+                               uint64_t pOffset,
+                               X86Relocator::Type pType,
+                               X86_32Relocator& pParent)
+{
+  X86_32GNULDBackend& ld_backend = pParent.getTarget();
+  Relocation& rel_entry = *ld_backend.getRelDyn().create();
+  rel_entry.setType(pType);
+  rel_entry.targetRef().assign(pFrag, pOffset);
+  if (pType == llvm::ELF::R_386_RELATIVE || NULL == pSym)
+    rel_entry.setSymInfo(NULL);
+  else
+    rel_entry.setSymInfo(pSym);
+
+  return rel_entry;
+}
+
+/// helper_use_relative_reloc - Check if symbol ceuse relocation
+/// R_386_RELATIVE
+static bool
+helper_use_relative_reloc(const ResolveInfo& pSym,
+                          const X86_32Relocator& pFactory)
+
+{
+  // if symbol is dynamic or undefine or preemptible
+  if (pSym.isDyn() ||
+      pSym.isUndef() ||
+      pFactory.getTarget().isSymbolPreemptible(pSym))
+    return false;
+  return true;
+}
+
+static
+X86_32GOTEntry& helper_GOT_init(Relocation& pReloc,
+                                bool pHasRel,
+					                      X86_32Relocator& pParent)
+{
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.symInfo();
+  X86_32GNULDBackend& ld_backend = pParent.getTarget();
+  assert(NULL == pParent.getSymGOTMap().lookUp(*rsym));
+
+  X86_32GOTEntry* got_entry = ld_backend.getGOT().create();
+  pParent.getSymGOTMap().record(*rsym, *got_entry);
+
+  if (!pHasRel) {
+    // No corresponding dynamic relocation, initialize to the symbol value.
+    got_entry->setValue(X86Relocator::SymVal);
+  }
+  else {
+    // Initialize got_entry content and the corresponding dynamic relocation.
+    if (helper_use_relative_reloc(*rsym, pParent)) {
+      helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_386_RELATIVE,
+                                                                       pParent);
+      got_entry->setValue(X86Relocator::SymVal);
+    }
+    else {
+      helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_386_GLOB_DAT,
+                                                                       pParent);
+      got_entry->setValue(0x0);
+    }
+  }
+  return *got_entry;
+}
+
+static
+X86Relocator::Address helper_GOT_ORG(X86_32Relocator& pParent)
+{
+  return pParent.getTarget().getGOTPLT().addr();
+}
+
+static
+X86Relocator::Address helper_get_GOT_address(Relocation& pReloc,
+                                             X86_32Relocator& pParent)
+{
+  X86_32GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
+  assert(NULL != got_entry);
+  return pParent.getTarget().getGOT().addr() + got_entry->getOffset();
+}
+
+static
+PLTEntryBase& helper_PLT_init(Relocation& pReloc, X86_32Relocator& pParent)
+{
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.symInfo();
+  X86_32GNULDBackend& ld_backend = pParent.getTarget();
+  assert(NULL == pParent.getSymPLTMap().lookUp(*rsym));
+
+  PLTEntryBase* plt_entry = ld_backend.getPLT().create();
+  pParent.getSymPLTMap().record(*rsym, *plt_entry);
+
+  // initialize plt and the corresponding gotplt and dyn rel entry.
+  assert(NULL == pParent.getSymGOTPLTMap().lookUp(*rsym) &&
+         "PLT entry not exist, but GOTPLT entry exist!");
+  X86_32GOTEntry* gotplt_entry = ld_backend.getGOTPLT().create();
+  pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
+
+  // init the corresponding rel entry in .rel.plt
+  Relocation& rel_entry = *ld_backend.getRelPLT().create();
+  rel_entry.setType(llvm::ELF::R_386_JUMP_SLOT);
+  rel_entry.targetRef().assign(*gotplt_entry);
+  rel_entry.setSymInfo(rsym);
+  return *plt_entry;
+}
+
+static
+X86Relocator::Address helper_get_PLT_address(ResolveInfo& pSym, X86_32Relocator& pParent)
+{
+  PLTEntryBase* plt_entry = pParent.getSymPLTMap().lookUp(pSym);
+  assert(NULL != plt_entry);
+  return pParent.getTarget().getPLT().addr() + plt_entry->getOffset();
+}
+
+//===--------------------------------------------------------------------===//
+// X86_32 Relocation Functions and Tables
 //===--------------------------------------------------------------------===//
 DECL_X86_32_APPLY_RELOC_FUNCS
 
@@ -58,7 +180,8 @@
 void X86Relocator::scanRelocation(Relocation& pReloc,
                                   IRBuilder& pLinker,
                                   Module& pModule,
-                                  LDSection& pSection)
+                                  LDSection& pSection,
+                                  Input& pInput)
 {
   if (LinkerConfig::Object == config().codeGenType())
     return;
@@ -67,7 +190,6 @@
   assert(NULL != rsym &&
          "ResolveInfo of relocation not set while scanRelocation");
 
-  pReloc.updateAddend();
   assert(NULL != pSection.getLink());
   if (0 == (pSection.getLink()->flag() & llvm::ELF::SHF_ALLOC))
     return;
@@ -82,12 +204,12 @@
   // check if we should issue undefined reference for the relocation target
   // symbol
   if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
-    fatal(diag::undefined_reference) << rsym->name();
+    issueUndefRef(pReloc, pSection, pInput);
 }
 
 void X86Relocator::addCopyReloc(ResolveInfo& pSym, X86GNULDBackend& pTarget)
 {
-  Relocation& rel_entry = *pTarget.getRelDyn().consumeEntry();
+  Relocation& rel_entry = *pTarget.getRelDyn().create();
   rel_entry.setType(pTarget.getCopyRelType());
   assert(pSym.outSymbol()->hasFragRef());
   rel_entry.targetRef().assign(*pSym.outSymbol()->fragRef());
@@ -202,9 +324,9 @@
 }
 
 void X86_32Relocator::scanLocalReloc(Relocation& pReloc,
-															     	 IRBuilder& pBuilder,
-																		 Module& pModule,
-																		 LDSection& pSection)
+                                     IRBuilder& pBuilder,
+                                     Module& pModule,
+                                     LDSection& pSection)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
@@ -212,13 +334,31 @@
   switch(pReloc.type()){
 
     case llvm::ELF::R_386_32:
+      // If buiding PIC object (shared library or PIC executable),
+      // a dynamic relocations with RELATIVE type to this location is needed.
+      // Reserve an entry in .rel.dyn
+      if (config().isCodeIndep()) {
+        // set Rel bit
+        rsym->setReserved(rsym->reserved() | ReserveRel);
+        getTarget().checkAndSetHasTextRel(*pSection.getLink());
+        // set up the dyn rel directly
+        helper_DynRel_init(rsym,
+                           *pReloc.targetRef().frag(),
+                           pReloc.targetRef().offset(),
+                           llvm::ELF::R_386_RELATIVE,
+                           *this);
+      }
+      return;
+
     case llvm::ELF::R_386_16:
     case llvm::ELF::R_386_8:
       // If buiding PIC object (shared library or PIC executable),
       // a dynamic relocations with RELATIVE type to this location is needed.
       // Reserve an entry in .rel.dyn
       if (config().isCodeIndep()) {
-        getTarget().getRelDyn().reserveEntry();
+        // set up the dyn rel directly
+        helper_DynRel_init(rsym, *pReloc.targetRef().frag(),
+                            pReloc.targetRef().offset(), pReloc.type(), *this);
         // set Rel bit
         rsym->setReserved(rsym->reserved() | ReserveRel);
         getTarget().checkAndSetHasTextRel(*pSection.getLink());
@@ -236,28 +376,25 @@
     case llvm::ELF::R_386_GOT32:
       // Symbol needs GOT entry, reserve entry in .got
       // return if we already create GOT for this symbol
-      if (rsym->reserved() & (ReserveGOT | GOTRel))
+      if (rsym->reserved() & ReserveGOT)
         return;
-      // FIXME: check STT_GNU_IFUNC symbol
-      getTarget().getGOT().reserve();
 
-      // If the GOT is used in statically linked binaries,
-      // the GOT entry is enough and no relocation is needed.
-      if (config().isCodeStatic()) {
-        rsym->setReserved(rsym->reserved() | ReserveGOT);
-        return;
-      }
+      // FIXME: check STT_GNU_IFUNC symbol
+
       // If building shared object or the symbol is undefined, a dynamic
       // relocation is needed to relocate this GOT entry. Reserve an
       // entry in .rel.dyn
       if (LinkerConfig::DynObj ==
                    config().codeGenType() || rsym->isUndef() || rsym->isDyn()) {
-        getTarget().getRelDyn().reserveEntry();
-        // set GOTRel bit
-        rsym->setReserved(rsym->reserved() | GOTRel);
+        helper_GOT_init(pReloc, true, *this);
+        // set GOT bit
+        rsym->setReserved(rsym->reserved() | ReserveGOT);
         return;
       }
-      // set GOT bit
+
+      // elsewhere if the GOT is used in statically linked binaries,
+      // the GOT entry is enough and no relocation is needed.
+      helper_GOT_init(pReloc, false, *this);
       rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
 
@@ -268,13 +405,9 @@
 
     case llvm::ELF::R_386_TLS_GD: {
       // FIXME: no linker optimization for TLS relocation
-      if (rsym->reserved() & GOTRel)
+      if (rsym->reserved() & ReserveGOT)
         return;
-      getTarget().getGOT().reserve(2);
-      // reserve an rel entry
-      getTarget().getRelDyn().reserveEntry();
-      // set GOTRel bit
-      rsym->setReserved(rsym->reserved() | GOTRel);
+
       // define the section symbol for .tdata or .tbss
       // the target symbol of the created dynamic relocation should be the
       // section symbol of the section which this symbol defined. so we
@@ -282,19 +415,40 @@
       ELFFileFormat* file_format = getTarget().getOutputFormat();
       const LDSection* sym_sect =
                &rsym->outSymbol()->fragRef()->frag()->getParent()->getSection();
+      LDSymbol* sect_sym = NULL;
       if (&file_format->getTData() == sym_sect) {
-        if (!getTarget().hasTDATASymbol())
-          getTarget().setTDATASymbol(*pModule.getSectionSymbolSet().get(*sym_sect));
+        if (!getTarget().hasTDATASymbol()) {
+          sect_sym = pModule.getSectionSymbolSet().get(*sym_sect);
+          getTarget().setTDATASymbol(*sect_sym);
+        }
       }
       else if (&file_format->getTBSS() == sym_sect || rsym->isCommon()) {
-        if (!getTarget().hasTBSSSymbol())
-          getTarget().setTBSSSymbol(*pModule.getSectionSymbolSet().get(*sym_sect));
+        if (!getTarget().hasTBSSSymbol()) {
+          sect_sym = pModule.getSectionSymbolSet().get(*sym_sect);
+          getTarget().setTBSSSymbol(*sect_sym);
+        }
       }
       else
         error(diag::invalid_tls) << rsym->name() << sym_sect->name();
+
+      // set up a pair of got entries and a dyn rel
+      // set GOT bit
+      rsym->setReserved(rsym->reserved() | ReserveGOT);
+      X86_32GOTEntry* got_entry1 = getTarget().getGOT().create();
+      X86_32GOTEntry* got_entry2 = getTarget().getGOT().create();
+      getSymGOTMap().record(*rsym, *got_entry1, *got_entry2);
+      // set up value of got entries, the value of got_entry2 should be the
+      // symbol value, which has to be set during apply relocation
+      got_entry1->setValue(0x0);
+
+      // setup dyn rel for got_entry1
+      Relocation& rel_entry1 = helper_DynRel_init(rsym, *got_entry1, 0x0,
+                                        llvm::ELF::R_386_TLS_DTPMOD32, *this);
+      // for local tls symbol, add rel entry against the section symbol this
+      // symbol belong to (.tdata or .tbss)
+      rel_entry1.setSymInfo(sect_sym->resolveInfo());
       return;
     }
-
     case llvm::ELF::R_386_TLS_LDM:
       getTLSModuleID();
       return;
@@ -302,46 +456,65 @@
     case llvm::ELF::R_386_TLS_LDO_32:
       return;
 
-    case llvm::ELF::R_386_TLS_IE:
+    case llvm::ELF::R_386_TLS_IE: {
       getTarget().setHasStaticTLS();
-      // if buildint shared object, a RELATIVE dynamic relocation is needed
+
+      // if building shared object, a RELATIVE dynamic relocation is needed
       if (LinkerConfig::DynObj == config().codeGenType()) {
-        getTarget().getRelDyn().reserveEntry();
+         helper_DynRel_init(rsym, *pReloc.targetRef().frag(),
+                                              pReloc.targetRef().offset(),
+                                              llvm::ELF::R_386_RELATIVE, *this);
         rsym->setReserved(rsym->reserved() | ReserveRel);
         getTarget().checkAndSetHasTextRel(*pSection.getLink());
-      } else {
+      }
+      else {
         // for local sym, we can convert ie to le if not building shared object
         convertTLSIEtoLE(pReloc, pSection);
         return;
       }
-      if (rsym->reserved() & GOTRel)
-        return;
-      // reserve got and dyn relocation entries for tp-relative offset
-      getTarget().getGOT().reserve();
-      getTarget().getRelDyn().reserveEntry();
-      // set GOTRel bit
-      rsym->setReserved(rsym->reserved() | GOTRel);
-      getTarget().getRelDyn().addSymbolToDynSym(*rsym->outSymbol());
-      return;
 
-    case llvm::ELF::R_386_TLS_GOTIE:
-      getTarget().setHasStaticTLS();
-      if (rsym->reserved() & GOTRel)
+      if (rsym->reserved() & ReserveGOT)
         return;
-      // reserve got and dyn relocation entries for tp-relative offset
-      getTarget().getGOT().reserve();
-      getTarget().getRelDyn().reserveEntry();
-      // set GOTRel bit
-      rsym->setReserved(rsym->reserved() | GOTRel);
+
+      // set up the got and the corresponding rel entry
+      X86_32GOTEntry* got_entry = getTarget().getGOT().create();
+      getSymGOTMap().record(*rsym, *got_entry);
+      got_entry->setValue(0x0);
+      helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_386_TLS_TPOFF,
+                                                                         *this);
+      // set GOT bit
+      rsym->setReserved(rsym->reserved() | ReserveGOT);
+      // add symbol to dyn sym table
       getTarget().getRelDyn().addSymbolToDynSym(*rsym->outSymbol());
       return;
+    }
+
+    case llvm::ELF::R_386_TLS_GOTIE: {
+      getTarget().setHasStaticTLS();
+      if (rsym->reserved() & ReserveGOT)
+        return;
+      // set up the got and the corresponding dyn rel
+      X86_32GOTEntry* got_entry = getTarget().getGOT().create();
+      getSymGOTMap().record(*rsym, *got_entry);
+      got_entry->setValue(0x0);
+      helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_386_TLS_TPOFF,
+                                                                        *this);
+      // set GOT bit
+      rsym->setReserved(rsym->reserved() | ReserveGOT);
+      getTarget().getRelDyn().addSymbolToDynSym(*rsym->outSymbol());
+      return;
+    }
 
     case llvm::ELF::R_386_TLS_LE:
     case llvm::ELF::R_386_TLS_LE_32:
       getTarget().setHasStaticTLS();
       // if buildint shared object, a dynamic relocation is needed
       if (LinkerConfig::DynObj == config().codeGenType()) {
-        getTarget().getRelDyn().reserveEntry();
+        helper_DynRel_init(rsym,
+                           *pReloc.targetRef().frag(),
+                           pReloc.targetRef().offset(),
+                           llvm::ELF::R_386_TLS_TPOFF,
+                           *this);
         rsym->setReserved(rsym->reserved() | ReserveRel);
         getTarget().checkAndSetHasTextRel(*pSection.getLink());
         // the target symbol of the dynamic relocation is rsym, so we need to
@@ -359,9 +532,9 @@
 }
 
 void X86_32Relocator::scanGlobalReloc(Relocation& pReloc,
-								 				 				 		  IRBuilder& pBuilder,
-								 				 				 		  Module& pModule,
-								 				 				 		  LDSection& pSection)
+                                      IRBuilder& pBuilder,
+                                      Module& pModule,
+                                      LDSection& pSection)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
@@ -375,29 +548,39 @@
       if (getTarget().symbolNeedsPLT(*rsym)) {
         // create plt for this symbol if it does not have one
         if (!(rsym->reserved() & ReservePLT)){
-          // Symbol needs PLT entry, we need to reserve a PLT entry
+          // Symbol needs PLT entry, we need a PLT entry
           // and the corresponding GOT and dynamic relocation entry
-          // in .got and .rel.plt. (GOT entry will be reserved simultaneously
-          // when calling X86PLT->reserveEntry())
-          getTarget().getPLT().reserveEntry();
-          getTarget().getGOTPLT().reserve();
-          getTarget().getRelPLT().reserveEntry();
+          // in .got and .rel.plt.
+          helper_PLT_init(pReloc, *this);
           // set PLT bit
           rsym->setReserved(rsym->reserved() | ReservePLT);
         }
       }
 
-      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT), true)) {
-        // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
-        getTarget().getRelDyn().reserveEntry();
+      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT),
+                                                                        true)) {
+        // symbol needs dynamic relocation entry, set up the dynrel entry
         if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
           LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym, getTarget());
           addCopyReloc(*cpy_sym.resolveInfo(), getTarget());
         }
         else {
-          // set Rel bit
+          // set Rel bit and the dyn rel
           rsym->setReserved(rsym->reserved() | ReserveRel);
-          getTarget().checkAndSetHasTextRel(pSection);
+          getTarget().checkAndSetHasTextRel(*pSection.getLink());
+          if (llvm::ELF::R_386_32 == pReloc.type() &&
+              helper_use_relative_reloc(*rsym, *this))
+            helper_DynRel_init(rsym,
+                               *pReloc.targetRef().frag(),
+                               pReloc.targetRef().offset(),
+                               llvm::ELF::R_386_RELATIVE,
+                               *this);
+          else
+            helper_DynRel_init(rsym,
+                               *pReloc.targetRef().frag(),
+                               pReloc.targetRef().offset(),
+                               pReloc.type(),
+                               *this);
         }
       }
       return;
@@ -422,17 +605,13 @@
       // if symbol is defined in the ouput file and it's not
       // preemptible, no need plt
       if (rsym->isDefine() && !rsym->isDyn() &&
-         !getTarget().isSymbolPreemptible(*rsym)) {
+          !getTarget().isSymbolPreemptible(*rsym))
         return;
-      }
 
-      // Symbol needs PLT entry, we need to reserve a PLT entry
+      // Symbol needs PLT entry, we need a PLT entry
       // and the corresponding GOT and dynamic relocation entry
-      // in .got and .rel.plt. (GOT entry will be reserved simultaneously
-      // when calling X86PLT->reserveEntry())
-      getTarget().getPLT().reserveEntry();
-      getTarget().getGOTPLT().reserve();
-      getTarget().getRelPLT().reserveEntry();
+      // in .got and .rel.plt
+      helper_PLT_init(pReloc, *this);
       // set PLT bit
       rsym->setReserved(rsym->reserved() | ReservePLT);
       return;
@@ -440,26 +619,16 @@
     case llvm::ELF::R_386_GOT32:
       // Symbol needs GOT entry, reserve entry in .got
       // return if we already create GOT for this symbol
-      if (rsym->reserved() & (ReserveGOT | GOTRel))
+      if (rsym->reserved() & ReserveGOT)
         return;
-      getTarget().getGOT().reserve();
-
-      // If the GOT is used in statically linked binaries,
-      // the GOT entry is enough and no relocation is needed.
-      if (config().isCodeStatic()) {
-        rsym->setReserved(rsym->reserved() | ReserveGOT);
-        return;
-      }
       // If building shared object or the symbol is undefined, a dynamic
       // relocation is needed to relocate this GOT entry. Reserve an
       // entry in .rel.dyn
       if (LinkerConfig::DynObj ==
-                   config().codeGenType() || rsym->isUndef() || rsym->isDyn()) {
-        getTarget().getRelDyn().reserveEntry();
-        // set GOTRel bit
-        rsym->setReserved(rsym->reserved() | GOTRel);
-        return;
-      }
+                   config().codeGenType() || rsym->isUndef() || rsym->isDyn())
+        helper_GOT_init(pReloc, true, *this);
+      else
+        helper_GOT_init(pReloc, false, *this);
       // set GOT bit
       rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
@@ -472,43 +641,65 @@
           LinkerConfig::DynObj != config().codeGenType()) {
         // create plt for this symbol if it does not have one
         if (!(rsym->reserved() & ReservePLT)){
-          // Symbol needs PLT entry, we need to reserve a PLT entry
+          // Symbol needs PLT entry, we need a PLT entry
           // and the corresponding GOT and dynamic relocation entry
-          // in .got and .rel.plt. (GOT entry will be reserved simultaneously
-          // when calling X86PLT->reserveEntry())
-          getTarget().getPLT().reserveEntry();
-          getTarget().getGOTPLT().reserve();
-          getTarget().getRelPLT().reserveEntry();
+          // in .got and .rel.plt.
           // set PLT bit
+          helper_PLT_init(pReloc, *this);
           rsym->setReserved(rsym->reserved() | ReservePLT);
         }
       }
 
-      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT), false)) {
-        // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
-        getTarget().getRelDyn().reserveEntry();
+      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT),
+                                                                       false)) {
+        // symbol needs dynamic relocation entry, setup an entry in .rel.dyn
         if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
-          LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym, getTarget());
+          LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym,
+                                                                   getTarget());
           addCopyReloc(*cpy_sym.resolveInfo(), getTarget());
         }
         else {
-          // set Rel bit
+          // set Rel bit and the dyn rel
           rsym->setReserved(rsym->reserved() | ReserveRel);
-          getTarget().checkAndSetHasTextRel(pSection);
+          getTarget().checkAndSetHasTextRel(*pSection.getLink());
+          if (llvm::ELF::R_386_32 == pReloc.type() &&
+              helper_use_relative_reloc(*rsym, *this))
+            helper_DynRel_init(rsym,
+                               *pReloc.targetRef().frag(),
+                               pReloc.targetRef().offset(),
+                               llvm::ELF::R_386_RELATIVE,
+                               *this);
+          else
+            helper_DynRel_init(rsym,
+                               *pReloc.targetRef().frag(),
+                               pReloc.targetRef().offset(),
+                               pReloc.type(),
+                               *this);
         }
       }
       return;
 
     case llvm::ELF::R_386_TLS_GD: {
       // FIXME: no linker optimization for TLS relocation
-      if (rsym->reserved() & GOTRel)
+      if (rsym->reserved() & ReserveGOT)
         return;
-      // reserve two pairs of got entry and dynamic relocation
-      getTarget().getGOT().reserve(2);
-      getTarget().getRelDyn().reserveEntry(2);
+
+      // set up a pair of got entries and a pair of dyn rel
+      X86_32GOTEntry* got_entry1 = getTarget().getGOT().create();
+      X86_32GOTEntry* got_entry2 = getTarget().getGOT().create();
+      getSymGOTMap().record(*rsym, *got_entry1, *got_entry2);
+      got_entry1->setValue(0x0);
+      got_entry2->setValue(0x0);
+      // setup dyn rel for got entries against rsym
+      helper_DynRel_init(rsym, *got_entry1, 0x0,
+                                        llvm::ELF::R_386_TLS_DTPMOD32, *this);
+      helper_DynRel_init(rsym, *got_entry2, 0x0,
+                                        llvm::ELF::R_386_TLS_DTPOFF32, *this);
+
+      // add the rsym to dynamic symbol table
       getTarget().getRelDyn().addSymbolToDynSym(*rsym->outSymbol());
-      // set GOTRel bit
-      rsym->setReserved(rsym->reserved() | GOTRel);
+      // set GOT bit
+      rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
     }
 
@@ -519,11 +710,13 @@
     case llvm::ELF::R_386_TLS_LDO_32:
       return;
 
-    case llvm::ELF::R_386_TLS_IE:
+    case llvm::ELF::R_386_TLS_IE: {
       getTarget().setHasStaticTLS();
       // if buildint shared object, a RELATIVE dynamic relocation is needed
       if (LinkerConfig::DynObj == config().codeGenType()) {
-        getTarget().getRelDyn().reserveEntry();
+        helper_DynRel_init(rsym, *pReloc.targetRef().frag(),
+                                               pReloc.targetRef().offset(),
+                                               llvm::ELF::R_386_RELATIVE, *this);
         rsym->setReserved(rsym->reserved() | ReserveRel);
         getTarget().checkAndSetHasTextRel(*pSection.getLink());
       } else {
@@ -533,34 +726,45 @@
           return;
         }
       }
-      if (rsym->reserved() & GOTRel)
+      if (rsym->reserved() & ReserveGOT)
         return;
-      // reserve got and dyn relocation entries for tp-relative offset
-      getTarget().getGOT().reserve();
-      getTarget().getRelDyn().reserveEntry();
-      getTarget().getRelDyn().addSymbolToDynSym(*rsym->outSymbol());
-      // set GOTRel bit
-      rsym->setReserved(rsym->reserved() | GOTRel);
+      // set up the got and the corresponding rel entry
+      X86_32GOTEntry* got_entry = getTarget().getGOT().create();
+      getSymGOTMap().record(*rsym, *got_entry);
+      got_entry->setValue(0x0);
+      helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_386_TLS_TPOFF,
+                                                                         *this);
+      // set GOT bit
+      rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
+    }
 
-    case llvm::ELF::R_386_TLS_GOTIE:
+    case llvm::ELF::R_386_TLS_GOTIE: {
       getTarget().setHasStaticTLS();
-      if (rsym->reserved() & GOTRel)
+      if (rsym->reserved() & ReserveGOT)
         return;
-      // reserve got and dyn relocation entries for tp-relative offset
-      getTarget().getGOT().reserve();
-      getTarget().getRelDyn().reserveEntry();
+      // set up the got and the corresponding dyn rel
+      X86_32GOTEntry* got_entry = getTarget().getGOT().create();
+      getSymGOTMap().record(*rsym, *got_entry);
+      got_entry->setValue(0x0);
+      helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_386_TLS_TPOFF,
+                                                                        *this);
       getTarget().getRelDyn().addSymbolToDynSym(*rsym->outSymbol());
-      // set GOTRel bit
-      rsym->setReserved(rsym->reserved() | GOTRel);
+      // set GOT bit
+      rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
+    }
 
     case llvm::ELF::R_386_TLS_LE:
     case llvm::ELF::R_386_TLS_LE_32:
       getTarget().setHasStaticTLS();
       // if buildint shared object, a dynamic relocation is needed
       if (LinkerConfig::DynObj == config().codeGenType()) {
-        getTarget().getRelDyn().reserveEntry();
+        helper_DynRel_init(rsym,
+                           *pReloc.targetRef().frag(),
+                           pReloc.targetRef().offset(),
+                           llvm::ELF::R_386_TLS_TPOFF,
+                           *this);
         getTarget().getRelDyn().addSymbolToDynSym(*rsym->outSymbol());
         rsym->setReserved(rsym->reserved() | ReserveRel);
         getTarget().checkAndSetHasTextRel(*pSection.getLink());
@@ -583,16 +787,11 @@
     return *got_entry;
 
   // Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
-  getTarget().getGOT().reserve(2);
-  got_entry = getTarget().getGOT().consume();
-  getTarget().getGOT().consume()->setValue(0x0);
+  got_entry = getTarget().getGOT().create();
+  getTarget().getGOT().create()->setValue(0x0);
 
-  getTarget().getRelDyn().reserveEntry();
-  Relocation* rel_entry = getTarget().getRelDyn().consumeEntry();
-  rel_entry->setType(llvm::ELF::R_386_TLS_DTPMOD32);
-  rel_entry->targetRef().assign(*got_entry, 0x0);
-  rel_entry->setSymInfo(NULL);
-
+  helper_DynRel_init(NULL, *got_entry, 0x0, llvm::ELF::R_386_TLS_DTPMOD32,
+                                                                          *this);
   return *got_entry;
 }
 
@@ -611,10 +810,11 @@
     off = 0;
 
   FragmentRef* fragref = FragmentRef::Create(*pReloc.targetRef().frag(), off);
-  // TODO: add symbols for R_386_TLS_OPT relocs
   Relocation* reloc = Relocation::Create(X86_32Relocator::R_386_TLS_OPT,
                                          *fragref,
                                          0x0);
+  // FIXME: should we create a special symbol for the tls opt instead?
+  reloc->setSymInfo(pReloc.symInfo());
 
   // 2. modify the opcodes to the appropriate ones
   uint8_t* op =  (reinterpret_cast<uint8_t*>(&reloc->target()));
@@ -647,154 +847,9 @@
   pReloc.setType(llvm::ELF::R_386_TLS_LE);
 }
 
-//===--------------------------------------------------------------------===//
-// Relocation helper function
-//===--------------------------------------------------------------------===//
-
-/// helper_DynRel - Get an relocation entry in .rel.dyn
-static
-Relocation& helper_DynRel(ResolveInfo* pSym,
-                          Fragment& pFrag,
-                          uint64_t pOffset,
-                          X86Relocator::Type pType,
-                          X86_32Relocator& pParent)
-{
-  X86_32GNULDBackend& ld_backend = pParent.getTarget();
-  Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
-  rel_entry.setType(pType);
-  rel_entry.targetRef().assign(pFrag, pOffset);
-  if (pType == llvm::ELF::R_386_RELATIVE || NULL == pSym)
-    rel_entry.setSymInfo(0);
-  else
-    rel_entry.setSymInfo(pSym);
-
-  return rel_entry;
-}
-
-
-/// helper_use_relative_reloc - Check if symbol can use relocation
-/// R_386_RELATIVE
-static bool
-helper_use_relative_reloc(const ResolveInfo& pSym,
-                          const X86_32Relocator& pFactory)
-
-{
-  // if symbol is dynamic or undefine or preemptible
-  if (pSym.isDyn() ||
-      pSym.isUndef() ||
-      pFactory.getTarget().isSymbolPreemptible(pSym))
-    return false;
-  return true;
-}
-
-static
-X86_32GOTEntry& helper_get_GOT_and_init(Relocation& pReloc,
-					X86_32Relocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  X86_32GNULDBackend& ld_backend = pParent.getTarget();
-
-  X86_32GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
-  if (NULL != got_entry)
-    return *got_entry;
-
-  // not found
-  got_entry = ld_backend.getGOT().consume();
-  pParent.getSymGOTMap().record(*rsym, *got_entry);
-
-  // If we first get this GOT entry, we should initialize it.
-  if (rsym->reserved() & X86Relocator::ReserveGOT) {
-    // No corresponding dynamic relocation, initialize to the symbol value.
-    got_entry->setValue(pReloc.symValue());
-  }
-  else if (rsym->reserved() & X86Relocator::GOTRel) {
-    // Initialize got_entry content and the corresponding dynamic relocation.
-    if (helper_use_relative_reloc(*rsym, pParent)) {
-      helper_DynRel(rsym, *got_entry, 0x0, llvm::ELF::R_386_RELATIVE, pParent);
-      got_entry->setValue(pReloc.symValue());
-    }
-    else {
-      helper_DynRel(rsym, *got_entry, 0x0, llvm::ELF::R_386_GLOB_DAT, pParent);
-      got_entry->setValue(0);
-    }
-  }
-  else {
-    fatal(diag::reserve_entry_number_mismatch_got);
-  }
-  return *got_entry;
-}
-
-
-static
-X86Relocator::Address helper_GOT_ORG(X86_32Relocator& pParent)
-{
-  return pParent.getTarget().getGOTPLT().addr();
-}
-
-
-static
-X86Relocator::Address helper_GOT(Relocation& pReloc, X86_32Relocator& pParent)
-{
-  X86_32GOTEntry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
-  X86Relocator::Address got_addr = pParent.getTarget().getGOT().addr();
-  return got_addr + got_entry.getOffset();
-}
-
-
-static
-PLTEntryBase& helper_get_PLT_and_init(Relocation& pReloc,
-				      X86_32Relocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  X86_32GNULDBackend& ld_backend = pParent.getTarget();
-
-  PLTEntryBase* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
-  if (NULL != plt_entry)
-    return *plt_entry;
-
-  // not found
-  plt_entry = ld_backend.getPLT().consume();
-  pParent.getSymPLTMap().record(*rsym, *plt_entry);
-  // If we first get this PLT entry, we should initialize it.
-  if (rsym->reserved() & X86Relocator::ReservePLT) {
-    X86_32GOTEntry* gotplt_entry = pParent.getSymGOTPLTMap().lookUp(*rsym);
-    assert(NULL == gotplt_entry && "PLT entry not exist, but DynRel entry exist!");
-    gotplt_entry = ld_backend.getGOTPLT().consume();
-    pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
-    // init the corresponding rel entry in .rel.plt
-    Relocation& rel_entry = *ld_backend.getRelPLT().consumeEntry();
-    rel_entry.setType(llvm::ELF::R_386_JUMP_SLOT);
-    rel_entry.targetRef().assign(*gotplt_entry);
-    rel_entry.setSymInfo(rsym);
-  }
-  else {
-    fatal(diag::reserve_entry_number_mismatch_plt);
-  }
-
-  return *plt_entry;
-}
-
-
-static
-X86Relocator::Address helper_PLT_ORG(X86_32Relocator& pParent)
-{
-  return pParent.getTarget().getPLT().addr();
-}
-
-
-static
-X86Relocator::Address helper_PLT(Relocation& pReloc, X86_32Relocator& pParent)
-{
-  PLTEntryBase& plt_entry = helper_get_PLT_and_init(pReloc, pParent);
-  return helper_PLT_ORG(pParent) + plt_entry.getOffset();
-}
-
-
-//=========================================//
-// Each relocation function implementation //
-//=========================================//
+//================================================//
+// X86_32 Each relocation function implementation //
+//================================================//
 
 // R_386_NONE
 X86Relocator::Result none(Relocation& pReloc, X86_32Relocator& pParent)
@@ -811,13 +866,12 @@
   Relocator::DWord A = pReloc.target() + pReloc.addend();
   Relocator::DWord S = pReloc.symValue();
   bool has_dyn_rel = pParent.getTarget().symbolNeedsDynRel(
-                              *rsym,
-                              (rsym->reserved() & X86Relocator::ReservePLT),
-                              true);
-  FragmentRef &target_fragref = pReloc.targetRef();
-  Fragment *target_frag = target_fragref.frag();
+                                  *rsym,
+                                  (rsym->reserved() & X86Relocator::ReservePLT),
+                                  true);
 
-  LDSection& target_sect = target_frag->getParent()->getSection();
+
+  LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
   // If the flag of target section is not ALLOC, we will not scan this relocation
   // but perform static relocation. (e.g., applying .debug section)
   if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
@@ -825,36 +879,18 @@
     return X86Relocator::OK;
   }
 
-  // A local symbol may need REL Type dynamic relocation
-  if (rsym->isLocal() && has_dyn_rel) {
-    X86Relocator::Type pType = pReloc.type();
-    if (llvm::ELF::R_386_32 == pType)
-      pType = llvm::ELF::R_386_RELATIVE;
-    helper_DynRel(rsym, *target_frag, target_fragref.offset(), pType, pParent);
-    pReloc.target() = S + A;
-    return X86Relocator::OK;
-  }
-
   // An external symbol may need PLT and dynamic relocation
   if (!rsym->isLocal()) {
     if (rsym->reserved() & X86Relocator::ReservePLT) {
-      S = helper_PLT(pReloc, pParent);
+      S = helper_get_PLT_address(*rsym, pParent);
     }
     // If we generate a dynamic relocation (except R_386_RELATIVE)
     // for a place, we should not perform static relocation on it
     // in order to keep the addend store in the place correct.
-    if (has_dyn_rel) {
-      if (llvm::ELF::R_386_32 == pReloc.type() &&
-          helper_use_relative_reloc(*rsym, pParent)) {
-        helper_DynRel(rsym, *target_frag, target_fragref.offset(),
-              llvm::ELF::R_386_RELATIVE, pParent);
-      }
-      else {
-        helper_DynRel(rsym, *target_frag, target_fragref.offset(),
-                      pReloc.type(), pParent);
+    if (has_dyn_rel)
+      if (llvm::ELF::R_386_32 != pReloc.type() ||
+          (!helper_use_relative_reloc(*rsym, pParent)))
         return X86Relocator::OK;
-      }
-    }
   }
 
   // perform static relocation
@@ -871,6 +907,10 @@
   Relocator::DWord A = pReloc.target() + pReloc.addend();
   Relocator::DWord S = pReloc.symValue();
   Relocator::DWord P = pReloc.place();
+  bool has_dyn_rel = pParent.getTarget().symbolNeedsDynRel(
+                                  *rsym,
+                                  (rsym->reserved() & X86Relocator::ReservePLT),
+                                  true);
 
   LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
   // If the flag of target section is not ALLOC, we will not scan this relocation
@@ -883,23 +923,12 @@
   // An external symbol may need PLT and dynamic relocation
   if (!rsym->isLocal()) {
     if (rsym->reserved() & X86Relocator::ReservePLT) {
-       S = helper_PLT(pReloc, pParent);
-       pReloc.target() = S + A - P;
+      S = helper_get_PLT_address(*rsym, pParent);
+      pReloc.target() = S + A - P;
     }
-    if (pParent.getTarget().symbolNeedsDynRel(
-                              *rsym,
-                              (rsym->reserved() & X86Relocator::ReservePLT),
-                              false)) {
-      if (helper_use_relative_reloc(*rsym, pParent) ) {
-        helper_DynRel(rsym, *pReloc.targetRef().frag(),
-              pReloc.targetRef().offset(), llvm::ELF::R_386_RELATIVE, pParent);
-      }
-      else {
-        helper_DynRel(rsym, *pReloc.targetRef().frag(),
-                          pReloc.targetRef().offset(), pReloc.type(), pParent);
-          return X86Relocator::OK;
-      }
-    }
+    if (has_dyn_rel)
+      if (!helper_use_relative_reloc(*rsym, pParent))
+        return X86Relocator::OK;
   }
 
    // perform static relocation
@@ -931,11 +960,18 @@
 // R_386_GOT32: GOT(S) + A - GOT_ORG
 X86Relocator::Result got32(Relocation& pReloc, X86_32Relocator& pParent)
 {
-  if (!(pReloc.symInfo()->reserved()
-       & (X86Relocator::ReserveGOT | X86Relocator::GOTRel))) {
+  ResolveInfo* rsym = pReloc.symInfo();
+  if (!(rsym->reserved() & (X86Relocator::ReserveGOT)))
     return X86Relocator::BadReloc;
-  }
-  X86Relocator::Address GOT_S   = helper_GOT(pReloc, pParent);
+
+  // set up got entry value if the got has no dyn rel or
+  // the dyn rel is RELATIVE
+  X86_32GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
+  assert(NULL != got_entry);
+  if (got_entry->getValue() == X86Relocator::SymVal)
+    got_entry->setValue(pReloc.symValue());
+
+  X86Relocator::Address GOT_S   = helper_get_GOT_address(pReloc, pParent);
   Relocator::DWord      A       = pReloc.target() + pReloc.addend();
   X86Relocator::Address GOT_ORG = helper_GOT_ORG(pParent);
   // Apply relocation.
@@ -949,7 +985,7 @@
   // PLT_S depends on if there is a PLT entry.
   X86Relocator::Address PLT_S;
   if ((pReloc.symInfo()->reserved() & X86Relocator::ReservePLT))
-    PLT_S = helper_PLT(pReloc, pParent);
+    PLT_S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
   else
     PLT_S = pReloc.symValue();
   Relocator::DWord      A = pReloc.target() + pReloc.addend();
@@ -964,50 +1000,19 @@
   // global-dynamic
   ResolveInfo* rsym = pReloc.symInfo();
   // must reserve two pairs of got and dynamic relocation
-  if (!(rsym->reserved() & X86Relocator::GOTRel)) {
-     return X86Relocator::BadReloc;
-  }
+  if (!(rsym->reserved() & X86Relocator::ReserveGOT))
+    return X86Relocator::BadReloc;
 
-  X86_32GNULDBackend& ld_backend = pParent.getTarget();
   ELFFileFormat* file_format = pParent.getTarget().getOutputFormat();
   // setup corresponding got and dynamic relocatio entries:
   // get first got entry, if there is already a got entry for rsym, then apply
   // this relocation to the got entry directly. If not, setup the corresponding
   // got and dyn relocation entries
-  X86_32GOTEntry* got_entry1 = pParent.getSymGOTMap().lookUp(*rsym);
+  X86_32GOTEntry* got_entry1 = pParent.getSymGOTMap().lookUpFirstEntry(*rsym);
 
-  if (NULL == got_entry1) {
-    // get and init two got entries if not exist
-    got_entry1 = ld_backend.getGOT().consume();
-    pParent.getSymGOTMap().record(*rsym, *got_entry1);
-    X86_32GOTEntry* got_entry2 = ld_backend.getGOT().consume();
-    got_entry1->setValue(0x0);
-    got_entry2->setValue(0x0);
-    // setup dyn rel for get_entry1
-    Relocation& rel_entry1 = helper_DynRel(rsym, *got_entry1, 0x0,
-                                        llvm::ELF::R_386_TLS_DTPMOD32, pParent);
-    if (rsym->isLocal()) {
-      // for local symbol, set got_entry2 to symbol value
-      got_entry2->setValue(pReloc.symValue());
-
-      // for local tls symbol, add rel entry against the section symbol this
-      // symbol belong to (.tdata or .tbss)
-      const LDSection* sym_sect =
-         &rsym->outSymbol()->fragRef()->frag()->getParent()->getSection();
-      ResolveInfo* sect_sym = NULL;
-      if (&file_format->getTData() == sym_sect)
-        sect_sym = pParent.getTarget().getTDATASymbol().resolveInfo();
-      else
-        sect_sym = pParent.getTarget().getTBSSSymbol().resolveInfo();
-      rel_entry1.setSymInfo(sect_sym);
-    }
-    else {
-      // for non-local symbol, add a pair of rel entries against this symbol
-      // for those two got entries
-      helper_DynRel(rsym, *got_entry2, 0x0,
-                                        llvm::ELF::R_386_TLS_DTPOFF32, pParent);
-    }
-  }
+  // set the got_entry2 value to symbol value
+  if (rsym->isLocal())
+     pParent.getSymGOTMap().lookUpSecondEntry(*rsym)->setValue(pReloc.symValue());
 
   // perform relocation to the first got entry
   Relocator::DWord A = pReloc.target() + pReloc.addend();
@@ -1051,31 +1056,13 @@
 X86Relocator::Result tls_ie(Relocation& pReloc, X86_32Relocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  if (!(rsym->reserved() & X86Relocator::GOTRel)) {
+  if (!(rsym->reserved() & X86Relocator::ReserveGOT)) {
      return X86Relocator::BadReloc;
   }
 
-  if (rsym->reserved() & X86Relocator::ReserveRel) {
-    // when building shared object, set up a RELATIVE dynamic relocation
-    helper_DynRel(rsym, *pReloc.targetRef().frag(), pReloc.targetRef().offset(),
-                                            llvm::ELF::R_386_RELATIVE, pParent);
-  }
-
   // set up the got and dynamic relocation entries if not exist
   X86_32GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
-  if (NULL == got_entry) {
-    // set got entry
-    X86_32GNULDBackend& ld_backend = pParent.getTarget();
-    got_entry = ld_backend.getGOT().consume();
-    pParent.getSymGOTMap().record(*rsym, *got_entry);
-    got_entry->setValue(0x0);
-    // set relocation entry
-    Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
-    rel_entry.setType(llvm::ELF::R_386_TLS_TPOFF);
-    rel_entry.setSymInfo(rsym);
-    rel_entry.targetRef().assign(*got_entry);
-  }
-
+  assert(NULL != got_entry);
   // perform relocation to the absolute address of got_entry
   X86Relocator::Address GOT_S =
                  pParent.getTarget().getGOT().addr() + got_entry->getOffset();
@@ -1090,24 +1077,13 @@
 X86Relocator::Result tls_gotie(Relocation& pReloc, X86_32Relocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  if (!(rsym->reserved() & X86Relocator::GOTRel)) {
+  if (!(rsym->reserved() & X86Relocator::ReserveGOT)) {
      return X86Relocator::BadReloc;
   }
 
   // set up the got and dynamic relocation entries if not exist
   X86_32GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
-  if (NULL == got_entry) {
-    // set got entry
-    X86_32GNULDBackend& ld_backend = pParent.getTarget();
-    got_entry = ld_backend.getGOT().consume();
-    pParent.getSymGOTMap().record(*rsym, *got_entry);
-    got_entry->setValue(0x0);
-    // set relocation entry
-    Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
-    rel_entry.setType(llvm::ELF::R_386_TLS_TPOFF);
-    rel_entry.setSymInfo(rsym);
-    rel_entry.targetRef().assign(*got_entry);
-  }
+  assert(NULL != got_entry);
 
   // All GOT offsets are relative to the end of the GOT.
   X86Relocator::SWord GOT_S = got_entry->getOffset() -
@@ -1121,23 +1097,19 @@
 // R_X86_TLS_LE
 X86Relocator::Result tls_le(Relocation& pReloc, X86_32Relocator& pParent)
 {
-  ResolveInfo* rsym = pReloc.symInfo();
-  if (pReloc.symInfo()->reserved() & X86Relocator::ReserveRel) {
-    helper_DynRel(rsym,
-                  *pReloc.targetRef().frag(),
-                  pReloc.targetRef().offset(),
-                  llvm::ELF::R_386_TLS_TPOFF,
-                  pParent);
+  if (pReloc.symInfo()->reserved() & X86Relocator::ReserveRel)
     return X86Relocator::OK;
-  }
 
   // perform static relocation
   // get TLS segment
-  ELFSegment* tls_seg = pParent.getTarget().elfSegmentTable().find(
-                                       llvm::ELF::PT_TLS, llvm::ELF::PF_R, 0x0);
+  ELFSegmentFactory::const_iterator tls_seg =
+    pParent.getTarget().elfSegmentTable().find(llvm::ELF::PT_TLS,
+                                               llvm::ELF::PF_R,
+                                               0x0);
+  assert(tls_seg != pParent.getTarget().elfSegmentTable().end());
   Relocator::DWord A = pReloc.target() + pReloc.addend();
   X86Relocator::Address S = pReloc.symValue();
-  pReloc.target() = S + A - tls_seg->memsz();
+  pReloc.target() = S + A - (*tls_seg)->memsz();
   return X86Relocator::OK;
 }
 
@@ -1147,7 +1119,130 @@
 }
 
 //===--------------------------------------------------------------------===//
-// Relocation Functions and Tables
+// X86_64 Relocation helper function
+//===--------------------------------------------------------------------===//
+/// helper_DynRel - Get an relocation entry in .rela.dyn
+static
+Relocation& helper_DynRel_init(ResolveInfo* pSym,
+                               Fragment& pFrag,
+                               uint64_t pOffset,
+                               X86Relocator::Type pType,
+                               X86_64Relocator& pParent)
+{
+  X86_64GNULDBackend& ld_backend = pParent.getTarget();
+  Relocation& rel_entry = *ld_backend.getRelDyn().create();
+  rel_entry.setType(pType);
+  rel_entry.targetRef().assign(pFrag, pOffset);
+  if (pType == llvm::ELF::R_X86_64_RELATIVE || NULL == pSym)
+    rel_entry.setSymInfo(NULL);
+  else
+    rel_entry.setSymInfo(pSym);
+
+  return rel_entry;
+}
+
+
+/// helper_use_relative_reloc - Check if symbol can use relocation
+/// R_X86_64_RELATIVE
+static bool
+helper_use_relative_reloc(const ResolveInfo& pSym,
+                          const X86_64Relocator& pFactory)
+
+{
+  // if symbol is dynamic or undefine or preemptible
+  if (pSym.isDyn() ||
+      pSym.isUndef() ||
+      pFactory.getTarget().isSymbolPreemptible(pSym))
+    return false;
+  return true;
+}
+
+static
+X86_64GOTEntry& helper_GOT_init(Relocation& pReloc,
+                                bool pHasRel,
+                                X86_64Relocator& pParent)
+{
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.symInfo();
+  X86_64GNULDBackend& ld_backend = pParent.getTarget();
+  assert(NULL == pParent.getSymGOTMap().lookUp(*rsym));
+
+  X86_64GOTEntry* got_entry = ld_backend.getGOT().create();
+  pParent.getSymGOTMap().record(*rsym, *got_entry);
+
+  // If we first get this GOT entry, we should initialize it.
+  if (!pHasRel) {
+    // No corresponding dynamic relocation, initialize to the symbol value.
+    got_entry->setValue(X86Relocator::SymVal);
+  }
+  else {
+    // Initialize got_entry content and the corresponding dynamic relocation.
+    if (helper_use_relative_reloc(*rsym, pParent)) {
+       Relocation& rel_entry = helper_DynRel_init(rsym, *got_entry, 0x0,
+                                         llvm::ELF::R_X86_64_RELATIVE, pParent);
+       rel_entry.setAddend(X86Relocator::SymVal);
+       pParent.getRelRelMap().record(pReloc, rel_entry);
+    }
+    else {
+       helper_DynRel_init(rsym, *got_entry, 0x0, llvm::ELF::R_X86_64_GLOB_DAT,
+                                                                       pParent);
+    }
+    got_entry->setValue(0);
+  }
+  return *got_entry;
+}
+
+static
+X86Relocator::Address helper_GOT_ORG(X86_64Relocator& pParent)
+{
+  return pParent.getTarget().getGOT().addr();
+}
+
+static
+X86Relocator::Address helper_get_GOT_address(Relocation& pReloc,
+                                             X86_64Relocator& pParent)
+{
+  X86_64GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
+  assert(NULL != got_entry);
+  return got_entry->getOffset();
+}
+
+static
+X86Relocator::Address helper_get_PLT_address(ResolveInfo& pSym,
+                                             X86_64Relocator& pParent)
+{
+  PLTEntryBase* plt_entry = pParent.getSymPLTMap().lookUp(pSym);
+  assert(NULL != plt_entry);
+  return pParent.getTarget().getPLT().addr() + plt_entry->getOffset();
+}
+
+static
+PLTEntryBase& helper_PLT_init(Relocation& pReloc, X86_64Relocator& pParent)
+{
+  // rsym - The relocation target symbol
+  ResolveInfo* rsym = pReloc.symInfo();
+  X86_64GNULDBackend& ld_backend = pParent.getTarget();
+  assert(NULL == pParent.getSymPLTMap().lookUp(*rsym));
+
+  PLTEntryBase* plt_entry = ld_backend.getPLT().create();
+  pParent.getSymPLTMap().record(*rsym, *plt_entry);
+
+  // initialize plt and the corresponding gotplt and dyn rel entry.
+  assert(NULL == pParent.getSymGOTPLTMap().lookUp(*rsym) &&
+         "PLT entry not exist, but DynRel entry exist!");
+  X86_64GOTEntry* gotplt_entry = ld_backend.getGOTPLT().create();
+  pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
+
+  // init the corresponding rel entry in .rel.plt
+  Relocation& rel_entry = *ld_backend.getRelPLT().create();
+  rel_entry.setType(llvm::ELF::R_X86_64_JUMP_SLOT);
+  rel_entry.targetRef().assign(*gotplt_entry);
+  rel_entry.setSymInfo(rsym);
+  return *plt_entry;
+}
+
+//===--------------------------------------------------------------------===//
+// X86_64 Relocation Functions and Tables
 //===--------------------------------------------------------------------===//
 DECL_X86_64_APPLY_RELOC_FUNCS
 
@@ -1210,6 +1305,22 @@
 
   switch(pReloc.type()){
     case llvm::ELF::R_X86_64_64:
+      // If buiding PIC object (shared library or PIC executable),
+      // a dynamic relocations with RELATIVE type to this location is needed.
+      // Reserve an entry in .rela.dyn
+      if (config().isCodeIndep()) {
+        Relocation& reloc = helper_DynRel_init(rsym,
+                                               *pReloc.targetRef().frag(),
+                                               pReloc.targetRef().offset(),
+                                               llvm::ELF::R_X86_64_RELATIVE,
+                                               *this);
+        getRelRelMap().record(pReloc, reloc);
+        // set Rel bit
+        rsym->setReserved(rsym->reserved() | ReserveRel);
+        getTarget().checkAndSetHasTextRel(*pSection.getLink());
+      }
+      return;
+
     case llvm::ELF::R_X86_64_32:
     case llvm::ELF::R_X86_64_16:
     case llvm::ELF::R_X86_64_8:
@@ -1218,7 +1329,12 @@
       // a dynamic relocations with RELATIVE type to this location is needed.
       // Reserve an entry in .rela.dyn
       if (config().isCodeIndep()) {
-        getTarget().getRelDyn().reserveEntry();
+        Relocation& reloc = helper_DynRel_init(rsym,
+                                               *pReloc.targetRef().frag(),
+                                               pReloc.targetRef().offset(),
+                                               pReloc.type(),
+                                               *this);
+        getRelRelMap().record(pReloc, reloc);
         // set Rel bit
         rsym->setReserved(rsym->reserved() | ReserveRel);
         getTarget().checkAndSetHasTextRel(*pSection.getLink());
@@ -1233,27 +1349,17 @@
     case llvm::ELF::R_X86_64_GOTPCREL:
       // Symbol needs GOT entry, reserve entry in .got
       // return if we already create GOT for this symbol
-      if (rsym->reserved() & (ReserveGOT | GOTRel))
+      if (rsym->reserved() & ReserveGOT)
         return;
-      getTarget().getGOT().reserve();
 
-      // If the GOT is used in statically linked binaries,
-      // the GOT entry is enough and no relocation is needed.
-      if (config().isCodeStatic()) {
-        rsym->setReserved(rsym->reserved() | ReserveGOT);
-        return;
-      }
       // If building shared object or the symbol is undefined, a dynamic
       // relocation is needed to relocate this GOT entry. Reserve an
       // entry in .rela.dyn
       if (LinkerConfig::DynObj ==
-                   config().codeGenType() || rsym->isUndef() || rsym->isDyn()) {
-        getTarget().getRelDyn().reserveEntry();
-        // set GOTRel bit
-        rsym->setReserved(rsym->reserved() | GOTRel);
-        return;
-      }
-      // set GOT bit
+                   config().codeGenType() || rsym->isUndef() || rsym->isDyn())
+        helper_GOT_init(pReloc, true, *this);
+      else
+        helper_GOT_init(pReloc, false, *this);
       rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
 
@@ -1285,26 +1391,41 @@
         if (!(rsym->reserved() & ReservePLT)){
           // Symbol needs PLT entry, we need to reserve a PLT entry
           // and the corresponding GOT and dynamic relocation entry
-          // in .got and .rela.plt. (GOT entry will be reserved simultaneously
-          // when calling X86PLT->reserveEntry())
-          getTarget().getPLT().reserveEntry();
-          getTarget().getGOTPLT().reserve();
-          getTarget().getRelPLT().reserveEntry();
+          // in .got and .rela.plt.
+          helper_PLT_init(pReloc, *this);
           // set PLT bit
           rsym->setReserved(rsym->reserved() | ReservePLT);
         }
       }
 
-      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT), true)) {
-        // symbol needs dynamic relocation entry, reserve an entry in .rela.dyn
-        getTarget().getRelDyn().reserveEntry();
+      if (getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT),
+                                                                        true)) {
+        // symbol needs dynamic relocation entry, set up the dynrel entry
         if (getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
           LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym, getTarget());
           addCopyReloc(*cpy_sym.resolveInfo(), getTarget());
         }
         else {
-          // set Rel bit
+          // set Rel bit and the dyn rel
           rsym->setReserved(rsym->reserved() | ReserveRel);
+          getTarget().checkAndSetHasTextRel(*pSection.getLink());
+          if (llvm::ELF::R_386_32 == pReloc.type() &&
+              helper_use_relative_reloc(*rsym, *this)) {
+            Relocation& reloc = helper_DynRel_init(rsym,
+                                                   *pReloc.targetRef().frag(),
+                                                   pReloc.targetRef().offset(),
+                                                   llvm::ELF::R_X86_64_RELATIVE,
+                                                   *this);
+            getRelRelMap().record(pReloc, reloc);
+          }
+          else {
+            Relocation& reloc = helper_DynRel_init(rsym,
+                                                   *pReloc.targetRef().frag(),
+                                                   pReloc.targetRef().offset(),
+                                                   pReloc.type(),
+                                                   *this);
+            getRelRelMap().record(pReloc, reloc);
+          }
 	        getTarget().checkAndSetHasTextRel(*pSection.getLink());
         }
       }
@@ -1313,26 +1434,17 @@
     case llvm::ELF::R_X86_64_GOTPCREL:
       // Symbol needs GOT entry, reserve entry in .got
       // return if we already create GOT for this symbol
-      if (rsym->reserved() & (ReserveGOT | GOTRel))
+      if (rsym->reserved() & ReserveGOT)
         return;
-      getTarget().getGOT().reserve();
 
-      // If the GOT is used in statically linked binaries,
-      // the GOT entry is enough and no relocation is needed.
-      if (config().isCodeStatic()) {
-        rsym->setReserved(rsym->reserved() | ReserveGOT);
-        return;
-      }
       // If building shared object or the symbol is undefined, a dynamic
       // relocation is needed to relocate this GOT entry. Reserve an
       // entry in .rela.dyn
       if (LinkerConfig::DynObj ==
-                   config().codeGenType() || rsym->isUndef() || rsym->isDyn()) {
-        getTarget().getRelDyn().reserveEntry();
-        // set GOTRel bit
-        rsym->setReserved(rsym->reserved() | GOTRel);
-        return;
-      }
+                   config().codeGenType() || rsym->isUndef() || rsym->isDyn())
+        helper_GOT_init(pReloc, true, *this);
+      else
+        helper_GOT_init(pReloc, false, *this);
       // set GOT bit
       rsym->setReserved(rsym->reserved() | ReserveGOT);
       return;
@@ -1355,13 +1467,10 @@
         return;
       }
 
-      // Symbol needs PLT entry, we need to reserve a PLT entry
+      // Symbol needs PLT entry, we need a PLT entry
       // and the corresponding GOT and dynamic relocation entry
-      // in .got and .rel.plt. (GOT entry will be reserved simultaneously
-      // when calling X86PLT->reserveEntry())
-      getTarget().getPLT().reserveEntry();
-      getTarget().getGOTPLT().reserve();
-      getTarget().getRelPLT().reserveEntry();
+      // in .got and .rel.plt.
+      helper_PLT_init(pReloc, *this);
       // set PLT bit
       rsym->setReserved(rsym->reserved() | ReservePLT);
       return;
@@ -1373,13 +1482,10 @@
           LinkerConfig::DynObj != config().codeGenType()) {
         // create plt for this symbol if it does not have one
         if (!(rsym->reserved() & ReservePLT)){
-          // Symbol needs PLT entry, we need to reserve a PLT entry
+          // Symbol needs PLT entry, we need a PLT entry
           // and the corresponding GOT and dynamic relocation entry
-          // in .got and .rel.plt. (GOT entry will be reserved simultaneously
-          // when calling X86PLT->reserveEntry())
-          getTarget().getPLT().reserveEntry();
-          getTarget().getGOTPLT().reserve();
-          getTarget().getRelPLT().reserveEntry();
+          // in .got and .rel.plt.
+          helper_PLT_init(pReloc, *this);
           // set PLT bit
           rsym->setReserved(rsym->reserved() | ReservePLT);
         }
@@ -1391,11 +1497,12 @@
       // All other dynamic relocations may lead to run-time relocation
       // overflow.
       if (getTarget().isDynamicSymbol(*rsym) &&
-	  getTarget().symbolNeedsDynRel(*rsym, (rsym->reserved() & ReservePLT), false) &&
-	  getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
-        getTarget().getRelDyn().reserveEntry();
-   	LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym, getTarget());
-	  addCopyReloc(*cpy_sym.resolveInfo(), getTarget());
+	        getTarget().symbolNeedsDynRel(*rsym,
+                                        (rsym->reserved() & ReservePLT),
+                                        false) &&
+	        getTarget().symbolNeedsCopyReloc(pReloc, *rsym)) {
+   	    LDSymbol& cpy_sym = defineSymbolforCopyReloc(pBuilder, *rsym, getTarget());
+	      addCopyReloc(*cpy_sym.resolveInfo(), getTarget());
       }
       return;
 
@@ -1406,147 +1513,9 @@
   } // end switch
 }
 
-//===--------------------------------------------------------------------===//
-// Relocation helper function
-//===--------------------------------------------------------------------===//
-/// helper_DynRel - Get an relocation entry in .rela.dyn
-static
-Relocation& helper_DynRel(ResolveInfo* pSym,
-                          Fragment& pFrag,
-                          uint64_t pOffset,
-                          X86Relocator::Type pType,
-                          X86_64Relocator& pParent)
-{
-  X86_64GNULDBackend& ld_backend = pParent.getTarget();
-  Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
-  rel_entry.setType(pType);
-  rel_entry.targetRef().assign(pFrag, pOffset);
-  if (pType == llvm::ELF::R_X86_64_RELATIVE || NULL == pSym)
-    rel_entry.setSymInfo(0);
-  else
-    rel_entry.setSymInfo(pSym);
-
-  return rel_entry;
-}
-
-
-/// helper_use_relative_reloc - Check if symbol can use relocation
-/// R_X86_64_RELATIVE
-static bool
-helper_use_relative_reloc(const ResolveInfo& pSym,
-                          const X86_64Relocator& pFactory)
-
-{
-  // if symbol is dynamic or undefine or preemptible
-  if (pSym.isDyn() ||
-      pSym.isUndef() ||
-      pFactory.getTarget().isSymbolPreemptible(pSym))
-    return false;
-  return true;
-}
-
-static
-X86_64GOTEntry& helper_get_GOT_and_init(Relocation& pReloc,
-					X86_64Relocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  X86_64GNULDBackend& ld_backend = pParent.getTarget();
-
-  X86_64GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
-  if (NULL != got_entry)
-    return *got_entry;
-
-  // not found
-  got_entry = ld_backend.getGOT().consume();
-  pParent.getSymGOTMap().record(*rsym, *got_entry);
-
-  // If we first get this GOT entry, we should initialize it.
-  if (rsym->reserved() & X86Relocator::ReserveGOT) {
-    // No corresponding dynamic relocation, initialize to the symbol value.
-    got_entry->setValue(pReloc.symValue());
-  }
-  else if (rsym->reserved() & X86Relocator::GOTRel) {
-    // Initialize got_entry content and the corresponding dynamic relocation.
-    if (helper_use_relative_reloc(*rsym, pParent)) {
-      Relocation& rel_entry = helper_DynRel(rsym, *got_entry, 0x0,
-					    llvm::ELF::R_X86_64_RELATIVE,
-					    pParent);
-      rel_entry.setAddend(pReloc.symValue());
-    }
-    else {
-      helper_DynRel(rsym, *got_entry, 0x0, llvm::ELF::R_X86_64_GLOB_DAT,
-		    pParent);
-    }
-    got_entry->setValue(0);
-  }
-  else {
-    fatal(diag::reserve_entry_number_mismatch_got);
-  }
-  return *got_entry;
-}
-
-static
-X86Relocator::Address helper_GOT_ORG(X86_64Relocator& pParent)
-{
-  return pParent.getTarget().getGOT().addr();
-}
-
-static
-X86Relocator::Address helper_GOT(Relocation& pReloc, X86_64Relocator& pParent)
-{
-  X86_64GOTEntry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
-  return got_entry.getOffset();
-}
-
-static
-PLTEntryBase& helper_get_PLT_and_init(Relocation& pReloc,
-				      X86_64Relocator& pParent)
-{
-  // rsym - The relocation target symbol
-  ResolveInfo* rsym = pReloc.symInfo();
-  X86_64GNULDBackend& ld_backend = pParent.getTarget();
-
-  PLTEntryBase* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
-  if (NULL != plt_entry)
-    return *plt_entry;
-
-  // not found
-  plt_entry = ld_backend.getPLT().consume();
-  pParent.getSymPLTMap().record(*rsym, *plt_entry);
-  // If we first get this PLT entry, we should initialize it.
-  if (rsym->reserved() & X86Relocator::ReservePLT) {
-    X86_64GOTEntry* gotplt_entry = pParent.getSymGOTPLTMap().lookUp(*rsym);
-    assert(NULL == gotplt_entry && "PLT entry not exist, but DynRel entry exist!");
-    gotplt_entry = ld_backend.getGOTPLT().consume();
-    pParent.getSymGOTPLTMap().record(*rsym, *gotplt_entry);
-    // init the corresponding rel entry in .rel.plt
-    Relocation& rel_entry = *ld_backend.getRelPLT().consumeEntry();
-    rel_entry.setType(llvm::ELF::R_X86_64_JUMP_SLOT);
-    rel_entry.targetRef().assign(*gotplt_entry);
-    rel_entry.setSymInfo(rsym);
-  }
-  else {
-    fatal(diag::reserve_entry_number_mismatch_plt);
-  }
-
-  return *plt_entry;
-}
-
-static
-X86Relocator::Address helper_PLT_ORG(X86_64Relocator& pParent)
-{
-  return pParent.getTarget().getPLT().addr();
-}
-
-static
-X86Relocator::Address helper_PLT(Relocation& pReloc, X86_64Relocator& pParent)
-{
-  PLTEntryBase& plt_entry = helper_get_PLT_and_init(pReloc, pParent);
-  return helper_PLT_ORG(pParent) + plt_entry.getOffset();
-}
-
+// ===
 //
+// ===
 // R_X86_64_NONE
 X86Relocator::Result none(Relocation& pReloc, X86_64Relocator& pParent)
 {
@@ -1562,15 +1531,10 @@
   ResolveInfo* rsym = pReloc.symInfo();
   Relocator::DWord A = pReloc.target() + pReloc.addend();
   Relocator::DWord S = pReloc.symValue();
-  bool has_dyn_rel = pParent.getTarget().symbolNeedsDynRel(
-                              *rsym,
-                              (rsym->reserved() & X86Relocator::ReservePLT),
-                              true);
+  Relocation* dyn_rel = pParent.getRelRelMap().lookUp(pReloc);
+  bool has_dyn_rel = (NULL != dyn_rel);
 
-  FragmentRef &target_fragref = pReloc.targetRef();
-  Fragment *target_frag = target_fragref.frag();
-
-  LDSection& target_sect = target_frag->getParent()->getSection();
+  LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
   // If the flag of target section is not ALLOC, we will not scan this relocation
   // but perform static relocation. (e.g., applying .debug section)
   if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
@@ -1580,19 +1544,14 @@
 
   // A local symbol may need RELA Type dynamic relocation
   if (rsym->isLocal() && has_dyn_rel) {
-    X86Relocator::Type pType = pReloc.type();
-    if (llvm::ELF::R_X86_64_64 == pType)
-      pType = llvm::ELF::R_X86_64_RELATIVE;
-    Relocation& rel_entry = helper_DynRel(rsym, *target_frag,
-        target_fragref.offset(), pType, pParent);
-    rel_entry.setAddend(S + A);
+    dyn_rel->setAddend(S + A);
     return X86Relocator::OK;
   }
 
   // An external symbol may need PLT and dynamic relocation
   if (!rsym->isLocal()) {
     if (rsym->reserved() & X86Relocator::ReservePLT) {
-      S = helper_PLT(pReloc, pParent);
+      S = helper_get_PLT_address(*rsym, pParent);
     }
     // If we generate a dynamic relocation (except R_X86_64_RELATIVE)
     // for a place, we should not perform static relocation on it
@@ -1600,14 +1559,10 @@
     if (has_dyn_rel) {
       if (llvm::ELF::R_X86_64_64 == pReloc.type() &&
           helper_use_relative_reloc(*rsym, pParent)) {
-        Relocation& rel_entry = helper_DynRel(rsym, *target_frag,
-            target_fragref.offset(), llvm::ELF::R_X86_64_RELATIVE, pParent);
-        rel_entry.setAddend(S + A);
+        dyn_rel->setAddend(S + A);
       }
       else {
-        Relocation& rel_entry = helper_DynRel(rsym, *target_frag,
-            target_fragref.offset(), pReloc.type(), pParent);
-        rel_entry.setAddend(A);
+        dyn_rel->setAddend(A);
         return X86Relocator::OK;
       }
     }
@@ -1624,13 +1579,9 @@
   ResolveInfo* rsym = pReloc.symInfo();
   Relocator::DWord A = pReloc.target() + pReloc.addend();
   Relocator::DWord S = pReloc.symValue();
-  bool has_dyn_rel = pParent.getTarget().symbolNeedsDynRel(
-                              *rsym,
-                              (rsym->reserved() & X86Relocator::ReservePLT),
-                              true);
 
   // There should be no dynamic relocations for R_X86_64_32S.
-  if (has_dyn_rel)
+  if (NULL != pParent.getRelRelMap().lookUp(pReloc))
     return X86Relocator::BadReloc;
 
   LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
@@ -1639,7 +1590,7 @@
   // An external symbol may need PLT and dynamic relocation
   if (0x0 != (llvm::ELF::SHF_ALLOC & target_sect.flag()) &&
       !rsym->isLocal() && rsym->reserved() & X86Relocator::ReservePLT)
-    S = helper_PLT(pReloc, pParent);
+    S = helper_get_PLT_address(*rsym, pParent);
 
 #if notyet
   // Check 32-bit signed overflow.
@@ -1656,11 +1607,22 @@
 // R_X86_64_GOTPCREL: GOT(S) + GOT_ORG + A - P
 X86Relocator::Result gotpcrel(Relocation& pReloc, X86_64Relocator& pParent)
 {
-  if (!(pReloc.symInfo()->reserved()
-       & (X86Relocator::ReserveGOT | X86Relocator::GOTRel))) {
+  if (!(pReloc.symInfo()->reserved() & X86Relocator::ReserveGOT)) {
     return X86Relocator::BadReloc;
   }
-  X86Relocator::Address GOT_S   = helper_GOT(pReloc, pParent);
+
+  // set symbol value of the got entry if needed
+  X86_64GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*pReloc.symInfo());
+  if (X86Relocator::SymVal == got_entry->getValue())
+    got_entry->setValue(pReloc.symValue());
+
+  // setup relocation addend if needed
+  Relocation* dyn_rel = pParent.getRelRelMap().lookUp(pReloc);
+  if ((NULL != dyn_rel) && (X86Relocator::SymVal == dyn_rel->addend())) {
+    dyn_rel->setAddend(pReloc.symValue());
+  }
+
+  X86Relocator::Address GOT_S   = helper_get_GOT_address(pReloc, pParent);
   Relocator::DWord      A       = pReloc.target() + pReloc.addend();
   X86Relocator::Address GOT_ORG = helper_GOT_ORG(pParent);
   // Apply relocation.
@@ -1674,7 +1636,7 @@
   // PLT_S depends on if there is a PLT entry.
   X86Relocator::Address PLT_S;
   if ((pReloc.symInfo()->reserved() & X86Relocator::ReservePLT))
-    PLT_S = helper_PLT(pReloc, pParent);
+    PLT_S = helper_get_PLT_address(*pReloc.symInfo(), pParent);
   else
     PLT_S = pReloc.symValue();
   Relocator::DWord      A = pReloc.target() + pReloc.addend();
@@ -1701,17 +1663,22 @@
     return X86Relocator::OK;
   }
 
+  // setup relocation addend if needed
+  Relocation* dyn_rel = pParent.getRelRelMap().lookUp(pReloc);
+  if ((NULL != dyn_rel) && (X86Relocator::SymVal == dyn_rel->addend())) {
+    dyn_rel->setAddend(S);
+  }
+
   // An external symbol may need PLT and dynamic relocation
   if (!rsym->isLocal()) {
     if (rsym->reserved() & X86Relocator::ReservePLT) {
-       S = helper_PLT(pReloc, pParent);
-       pReloc.target() = S + A - P;
+       S = helper_get_PLT_address(*rsym, pParent);
     }
     if (pParent.getTarget().symbolNeedsDynRel(
                               *rsym,
                               (rsym->reserved() & X86Relocator::ReservePLT),
                               false)) {
-          return X86Relocator::Overflow;
+      return X86Relocator::Overflow;
     }
   }
 
diff --git a/lib/Target/X86/X86Relocator.h b/lib/Target/X86/X86Relocator.h
index d6e97ed..da67464 100644
--- a/lib/Target/X86/X86Relocator.h
+++ b/lib/Target/X86/X86Relocator.h
@@ -15,7 +15,7 @@
 #include <mcld/LD/Relocator.h>
 #include <mcld/Target/GOT.h>
 #include <mcld/Target/PLT.h>
-#include <mcld/Target/SymbolEntryMap.h>
+#include <mcld/Target/KeyEntryMap.h>
 #include "X86LDBackend.h"
 
 namespace mcld {
@@ -30,49 +30,41 @@
 class X86Relocator : public Relocator
 {
 public:
-  typedef SymbolEntryMap<PLTEntryBase> SymPLTMap;
+  typedef KeyEntryMap<ResolveInfo, PLTEntryBase> SymPLTMap;
 
   /** \enum ReservedEntryType
    *  \brief The reserved entry type of reserved space in ResolveInfo.
    *
    *  This is used for sacnRelocation to record what kinds of entries are
-   *  reserved for this resolved symbol
+   *  reserved for this resolved symbol. In X86, there are three kinds of
+   *  entries, GOT, PLT, and dynamic reloction.
    *
-   *  In X86, there are three kinds of entries, GOT, PLT, and dynamic reloction.
-   *  GOT may needs a corresponding relocation to relocate itself, so we
-   *  separate GOT to two situations: GOT and GOTRel. Besides, for the same
-   *  symbol, there might be two kinds of entries reserved for different location.
-   *  For example, reference to the same symbol, one may use GOT and the other may
-   *  use dynamic relocation.
-   *
-   *  bit:  3       2      1     0
-   *   | PLT | GOTRel | GOT | Rel |
+   *  bit:  3     2     1     0
+   *   |    | PLT | GOT | Rel |
    *
    *  value    Name         - Description
    *
    *  0000     None         - no reserved entry
    *  0001     ReserveRel   - reserve an dynamic relocation entry
    *  0010     ReserveGOT   - reserve an GOT entry
-   *  0011     GOTandRel    - For different relocation, we've reserved GOT and
-   *                          Rel for different location.
-   *  0100     GOTRel       - reserve an GOT entry and the corresponding Dyncamic
-   *                          relocation entry which relocate this GOT entry
-   *  0101     GOTRelandRel - For different relocation, we've reserved GOTRel
-   *                          and relocation entry for different location.
-   *  1000     ReservePLT   - reserve an PLT entry and the corresponding GOT,
-   *                          Dynamic relocation entries
-   *  1001     PLTandRel    - For different relocation, we've reserved PLT and
-   *                          Rel for different location.
+   *  0100     ReservePLT   - reserve an PLT entry and the corresponding GOT,
+   *
    */
   enum ReservedEntryType {
     None         = 0,
     ReserveRel   = 1,
     ReserveGOT   = 2,
-    GOTandRel    = 3,
-    GOTRel       = 4,
-    GOTRelandRel = 5,
-    ReservePLT   = 8,
-    PLTandRel    = 9
+    ReservePLT   = 4,
+  };
+
+  /** \enum EntryValue
+   *  \brief The value of the entries. The symbol value will be decided at after
+   *  layout, so we mark the entry during scanRelocation and fill up the actual
+   *  value when applying relocations.
+   */
+  enum EntryValue {
+    Default = 0,
+    SymVal  = 1
   };
 
 public:
@@ -95,7 +87,8 @@
   void scanRelocation(Relocation& pReloc,
                       IRBuilder& pBuilder,
                       Module& pModule,
-                      LDSection& pSection);
+                      LDSection& pSection,
+                      Input& pInput);
 
 protected:
   /// addCopyReloc - add a copy relocation into .rel.dyn for pSym
@@ -131,8 +124,8 @@
 class X86_32Relocator : public X86Relocator
 {
 public:
-  typedef SymbolEntryMap<X86_32GOTEntry> SymGOTMap;
-  typedef SymbolEntryMap<X86_32GOTEntry> SymGOTPLTMap;
+  typedef KeyEntryMap<ResolveInfo, X86_32GOTEntry> SymGOTMap;
+  typedef KeyEntryMap<ResolveInfo, X86_32GOTEntry> SymGOTPLTMap;
 
   enum {
     R_386_TLS_OPT = 44 // mcld internal relocation type
@@ -189,8 +182,9 @@
 class X86_64Relocator : public X86Relocator
 {
 public:
-  typedef SymbolEntryMap<X86_64GOTEntry> SymGOTMap;
-  typedef SymbolEntryMap<X86_64GOTEntry> SymGOTPLTMap;
+  typedef KeyEntryMap<ResolveInfo, X86_64GOTEntry> SymGOTMap;
+  typedef KeyEntryMap<ResolveInfo, X86_64GOTEntry> SymGOTPLTMap;
+  typedef KeyEntryMap<Relocation, Relocation> RelRelMap;
 
 public:
   X86_64Relocator(X86_64GNULDBackend& pParent, const LinkerConfig& pConfig);
@@ -213,6 +207,9 @@
   const SymGOTPLTMap& getSymGOTPLTMap() const { return m_SymGOTPLTMap; }
   SymGOTPLTMap&       getSymGOTPLTMap()       { return m_SymGOTPLTMap; }
 
+  const RelRelMap& getRelRelMap() const { return m_RelRelMap; }
+  RelRelMap&       getRelRelMap()       { return m_RelRelMap; }
+
 private:
   void scanLocalReloc(Relocation& pReloc,
                       IRBuilder& pBuilder,
@@ -228,6 +225,7 @@
   X86_64GNULDBackend& m_Target;
   SymGOTMap m_SymGOTMap;
   SymGOTPLTMap m_SymGOTPLTMap;
+  RelRelMap m_RelRelMap;
 };
 
 } // namespace of mcld
diff --git a/lib/Target/X86/X86TargetMachine.cpp b/lib/Target/X86/X86TargetMachine.cpp
index b419fd1..82fea93 100644
--- a/lib/Target/X86/X86TargetMachine.cpp
+++ b/lib/Target/X86/X86TargetMachine.cpp
@@ -9,7 +9,6 @@
 #include "X86TargetMachine.h"
 
 #include "X86.h"
-#include <mcld/Target/TargetMachine.h>
 #include <mcld/Support/TargetRegistry.h>
 
 extern "C" void MCLDInitializeX86LDTarget() {
@@ -18,13 +17,15 @@
   mcld::RegisterTargetMachine<mcld::X86TargetMachine> Y(mcld::TheX86_64Target);
 }
 
-mcld::X86TargetMachine::X86TargetMachine(llvm::TargetMachine& pPM,
-                                         const mcld::Target &pTarget,
-                                         const std::string& pTriple)
-  : mcld::MCLDTargetMachine(pPM, pTarget, pTriple) {
-}
+using namespace mcld;
 
-mcld::X86TargetMachine::~X86TargetMachine()
-{
+//===----------------------------------------------------------------------===//
+// X86TargetMachine
+//===----------------------------------------------------------------------===//
+X86TargetMachine::X86TargetMachine(llvm::TargetMachine& pPM,
+                                   const llvm::Target& pLLVMTarget,
+                                   const mcld::Target& pMCLDTarget,
+                                   const std::string& pTriple)
+  : MCLDTargetMachine(pPM, pLLVMTarget, pMCLDTarget, pTriple) {
 }
 
diff --git a/lib/Target/X86/X86TargetMachine.h b/lib/Target/X86/X86TargetMachine.h
index 9034741..b9d78e1 100644
--- a/lib/Target/X86/X86TargetMachine.h
+++ b/lib/Target/X86/X86TargetMachine.h
@@ -9,18 +9,17 @@
 #ifndef MCLD_X86_TARGET_MACHINE_H
 #define MCLD_X86_TARGET_MACHINE_H
 #include "X86.h"
-#include <mcld/Target/TargetMachine.h>
+#include <mcld/CodeGen/TargetMachine.h>
 
 namespace mcld {
 
 class X86TargetMachine : public MCLDTargetMachine
 {
 public:
-  X86TargetMachine(llvm::TargetMachine &pTM,
-                   const mcld::Target &pTarget,
-                   const std::string &pTriple);
-
-  virtual ~X86TargetMachine();
+  X86TargetMachine(llvm::TargetMachine& pTM,
+                   const llvm::Target& pLLVMTarget,
+                   const mcld::Target& pMCLDTarget,
+                   const std::string& pTriple);
 };
 
 } // namespace of mcld
diff --git a/templates/header.h b/templates/header.h
new file mode 100644
index 0000000..2b9acf7
--- /dev/null
+++ b/templates/header.h
@@ -0,0 +1,29 @@
+//===- header.h -----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_${CLASS_NAME}_H
+#define MCLD_${CLASS_NAME}_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+namespace mcld
+{
+
+/** \class ${class_name}
+ *  \brief ${brief}
+ */
+class ${class_name}
+{
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/templates/headerTest.h b/templates/headerTest.h
new file mode 100644
index 0000000..d36bda1
--- /dev/null
+++ b/templates/headerTest.h
@@ -0,0 +1,40 @@
+//===- headerTest.h -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_${CLASS_NAME}_TEST_H
+#define MCLD_${CLASS_NAME}_TEST_H
+
+#include <gtest.h>
+
+namespace mcld {
+
+class ${class_name};
+
+namespace test {
+
+class ${class_name}Test : public ::testing::Test
+{
+public:
+  // Constructor can do set-up work for all test here.
+  ${class_name}Test();
+
+  // Destructor can do clean-up work that doesn't throw exceptions here.
+  virtual ~${class_name}Test();
+
+  // SetUp() will be called immediately before each test.
+  virtual void SetUp();
+
+  // TearDown() will be called immediately after each test.
+  virtual void TearDown();
+};
+
+} // namespace of test
+} // namespace of mcld
+
+#endif
+
diff --git a/templates/impl.cpp b/templates/impl.cpp
new file mode 100644
index 0000000..fe468d8
--- /dev/null
+++ b/templates/impl.cpp
@@ -0,0 +1,16 @@
+//===- impl.cpp -----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/${deployment}/${class_name}.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// ${class_name}
+//===----------------------------------------------------------------------===//
+
diff --git a/templates/implTest.cpp b/templates/implTest.cpp
new file mode 100644
index 0000000..fbfdf05
--- /dev/null
+++ b/templates/implTest.cpp
@@ -0,0 +1,44 @@
+//===- implTest.cpp -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/${deployment}/${class_name}.h>
+#include "${class_name}Test.h"
+
+using namespace mcld;
+using namespace mcld::test;
+
+
+// Constructor can do set-up work for all test here.
+${class_name}Test::${class_name}Test()
+{
+}
+
+// Destructor can do clean-up work that doesn't throw exceptions here.
+${class_name}Test::~${class_name}Test()
+{
+}
+
+// SetUp() will be called immediately before each test.
+void ${class_name}Test::SetUp()
+{
+}
+
+// TearDown() will be called immediately after each test.
+void ${class_name}Test::TearDown()
+{
+}
+
+//===----------------------------------------------------------------------===//
+// Testcases
+//===----------------------------------------------------------------------===//
+/** 
+TEST_F( ${class_name}Test, name of  the testcase for ${class_name} ) {
+	Write you exercise here
+}
+**/
+
diff --git a/tools/mcld/include/alone/Config/Config.h.in b/tools/mcld/include/alone/Config/Config.h.in
deleted file mode 100644
index 6618b08..0000000
--- a/tools/mcld/include/alone/Config/Config.h.in
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef ALONE_CONFIG_CONFIG_H
-#define ALONE_CONFIG_CONFIG_H
-
-#if defined(TARGET_BUILD)
-  #define PROVIDE_@PROVIDE_ALONE_TARGET@_CODEGEN
-  #define DEFAULT_@DEFAULT_ALONE_TARGET@_CODEGEN
-#else
-  #define PROVIDE_ARM_CODEGEN
-  #define PROVIDE_X86_CODEGEN
-  #define PROVIDE_MIPS_CODEGEN
-  #define DEFAULT_@DEFAULT_ALONE_TARGET@_CODEGEN
-#endif
-
-#define DEFAULT_ARM_TRIPLE_STRING "armv7-none-linux-gnueabi"
-#define DEFAULT_X86_TRIPLE_STRING "i686-unknown-linux"
-#define DEFAULT_MIPS_TRIPLE_STRING "mipsel-none-linux-gnueabi"
-#define DEFAULT_X86_64_TRIPLE_STRING "x86_64-unknown-linux"
-
-#define DEFAULT_TARGET_TRIPLE_STRING DEFAULT_@DEFAULT_ALONE_TARGET@_TRIPLE_STRING
-
-#endif // ALONE_CONFIG_CONFIG_H
diff --git a/tools/mcld/include/alone/Linker.h b/tools/mcld/include/alone/Linker.h
deleted file mode 100644
index 987b36a..0000000
--- a/tools/mcld/include/alone/Linker.h
+++ /dev/null
@@ -1,94 +0,0 @@
-//===- Linker.h -----------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef ALONE_LINKER_H
-#define ALONE_LINKER_H
-
-#include <string>
-
-namespace mcld {
-
-class Module;
-class IRBuilder;
-class LinkerConfig;
-class Linker;
-class Input;
-class MemoryArea;
-
-namespace sys { namespace fs {
-
-class Path;
-
-} } // end namespace sys::fs
-
-} // end namespace mcld
-
-namespace alone {
-
-class LinkerConfig;
-
-class Linker {
-public:
-  enum ErrorCode {
-    kSuccess,
-    kDoubleConfig,
-    kDelegateLDInfo,
-    kFindNameSpec,
-    kOpenObjectFile,
-    kOpenMemory,
-    kNotConfig,
-    kNotSetUpOutput,
-    kOpenOutput,
-    kReadSections,
-    kReadSymbols,
-    kAddAdditionalSymbols,
-    kMaxErrorCode
-  };
-
-  static const char *GetErrorString(enum ErrorCode pErrCode);
-
-private:
-  const mcld::LinkerConfig *mLDConfig;
-  mcld::Module *mModule;
-  mcld::Linker *mLinker;
-  mcld::IRBuilder *mBuilder;
-  std::string mSOName;
-  std::string mOutputPath;
-  int mOutputHandler;
-
-public:
-  Linker();
-
-  Linker(const LinkerConfig& pConfig);
-
-  ~Linker();
-
-  enum ErrorCode config(const LinkerConfig& pConfig);
-
-  enum ErrorCode addNameSpec(const std::string &pNameSpec);
-
-  enum ErrorCode addObject(const std::string &pObjectPath);
-
-  enum ErrorCode addObject(void* pMemory, size_t pSize);
-
-  enum ErrorCode addCode(void* pMemory, size_t pSize);
-
-  enum ErrorCode setOutput(const std::string &pPath);
-
-  enum ErrorCode setOutput(int pFileHandler);
-
-  enum ErrorCode link();
-
-private:
-  enum ErrorCode extractFiles(const LinkerConfig& pConfig);
-};
-
-} // end namespace alone
-
-#endif // ALONE_LINKER_H
diff --git a/tools/mcld/include/alone/Support/Initialization.h b/tools/mcld/include/alone/Support/Initialization.h
deleted file mode 100644
index 9af994e..0000000
--- a/tools/mcld/include/alone/Support/Initialization.h
+++ /dev/null
@@ -1,23 +0,0 @@
-//===- Initialization.h ---------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef ALONE_SUPPORT_INITIALIZATION_H
-#define ALONE_SUPPORT_INITIALIZATION_H
-
-namespace alone {
-
-namespace init {
-
-void Initialize();
-
-} // end namespace init
-
-} // end namespace alone
-
-#endif // ALONE_SUPPORT_INITIALIZATION_H
diff --git a/tools/mcld/include/alone/Support/LinkerConfig.h b/tools/mcld/include/alone/Support/LinkerConfig.h
deleted file mode 100644
index 8f36ec5..0000000
--- a/tools/mcld/include/alone/Support/LinkerConfig.h
+++ /dev/null
@@ -1,123 +0,0 @@
-//===- Linker.h -----------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef ALONE_SUPPORT_LINKER_CONFIG_H
-#define ALONE_SUPPORT_LINKER_CONFIG_H
-
-#include <string>
-
-#include <mcld/LinkerConfig.h>
-#include <mcld/LinkerScript.h>
-#include <mcld/Support/TargetRegistry.h>
-#include <mcld/LD/DiagnosticLineInfo.h>
-#include <mcld/LD/DiagnosticPrinter.h>
-
-namespace alone {
-
-class LinkerConfig {
-private:
-  //===--------------------------------------------------------------------===//
-  // Available Configurations
-  //===--------------------------------------------------------------------===//
-  const std::string mTriple;
-  std::string mSOName;
-
-private:
-  //===--------------------------------------------------------------------===//
-  // These are generated by LinkerConfig during initialize().
-  //===--------------------------------------------------------------------===//
-  const mcld::Target *mTarget;
-  bool initializeTarget();
-
-  mcld::LinkerConfig *mLDConfig;
-  bool initializeLDInfo();
-
-  mcld::LinkerScript *mLDScript;
-  bool initializeLDScript();
-
-  mcld::DiagnosticLineInfo *mDiagLineInfo;
-  mcld::DiagnosticPrinter *mDiagPrinter;
-  bool initializeDiagnostic();
-
-public:
-  enum ZOptionEnum {
-    kCombReloc     = 1 << 0,  ///< [on] -z combreloc, [off] -z nocombreloc
-    kDefs          = 1 << 1,  ///< -z defs
-    kExecStack     = 1 << 2,  ///< [on] -z execstack, [off] -z noexecstack
-    kInitFirst     = 1 << 3,  ///< -z initfirst
-    kInterPose     = 1 << 4,  ///< -z interpose
-    kLoadFltr      = 1 << 5,  ///< -z loadfltr
-    kMulDefs       = 1 << 6,  ///< -z muldefs
-    kNoCopyReloc   = 1 << 7,  ///< -z nocopyreloc
-    kNoDefaultLib  = 1 << 8,  ///< -z nodefaultlib
-    kNoDelete      = 1 << 9,  ///< -z nodelete
-    kNoDLOpen      = 1 << 10, ///< -z nodlopen
-    kNoDump        = 1 << 11, ///< -z nodump
-    kRelro         = 1 << 12, ///< [on] -z relro, [off] -z norelro
-    kLazy          = 1 << 13, ///< [on] -z lazy, [off] -z now
-    kOrigin        = 1 << 14, ///< -z origin
-    kZOptionMask   = 0xFFFF
-  };
-
-public:
-  //===--------------------------------------------------------------------===//
-  // Getters
-  //===--------------------------------------------------------------------===//
-  inline const std::string &getTriple() const
-  { return mTriple; }
-
-  inline const mcld::Target *getTarget() const
-  { return mTarget; }
-
-  inline mcld::LinkerConfig* getLDConfig()
-  { return mLDConfig; }
-
-  inline const mcld::LinkerConfig* getLDConfig() const
-  { return mLDConfig; }
-
-  inline mcld::LinkerScript* getLDScript()
-  { return mLDScript; }
-
-  inline const mcld::LinkerScript* getLDScript() const
-  { return mLDScript; }
-
-  bool isShared() const;
-
-  inline std::string getSOName() const
-  { return mSOName; }
-
-  void setShared(bool pEnable = true);
-
-  void setBsymbolic(bool pEnable = true);
-
-  void setDefineCommon(bool pEnable = true);
-
-  void setSOName(const std::string &pSOName);
-
-  void setDyld(const std::string &pDyld);
-
-  void setSysRoot(const std::string &pSysRoot);
-
-  void setZOption(unsigned int pOptions);
-
-  void addWrap(const std::string &pWrapSymbol);
-
-  void addPortable(const std::string &pPortableSymbol);
-
-  void addSearchDir(const std::string &pDir);
-
-public:
-  LinkerConfig(const std::string& pTriple);
-
-  virtual ~LinkerConfig();
-};
-
-} // end namespace alone
-
-#endif // ALONE_SUPPORT_LINKER_CONFIG_H
diff --git a/tools/mcld/include/alone/Support/Log.h b/tools/mcld/include/alone/Support/Log.h
deleted file mode 100644
index e3c80d1..0000000
--- a/tools/mcld/include/alone/Support/Log.h
+++ /dev/null
@@ -1,18 +0,0 @@
-//===- Log.h --------------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef ALONE_SUPPORT_LOG_H
-#define ALONE_SUPPORT_LOG_H
-
-#include <cstdio>
-
-#define ALOGE(fmt, args...) \
-printf("%s:%s:%d: " fmt, __FILE__, __FUNCTION__, __LINE__, args)
-
-#endif // ALONE_SUPPORT_LOG_H
diff --git a/tools/mcld/include/alone/Support/TargetLinkerConfigs.h b/tools/mcld/include/alone/Support/TargetLinkerConfigs.h
deleted file mode 100644
index 3bb6b7b..0000000
--- a/tools/mcld/include/alone/Support/TargetLinkerConfigs.h
+++ /dev/null
@@ -1,89 +0,0 @@
-//===- TargetLinkerConfig.h -----------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef ALONE_SUPPORT_TARGET_LINKER_CONFIGS_H
-#define ALONE_SUPPORT_TARGET_LINKER_CONFIGS_H
-
-#include <string>
-
-#include "alone/Config/Config.h"
-#include "alone/Support/LinkerConfig.h"
-
-namespace alone {
-
-//===----------------------------------------------------------------------===//
-// ARM
-//===----------------------------------------------------------------------===//
-#if defined(PROVIDE_ARM_CODEGEN)
-class ARMLinkerConfig : public LinkerConfig {
-public:
-  ARMLinkerConfig();
-};
-#endif // defined(PROVIDE_ARM_CODEGEN)
-
-//===----------------------------------------------------------------------===//
-// MIPS
-//===----------------------------------------------------------------------===//
-#if defined(PROVIDE_MIPS_CODEGEN)
-class MipsLinkerConfig : public LinkerConfig {
-public:
-  MipsLinkerConfig();
-};
-#endif // defined(PROVIDE_MIPS_CODEGEN)
-
-//===----------------------------------------------------------------------===//
-// X86 and X86_64
-//===----------------------------------------------------------------------===//
-#if defined(PROVIDE_X86_CODEGEN)
-class X86FamilyLinkerConfigBase : public LinkerConfig {
-public:
-  X86FamilyLinkerConfigBase(const std::string& pTriple);
-};
-
-class X86_32LinkerConfig : public X86FamilyLinkerConfigBase {
-public:
-  X86_32LinkerConfig();
-};
-
-class X86_64LinkerConfig : public X86FamilyLinkerConfigBase {
-public:
-  X86_64LinkerConfig();
-};
-#endif // defined(PROVIDE_X86_CODEGEN)
-
-//===----------------------------------------------------------------------===//
-// Default target
-//===----------------------------------------------------------------------===//
-class DefaultLinkerConfig : public
-#if defined (DEFAULT_ARM_CODEGEN)
-  ARMLinkerConfig
-#elif defined (DEFAULT_MIPS_CODEGEN)
-  MipsLinkerConfig
-#elif defined (DEFAULT_X86_CODEGEN)
-  X86_32LinkerConfig
-#elif defined (DEFAULT_X86_64_CODEGEN)
-  X86_64LinkerConfig
-#else
-#  error "Unsupported Default Target!"
-#endif
-{ };
-
-#if !defined(TARGET_BUILD)
-//===----------------------------------------------------------------------===//
-// General target
-//===----------------------------------------------------------------------===//
-class GeneralLinkerConfig : public LinkerConfig {
-public:
-  GeneralLinkerConfig(const std::string& pTriple);
-};
-#endif // !defined(TARGET_BUILD)
-
-} // end namespace alone
-
-#endif // ALONE_SUPPORT_LINKER_CONFIG_H
diff --git a/tools/mcld/lib/Core/Linker.cpp b/tools/mcld/lib/Core/Linker.cpp
deleted file mode 100644
index 99d658c..0000000
--- a/tools/mcld/lib/Core/Linker.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-//===- Linker.cpp ---------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "alone/Linker.h"
-#include "alone/Support/LinkerConfig.h"
-#include "alone/Support/Log.h"
-
-#include <llvm/Support/ELF.h>
-
-#include <mcld/Module.h>
-#include <mcld/IRBuilder.h>
-#include <mcld/MC/MCLDInput.h>
-#include <mcld/Linker.h>
-#include <mcld/LD/LDSection.h>
-#include <mcld/LD/LDContext.h>
-#include <mcld/Support/Path.h>
-
-using namespace alone;
-
-const char* Linker::GetErrorString(enum Linker::ErrorCode pErrCode) {
-  static const char* ErrorString[] = {
-    /* kSuccess */
-    "Successfully compiled.",
-    /* kDoubleConfig */
-    "Configure Linker twice.",
-    /* kDelegateLDInfo */
-    "Cannot get linker information",
-    /* kFindNameSpec */
-    "Cannot find -lnamespec",
-    /* kOpenObjectFile */
-    "Cannot open object file",
-    /* kNotConfig */
-    "Linker::config() is not called",
-    /* kNotSetUpOutput */
-    "Linker::setOutput() is not called before add input files",
-    /* kOpenOutput */
-    "Cannot open output file",
-    /* kReadSections */
-    "Cannot read sections",
-    /* kReadSymbols */
-    "Cannot read symbols",
-    /* kAddAdditionalSymbols */
-    "Cannot add standard and target symbols",
-    /* kMaxErrorCode */
-    "(Unknown error code)"
-  };
-
-  if (pErrCode > kMaxErrorCode) {
-    pErrCode = kMaxErrorCode;
-  }
-
-  return ErrorString[ static_cast<size_t>(pErrCode) ];
-}
-
-//===----------------------------------------------------------------------===//
-// Linker
-//===----------------------------------------------------------------------===//
-Linker::Linker()
-  : mLDConfig(NULL), mModule(NULL), mLinker(NULL), mBuilder(NULL),
-    mOutputHandler(-1) {
-}
-
-Linker::Linker(const LinkerConfig& pConfig)
-  : mLDConfig(NULL), mModule(NULL), mLinker(NULL), mBuilder(NULL),
-    mOutputHandler(-1) {
-
-  const std::string &triple = pConfig.getTriple();
-
-  enum ErrorCode err = config(pConfig);
-  if (kSuccess != err) {
-    ALOGE("%s (%s)", GetErrorString(err), triple.c_str());
-    return;
-  }
-
-  return;
-}
-
-Linker::~Linker() {
-  delete mModule;
-  delete mLinker;
-  delete mBuilder;
-}
-
-enum Linker::ErrorCode Linker::extractFiles(const LinkerConfig& pConfig) {
-  mLDConfig = pConfig.getLDConfig();
-  if (mLDConfig == NULL) {
-    return kDelegateLDInfo;
-  }
-  return kSuccess;
-}
-
-enum Linker::ErrorCode Linker::config(const LinkerConfig& pConfig) {
-  if (mLDConfig != NULL) {
-    return kDoubleConfig;
-  }
-
-  extractFiles(pConfig);
-
-  mModule = new mcld::Module(mLDConfig->options().soname(),
-                   const_cast<mcld::LinkerScript&>(*pConfig.getLDScript()));
-
-  mBuilder = new mcld::IRBuilder(*mModule, *mLDConfig);
-
-  mLinker = new mcld::Linker();
-
-  mLinker->emulate(const_cast<mcld::LinkerScript&>(*pConfig.getLDScript()),
-                   const_cast<mcld::LinkerConfig&>(*mLDConfig));
-
-  return kSuccess;
-}
-
-enum Linker::ErrorCode Linker::addNameSpec(const std::string &pNameSpec) {
-  mcld::Input* input = mBuilder->ReadInput(pNameSpec);
-  if (NULL == input)
-    return kFindNameSpec;
-  return kSuccess;
-}
-
-/// addObject - Add a object file by the filename.
-enum Linker::ErrorCode Linker::addObject(const std::string &pObjectPath) {
-  mcld::Input* input = mBuilder->ReadInput(pObjectPath, pObjectPath);
-  if (NULL == input)
-    return kOpenObjectFile;
-  return kSuccess;
-}
-
-/// addObject - Add a piece of memory. The memory is of ELF format.
-enum Linker::ErrorCode Linker::addObject(void* pMemory, size_t pSize) {
-  mcld::Input* input = mBuilder->ReadInput("NAN", pMemory, pSize);
-  if (NULL == input)
-    return kOpenMemory;
-  return kSuccess;
-}
-
-enum Linker::ErrorCode Linker::addCode(void* pMemory, size_t pSize) {
-  mcld::Input* input = mBuilder->CreateInput("NAN", "NAN", mcld::Input::Object);
-  mcld::LDSection* sect = mBuilder->CreateELFHeader(*input, ".text",
-                                llvm::ELF::SHT_PROGBITS,
-                                llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR,
-                                0x1);
-  mcld::SectionData* data = mBuilder->CreateSectionData(*sect);
-  mcld::Fragment* frag = mBuilder->CreateRegion(pMemory, pSize);
-  mBuilder->AppendFragment(*frag, *data);
-  return kSuccess;
-}
-
-enum Linker::ErrorCode Linker::setOutput(const std::string &pPath) {
-  mOutputPath = pPath;
-  return kSuccess;
-}
-
-enum Linker::ErrorCode Linker::setOutput(int pFileHandler) {
-  mOutputHandler = pFileHandler;
-  return kSuccess;
-}
-
-enum Linker::ErrorCode Linker::link() {
-  mLinker->link(*mModule, *mBuilder);
-  if (!mOutputPath.empty()) {
-    mLinker->emit(mOutputPath);
-    return kSuccess;
-  }
-
-  if (-1 != mOutputHandler) {
-    mLinker->emit(mOutputHandler);
-    return kSuccess;
-  }
-  return kNotSetUpOutput;
-}
-
diff --git a/tools/mcld/lib/Support/Initialization.cpp b/tools/mcld/lib/Support/Initialization.cpp
deleted file mode 100644
index 71bd57d..0000000
--- a/tools/mcld/lib/Support/Initialization.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//===- Initialization.cpp -------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "alone/Support/Initialization.h"
-
-#include <cstdlib>
-
-#include <llvm/Support/ErrorHandling.h>
-#include <llvm/Support/TargetSelect.h>
-
-#include <mcld/Support/TargetSelect.h>
-#include <mcld/Support/TargetRegistry.h>
-
-#include "alone/Config/Config.h"
-#include "alone/Support/Log.h"
-
-namespace {
-
-void llvm_error_handler(void *pUserData, const std::string &pMessage) {
-  ALOGE("%s", pMessage.c_str());
-  ::exit(1);
-}
-
-} // end anonymous namespace
-
-void alone::init::Initialize() {
-  static bool is_initialized = false;
-
-  if (is_initialized) {
-    return;
-  }
-
-  // Setup error handler for LLVM.
-  llvm::remove_fatal_error_handler();
-  llvm::install_fatal_error_handler(llvm_error_handler, NULL);
-
-#if defined(PROVIDE_ARM_CODEGEN)
-  LLVMInitializeARMAsmPrinter();
-# if USE_DISASSEMBLER
-  LLVMInitializeARMDisassembler();
-# endif
-  LLVMInitializeARMTargetMC();
-  LLVMInitializeARMTargetInfo();
-  LLVMInitializeARMTarget();
-  MCLDInitializeARMLDTargetInfo();
-  MCLDInitializeARMLDTarget();
-  MCLDInitializeARMLDBackend();
-  MCLDInitializeARMDiagnosticLineInfo();
-#endif
-
-#if defined(PROVIDE_MIPS_CODEGEN)
-  LLVMInitializeMipsAsmPrinter();
-# if USE_DISASSEMBLER
-  LLVMInitializeMipsDisassembler();
-# endif
-  LLVMInitializeMipsTargetMC();
-  LLVMInitializeMipsTargetInfo();
-  LLVMInitializeMipsTarget();
-  MCLDInitializeMipsLDTargetInfo();
-  MCLDInitializeMipsLDTarget();
-  MCLDInitializeMipsLDBackend();
-  MCLDInitializeMipsDiagnosticLineInfo();
-#endif
-
-#if defined(PROVIDE_X86_CODEGEN)
-  LLVMInitializeX86AsmPrinter();
-# if USE_DISASSEMBLER
-  LLVMInitializeX86Disassembler();
-# endif
-  LLVMInitializeX86TargetMC();
-  LLVMInitializeX86TargetInfo();
-  LLVMInitializeX86Target();
-  MCLDInitializeX86LDTargetInfo();
-  MCLDInitializeX86LDTarget();
-  MCLDInitializeX86LDBackend();
-  MCLDInitializeX86DiagnosticLineInfo();
-#endif
-
-  is_initialized = true;
-
-  return;
-}
diff --git a/tools/mcld/lib/Support/LinkerConfig.cpp b/tools/mcld/lib/Support/LinkerConfig.cpp
deleted file mode 100644
index e968cc1..0000000
--- a/tools/mcld/lib/Support/LinkerConfig.cpp
+++ /dev/null
@@ -1,340 +0,0 @@
-//===- LinkerConfig.cpp ---------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "alone/Support/LinkerConfig.h"
-#include "alone/Support/Log.h"
-
-#include <llvm/Support/Signals.h>
-
-#include <mcld/MC/MCLDDirectory.h>
-#include <mcld/MC/ZOption.h>
-#include <mcld/LD/TextDiagnosticPrinter.h>
-#include <mcld/Support/Path.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Support/raw_ostream.h>
-
-using namespace alone;
-
-LinkerConfig::LinkerConfig(const std::string &pTriple)
-  : mTriple(pTriple), mSOName(), mTarget(NULL), mLDConfig(NULL),
-    mLDScript(NULL), mDiagLineInfo(NULL), mDiagPrinter(NULL) {
-
-  initializeTarget();
-  initializeLDScript();
-  initializeLDInfo();
-  initializeDiagnostic();
-}
-
-LinkerConfig::~LinkerConfig() {
-  delete mLDConfig;
-
-  if (mDiagPrinter->getNumErrors() != 0) {
-    // If here, the program failed ungracefully. Run the interrupt handlers to
-    // ensure any other cleanups (e.g., files that registered by
-    // RemoveFileOnSignal(...)) getting done before exit.
-    llvm::sys::RunInterruptHandlers();
-  }
-  mDiagPrinter->finish();
-
-  delete mLDScript;
-  delete mDiagLineInfo;
-  delete mDiagPrinter;
-}
-
-bool LinkerConfig::initializeTarget() {
-  std::string error;
-  mTarget = mcld::TargetRegistry::lookupTarget(mTriple, error);
-  if (NULL != mTarget) {
-    return true;
-  } else {
-    ALOGE("Cannot initialize mcld::Target for given triple '%s'! (%s)\n",
-          mTriple.c_str(), error.c_str());
-    return false;
-  }
-}
-
-bool LinkerConfig::initializeLDInfo() {
-  if (NULL != mLDConfig) {
-    ALOGE("Cannot initialize mcld::MCLDInfo for given triple '%s!\n",
-          mTriple.c_str());
-    return false;
-  }
-
-  mLDConfig = new mcld::LinkerConfig(getTriple());
-  mLDConfig->setCodeGenType(mcld::LinkerConfig::Exec);
-
-  struct NameMap {
-    const char* from;
-    const char* to;
-  };
-
-  static const NameMap map[] =
-  {
-    {".text", ".text"},
-    {".rodata", ".rodata"},
-    {".data.rel.ro.local", ".data.rel.ro.local"},
-    {".data.rel.ro", ".data.rel.ro"},
-    {".data", ".data"},
-    {".bss", ".bss"},
-    {".tdata", ".tdata"},
-    {".tbss", ".tbss"},
-    {".init_array", ".init_array"},
-    {".fini_array", ".fini_array"},
-    // TODO: Support DT_INIT_ARRAY for all constructors?
-    {".ctors", ".ctors"},
-    {".dtors", ".dtors"},
-    // FIXME: in GNU ld, if we are creating a shared object .sdata2 and .sbss2
-    // sections would be handled differently.
-    {".sdata2", ".sdata"},
-    {".sbss2", ".sbss"},
-    {".sdata", ".sdata"},
-    {".sbss", ".sbss"},
-    {".lrodata", ".lrodata"},
-    {".ldata", ".ldata"},
-    {".lbss", ".lbss"},
-    {".gcc_except_table", ".gcc_except_table"},
-    {".gnu.linkonce.d.rel.ro.local", ".data.rel.ro.local"},
-    {".gnu.linkonce.d.rel.ro", ".data.rel.ro"},
-    {".gnu.linkonce.r", ".rodata"},
-    {".gnu.linkonce.d", ".data"},
-    {".gnu.linkonce.b", ".bss"},
-    {".gnu.linkonce.sb2", ".sbss"},
-    {".gnu.linkonce.sb", ".sbss"},
-    {".gnu.linkonce.s2", ".sdata"},
-    {".gnu.linkonce.s", ".sdata"},
-    {".gnu.linkonce.wi", ".debug_info"},
-    {".gnu.linkonce.td", ".tdata"},
-    {".gnu.linkonce.tb", ".tbss"},
-    {".gnu.linkonce.t", ".text"},
-    {".gnu.linkonce.lr", ".lrodata"},
-    {".gnu.linkonce.lb", ".lbss"},
-    {".gnu.linkonce.l", ".ldata"},
-  };
-
-  if (mLDConfig->codeGenType() != mcld::LinkerConfig::Object) {
-    const unsigned int map_size =  (sizeof(map) / sizeof(map[0]) );
-    for (unsigned int i = 0; i < map_size; ++i) {
-      bool exist = false;
-      mLDScript->sectionMap().append(map[i].from,
-                                               map[i].to,
-                                               exist);
-    }
-  }
-  return true;
-}
-
-bool LinkerConfig::initializeLDScript() {
-  mLDScript = new mcld::LinkerScript();
-  return true;
-}
-
-bool LinkerConfig::initializeDiagnostic() {
-  // Set up MsgHandler.
-  mDiagPrinter = new mcld::TextDiagnosticPrinter(mcld::errs(), *mLDConfig);
-
-  mcld::InitializeDiagnosticEngine(*mLDConfig, mDiagPrinter);
-
-  mDiagLineInfo = mTarget->createDiagnosticLineInfo(*mTarget, mTriple);
-
-  mcld::getDiagnosticEngine().setLineInfo(*mDiagLineInfo);
-  return true;
-}
-
-bool LinkerConfig::isShared() const {
-  return (mcld::LinkerConfig::DynObj == mLDConfig->codeGenType());
-}
-
-void LinkerConfig::setShared(bool pEnable) {
-  if (pEnable)
-    mLDConfig->setCodeGenType(mcld::LinkerConfig::DynObj);
-  else
-    mLDConfig->setCodeGenType(mcld::LinkerConfig::Exec);
-  return;
-}
-
-void LinkerConfig::setBsymbolic(bool pEnable) {
-  mLDConfig->options().setBsymbolic(pEnable);
-  return;
-}
-
-void LinkerConfig::setDefineCommon(bool pEnable) {
-  mLDConfig->options().setDefineCommon(pEnable);
-  return;
-}
-
-void LinkerConfig::setSOName(const std::string &pSOName) {
-  mLDConfig->options().setSOName(pSOName);
-  return;
-}
-
-void LinkerConfig::setDyld(const std::string &pDyld) {
-  mLDConfig->options().setDyld(pDyld);
-  return;
-}
-
-void LinkerConfig::setSysRoot(const std::string &pSysRoot) {
-  mLDScript->setSysroot(mcld::sys::fs::Path(pSysRoot));
-  return;
-}
-
-void LinkerConfig::setZOption(unsigned int pOptions) {
-  mcld::ZOption option;
-  if (pOptions & kCombReloc) {
-    option.setKind(mcld::ZOption::CombReloc);
-    mLDConfig->options().addZOption(option);
-  }
-  else {
-    option.setKind(mcld::ZOption::NoCombReloc);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kDefs) {
-    option.setKind(mcld::ZOption::Defs);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kExecStack) {
-    option.setKind(mcld::ZOption::ExecStack);
-    mLDConfig->options().addZOption(option);
-  }
-  else {
-    option.setKind(mcld::ZOption::NoExecStack);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kInitFirst) {
-    option.setKind(mcld::ZOption::InitFirst);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kInterPose) {
-    option.setKind(mcld::ZOption::InterPose);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kLoadFltr) {
-    option.setKind(mcld::ZOption::LoadFltr);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kMulDefs) {
-    option.setKind(mcld::ZOption::MulDefs);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kNoCopyReloc) {
-    option.setKind(mcld::ZOption::NoCopyReloc);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kNoDefaultLib) {
-    option.setKind(mcld::ZOption::NoDefaultLib);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kNoDelete) {
-    option.setKind(mcld::ZOption::NoDelete);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kNoDLOpen) {
-    option.setKind(mcld::ZOption::NoDLOpen);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kNoDump) {
-    option.setKind(mcld::ZOption::NoDump);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kRelro) {
-    option.setKind(mcld::ZOption::Relro);
-    mLDConfig->options().addZOption(option);
-  }
-  else {
-    option.setKind(mcld::ZOption::NoRelro);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kLazy) {
-    option.setKind(mcld::ZOption::Lazy);
-    mLDConfig->options().addZOption(option);
-  }
-  else {
-    option.setKind(mcld::ZOption::Now);
-    mLDConfig->options().addZOption(option);
-  }
-
-  if (pOptions & kOrigin) {
-    option.setKind(mcld::ZOption::Origin);
-    mLDConfig->options().addZOption(option);
-  }
-}
-
-void LinkerConfig::addWrap(const std::string &pWrapSymbol) {
-  bool exist = false;
-
-  // Add wname -> __wrap_wname.
-  mcld::StringEntry<llvm::StringRef>* to_wrap =
-               mLDScript->renameMap().insert(pWrapSymbol, exist);
-
-  std::string to_wrap_str = "__wrap_" + pWrapSymbol;
-  to_wrap->setValue(to_wrap_str);
-
-  if (exist) {
-    mcld::warning(mcld::diag::rewrap) << pWrapSymbol << to_wrap_str;
-  }
-
-  // Add __real_wname -> wname.
-  std::string from_real_str = "__real_" + pWrapSymbol;
-  mcld::StringEntry<llvm::StringRef>* from_real =
-             mLDScript->renameMap().insert(from_real_str, exist);
-  from_real->setValue(pWrapSymbol);
-
-  if (exist) {
-    mcld::warning(mcld::diag::rewrap) << pWrapSymbol << from_real_str;
-  }
-
-  return;
-}
-
-void LinkerConfig::addPortable(const std::string &pPortableSymbol) {
-  bool exist = false;
-
-  // Add pname -> pname_portable.
-  mcld::StringEntry<llvm::StringRef>* to_port =
-                mLDScript->renameMap().insert(pPortableSymbol, exist);
-
-  std::string to_port_str = pPortableSymbol + "_portable";
-  to_port->setValue(to_port_str);
-
-  if (exist) {
-    mcld::warning(mcld::diag::rewrap) << pPortableSymbol << to_port_str;
-}
-
-  // Add __real_pname -> pname.
-  std::string from_real_str = "__real_" + pPortableSymbol;
-  mcld::StringEntry<llvm::StringRef>* from_real =
-           mLDScript->renameMap().insert(from_real_str, exist);
-
-  from_real->setValue(pPortableSymbol);
-
-  if (exist) {
-    mcld::warning(mcld::diag::rewrap) << pPortableSymbol << from_real_str;
-  }
-
-  return;
-}
-
-void LinkerConfig::addSearchDir(const std::string &pDirPath) {
-  // SearchDirs will remove the created MCLDDirectory.
-  if (!mLDScript->directories().insert(pDirPath)) {
-    mcld::warning(mcld::diag::warn_cannot_open_search_dir) << pDirPath;
-  }
-}
diff --git a/tools/mcld/lib/Support/TargetLinkerConfigs.cpp b/tools/mcld/lib/Support/TargetLinkerConfigs.cpp
deleted file mode 100644
index d8722f6..0000000
--- a/tools/mcld/lib/Support/TargetLinkerConfigs.cpp
+++ /dev/null
@@ -1,175 +0,0 @@
-//===- TargetLinkerConfigs.cpp --------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "alone/Config/Config.h"
-#include "alone/Support/TargetLinkerConfigs.h"
-
-#include <mcld/TargetOptions.h>
-#include <mcld/MC/InputFactory.h>
-#include <mcld/Fragment/Relocation.h>
-
-using namespace alone;
-
-#ifdef TARGET_BUILD
-static const char* gDefaultDyld = "/system/bin/linker";
-static const char* gDefaultSysroot = "/system";
-#else
-static const char* gDefaultDyld = "/usr/lib/ld.so.1";
-static const char* gDefaultSysroot = "/";
-#endif
-
-//===----------------------------------------------------------------------===//
-// ARM
-//===----------------------------------------------------------------------===//
-#if defined(PROVIDE_ARM_CODEGEN)
-ARMLinkerConfig::ARMLinkerConfig() : LinkerConfig(DEFAULT_ARM_TRIPLE_STRING) {
-
-  // set up target-dependent options
-  getLDConfig()->targets().setEndian(mcld::TargetOptions::Little);
-  getLDConfig()->targets().setBitClass(32);
-
-  // set up target-dependent constraints of attributes
-  getLDConfig()->attribute().constraint().enableWholeArchive();
-  getLDConfig()->attribute().constraint().disableAsNeeded();
-  getLDConfig()->attribute().constraint().setSharedSystem();
-
-  // set up the predefined attributes
-  getLDConfig()->attribute().predefined().unsetWholeArchive();
-  getLDConfig()->attribute().predefined().setDynamic();
-
-  // set up target dependent options
-  if (getLDScript()->sysroot().empty()) {
-    getLDScript()->setSysroot(gDefaultSysroot);
-  }
-
-  if (!getLDConfig()->options().hasDyld()) {
-    getLDConfig()->options().setDyld(gDefaultDyld);
-  }
-
-  // set up section map
-  if (getLDConfig()->codeGenType() != mcld::LinkerConfig::Object) {
-    bool exist = false;
-    getLDScript()->sectionMap().append(".ARM.exidx", ".ARM.exidx", exist);
-    getLDScript()->sectionMap().append(".ARM.extab", ".ARM.extab", exist);
-    getLDScript()->sectionMap().append(".ARM.attributes", ".ARM.attributes", exist);
-  }
-
-  // set up relocation factory
-  mcld::Relocation::SetUp(*getLDConfig());
-}
-#endif // defined(PROVIDE_ARM_CODEGEN)
-
-//===----------------------------------------------------------------------===//
-// Mips
-//===----------------------------------------------------------------------===//
-#if defined(PROVIDE_MIPS_CODEGEN)
-MipsLinkerConfig::MipsLinkerConfig()
-  : LinkerConfig(DEFAULT_MIPS_TRIPLE_STRING) {
-
-  // set up target-dependent options
-  getLDConfig()->targets().setEndian(mcld::TargetOptions::Little);
-  getLDConfig()->targets().setBitClass(32);
-
-  // set up target-dependent constraints of attibutes
-  getLDConfig()->attribute().constraint().enableWholeArchive();
-  getLDConfig()->attribute().constraint().disableAsNeeded();
-  getLDConfig()->attribute().constraint().setSharedSystem();
-
-  // set up the predefined attributes
-  getLDConfig()->attribute().predefined().unsetWholeArchive();
-  getLDConfig()->attribute().predefined().setDynamic();
-
-  // set up target dependent options
-  if (getLDScript()->sysroot().empty()) {
-    getLDScript()->setSysroot(gDefaultSysroot);
-  }
-
-  if (!getLDConfig()->options().hasDyld()) {
-    getLDConfig()->options().setDyld(gDefaultDyld);
-  }
-
-  // set up relocation factory
-  mcld::Relocation::SetUp(*getLDConfig());
-}
-#endif // defined(PROVIDE_MIPS_CODEGEN)
-
-//===----------------------------------------------------------------------===//
-// X86 and X86_64
-//===----------------------------------------------------------------------===//
-#if defined(PROVIDE_X86_CODEGEN)
-X86FamilyLinkerConfigBase::X86FamilyLinkerConfigBase(const std::string& pTriple)
-  : LinkerConfig(pTriple) {
-  // set up target-dependent options
-  getLDConfig()->targets().setEndian(mcld::TargetOptions::Little);
-  getLDConfig()->targets().setBitClass(32);
-
-  // set up target-dependent constraints of attibutes
-  getLDConfig()->attribute().constraint().enableWholeArchive();
-  getLDConfig()->attribute().constraint().disableAsNeeded();
-  getLDConfig()->attribute().constraint().setSharedSystem();
-
-  // set up the predefined attributes
-  getLDConfig()->attribute().predefined().unsetWholeArchive();
-  getLDConfig()->attribute().predefined().setDynamic();
-
-  // set up target dependent options
-  if (getLDScript()->sysroot().empty()) {
-    getLDScript()->setSysroot(gDefaultSysroot);
-  }
-
-  if (!getLDConfig()->options().hasDyld()) {
-    getLDConfig()->options().setDyld(gDefaultDyld);
-  }
-
-  // set up relocation factory
-  mcld::Relocation::SetUp(*getLDConfig());
-}
-
-X86_32LinkerConfig::X86_32LinkerConfig()
-  : X86FamilyLinkerConfigBase(DEFAULT_X86_TRIPLE_STRING) {
-}
-
-X86_64LinkerConfig::X86_64LinkerConfig()
-  : X86FamilyLinkerConfigBase(DEFAULT_X86_64_TRIPLE_STRING) {
-}
-#endif // defined(PROVIDE_X86_CODEGEN)
-
-#if !defined(TARGET_BUILD)
-//===----------------------------------------------------------------------===//
-// General
-//===----------------------------------------------------------------------===//
-GeneralLinkerConfig::GeneralLinkerConfig(const std::string& pTriple)
-  : LinkerConfig(pTriple) {
-
-  // set up target-dependent options
-  getLDConfig()->targets().setEndian(mcld::TargetOptions::Little);
-  getLDConfig()->targets().setBitClass(32);
-
-  // set up target-dependent constraints of attributes
-  getLDConfig()->attribute().constraint().enableWholeArchive();
-  getLDConfig()->attribute().constraint().disableAsNeeded();
-  getLDConfig()->attribute().constraint().setSharedSystem();
-
-  // set up the predefined attributes
-  getLDConfig()->attribute().predefined().unsetWholeArchive();
-  getLDConfig()->attribute().predefined().setDynamic();
-
-  // set up section map
-  if (llvm::Triple::arm == getLDConfig()->targets().triple().getArch() &&
-      getLDConfig()->codeGenType() != mcld::LinkerConfig::Object) {
-    bool exist = false;
-    getLDScript()->sectionMap().append(".ARM.exidx", ".ARM.exidx", exist);
-    getLDScript()->sectionMap().append(".ARM.extab", ".ARM.extab", exist);
-    getLDScript()->sectionMap().append(".ARM.attributes", ".ARM.attributes", exist);
-  }
-
-  // set up relocation factory
-  mcld::Relocation::SetUp(*getLDConfig());
-}
-#endif // defined(TARGET_BUILD)
diff --git a/tools/mcld/main.cpp b/tools/mcld/main.cpp
index 968c5e6..dcb8140 100644
--- a/tools/mcld/main.cpp
+++ b/tools/mcld/main.cpp
@@ -1,4 +1,4 @@
-//===- mcld.cpp -----------------------------------------------------------===//
+//===- llvm-mcld.cpp ------------------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -6,367 +6,1552 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include <mcld/Module.h>
+#include <mcld/LinkerConfig.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/CodeGen/TargetMachine.h>
+#include <mcld/Support/TargetSelect.h>
+#include <mcld/Support/TargetRegistry.h>
+#include <mcld/Support/CommandLine.h>
+#include <mcld/Support/Path.h>
+#include <mcld/Support/RealPath.h>
+#include <mcld/Support/MsgHandling.h>
+#include <mcld/Support/FileHandle.h>
+#include <mcld/Support/FileSystem.h>
+#include <mcld/Support/raw_ostream.h>
+#include <mcld/Support/SystemUtils.h>
+#include <mcld/Support/ToolOutputFile.h>
+#include <mcld/LD/DiagnosticLineInfo.h>
+#include <mcld/LD/TextDiagnosticPrinter.h>
 
-#include <stdlib.h>
-#include <string>
-
-#include <llvm/ADT/SmallString.h>
+#include <llvm/PassManager.h>
+#include <llvm/Pass.h>
+#include <llvm/IR/Module.h>
+#include <llvm/IR/DataLayout.h>
+#include <llvm/IR/LLVMContext.h>
+#include <llvm/IRReader/IRReader.h>
+#include <llvm/ADT/Triple.h>
+#include <llvm/ADT/StringSwitch.h>
+#include <llvm/MC/SubtargetFeature.h>
 #include <llvm/Support/CommandLine.h>
-#include <llvm/Support/FileSystem.h>
-#include <llvm/Support/Path.h>
-#include <llvm/Support/raw_ostream.h>
-#include <llvm/Support/system_error.h>
+#include <llvm/Support/Debug.h>
+#include <llvm/Support/FormattedStream.h>
+#include <llvm/Support/Host.h>
+#include <llvm/Support/ManagedStatic.h>
+#include <llvm/Support/Signals.h>
+#include <llvm/Support/SourceMgr.h>
+#include <llvm/Support/TargetSelect.h>
+#include <llvm/Support/TargetRegistry.h>
+#include <llvm/Support/Process.h>
+#include <llvm/Target/TargetMachine.h>
 
-#include <mcld/Config/Config.h>
+#include <iostream>
 
-#include <alone/Config/Config.h>
-#include <alone/Support/LinkerConfig.h>
-#include <alone/Support/Initialization.h>
-#include <alone/Support/TargetLinkerConfigs.h>
-#include <alone/Linker.h>
+using namespace std;
 
-using namespace alone;
-
-//===----------------------------------------------------------------------===//
-// Compiler Options
-//===----------------------------------------------------------------------===//
-#ifdef TARGET_BUILD
-static const std::string OptTargetTriple(DEFAULT_TARGET_TRIPLE_STRING);
-#else
-static llvm::cl::opt<std::string>
-OptTargetTriple("mtriple",
-                llvm::cl::desc("Specify the target triple (default: "
-                                DEFAULT_TARGET_TRIPLE_STRING ")"),
-                llvm::cl::init(DEFAULT_TARGET_TRIPLE_STRING),
-                llvm::cl::value_desc("triple"));
-
-static llvm::cl::alias OptTargetTripleC("C", llvm::cl::NotHidden,
-                                        llvm::cl::desc("Alias for -mtriple"),
-                                        llvm::cl::aliasopt(OptTargetTriple));
+#if defined(HAVE_UNISTD_H)
+# include <unistd.h>
 #endif
 
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <io.h>
+#ifndef STDIN_FILENO
+# define STDIN_FILENO 0
+#endif
+#ifndef STDOUT_FILENO
+# define STDOUT_FILENO 1
+#endif
+#ifndef STDERR_FILENO
+# define STDERR_FILENO 2
+#endif
+#endif
+
+using namespace llvm;
+
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+
+static cl::opt<bool>
+UnitTest("unittest",  cl::desc("do unit test") );
+
+int unit_test( int argc, char* argv[] )
+{
+  testing::InitGoogleTest( &argc, argv );
+  return RUN_ALL_TESTS();
+}
+
+#endif
+
+// General options for llc.  Other pass-specific options are specified
+// within the corresponding llc passes, and target-specific options
+// and back-end code generation options are specified with the target machine.
+//
+// Determine optimization level.
+static cl::opt<char>
+OptLevel("O",
+         cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
+                  "(default = '-O2')"),
+         cl::Prefix,
+         cl::ZeroOrMore,
+         cl::init(' '));
+
+static cl::opt<std::string>
+TargetTriple("mtriple", cl::desc("Override target triple for module"));
+
+static cl::opt<std::string>
+MArch("march", cl::desc("Architecture to generate code for (see --version)"));
+
+static cl::opt<std::string>
+MCPU("mcpu",
+  cl::desc("Target a specific cpu type (-mcpu=help for details)"),
+  cl::value_desc("cpu-name"),
+  cl::init(""));
+
+static cl::list<std::string>
+MAttrs("mattr",
+  cl::CommaSeparated,
+  cl::desc("Target specific attributes (-mattr=help for details)"),
+  cl::value_desc("a1,+a2,-a3,..."));
+
+static cl::opt<llvm::CodeModel::Model>
+CMModel("code-model",
+        cl::desc("Choose code model"),
+        cl::init(CodeModel::Default),
+        cl::values(clEnumValN(CodeModel::Default, "default",
+                              "Target default code model"),
+                   clEnumValN(CodeModel::Small, "small",
+                              "Small code model"),
+                   clEnumValN(CodeModel::Kernel, "kernel",
+                              "Kernel code model"),
+                   clEnumValN(CodeModel::Medium, "medium",
+                              "Medium code model"),
+                   clEnumValN(CodeModel::Large, "large",
+                              "Large code model"),
+                   clEnumValEnd));
+
+cl::opt<bool> NoVerify("disable-verify", cl::Hidden,
+                       cl::desc("Do not verify input module"));
+
+static cl::opt<bool>
+EnableFPMAD("enable-fp-mad",
+  cl::desc("Enable less precise MAD instructions to be generated"),
+  cl::init(false));
+
+static cl::opt<bool>
+DisableFPElim("disable-fp-elim",
+  cl::desc("Disable frame pointer elimination optimization"),
+  cl::init(false));
+
+static cl::opt<llvm::FPOpFusion::FPOpFusionMode>
+FuseFPOps("fuse-fp-ops",
+  cl::desc("Enable aggresive formation of fused FP ops"),
+  cl::init(FPOpFusion::Standard),
+  cl::values(
+    clEnumValN(FPOpFusion::Fast, "fast",
+               "Fuse FP ops whenever profitable"),
+    clEnumValN(FPOpFusion::Standard, "standard",
+               "Only fuse 'blessed' FP ops."),
+    clEnumValN(FPOpFusion::Strict, "strict",
+               "Only fuse FP ops when the result won't be effected."),
+    clEnumValEnd));
+
+static cl::opt<bool>
+EnableUnsafeFPMath("enable-unsafe-fp-math",
+  cl::desc("Enable optimizations that may decrease FP precision"),
+  cl::init(false));
+
+static cl::opt<bool>
+EnableNoInfsFPMath("enable-no-infs-fp-math",
+  cl::desc("Enable FP math optimizations that assume no +-Infs"),
+  cl::init(false));
+
+static cl::opt<bool>
+EnableNoNaNsFPMath("enable-no-nans-fp-math",
+  cl::desc("Enable FP math optimizations that assume no NaNs"),
+  cl::init(false));
+
+static cl::opt<bool>
+EnableHonorSignDependentRoundingFPMath("enable-sign-dependent-rounding-fp-math",
+  cl::Hidden,
+  cl::desc("Force codegen to assume rounding mode can change dynamically"),
+  cl::init(false));
+
+static cl::opt<bool>
+GenerateSoftFloatCalls("soft-float",
+  cl::desc("Generate software floating point library calls"),
+  cl::init(false));
+
+static cl::opt<llvm::FloatABI::ABIType>
+FloatABIForCalls("float-abi",
+  cl::desc("Choose float ABI type"),
+  cl::init(FloatABI::Default),
+  cl::values(
+    clEnumValN(FloatABI::Default, "default",
+               "Target default float ABI type"),
+    clEnumValN(FloatABI::Soft, "soft",
+               "Soft float ABI (implied by -soft-float)"),
+    clEnumValN(FloatABI::Hard, "hard",
+               "Hard float ABI (uses FP registers)"),
+    clEnumValEnd));
+
+static cl::opt<bool>
+DontPlaceZerosInBSS("nozero-initialized-in-bss",
+  cl::desc("Don't place zero-initialized symbols into bss section"),
+  cl::init(false));
+
+// In debug builds, make this default to true.
+#ifdef NDEBUG
+#define EMIT_DEBUG false
+#else
+#define EMIT_DEBUG true
+#endif
+static cl::opt<bool>
+EmitJitDebugInfo("jit-emit-debug",
+  cl::desc("Emit debug information to debugger"),
+  cl::init(EMIT_DEBUG));
+#undef EMIT_DEBUG
+
+static cl::opt<bool>
+EmitJitDebugInfoToDisk("jit-emit-debug-to-disk",
+  cl::Hidden,
+  cl::desc("Emit debug info objfiles to disk"),
+  cl::init(false));
+
+static cl::opt<bool>
+EnableGuaranteedTailCallOpt("tailcallopt",
+  cl::desc("Turn fastcc calls into tail calls by (potentially) changing ABI."),
+  cl::init(false));
+
+static cl::opt<unsigned>
+OverrideStackAlignment("stack-alignment",
+  cl::desc("Override default stack alignment"),
+  cl::init(0));
+
+// --script is an alias, but cl::alias doesn't work correctly with cl::list.
+static cl::list<std::string>
+ArgLinkerScript("T",
+             cl::ZeroOrMore,
+             cl::desc("Linker script"),
+             cl::value_desc("file"));
+
+static cl::opt<std::string>
+TrapFuncName("trap-func", cl::Hidden,
+  cl::desc("Emit a call to trap function rather than a trap instruction"),
+  cl::init(""));
+
+static cl::opt<bool>
+SegmentedStacks("segmented-stacks",
+  cl::desc("Use segmented stacks if possible."),
+  cl::init(false));
+
 //===----------------------------------------------------------------------===//
 // Command Line Options
 // There are four kinds of command line options:
-//   1. input, (may be a file, such as -m and /tmp/XXXX.o.)
-//   2. scripting options, (represent a subset of link scripting language, such
-//      as --defsym.)
-//   3. and general options. (the rest of options)
+//   1. Bitcode option. Used to represent a bitcode.
+//   2. Attribute options. Attributes describes the input file after them. For
+//      example, --as-needed affects the input file after this option. Attribute
+//      options are not attributes. Attribute options are the options that is
+//      used to define a legal attribute.
+//   3. Scripting options, Used to represent a subset of link scripting
+//      language, such as --defsym.
+//   4. General options. (the rest of options)
+//===----------------------------------------------------------------------===//
+// Bitcode Options
+//===----------------------------------------------------------------------===//
+static cl::opt<mcld::sys::fs::Path, false, llvm::cl::parser<mcld::sys::fs::Path> >
+ArgBitcodeFilename("dB",
+              cl::desc("set default bitcode"),
+              cl::value_desc("bitcode"));
+
 //===----------------------------------------------------------------------===//
 // General Options
 //===----------------------------------------------------------------------===//
-static llvm::cl::opt<std::string>
-OptOutputFilename("o",
-                  llvm::cl::desc("Output filename"),
-                  llvm::cl::value_desc("filename"));
+static cl::opt<mcld::sys::fs::Path, false, llvm::cl::parser<mcld::sys::fs::Path> >
+ArgOutputFilename("o",
+               cl::desc("Output filename"),
+               cl::value_desc("filename"));
 
-static llvm::cl::opt<std::string>
-OptSysRoot("sysroot", llvm::cl::desc("Use directory as the location of the "
-                                     "sysroot, overriding the configure-time "
-                                     "default."),
-           llvm::cl::value_desc("directory"),
-           llvm::cl::ValueRequired);
+static cl::alias
+AliasOutputFilename("output",
+                    cl::desc("alias for -o"),
+                    cl::aliasopt(ArgOutputFilename));
 
-static llvm::cl::list<std::string>
-OptSearchDirList("L",
-                 llvm::cl::ZeroOrMore,
-                 llvm::cl::desc("Add path searchdir to the list of paths that "
-                                "mcld will search for archive libraries and "
-                                "mcld control scripts."),
-                 llvm::cl::value_desc("searchdir"),
-                 llvm::cl::Prefix);
+static cl::opt<mcld::sys::fs::Path, false, llvm::cl::parser<mcld::sys::fs::Path> >
+ArgSysRoot("sysroot",
+           cl::desc("Use directory as the location of the sysroot, overriding the configure-time default."),
+           cl::value_desc("directory"),
+           cl::ValueRequired);
 
-static llvm::cl::opt<std::string>
-OptSOName("soname",
-          llvm::cl::desc("Set internal name of shared library"),
-          llvm::cl::value_desc("name"));
+static cl::list<std::string, bool, llvm::cl::SearchDirParser>
+ArgSearchDirList("L",
+                 cl::ZeroOrMore,
+                 cl::desc("Add path searchdir to the list of paths that ld will search for archive libraries and ld control scripts."),
+                 cl::value_desc("searchdir"),
+                 cl::Prefix);
+
+static cl::alias
+ArgSearchDirListAlias("library-path",
+                      cl::desc("alias for -L"),
+                      cl::aliasopt(ArgSearchDirList));
+
+static cl::opt<bool>
+ArgTrace("t",
+         cl::desc("Print the names of the input files as ld processes them."));
+
+static cl::alias
+ArgTraceAlias("trace",
+              cl::desc("alias for -t"),
+              cl::aliasopt(ArgTrace));
+
+static cl::opt<int>
+ArgVerbose("verbose",
+           cl::init(-1),
+           cl::desc("Display the version number for ld and list the linker emulations supported."));
+
+static cl::opt<bool>
+ArgVersion("V",
+           cl::init(false),
+           cl::desc("Display the version number for MCLinker."));
+
+static cl::opt<int>
+ArgMaxErrorNum("error-limit",
+               cl::init(-1),
+               cl::desc("limits the maximum number of erros."));
+
+static cl::opt<int>
+ArgMaxWarnNum("warning-limit",
+               cl::init(-1),
+               cl::desc("limits the maximum number of warnings."));
+
+static cl::opt<std::string>
+ArgEntry("e",
+         cl::desc("Use entry as the explicit symbol for beginning execution of your program."),
+         cl::value_desc("entry"),
+         cl::ValueRequired);
+
+static cl::alias
+ArgEntryAlias("entry",
+              cl::desc("alias for -e"),
+              cl::aliasopt(ArgEntry));
+
+static cl::opt<bool>
+ArgBsymbolic("Bsymbolic",
+             cl::desc("Bind references within the shared library."),
+             cl::init(false));
+
+static cl::opt<bool>
+ArgBgroup("Bgroup",
+          cl::desc("Info the dynamic linker to perform lookups only inside the group."),
+          cl::init(false));
+
+static cl::opt<std::string>
+ArgSOName("soname",
+          cl::desc("Set internal name of shared library"),
+          cl::value_desc("name"));
+
+static cl::opt<bool>
+ArgNoUndefined("no-undefined",
+               cl::desc("Do not allow unresolved references"),
+               cl::init(false));
+
+static cl::opt<bool>
+ArgAllowMulDefs("allow-multiple-definition",
+                cl::desc("Allow multiple definition"),
+                cl::init(false));
+
+static cl::opt<bool>
+ArgEhFrameHdr("eh-frame-hdr",
+              cl::ZeroOrMore,
+              cl::desc("Request creation of \".eh_frame_hdr\" section and ELF \"PT_GNU_EH_FRAME\" segment header."),
+              cl::init(false));
+
+static cl::list<mcld::ZOption, bool, llvm::cl::parser<mcld::ZOption> >
+ArgZOptionList("z",
+               cl::ZeroOrMore,
+               cl::desc("The -z options for GNU ld compatibility."),
+               cl::value_desc("keyword"),
+               cl::Prefix);
+
+cl::opt<mcld::CodeGenFileType>
+ArgFileType("filetype", cl::init(mcld::CGFT_EXEFile),
+  cl::desc("Choose a file type (not all types are supported by all targets):"),
+  cl::values(
+       clEnumValN(mcld::CGFT_ASMFile, "asm",
+                  "Emit an assembly ('.s') file"),
+       clEnumValN(mcld::CGFT_OBJFile, "obj",
+                  "Emit a relocatable object ('.o') file"),
+       clEnumValN(mcld::CGFT_DSOFile, "dso",
+                  "Emit an dynamic shared object ('.so') file"),
+       clEnumValN(mcld::CGFT_EXEFile, "exe",
+                  "Emit a executable ('.exe') file"),
+       clEnumValN(mcld::CGFT_NULLFile, "null",
+                  "Emit nothing, for performance testing"),
+       clEnumValEnd));
+
+static cl::opt<bool>
+ArgShared("shared",
+          cl::desc("Create a shared library."),
+          cl::init(false));
+
+static cl::alias
+ArgSharedAlias("Bshareable",
+               cl::desc("alias for -shared"),
+               cl::aliasopt(ArgShared));
+
+static cl::opt<bool>
+ArgPIE("pie",
+       cl::desc("Emit a position-independent executable file"),
+       cl::init(false));
+
+static cl::opt<bool>
+ArgRelocatable("relocatable",
+               cl::desc("Generate relocatable output"),
+               cl::init(false));
+
+static cl::alias
+ArgRelocatableAlias("r",
+                    cl::desc("alias for --relocatable"),
+                    cl::aliasopt(ArgRelocatable));
+
+static cl::opt<Reloc::Model>
+ArgRelocModel("relocation-model",
+             cl::desc("Choose relocation model"),
+             cl::init(Reloc::Default),
+             cl::values(
+               clEnumValN(Reloc::Default, "default",
+                       "Target default relocation model"),
+               clEnumValN(Reloc::Static, "static",
+                       "Non-relocatable code"),
+               clEnumValN(Reloc::PIC_, "pic",
+                       "Fully relocatable, position independent code"),
+               clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic",
+                       "Relocatable external references, non-relocatable code"),
+               clEnumValEnd));
+
+static cl::opt<bool>
+ArgFPIC("fPIC",
+        cl::desc("Set relocation model to pic. The same as -relocation-model=pic."),
+        cl::init(false));
+
+static cl::opt<std::string>
+ArgDyld("dynamic-linker",
+        cl::ZeroOrMore,
+        cl::desc("Set the name of the dynamic linker."),
+        cl::value_desc("Program"));
+
+namespace color {
+enum Color {
+  Never,
+  Always,
+  Auto
+};
+} // namespace of color
+
+static cl::opt<color::Color>
+ArgColor("color",
+  cl::value_desc("WHEN"),
+  cl::desc("Surround the result strings with the marker"),
+  cl::init(color::Auto),
+  cl::values(
+    clEnumValN(color::Never, "never",
+      "do not surround result strings"),
+    clEnumValN(color::Always, "always",
+      "always surround result strings, even the output is a plain file"),
+    clEnumValN(color::Auto, "auto",
+      "surround result strings only if the output is a tty"),
+    clEnumValEnd));
+
+static cl::opt<bool>
+ArgDiscardLocals("discard-locals",
+                 cl::desc("Delete all temporary local symbols."),
+                 cl::init(false));
+
+static cl::alias
+ArgDiscardLocalsAlias("X",
+                      cl::desc("alias for --discard-locals"),
+                      cl::aliasopt(ArgDiscardLocals));
+
+static cl::opt<bool>
+ArgDiscardAll("discard-all",
+              cl::desc("Delete all local symbols."),
+              cl::init(false));
+
+static cl::alias
+ArgDiscardAllAlias("x",
+                   cl::desc("alias for --discard-all"),
+                   cl::aliasopt(ArgDiscardAll));
+
+static cl::opt<bool>
+ArgStripDebug("strip-debug",
+              cl::desc("Omit debugger symbol information from the output file."),
+              cl::init(false));
+
+static cl::alias
+ArgStripDebugAlias("S",
+                   cl::desc("alias for --strip-debug"),
+                   cl::aliasopt(ArgStripDebug));
+
+static cl::opt<bool>
+ArgStripAll("strip-all",
+            cl::desc("Omit all symbol information from the output file."),
+            cl::init(false));
+
+static cl::alias
+ArgStripAllAlias("s",
+                 cl::desc("alias for --strip-all"),
+                 cl::aliasopt(ArgStripAll));
+
+static cl::opt<bool>
+ArgNMagic("nmagic",
+          cl::desc("Do not page align data"),
+          cl::init(false));
+
+static cl::alias
+ArgNMagicAlias("n",
+               cl::desc("alias for --nmagic"),
+               cl::aliasopt(ArgNMagic));
+
+static cl::opt<bool>
+ArgOMagic("omagic",
+          cl::desc("Do not page align data, do not make text readonly"),
+          cl::init(false));
+
+static cl::alias
+ArgOMagicAlias("N",
+               cl::desc("alias for --omagic"),
+               cl::aliasopt(ArgOMagic));
 
 
-static llvm::cl::opt<bool>
-OptShared("shared",
-          llvm::cl::desc("Create a shared library."),
-          llvm::cl::init(false));
+static cl::opt<int>
+ArgGPSize("G",
+          cl::desc("Set the maximum size of objects to be optimized using GP"),
+          cl::init(8));
 
-static llvm::cl::opt<bool>
-OptBsymbolic("Bsymbolic",
-             llvm::cl::desc("Bind references within the shared library."),
-             llvm::cl::init(true));
+static bool ArgGenUnwindInfo;
 
-static llvm::cl::opt<std::string>
-OptDyld("dynamic-linker",
-        llvm::cl::desc("Set the name of the dynamic linker."),
-        llvm::cl::value_desc("Program"));
+static cl::opt<bool, true, cl::FalseParser>
+ArgNoGenUnwindInfoFlag("no-ld-generated-unwind-info",
+                       cl::ZeroOrMore, cl::location(ArgGenUnwindInfo),
+                       cl::desc("Don't create unwind info for linker generated"
+                                " sections to save size"),
+                       cl::init(false),
+                       cl::ValueDisallowed);
+static cl::opt<bool, true>
+ArgGenUnwindInfoFlag("ld-generated-unwind-info",
+                     cl::ZeroOrMore, cl::location(ArgGenUnwindInfo),
+                     cl::desc("Request creation of unwind info for linker"
+                              " generated code sections like PLT."),
+                     cl::init(true),
+                     cl::ValueDisallowed);
+/// @{
+/// @{
+/// @name FIXME: begin of unsupported options
+/// @}
+static cl::opt<bool>
+ArgGCSections("gc-sections",
+              cl::ZeroOrMore,
+              cl::desc("Enable garbage collection of unused input sections."),
+              cl::init(false));
 
-static llvm::cl::opt<bool>
-OptRelocatable("relocatable",
-               llvm::cl::desc("Generate relocatable output"),
-               llvm::cl::init(false));
+static cl::opt<bool>
+ArgNoGCSections("no-gc-sections",
+                cl::ZeroOrMore,
+                cl::desc("disable garbage collection of unused input sections."),
+                cl::init(false));
 
-static llvm::cl::alias
-OptRelocatableAlias("r",
-                    llvm::cl::desc("alias for --relocatable"),
-                    llvm::cl::aliasopt(OptRelocatable));
+namespace icf {
+enum Mode {
+  None,
+  All,
+  Safe
+};
+} // namespace of icf
 
-static llvm::cl::opt<bool>
-OptDefineCommon("d",
-                llvm::cl::ZeroOrMore,
-                llvm::cl::desc("Define common symbol"),
-                llvm::cl::init(false));
+static cl::opt<icf::Mode>
+ArgICF("icf",
+       cl::ZeroOrMore,
+       cl::desc("Identical Code Folding"),
+       cl::init(icf::None),
+       cl::values(
+         clEnumValN(icf::None, "none",
+           "do not perform cold folding"),
+         clEnumValN(icf::All, "all",
+           "always preform cold folding"),
+         clEnumValN(icf::Safe, "safe",
+           "Folds ctors, dtors and functions whose pointers are definitely not taken."),
+         clEnumValEnd));
 
-static llvm::cl::alias
-OptDefineCommonAlias1("dc",
-                      llvm::cl::desc("alias for -d"),
-                      llvm::cl::aliasopt(OptDefineCommon));
+// FIXME: add this to target options?
+static cl::opt<bool>
+ArgFIXCA8("fix-cortex-a8",
+          cl::desc("Enable Cortex-A8 Thumb-2 branch erratum fix"),
+          cl::init(false));
 
-static llvm::cl::alias
-OptDefineCommonAlias2("dp",
-                      llvm::cl::desc("alias for -d"),
-                      llvm::cl::aliasopt(OptDefineCommon));
+static cl::opt<bool>
+ArgExportDynamic("export-dynamic",
+                 cl::desc("Export all dynamic symbols"),
+                 cl::init(false));
 
+static cl::alias
+ArgExportDynamicAlias("E",
+                      cl::desc("alias for --export-dynamic"),
+                      cl::aliasopt(ArgExportDynamic));
 
-//===----------------------------------------------------------------------===//
-// Inputs
-//===----------------------------------------------------------------------===//
-static llvm::cl::list<std::string>
-OptInputObjectFiles(llvm::cl::Positional,
-                    llvm::cl::desc("[input object files]"),
-                    llvm::cl::OneOrMore);
+static cl::opt<std::string>
+ArgEmulation("m",
+             cl::ZeroOrMore,
+             cl::desc("Set GNU linker emulation"),
+             cl::value_desc("emulation"),
+             cl::Prefix);
 
-static llvm::cl::list<std::string>
-OptNameSpecList("l",
-                llvm::cl::ZeroOrMore,
-                llvm::cl::desc("Add the archive or object file specified by "
-                               "namespec to the list of files to link."),
-                llvm::cl::value_desc("namespec"),
-                llvm::cl::Prefix);
+static cl::list<std::string, bool, llvm::cl::SearchDirParser>
+ArgRuntimePathLink("rpath-link",
+                   cl::ZeroOrMore,
+                   cl::desc("Add a directory to the link time library search path"),
+                   cl::value_desc("dir"));
+
+static cl::list<std::string>
+ArgExcludeLIBS("exclude-libs",
+               cl::CommaSeparated,
+               cl::desc("Exclude libraries from automatic export"),
+               cl::value_desc("lib1,lib2,..."));
+
+static cl::opt<std::string>
+ArgBuildID("build-id",
+           cl::desc("Request creation of \".note.gnu.build-id\" ELF note section."),
+           cl::value_desc("style"),
+           cl::ValueOptional);
+
+static cl::opt<std::string>
+ArgForceUndefined("u",
+                  cl::desc("Force symbol to be undefined in the output file"),
+                  cl::value_desc("symbol"));
+
+static cl::alias
+ArgForceUndefinedAlias("undefined",
+                       cl::desc("alias for -u"),
+                       cl::aliasopt(ArgForceUndefined));
+
+static cl::opt<std::string>
+ArgVersionScript("version-script",
+                 cl::desc("Version script."),
+                 cl::value_desc("Version script"));
+
+static cl::opt<bool>
+ArgWarnCommon("warn-common",
+              cl::desc("warn common symbol"),
+              cl::init(false));
+
+static cl::opt<mcld::GeneralOptions::HashStyle>
+ArgHashStyle("hash-style", cl::init(mcld::GeneralOptions::SystemV),
+  cl::desc("Set the type of linker's hash table(s)."),
+  cl::values(
+       clEnumValN(mcld::GeneralOptions::SystemV, "sysv",
+                 "classic ELF .hash section"),
+       clEnumValN(mcld::GeneralOptions::GNU, "gnu",
+                 "new style GNU .gnu.hash section"),
+       clEnumValN(mcld::GeneralOptions::Both, "both",
+                 "both the classic ELF and new style GNU hash tables"),
+       clEnumValEnd));
+
+static cl::opt<std::string>
+ArgFilter("F",
+          cl::desc("Filter for shared object symbol table"),
+          cl::value_desc("name"));
+
+static cl::alias
+ArgFilterAlias("filter",
+               cl::desc("alias for -F"),
+               cl::aliasopt(ArgFilterAlias));
+
+static cl::list<std::string>
+ArgAuxiliary("f",
+             cl::ZeroOrMore,
+             cl::desc("Auxiliary filter for shared object symbol table"),
+             cl::value_desc("name"));
+
+static cl::alias
+ArgAuxiliaryAlias("auxiliary",
+                  cl::desc("alias for -f"),
+                  cl::aliasopt(ArgAuxiliary));
+
+static cl::opt<bool>
+ArgUseGold("use-gold",
+          cl::desc("GCC/collect2 compatibility: uses ld.gold.  Ignored"),
+          cl::init(false));
+
+static cl::opt<bool>
+ArgUseMCLD("use-mcld",
+          cl::desc("GCC/collect2 compatibility: uses ld.mcld.  Ignored"),
+          cl::init(false));
+
+static cl::opt<bool>
+ArgUseLD("use-ld",
+          cl::desc("GCC/collect2 compatibility: uses ld.bfd.  Ignored"),
+          cl::init(false));
+
+static cl::opt<bool>
+ArgEB("EB",
+      cl::desc("Link big-endian objects. This affects the default output format."),
+      cl::init(false));
+
+static cl::opt<bool>
+ArgEL("EL",
+      cl::desc("Link little-endian objects. This affects the default output format."),
+      cl::init(false));
+
+static cl::list<std::string>
+ArgPlugin("plugin",
+          cl::desc("Load a plugin library."),
+          cl::value_desc("plugin"));
+
+static cl::list<std::string>
+ArgPluginOpt("plugin-opt",
+             cl::desc("	Pass an option to the plugin."),
+             cl::value_desc("option"));
+
+static cl::opt<bool>
+ArgSVR4Compatibility("Qy",
+                    cl::desc("This option is ignored for SVR4 compatibility"),
+                    cl::init(false));
+
+static cl::list<std::string>
+ArgY("Y",
+     cl::desc("Add path to the default library search path"),
+     cl::value_desc("default-search-path"));
+
+static cl::opt<bool>
+ArgARMCompatibility("p",
+                    cl::desc("Ignore for ARM backward compatibility"),
+                    cl::init(false));
+
+/// @{
+/// @name FIXME: end of unsupported options
+/// @}
+
+static cl::opt<bool>
+ArgNoWarnMismatch("no-warn-mismatch",
+                  cl::desc("Allow linking together mismatched input files."),
+                  cl::init(false));
+
+static cl::opt<bool>
+ArgNoStdlib("nostdlib",
+            cl::desc("Only search lib dirs explicitly specified on cmdline"),
+            cl::init(false));
+
+static cl::list<std::string, bool, llvm::cl::SearchDirParser>
+ArgRuntimePath("rpath",
+               cl::ZeroOrMore,
+               cl::desc("Add a directory to the runtime library search path"),
+               cl::value_desc("dir"));
+
+static cl::alias
+ArgRuntimePathAlias("R",
+                    cl::desc("alias for --rpath"),
+                    cl::aliasopt(ArgRuntimePath), cl::Prefix);
+
+static cl::opt<bool>
+ArgEnableNewDTags("enable-new-dtags",
+                  cl::desc("Enable use of DT_RUNPATH and DT_FLAGS"),
+                  cl::init(false));
+
+static cl::opt<bool>
+ArgPrintMap("M",
+            cl::desc("Print a link map to the standard output."),
+            cl::init(false));
+
+static cl::alias
+ArgPrintMapAlias("print-map",
+                 cl::desc("alias for -M"),
+                 cl::aliasopt(ArgPrintMap));
+
+static bool ArgFatalWarnings;
+
+static cl::opt<bool, true, cl::FalseParser>
+ArgNoFatalWarnings("no-fatal-warnings",
+              cl::location(ArgFatalWarnings),
+              cl::desc("do not turn warnings into errors"),
+              cl::init(false),
+              cl::ValueDisallowed);
+
+static cl::opt<bool, true>
+ArgFatalWarningsFlag("fatal-warnings",
+              cl::location(ArgFatalWarnings),
+              cl::desc("turn all warnings into errors"),
+              cl::init(false),
+              cl::ValueDisallowed);
+
+static cl::opt<bool>
+ArgWarnSharedTextrel("warn-shared-textrel",
+                     cl::desc("Warn if adding DT_TEXTREL in a shared object."),
+                     cl::init(false));
+
+namespace format {
+enum Format {
+  Binary,
+  Unknown // decided by triple
+};
+} // namespace of format
+
+static cl::opt<format::Format>
+ArgFormat("b",
+  cl::value_desc("Format"),
+  cl::desc("set input format"),
+  cl::init(format::Unknown),
+  cl::values(
+    clEnumValN(format::Binary, "binary",
+      "read in binary machine code."),
+    clEnumValEnd));
+
+static cl::alias
+ArgFormatAlias("format",
+               cl::desc("alias for -b"),
+               cl::aliasopt(ArgFormat));
+
+static cl::opt<format::Format>
+ArgOFormat("oformat",
+  cl::value_desc("Format"),
+  cl::desc("set output format"),
+  cl::init(format::Unknown),
+  cl::values(
+    clEnumValN(format::Binary, "binary",
+      "generate binary machine code."),
+    clEnumValEnd));
+
+static cl::opt<bool>
+ArgDefineCommon("d",
+                cl::ZeroOrMore,
+                cl::desc("Define common symbol"),
+                cl::init(false));
+
+static cl::alias
+ArgDefineCommonAlias1("dc",
+                      cl::ZeroOrMore,
+                      cl::desc("alias for -d"),
+                      cl::aliasopt(ArgDefineCommon));
+
+static cl::alias
+ArgDefineCommonAlias2("dp",
+                      cl::ZeroOrMore,
+                      cl::desc("alias for -d"),
+                      cl::aliasopt(ArgDefineCommon));
 
 //===----------------------------------------------------------------------===//
 // Scripting Options
 //===----------------------------------------------------------------------===//
-static llvm::cl::list<std::string>
-OptWrapList("wrap",
-            llvm::cl::ZeroOrMore,
-            llvm::cl::desc("Use a wrap function fo symbol."),
-            llvm::cl::value_desc("symbol"));
+static cl::list<std::string>
+ArgWrapList("wrap",
+            cl::ZeroOrMore,
+            cl::desc("Use a wrap function fo symbol."),
+            cl::value_desc("symbol"));
 
-static llvm::cl::list<std::string>
-OptPortableList("portable",
-                llvm::cl::ZeroOrMore,
-                llvm::cl::desc("Use a portable function to symbol."),
-                llvm::cl::value_desc("symbol"));
+static cl::list<std::string>
+ArgPortList("portable",
+            cl::ZeroOrMore,
+            cl::desc("Use a portable function fo symbol."),
+            cl::value_desc("symbol"));
+
+static cl::list<std::string>
+ArgAddressMapList("section-start",
+                  cl::ZeroOrMore,
+                  cl::desc("Locate a output section at the given absolute address"),
+                  cl::value_desc("Set address of section"),
+                  cl::Prefix);
+
+static cl::opt<unsigned long long>
+ArgBssSegAddr("Tbss",
+              cl::desc("Set the address of the bss segment"),
+              cl::init(-1U));
+
+static cl::opt<unsigned long long>
+ArgDataSegAddr("Tdata",
+               cl::desc("Set the address of the data segment"),
+               cl::init(-1U));
+
+static cl::opt<unsigned long long>
+ArgTextSegAddr("Ttext",
+               cl::desc("Set the address of the text segment"),
+               cl::init(-1U));
+
+static cl::alias
+ArgTextSegAddrAlias("Ttext-segment",
+                    cl::desc("alias for -Ttext"),
+                    cl::aliasopt(ArgTextSegAddr));
 
 //===----------------------------------------------------------------------===//
-// Helper Functions
+// non-member functions
 //===----------------------------------------------------------------------===//
-// Override "mcld -version"
-static void MCLDVersionPrinter() {
-  llvm::raw_ostream &os = llvm::outs();
-  os << "mcld (The MCLinker Project, http://mclinker.googlecode.com/):\n"
-     << "  version: " MCLD_VERSION "\n"
-     << "  Default target: " << DEFAULT_TARGET_TRIPLE_STRING << "\n";
+/// GetOutputStream - get the output stream.
+static mcld::ToolOutputFile *GetOutputStream(const char* pTargetName,
+                                             Triple::OSType pOSType,
+                                             mcld::CodeGenFileType pFileType,
+                                             const mcld::sys::fs::Path& pInputFilename,
+                                             mcld::sys::fs::Path& pOutputFilename)
+{
+  if (pOutputFilename.empty()) {
+    if (0 == pInputFilename.native().compare("-"))
+      pOutputFilename.assign("-");
+    else {
+      switch(pFileType) {
+      case mcld::CGFT_ASMFile: {
+        if (0 == pInputFilename.native().compare("-"))
+          pOutputFilename.assign("_out");
+        else
+          pOutputFilename.assign(pInputFilename.stem().native());
 
-  os << "\n";
+        if (0 == strcmp(pTargetName, "c"))
+          pOutputFilename.native() += ".cbe.c";
+        else if (0 == strcmp(pTargetName, "cpp"))
+          pOutputFilename.native() += ".cpp";
+        else
+          pOutputFilename.native() += ".s";
+      }
+      break;
 
-  os << "LLVM (http://llvm.org/):\n";
+      case mcld::CGFT_OBJFile: {
+        if (0 == pInputFilename.native().compare("-"))
+          pOutputFilename.assign("_out");
+        else
+          pOutputFilename.assign(pInputFilename.stem().native());
 
-  return;
+        if (pOSType == Triple::Win32)
+          pOutputFilename.native() += ".obj";
+        else
+          pOutputFilename.native() += ".o";
+      }
+      break;
+
+      case mcld::CGFT_PARTIAL: {
+        if (Triple::Win32 == pOSType) {
+          if (0 == pInputFilename.native().compare("-"))
+            pOutputFilename.assign("_out");
+          else
+            pOutputFilename.assign(pInputFilename.stem().native());
+          pOutputFilename.native() += ".obj";
+        }
+        else
+          pOutputFilename.assign("a.out");
+      }
+      break;
+
+      case mcld::CGFT_DSOFile: {
+        if (Triple::Win32 == pOSType) {
+          if (0 == pInputFilename.native().compare("-"))
+            pOutputFilename.assign("_out");
+          else
+            pOutputFilename.assign(pInputFilename.stem().native());
+          pOutputFilename.native() += ".dll";
+        }
+        else
+          pOutputFilename.assign("a.out");
+      }
+      break;
+
+      case mcld::CGFT_EXEFile: {
+        if (Triple::Win32 == pOSType) {
+          if (0 == pInputFilename.native().compare("-"))
+            pOutputFilename.assign("_out");
+          else
+            pOutputFilename.assign(pInputFilename.stem().native());
+          pOutputFilename.native() += ".exe";
+        }
+        else
+          pOutputFilename.assign("a.out");
+      }
+      break;
+
+      case mcld::CGFT_NULLFile:
+        break;
+      default:
+        llvm::report_fatal_error("Unknown output file type.\n");
+      } // end of switch
+    } // end of ! pInputFilename == "-"
+  } // end of if empty pOutputFilename
+
+  mcld::FileHandle::Permission permission;
+  switch (pFileType) {
+  default: assert(0 && "Unknown file type");
+  case mcld::CGFT_ASMFile:
+  case mcld::CGFT_OBJFile:
+  case mcld::CGFT_PARTIAL:
+    permission = mcld::FileHandle::Permission(0x644);
+    break;
+  case mcld::CGFT_DSOFile:
+  case mcld::CGFT_EXEFile:
+  case mcld::CGFT_BINARY:
+  case mcld::CGFT_NULLFile:
+    permission = mcld::FileHandle::Permission(0x755);
+    break;
+  }
+
+  // Open the file.
+  mcld::ToolOutputFile* result_output =
+    new mcld::ToolOutputFile(pOutputFilename,
+                             mcld::FileHandle::ReadWrite |
+                               mcld::FileHandle::Create |
+                               mcld::FileHandle::Truncate,
+                             permission);
+
+  return result_output;
 }
 
-#define DEFAULT_OUTPUT_PATH "a.out"
-static inline
-std::string DetermineOutputFilename(const std::string &pOutputPath) {
-  if (!pOutputPath.empty()) {
-    return pOutputPath;
+/// ParseProgName - Parse program name
+/// This function simplifies cross-compiling by reading triple from the program
+/// name. For example, if the program name is `arm-linux-eabi-ld.mcld', we can
+/// get the triple is arm-linux-eabi by the program name.
+static std::string ParseProgName(const char *progname)
+{
+  static const char *suffixes[] = {
+    "ld",
+    "ld.mcld",
+  };
+
+  std::string ProgName(mcld::sys::fs::Path(progname).stem().native());
+
+  for (size_t i = 0; i < sizeof(suffixes) / sizeof(suffixes[0]); ++i) {
+    if (ProgName == suffixes[i])
+      return std::string();
   }
 
-  // User does't specify the value to -o
-  if (OptInputObjectFiles.size() > 1) {
-    llvm::errs() << "Use " DEFAULT_OUTPUT_PATH " for output file!\n";
-    return DEFAULT_OUTPUT_PATH;
+  StringRef ProgNameRef(ProgName);
+  StringRef Prefix;
+
+  for (size_t i = 0; i < sizeof(suffixes) / sizeof(suffixes[0]); ++i) {
+    if (!ProgNameRef.endswith(suffixes[i]))
+      continue;
+
+    StringRef::size_type LastComponent = ProgNameRef.rfind('-',
+      ProgNameRef.size() - strlen(suffixes[i]));
+    if (LastComponent == StringRef::npos)
+      continue;
+    StringRef Prefix = ProgNameRef.slice(0, LastComponent);
+    std::string IgnoredError;
+    if (!mcld::TargetRegistry::lookupTarget(Prefix, IgnoredError))
+      continue;
+    return Prefix.str();
   }
-
-  // There's only one input file
-  const std::string &input_path = OptInputObjectFiles[0];
-  llvm::SmallString<200> output_path(input_path);
-
-  llvm::error_code err = llvm::sys::fs::make_absolute(output_path);
-  if (llvm::errc::success != err) {
-    llvm::errs() << "Failed to determine the absolute path of `" << input_path
-                 << "'! (detail: " << err.message() << ")\n";
-    return "";
-  }
-
-  llvm::sys::path::remove_filename(output_path);
-  llvm::sys::path::append(output_path, "a.out");
-
-  return output_path.c_str();
+  return std::string();
 }
 
-static inline
-bool ConfigLinker(Linker &pLinker, const std::string &pOutputFilename) {
-  LinkerConfig* config = NULL;
+static Triple ParseEmulation(const std::string& pEmulation)
+{
+  Triple result = StringSwitch<Triple>(pEmulation)
+    .Case("armelf_linux_eabi", Triple("arm", "", "linux", "gnueabi"))
+    .Case("elf_i386",          Triple("i386", "", "", "gnu"))
+    .Case("elf_x86_64",        Triple("x86_64", "", "", "gnu"))
+    .Case("elf32_x86_64",      Triple("x86_64", "", "", "gnux32"))
+    .Case("elf_i386_fbsd",     Triple("i386", "", "freebsd", "gnu"))
+    .Case("elf_x86_64_fbsd",   Triple("x86_64", "", "freebsd", "gnu"))
+    .Case("elf32ltsmip",       Triple("mipsel", "", "", "gnu"))
+    .Default(Triple());
 
-#ifdef TARGET_BUILD
-  config = new (std::nothrow) DefaultLinkerConfig();
-#else
-  config = new (std::nothrow) GeneralLinkerConfig(OptTargetTriple);
+  if (result.getArch()        == Triple::UnknownArch &&
+      result.getOS()          == Triple::UnknownOS &&
+      result.getEnvironment() == Triple::UnknownEnvironment)
+    mcld::error(mcld::diag::err_invalid_emulation) << pEmulation << "\n";
+
+  return result;
+}
+
+static bool ShouldColorize()
+{
+   const char* term = getenv("TERM");
+   return term && (0 != strcmp(term, "dumb"));
+}
+
+static bool ProcessLinkerOptionsFromCommand(mcld::LinkerScript& pScript,
+                                            mcld::LinkerConfig& pConfig)
+{
+  // -----  Set up General Options  ----- //
+  // set up colorize
+  switch (ArgColor) {
+    case color::Never:
+      pConfig.options().setColor(false);
+    break;
+    case color::Always:
+      pConfig.options().setColor(true);
+    break;
+    case color::Auto:
+      bool color_option = ShouldColorize() &&
+                 llvm::sys::Process::FileDescriptorIsDisplayed(STDOUT_FILENO);
+      pConfig.options().setColor(color_option);
+    break;
+  }
+
+  mcld::outs().setColor(pConfig.options().color());
+  mcld::errs().setColor(pConfig.options().color());
+
+  // set up soname
+  pConfig.options().setSOName(ArgSOName);
+
+  // add all rpath entries
+  cl::list<std::string>::iterator rp;
+  cl::list<std::string>::iterator rpEnd = ArgRuntimePath.end();
+  for (rp = ArgRuntimePath.begin(); rp != rpEnd; ++rp) {
+    pConfig.options().getRpathList().push_back(*rp);
+  }
+
+  // add all linker scripts
+  cl::list<std::string>::iterator sp;
+  cl::list<std::string>::iterator spEnd = ArgLinkerScript.end();
+  for (sp = ArgLinkerScript.begin(); sp != spEnd; ++sp) {
+    pConfig.options().getScriptList().push_back(*sp);
+  }
+
+  pConfig.options().setGenUnwindInfo(ArgGenUnwindInfo);
+
+  // --fatal-warnings
+  // pConfig.options().setFatalWarnings(ArgFatalWarnings);
+
+  // -shared or -pie
+  if (true == ArgShared || true == ArgPIE) {
+    ArgFileType = mcld::CGFT_DSOFile;
+  }
+  else if (true == ArgRelocatable) {
+    ArgFileType = mcld::CGFT_PARTIAL;
+  }
+  else if (format::Binary == ArgOFormat) {
+    ArgFileType = mcld::CGFT_BINARY;
+  }
+
+  // -b [input-format], --format=[input-format]
+  if (format::Binary == ArgFormat)
+    pConfig.options().setBinaryInput();
+
+  // -V
+  if (ArgVersion) {
+    mcld::outs() << "MCLinker - "
+                 << mcld::LinkerConfig::version()
+                 << "\n";
+  }
+
+  // set up sysroot
+  if (!ArgSysRoot.empty()) {
+    if (exists(ArgSysRoot) && is_directory(ArgSysRoot))
+      pScript.setSysroot(ArgSysRoot);
+  }
+
+  // add all search directories
+  cl::list<std::string>::iterator sd;
+  cl::list<std::string>::iterator sdEnd = ArgSearchDirList.end();
+  for (sd=ArgSearchDirList.begin(); sd!=sdEnd; ++sd) {
+    if (!pScript.directories().insert(*sd)) {
+      // FIXME: need a warning function
+      errs() << "WARNING: can not open search directory `-L"
+             << *sd
+             << "'.\n";
+    }
+  }
+
+  pConfig.options().setPIE(ArgPIE);
+  pConfig.options().setTrace(ArgTrace);
+  pConfig.options().setVerbose(ArgVerbose);
+  pConfig.options().setMaxErrorNum(ArgMaxErrorNum);
+  pConfig.options().setMaxWarnNum(ArgMaxWarnNum);
+  pConfig.options().setBsymbolic(ArgBsymbolic);
+  pConfig.options().setBgroup(ArgBgroup);
+  pConfig.options().setDyld(ArgDyld);
+  pConfig.options().setNoUndefined(ArgNoUndefined);
+  pConfig.options().setMulDefs(ArgAllowMulDefs);
+  pConfig.options().setEhFrameHdr(ArgEhFrameHdr);
+  pConfig.options().setNMagic(ArgNMagic);
+  pConfig.options().setOMagic(ArgOMagic);
+  pConfig.options().setStripDebug(ArgStripDebug || ArgStripAll);
+  pConfig.options().setExportDynamic(ArgExportDynamic);
+  pConfig.options().setWarnSharedTextrel(ArgWarnSharedTextrel);
+  pConfig.options().setDefineCommon(ArgDefineCommon);
+  pConfig.options().setNewDTags(ArgEnableNewDTags);
+  pConfig.options().setHashStyle(ArgHashStyle);
+  pConfig.options().setNoStdlib(ArgNoStdlib);
+  pConfig.options().setPrintMap(ArgPrintMap);
+  pConfig.options().setGCSections(ArgGCSections);
+  pConfig.options().setGPSize(ArgGPSize);
+  if (ArgNoWarnMismatch)
+    pConfig.options().setWarnMismatch(false);
+  else
+    pConfig.options().setWarnMismatch(true);
+
+  if (ArgStripAll)
+    pConfig.options().setStripSymbols(mcld::GeneralOptions::StripAllSymbols);
+  else if (ArgDiscardAll)
+    pConfig.options().setStripSymbols(mcld::GeneralOptions::StripLocals);
+  else if (ArgDiscardLocals)
+    pConfig.options().setStripSymbols(mcld::GeneralOptions::StripTemporaries);
+  else
+    pConfig.options().setStripSymbols(mcld::GeneralOptions::KeepAllSymbols);
+
+  // set up entry point from -e
+  pScript.setEntry(ArgEntry);
+
+  // set up rename map, for --wrap
+  cl::list<std::string>::iterator wname;
+  cl::list<std::string>::iterator wnameEnd = ArgWrapList.end();
+  for (wname = ArgWrapList.begin(); wname != wnameEnd; ++wname) {
+    bool exist = false;
+
+    // add wname -> __wrap_wname
+    mcld::StringEntry<llvm::StringRef>* to_wrap =
+                                     pScript.renameMap().insert(*wname, exist);
+
+    std::string to_wrap_str = "__wrap_" + *wname;
+    to_wrap->setValue(to_wrap_str);
+
+    if (exist)
+      mcld::warning(mcld::diag::rewrap) << *wname << to_wrap_str;
+
+    // add __real_wname -> wname
+    std::string from_real_str = "__real_" + *wname;
+    mcld::StringEntry<llvm::StringRef>* from_real =
+                              pScript.renameMap().insert(from_real_str, exist);
+    from_real->setValue(*wname);
+    if (exist)
+      mcld::warning(mcld::diag::rewrap) << *wname << from_real_str;
+  } // end of for
+
+  // set up rename map, for --portable
+  cl::list<std::string>::iterator pname;
+  cl::list<std::string>::iterator pnameEnd = ArgPortList.end();
+  for (pname = ArgPortList.begin(); pname != pnameEnd; ++pname) {
+    bool exist = false;
+
+    // add pname -> pname_portable
+    mcld::StringEntry<llvm::StringRef>* to_port =
+                                     pScript.renameMap().insert(*pname, exist);
+
+    std::string to_port_str = *pname + "_portable";
+    to_port->setValue(to_port_str);
+
+    if (exist)
+      mcld::warning(mcld::diag::rewrap) << *pname << to_port_str;
+
+    // add __real_pname -> pname
+    std::string from_real_str = "__real_" + *pname;
+    mcld::StringEntry<llvm::StringRef>* from_real =
+                              pScript.renameMap().insert(from_real_str, exist);
+
+    from_real->setValue(*pname);
+    if (exist)
+      mcld::warning(mcld::diag::rewrap) << *pname << from_real_str;
+  } // end of for
+
+  // add -z options
+  cl::list<mcld::ZOption>::iterator zOpt;
+  cl::list<mcld::ZOption>::iterator zOptEnd = ArgZOptionList.end();
+  for (zOpt = ArgZOptionList.begin(); zOpt != zOptEnd; ++zOpt) {
+    pConfig.options().addZOption(*zOpt);
+  }
+
+  // set up icf mode
+  switch (ArgICF) {
+    case icf::None:
+      break;
+    case icf::All:
+    case icf::Safe:
+    default:
+      mcld::warning(mcld::diag::warn_unsupported_option) << ArgICF.ArgStr;
+      break;
+  }
+
+  if (ArgFIXCA8) {
+    mcld::warning(mcld::diag::warn_unsupported_option) << ArgFIXCA8.ArgStr;
+  }
+
+  // add address mappings
+  // -Ttext
+  if (-1U != ArgTextSegAddr) {
+    bool exist = false;
+    mcld::StringEntry<uint64_t>* text_mapping =
+                                   pScript.addressMap().insert(".text", exist);
+    text_mapping->setValue(ArgTextSegAddr);
+  }
+  // -Tdata
+  if (-1U != ArgDataSegAddr) {
+    bool exist = false;
+    mcld::StringEntry<uint64_t>* data_mapping =
+                                   pScript.addressMap().insert(".data", exist);
+    data_mapping->setValue(ArgDataSegAddr);
+  }
+  // -Tbss
+  if (-1U != ArgBssSegAddr) {
+    bool exist = false;
+    mcld::StringEntry<uint64_t>* bss_mapping =
+                                    pScript.addressMap().insert(".bss", exist);
+    bss_mapping->setValue(ArgBssSegAddr);
+  }
+  // --section-start SECTION=ADDRESS
+  for (cl::list<std::string>::iterator
+       it = ArgAddressMapList.begin(), ie = ArgAddressMapList.end();
+       it != ie; ++it) {
+    // FIXME: Add a cl::parser
+    size_t pos = (*it).find_last_of('=');
+    llvm::StringRef script(*it);
+    uint64_t address = 0x0;
+    script.substr(pos + 1).getAsInteger(0, address);
+    bool exist = false;
+    mcld::StringEntry<uint64_t>* addr_mapping =
+                     pScript.addressMap().insert(script.substr(0, pos), exist);
+    addr_mapping->setValue(address);
+  }
+
+  // set up filter/aux filter for shared object
+  pConfig.options().setFilter(ArgFilter);
+
+  cl::list<std::string>::iterator aux;
+  cl::list<std::string>::iterator auxEnd = ArgAuxiliary.end();
+  for (aux = ArgAuxiliary.begin(); aux != auxEnd; ++aux)
+    pConfig.options().getAuxiliaryList().push_back(*aux);
+
+  return true;
+}
+
+int main(int argc, char* argv[])
+{
+  sys::PrintStackTraceOnErrorSignal();
+
+  LLVMContext &Context = getGlobalContext();
+  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
+
+  // Initialize targets first, so that --version shows registered targets.
+  InitializeAllTargets();
+  InitializeAllAsmPrinters();
+  InitializeAllAsmParsers();
+  InitializeAllTargetMCs();
+  mcld::InitializeAllTargets();
+  mcld::InitializeAllLinkers();
+  mcld::InitializeAllEmulations();
+  mcld::InitializeAllDiagnostics();
+
+  cl::ParseCommandLineOptions(argc, argv, "MCLinker\n");
+
+#ifdef ENABLE_UNITTEST
+  if (UnitTest) {
+    return unit_test( argc, argv );
+  }
 #endif
-  if (config == NULL) {
-    llvm::errs() << "Out of memory when create the linker configuration!\n";
-    return false;
+
+  // Load the module to be compiled...
+  std::auto_ptr<llvm::Module> M;
+
+  // Load the module to be linked...
+  mcld::LinkerScript LDScript;
+  mcld::Module LDIRModule(LDScript);
+  mcld::LinkerConfig LDConfig;
+
+  // Process the linker input from the command line
+  if (!ProcessLinkerOptionsFromCommand(LDScript, LDConfig)) {
+    errs() << argv[0] << ": failed to process linker options from command line!\n";
+    return 1;
   }
 
-  // Setup the configuration accroding to the command line options.
+  if (ArgBitcodeFilename.empty() &&
+      (mcld::CGFT_DSOFile != ArgFileType &&
+       mcld::CGFT_EXEFile != ArgFileType &&
+       mcld::CGFT_PARTIAL != ArgFileType &&
+       mcld::CGFT_BINARY  != ArgFileType)) {
+    // If the file is not given, forcefully read from stdin
+    if (ArgVerbose >= 0) {
+      errs() << "** The bitcode/llvm asm file is not given. Read from stdin.\n"
+             << "** Specify input bitcode/llvm asm file by\n\n"
+             << "          llvm-mcld -dB [the bitcode/llvm asm]\n\n";
+    }
 
-  // 1. Set up soname.
-  if (!OptSOName.empty()) {
-    config->setSOName(OptSOName);
+    ArgBitcodeFilename.assign("-");
+  }
+
+  if (!ArgBitcodeFilename.empty()) {
+    SMDiagnostic Err;
+    M.reset(ParseIRFile(ArgBitcodeFilename.native(), Err, Context));
+
+    if (M.get() == 0) {
+      Err.print(argv[0], errs());
+      errs() << "** Failed to to the given bitcode/llvm asm file '"
+             << ArgBitcodeFilename.native() << "'. **\n";
+      return 1;
+    }
+  }
+  else {
+    // If here, output must be dynamic shared object (mcld::CGFT_DSOFile) and
+    // executable file (mcld::CGFT_EXEFile).
+    M.reset(new Module("Empty Module", Context));
+  }
+  Module &mod = *M.get();
+
+  // If we are supposed to override the target triple, do so now.
+  Triple TheTriple;
+  if (!TargetTriple.empty()) {
+    // 1. Use the triple from command.
+    TheTriple.setTriple(TargetTriple);
+    mod.setTargetTriple(TargetTriple);
+  } else if (!mod.getTargetTriple().empty()) {
+    // 2. Use the triple in the input Module.
+    TheTriple.setTriple(mod.getTargetTriple());
   } else {
-    config->setSOName(pOutputFilename);
-  }
-
-  // 2. If given, set up sysroot.
-  if (!OptSysRoot.empty()) {
-    config->setSysRoot(OptSysRoot);
-  }
-
-  // 3. If given, set up dynamic linker path.
-  if (!OptDyld.empty()) {
-    config->setDyld(OptDyld);
-  }
-
-  // 4. If given, set up wrapped symbols.
-  llvm::cl::list<std::string>::iterator wrap, wrap_end = OptWrapList.end();
-  for (wrap = OptWrapList.begin(); wrap != wrap_end; ++wrap) {
-    config->addWrap(*wrap);
-  }
-
-  // 5. If given, set up portable symbols.
-  llvm::cl::list<std::string>::iterator portable, portable_end = OptPortableList.end();
-  for (portable = OptPortableList.begin(); portable != portable_end; ++portable) {
-    config->addPortable(*portable);
-  }
-
-  // 6. if given, set up search directories.
-  llvm::cl::list<std::string>::iterator sdir, sdir_end = OptSearchDirList.end();
-  for (sdir = OptSearchDirList.begin(); sdir != sdir_end; ++sdir) {
-    config->addSearchDir(*sdir);
-  }
-
-  // 7. Set up output's type.
-  config->setShared(OptShared);
-
-  // 8. Set up -Bsymbolic.
-  config->setBsymbolic(OptBsymbolic);
-
-  // 9. Set up -d (define common symbols)
-  config->setDefineCommon(OptDefineCommon);
-
-  Linker::ErrorCode result = pLinker.config(*config);
-  if (Linker::kSuccess != result) {
-    llvm::errs() << "Failed to configure the linker! (detail: "
-                 << Linker::GetErrorString(result) << ")\n";
-    return false;
-  }
-
-  return true;
-}
-
-static inline
-bool PrepareInputOutput(Linker &pLinker, const std::string &pOutputPath) {
-  // -----  Set output  ----- //
-
-  // FIXME: Current MCLinker requires one to set up output before inputs. The
-  // constraint will be relaxed in the furture.
-  Linker::ErrorCode result = pLinker.setOutput(pOutputPath);
-
-  if (Linker::kSuccess != result) {
-    llvm::errs() << "Failed to open the output file! (detail: "
-                 << pOutputPath << ": "
-                 << Linker::GetErrorString(result) << ")\n";
-    return false;
-  }
-
-  // -----  Set inputs  ----- //
-  llvm::cl::list<std::string>::iterator file_it = OptInputObjectFiles.begin();
-  llvm::cl::list<std::string>::iterator lib_it  = OptNameSpecList.begin();
-
-  llvm::cl::list<std::string>::iterator file_begin = OptInputObjectFiles.begin();
-  llvm::cl::list<std::string>::iterator lib_begin = OptNameSpecList.begin();
-  llvm::cl::list<std::string>::iterator file_end = OptInputObjectFiles.end();
-  llvm::cl::list<std::string>::iterator lib_end = OptNameSpecList.end();
-
-  unsigned lib_pos = 0, file_pos = 0;
-  while (true) {
-    if (lib_it != lib_end) {
-      lib_pos = OptNameSpecList.getPosition(lib_it - lib_begin);
+    std::string ProgNameTriple = ParseProgName(argv[0]);
+    if (!ProgNameTriple.empty()) {
+      // 3. Use the triple from the program name prefix.
+      TheTriple.setTriple(ProgNameTriple);
+      mod.setTargetTriple(ProgNameTriple);
     } else {
-      lib_pos = 0;
-    }
-
-    if (file_it != file_end) {
-      file_pos = OptInputObjectFiles.getPosition(file_it - file_begin);
-    } else {
-      file_pos = 0;
-    }
-
-    if ((file_pos != 0) && ((lib_pos == 0) || (file_pos < lib_pos))) {
-      result = pLinker.addObject(*file_it);
-      if (Linker::kSuccess != result) {
-        llvm::errs() << "Failed to open the input file! (detail: " << *file_it
-                     << ": " << Linker::GetErrorString(result) << ")\n";
-        return false;
-      }
-      ++file_it;
-    } else if ((lib_pos != 0) && ((file_pos == 0) || (lib_pos < file_pos))) {
-      result = pLinker.addNameSpec(*lib_it);
-      if (Linker::kSuccess != result) {
-        llvm::errs() << "Failed to open the namespec! (detail: " << *lib_it
-                     << ": " << Linker::GetErrorString(result) << ")\n";
-        return false;
-      }
-      ++lib_it;
-    } else {
-      break; // we're done with the list
+      // 4. Use the default target triple.
+      TheTriple.setTriple(mcld::sys::getDefaultTargetTriple());
     }
   }
 
-  return true;
+  // If a specific emulation was requested, apply it now.
+  if (!ArgEmulation.empty()) {
+    Triple EmulationTriple = ParseEmulation(ArgEmulation);
+    if (EmulationTriple.getArch() != Triple::UnknownArch)
+      TheTriple.setArch(EmulationTriple.getArch());
+    if (EmulationTriple.getOS() != Triple::UnknownOS)
+      TheTriple.setOS(EmulationTriple.getOS());
+    if (EmulationTriple.getEnvironment() != Triple::UnknownEnvironment)
+      TheTriple.setEnvironment(EmulationTriple.getEnvironment());
+  }
+
+  // Get the target specific parser.
+  std::string error;
+  const llvm::Target *LLVMTarget = llvm::TargetRegistry::lookupTarget(MArch,
+                                                                      TheTriple,
+                                                                      error);
+  if (NULL == LLVMTarget) {
+    errs() << argv[0] << ": " << error;
+    return 1;
+  }
+
+  // Allocate target machine.  First, check whether the user has explicitly
+  // specified an architecture to compile for. If so we have to look it up by
+  // name, because it might be a backend that has no mapping to a target triple.
+  const mcld::Target *MCLDTarget = mcld::TargetRegistry::lookupTarget(MArch,
+                                                                     TheTriple,
+                                                                     error);
+  if (NULL == MCLDTarget) {
+    errs() << argv[0] << ": " << error;
+    return 1;
+  }
+
+
+  LDConfig.targets().setTriple(TheTriple);
+
+  // Package up features to be passed to target/subtarget
+  std::string FeaturesStr;
+  if (MAttrs.size()) {
+    SubtargetFeatures Features;
+    for (unsigned i = 0; i != MAttrs.size(); ++i)
+      Features.AddFeature(MAttrs[i]);
+    FeaturesStr = Features.getString();
+  }
+
+  CodeGenOpt::Level OLvl = CodeGenOpt::Default;
+  switch (OptLevel) {
+  default:
+    errs() << argv[0] << ": invalid optimization level.\n";
+    return 1;
+  case ' ': break;
+  case '0': OLvl = CodeGenOpt::None; break;
+  case '1': OLvl = CodeGenOpt::Less; break;
+  case '2': OLvl = CodeGenOpt::Default; break;
+  case '3': OLvl = CodeGenOpt::Aggressive; break;
+  }
+
+  // set -fPIC
+  if (ArgFPIC)
+    ArgRelocModel = Reloc::PIC_;
+
+  TargetOptions Options;
+  Options.LessPreciseFPMADOption = EnableFPMAD;
+  Options.NoFramePointerElim = DisableFPElim;
+  Options.AllowFPOpFusion = FuseFPOps;
+  Options.UnsafeFPMath = EnableUnsafeFPMath;
+  Options.NoInfsFPMath = EnableNoInfsFPMath;
+  Options.NoNaNsFPMath = EnableNoNaNsFPMath;
+  Options.HonorSignDependentRoundingFPMathOption =
+      EnableHonorSignDependentRoundingFPMath;
+  Options.UseSoftFloat = GenerateSoftFloatCalls;
+  if (FloatABIForCalls != FloatABI::Default)
+    Options.FloatABIType = FloatABIForCalls;
+  Options.NoZerosInBSS = DontPlaceZerosInBSS;
+  Options.JITEmitDebugInfo = EmitJitDebugInfo;
+  Options.JITEmitDebugInfoToDisk = EmitJitDebugInfoToDisk;
+  Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
+  Options.StackAlignmentOverride = OverrideStackAlignment;
+  Options.TrapFuncName = TrapFuncName;
+  Options.EnableSegmentedStacks = SegmentedStacks;
+
+  OwningPtr<llvm::TargetMachine>
+    TM(LLVMTarget->createTargetMachine(TheTriple.getTriple(),
+                                       MCPU, FeaturesStr, Options,
+                                       ArgRelocModel, CMModel, OLvl));
+
+  std::auto_ptr<mcld::MCLDTargetMachine> target_machine(
+          MCLDTarget->createTargetMachine(TheTriple.getTriple(),
+                                        *LLVMTarget,
+                                        *TM.get()));
+
+  assert(target_machine.get() && "Could not allocate target machine!");
+  mcld::MCLDTargetMachine &TheTargetMachine = *target_machine.get();
+
+  LDConfig.targets().setTargetCPU(MCPU);
+  LDConfig.targets().setTargetFeatureString(FeaturesStr);
+
+  TheTargetMachine.getTM().setMCUseLoc(false);
+  TheTargetMachine.getTM().setMCUseCFI(false);
+
+  // FIXME: Move the initialization of LineInfo to mcld::Linker when we
+  // finish LineInfo's implementation.
+  OwningPtr<mcld::DiagnosticLineInfo>
+    diag_line_info(MCLDTarget->createDiagnosticLineInfo(*MCLDTarget,
+                                                       TheTriple.getTriple()));
+
+  mcld::getDiagnosticEngine().setLineInfo(*diag_line_info.take());
+
+  // Figure out where we are going to send the output...
+  OwningPtr<mcld::ToolOutputFile>
+  Out(GetOutputStream(MCLDTarget->name(),
+                      TheTriple.getOS(),
+                      ArgFileType,
+                      ArgBitcodeFilename,
+                      ArgOutputFilename));
+  if (!Out) {
+    // FIXME: show some error message pls.
+    return 1;
+  }
+
+  // Build up all of the passes that we want to do to the module.
+  PassManager PM;
+
+  // Add the data layout from the target machine, if it exists, or the module.
+  if (const DataLayout *DL = TheTargetMachine.getTM().getDataLayout())
+    PM.add(new DataLayout(*DL));
+   else
+    PM.add(new DataLayout(&mod));
+
+  // Override default to generate verbose assembly.
+  TheTargetMachine.getTM().setAsmVerbosityDefault(true);
+
+  {
+    // Ask the target to add backend passes as necessary.
+    if(TheTargetMachine.addPassesToEmitFile(PM,
+                                            *Out,
+                                            ArgFileType,
+                                            OLvl,
+                                            LDIRModule,
+                                            LDConfig,
+                                            NoVerify)) {
+      errs() << argv[0] << ": target does not support generation of this"
+             << " file type!\n";
+      return 1;
+    }
+
+    // Before executing passes, print the final values of the LLVM options.
+    cl::PrintOptionValues();
+
+    PM.run(mod);
+  }
+
+  if (mcld::getDiagnosticEngine().getPrinter()->getNumErrors())
+    return 1;
+
+  // Declare success.
+  Out->keep();
+  return 0;
 }
-
-static inline bool LinkFiles(Linker &pLinker) {
-  Linker::ErrorCode result = pLinker.link();
-  if (Linker::kSuccess != result) {
-    llvm::errs() << "Failed to linking! (detail: "
-                 << Linker::GetErrorString(result) << "\n";
-    return false;
-  }
-  return true;
-}
-
-int main(int argc, char** argv) {
-  llvm::cl::SetVersionPrinter(MCLDVersionPrinter);
-  llvm::cl::ParseCommandLineOptions(argc, argv);
-  init::Initialize();
-
-  std::string OutputFilename = DetermineOutputFilename(OptOutputFilename);
-  if (OutputFilename.empty()) {
-    return EXIT_FAILURE;
-  }
-
-  Linker linker;
-  if (!ConfigLinker(linker, OutputFilename)) {
-    return EXIT_FAILURE;
-  }
-
-  if (!PrepareInputOutput(linker, OutputFilename)) {
-    return EXIT_FAILURE;
-  }
-
-  if (!LinkFiles(linker)) {
-    return EXIT_FAILURE;
-  }
-
-  return EXIT_SUCCESS;
-}
-
diff --git a/unittests/BinTreeTest.cpp b/unittests/BinTreeTest.cpp
index 5d2cd0a..e436752 100644
--- a/unittests/BinTreeTest.cpp
+++ b/unittests/BinTreeTest.cpp
@@ -124,47 +124,46 @@
 
 TEST_F( BinTreeTest, DFSIterator_BasicTraversal)
 {
-  int a = 111;
+  int a = 111, b = 10, c = 9, d = 8, e = 7;
   BinaryTree<int>::iterator pos = m_pTestee->root();
 
   m_pTestee->join<InputTree::Inclusive>(pos,a);
   pos.move<InputTree::Inclusive>();
-  m_pTestee->join<InputTree::Positional>(pos,10);
-  m_pTestee->join<InputTree::Inclusive>(pos,9);
+  m_pTestee->join<InputTree::Positional>(pos,b);
+  m_pTestee->join<InputTree::Inclusive>(pos,c);
   pos.move<InputTree::Inclusive>();
-  m_pTestee->join<InputTree::Positional>(pos,8);
-  m_pTestee->join<InputTree::Inclusive>(pos,7);
+  m_pTestee->join<InputTree::Positional>(pos,d);
+  m_pTestee->join<InputTree::Inclusive>(pos,e);
 
   BinaryTree<int>::dfs_iterator dfs_it = m_pTestee->dfs_begin();
   BinaryTree<int>::dfs_iterator dfs_end = m_pTestee->dfs_end();
 
   ASSERT_EQ(111, **dfs_it);
   ++dfs_it;
-  ASSERT_EQ(9, **dfs_it);
+  EXPECT_EQ(9, **dfs_it);
   ++dfs_it;
-  ASSERT_EQ(7, **dfs_it);
+  EXPECT_EQ(7, **dfs_it);
   ++dfs_it;
-  ASSERT_EQ(8, **dfs_it);
+  EXPECT_EQ(8, **dfs_it);
   ++dfs_it;
-  ASSERT_EQ(10, **dfs_it);
+  EXPECT_EQ(10, **dfs_it);
   ++dfs_it;
-  ASSERT_TRUE( dfs_it ==  dfs_end);
-  BinaryTree<int>::bfs_iterator bfs_it = m_pTestee->bfs_begin();
-  BinaryTree<int>::bfs_iterator bfs_end = m_pTestee->bfs_end();
+  EXPECT_TRUE( dfs_it ==  dfs_end);
 }
 
 TEST_F( BinTreeTest, DFSIterator_RightMostTree)
 {
+  int a = 0, b = 1, c = 2, d = 3, e = 4;
   BinaryTree<int>::iterator pos = m_pTestee->root();
-  m_pTestee->join<InputTree::Inclusive>(pos,0);
+  m_pTestee->join<InputTree::Inclusive>(pos,a);
   pos.move<InputTree::Inclusive>();
-  m_pTestee->join<InputTree::Positional>(pos,1);
+  m_pTestee->join<InputTree::Positional>(pos,b);
   pos.move<InputTree::Positional>();
-  m_pTestee->join<InputTree::Positional>(pos,2);
+  m_pTestee->join<InputTree::Positional>(pos,c);
   pos.move<InputTree::Positional>();
-  m_pTestee->join<InputTree::Positional>(pos,3);
+  m_pTestee->join<InputTree::Positional>(pos,d);
   pos.move<InputTree::Positional>();
-  m_pTestee->join<InputTree::Positional>(pos,4);
+  m_pTestee->join<InputTree::Positional>(pos,e);
 
   BinaryTree<int>::dfs_iterator dfs_it = m_pTestee->dfs_begin();
   BinaryTree<int>::dfs_iterator dfs_end = m_pTestee->dfs_end();
@@ -199,16 +198,16 @@
 
 TEST_F( BinTreeTest, BFSIterator_BasicTraversal)
 {
-  int a = 111;
+  int a = 111, b = 10, c = 9, d = 8, e = 7;
   BinaryTree<int>::iterator pos = m_pTestee->root();
 
   m_pTestee->join<InputTree::Inclusive>(pos,a);
   pos.move<InputTree::Inclusive>();
-  m_pTestee->join<InputTree::Positional>(pos,10);
-  m_pTestee->join<InputTree::Inclusive>(pos,9);
+  m_pTestee->join<InputTree::Positional>(pos,b);
+  m_pTestee->join<InputTree::Inclusive>(pos,c);
   pos.move<InputTree::Inclusive>();
-  m_pTestee->join<InputTree::Positional>(pos,8);
-  m_pTestee->join<InputTree::Inclusive>(pos,7);
+  m_pTestee->join<InputTree::Positional>(pos,d);
+  m_pTestee->join<InputTree::Inclusive>(pos,e);
 
   BinaryTree<int>::bfs_iterator bfs_it = m_pTestee->bfs_begin();
   BinaryTree<int>::bfs_iterator bfs_end = m_pTestee->bfs_end();
@@ -230,16 +229,17 @@
 
 TEST_F( BinTreeTest, BFSIterator_RightMostTree)
 {
+  int a = 0, b = 1, c = 2, d = 3, e = 4;
   BinaryTree<int>::iterator pos = m_pTestee->root();
-  m_pTestee->join<InputTree::Inclusive>(pos,0);
+  m_pTestee->join<InputTree::Inclusive>(pos,a);
   pos.move<InputTree::Inclusive>();
-  m_pTestee->join<InputTree::Positional>(pos,1);
+  m_pTestee->join<InputTree::Positional>(pos,b);
   pos.move<InputTree::Positional>();
-  m_pTestee->join<InputTree::Positional>(pos,2);
+  m_pTestee->join<InputTree::Positional>(pos,c);
   pos.move<InputTree::Positional>();
-  m_pTestee->join<InputTree::Positional>(pos,3);
+  m_pTestee->join<InputTree::Positional>(pos,d);
   pos.move<InputTree::Positional>();
-  m_pTestee->join<InputTree::Positional>(pos,4);
+  m_pTestee->join<InputTree::Positional>(pos,e);
 
   BinaryTree<int>::bfs_iterator bfs_it = m_pTestee->bfs_begin();
   BinaryTree<int>::bfs_iterator bfs_end = m_pTestee->bfs_end();
@@ -274,17 +274,18 @@
 
 TEST_F( BinTreeTest, TreeIterator)
 {
+  int a = 0, b = 1, c = 2, d = 3, e = 4, f = 5;
   BinaryTree<int>::iterator pos = m_pTestee->root();
-  m_pTestee->join<InputTree::Inclusive>(pos,0);
+  m_pTestee->join<InputTree::Inclusive>(pos,a);
   pos.move<InputTree::Inclusive>();
-  m_pTestee->join<InputTree::Positional>(pos,1);
+  m_pTestee->join<InputTree::Positional>(pos,b);
   pos.move<InputTree::Positional>();
-  m_pTestee->join<InputTree::Inclusive>(pos,2);
-  m_pTestee->join<InputTree::Positional>(pos,5);
+  m_pTestee->join<InputTree::Inclusive>(pos,c);
+  m_pTestee->join<InputTree::Positional>(pos,f);
   pos.move<InputTree::Inclusive>();
-  m_pTestee->join<InputTree::Positional>(pos,3);
+  m_pTestee->join<InputTree::Positional>(pos,d);
   pos.move<InputTree::Positional>();
-  m_pTestee->join<InputTree::Positional>(pos,4);
+  m_pTestee->join<InputTree::Positional>(pos,e);
 
   BinaryTree<int>::iterator it = m_pTestee->begin();
   BinaryTree<int>::iterator end = m_pTestee->end();
diff --git a/unittests/DirIteratorTest.cpp b/unittests/DirIteratorTest.cpp
index f319172..13472ac 100644
--- a/unittests/DirIteratorTest.cpp
+++ b/unittests/DirIteratorTest.cpp
@@ -6,9 +6,9 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "mcld/Support/Directory.h"
+#include <mcld/Support/Directory.h>
 #include "DirIteratorTest.h"
-#include "errno.h"
+#include <errno.h>
 
 using namespace mcld;
 using namespace mcld::sys::fs;
diff --git a/unittests/ELFBinaryReaderTest.cpp b/unittests/ELFBinaryReaderTest.cpp
new file mode 100644
index 0000000..7792717
--- /dev/null
+++ b/unittests/ELFBinaryReaderTest.cpp
@@ -0,0 +1,64 @@
+//===- ELFBinaryReaderTest.cpp --------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/LD/ELFBinaryReader.h>
+#include <mcld/Module.h>
+#include <mcld/LinkerScript.h>
+#include <mcld/LinkerConfig.h>
+#include <mcld/IRBuilder.h>
+#include <mcld/GeneralOptions.h>
+#include <mcld/MC/Input.h>
+
+#include "ELFBinaryReaderTest.h"
+
+using namespace mcld;
+using namespace mcld::test;
+
+
+// Constructor can do set-up work for all test here.
+ELFBinaryReaderTest::ELFBinaryReaderTest()
+{
+}
+
+// Destructor can do clean-up work that doesn't throw exceptions here.
+ELFBinaryReaderTest::~ELFBinaryReaderTest()
+{
+}
+
+// SetUp() will be called immediately before each test.
+void ELFBinaryReaderTest::SetUp()
+{
+}
+
+// TearDown() will be called immediately after each test.
+void ELFBinaryReaderTest::TearDown()
+{
+}
+
+//===----------------------------------------------------------------------===//
+// Testcases
+//===----------------------------------------------------------------------===//
+TEST_F( ELFBinaryReaderTest, is_myformat) {
+  LinkerScript script;
+  Module module("test", script);
+  LinkerConfig config;
+  IRBuilder builder(module, config);
+  ELFBinaryReader *reader = new ELFBinaryReader(builder, config);
+
+  Input input("test.bin");
+
+  bool doContinue = false;
+  config.options().setBinaryInput();
+  ASSERT_TRUE(reader->isMyFormat(input, doContinue));
+
+  config.options().setBinaryInput(false);
+  ASSERT_FALSE(reader->isMyFormat(input, doContinue));
+
+  delete reader;
+}
+
diff --git a/unittests/ELFBinaryReaderTest.h b/unittests/ELFBinaryReaderTest.h
new file mode 100644
index 0000000..a9ea042
--- /dev/null
+++ b/unittests/ELFBinaryReaderTest.h
@@ -0,0 +1,39 @@
+//===- ELFBinaryReaderTest.h ----------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_ELFBINARYREADER_TEST_H
+#define MCLD_ELFBINARYREADER_TEST_H
+
+#include <gtest.h>
+
+namespace mcld {
+class ELFBinaryReader;
+
+namespace test {
+
+class ELFBinaryReaderTest : public ::testing::Test
+{
+public:
+  // Constructor can do set-up work for all test here.
+  ELFBinaryReaderTest();
+
+  // Destructor can do clean-up work that doesn't throw exceptions here.
+  virtual ~ELFBinaryReaderTest();
+
+  // SetUp() will be called immediately before each test.
+  virtual void SetUp();
+
+  // TearDown() will be called immediately after each test.
+  virtual void TearDown();
+};
+
+} // namespace of test
+} // namespace of mcld
+
+#endif
+
diff --git a/unittests/ELFReaderTest.cpp b/unittests/ELFReaderTest.cpp
index ddbc6d5..1ff2a31 100644
--- a/unittests/ELFReaderTest.cpp
+++ b/unittests/ELFReaderTest.cpp
@@ -8,12 +8,14 @@
 //===----------------------------------------------------------------------===//
 #include <cstdio>
 
+#include <llvm/ADT/StringRef.h>
 #include <llvm/Support/ELF.h>
 #include <mcld/IRBuilder.h>
 #include <mcld/TargetOptions.h>
 #include <mcld/LD/ELFReader.h>
-#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/Input.h>
 #include <mcld/Support/Path.h>
+#include <mcld/Support/MemoryArea.h>
 #include <../lib/Target/X86/X86LDBackend.h>
 #include <../lib/Target/X86/X86GNUInfo.h>
 
@@ -66,11 +68,10 @@
 
   ASSERT_TRUE(m_pInput->hasMemArea());
   size_t hdr_size = m_pELFReader->getELFHeaderSize();
-  MemoryRegion* region = m_pInput->memArea()->request(m_pInput->fileOffset(),
-                                                    hdr_size);
-  uint8_t* ELF_hdr = region->start();
+  llvm::StringRef region = m_pInput->memArea()->request(m_pInput->fileOffset(),
+                                                        hdr_size);
+  const char* ELF_hdr = region.begin();
   bool shdr_result = m_pELFReader->readSectionHeaders(*m_pInput, ELF_hdr);
-  m_pInput->memArea()->release(region);
   ASSERT_TRUE(shdr_result);
 }
 
@@ -109,22 +110,18 @@
   LDSection* strtab_shdr = symtab_shdr->getLink();
   ASSERT_TRUE(NULL!=strtab_shdr);
 
-  MemoryRegion* symtab_region = m_pInput->memArea()->request(
-                         m_pInput->fileOffset() + symtab_shdr->offset(),
-                         symtab_shdr->size());
+  llvm::StringRef symtab_region = m_pInput->memArea()->request(
+      m_pInput->fileOffset() + symtab_shdr->offset(), symtab_shdr->size());
 
-  MemoryRegion* strtab_region = m_pInput->memArea()->request(
-                         m_pInput->fileOffset() + strtab_shdr->offset(),
-                         strtab_shdr->size());
-  char* strtab = reinterpret_cast<char*>(strtab_region->start());
+  llvm::StringRef strtab_region = m_pInput->memArea()->request(
+      m_pInput->fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
+  const char* strtab = strtab_region.begin();
   bool result = m_pELFReader->readSymbols(*m_pInput, *m_pIRBuilder,
-                                          *symtab_region, strtab);
+                                          symtab_region, strtab);
   ASSERT_TRUE(result);
   ASSERT_EQ("hello.c", std::string(m_pInput->context()->getSymbol(1)->name()));
   ASSERT_EQ("puts", std::string(m_pInput->context()->getSymbol(10)->name()));
   ASSERT_TRUE(NULL==m_pInput->context()->getSymbol(11));
-  m_pInput->memArea()->release(symtab_region);
-  m_pInput->memArea()->release(strtab_region);
 
   // -- read relocations
   MemoryArea* mem = m_pInput->memArea();
@@ -134,12 +131,11 @@
 
   uint64_t offset = m_pInput->fileOffset() + (*rs)->offset();
   uint64_t size = (*rs)->size();
-  MemoryRegion* region = mem->request(offset, size);
+  llvm::StringRef region = mem->request(offset, size);
   IRBuilder::CreateRelocData(**rs); /// create relocation data for the header
 
   ASSERT_EQ(llvm::ELF::SHT_RELA, (*rs)->type());
-  ASSERT_TRUE(m_pELFReader->readRela(*m_pInput, **rs, *region));
-  mem->release(region);
+  ASSERT_TRUE(m_pELFReader->readRela(*m_pInput, **rs, region));
 
   const RelocData::RelocationListType &rRelocs =
                           (*rs)->getRelocData()->getRelocationList();
@@ -158,7 +154,8 @@
 }
 
 TEST_F( ELFReaderTest, is_my_format ) {
-  ASSERT_TRUE( m_pELFObjReader->isMyFormat(*m_pInput) );
+  bool doContinue;
+  ASSERT_TRUE( m_pELFObjReader->isMyFormat(*m_pInput, doContinue) );
 }
 
 
diff --git a/unittests/ELFReaderTest.h b/unittests/ELFReaderTest.h
index 58ec470..abe99b1 100644
--- a/unittests/ELFReaderTest.h
+++ b/unittests/ELFReaderTest.h
@@ -19,7 +19,7 @@
 #include <mcld/MC/InputBuilder.h>
 
 namespace mcld {
-  class ELFReader<64, true>;
+  template<> class ELFReader<64, true>;
 } // namespace for mcld
 
 namespace mcldtest
diff --git a/unittests/FragmentRefTest.cpp b/unittests/FragmentRefTest.cpp
index 599289d..881cdb8 100644
--- a/unittests/FragmentRefTest.cpp
+++ b/unittests/FragmentRefTest.cpp
@@ -14,6 +14,7 @@
 #include <mcld/Support/FileHandle.h>
 #include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/Path.h>
+#include <llvm/ADT/StringRef.h>
 
 using namespace mcld;
 using namespace mcld::sys::fs;
@@ -48,18 +49,18 @@
   MemoryAreaFactory* areaFactory = new MemoryAreaFactory(1);
   MemoryArea* area = areaFactory->produce(path, FileHandle::ReadWrite);
 
-  MemoryRegion* region = area->request(0, 4096);
-  RegionFragment *frag = new RegionFragment(*region);
+  llvm::StringRef region = area->request(0, 4096);
+  RegionFragment *frag = new RegionFragment(region);
   FragmentRef *ref = FragmentRef::Create(*frag, 0x0);
 
-  ASSERT_EQ('H', region->getBuffer()[0]);
-  ASSERT_TRUE(4096 == region->size());
-  ASSERT_EQ('H', frag->getRegion().getBuffer()[0]);
+  ASSERT_EQ('H', region.data()[0]);
+  ASSERT_TRUE(4096 == region.size());
+  ASSERT_EQ('H', frag->getRegion().data()[0]);
   ASSERT_TRUE(4096 == frag->getRegion().size());
   ASSERT_EQ(frag, ref->frag());
-  ASSERT_EQ('H', static_cast<RegionFragment*>(ref->frag())->getRegion().getBuffer()[0]);
+  ASSERT_EQ('H', static_cast<RegionFragment*>(ref->frag())->getRegion().data()[0]);
   ASSERT_TRUE(4096 == static_cast<RegionFragment*>(ref->frag())->getRegion().size());
-  ASSERT_EQ('H', ref->deref()[0]);
+  //ASSERT_EQ('H', ref->deref()[0]);
 
   ASSERT_TRUE(RegionFragment::classof(frag));
 
diff --git a/unittests/GraphTest.cpp b/unittests/GraphTest.cpp
new file mode 100644
index 0000000..38fc0d4
--- /dev/null
+++ b/unittests/GraphTest.cpp
@@ -0,0 +1,340 @@
+//===- GraphTest.cpp ------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "GraphTest.h"
+#include <mcld/ADT/GraphLite/Digraph.h>
+#include <mcld/ADT/GraphLite/ListDigraph.h>
+
+using namespace mcld;
+using namespace mcld::test;
+using namespace mcld::graph;
+
+// Constructor can do set-up work for all test here.
+GraphTest::GraphTest()
+{
+}
+
+// Destructor can do clean-up work that doesn't throw exceptions here.
+GraphTest::~GraphTest()
+{
+}
+
+// SetUp() will be called immediately before each test.
+void GraphTest::SetUp()
+{
+}
+
+// TearDown() will be called immediately after each test.
+void GraphTest::TearDown()
+{
+}
+
+//===----------------------------------------------------------------------===//
+// Testcases
+//===----------------------------------------------------------------------===//
+TEST_F(GraphTest, list_digraph_add_n_erase_nodes_1)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ASSERT_TRUE(NULL == u1->first_in);
+  ASSERT_TRUE(NULL == u1->first_out);
+  ASSERT_TRUE(u2   == u1->prev);
+  ASSERT_TRUE(NULL == u1->next);
+
+  ASSERT_TRUE(NULL == u2->first_in);
+  ASSERT_TRUE(NULL == u2->first_out);
+  ASSERT_TRUE(u3   == u2->prev);
+  ASSERT_TRUE(u1   == u2->next);
+
+  ASSERT_TRUE(NULL == u3->first_in);
+  ASSERT_TRUE(NULL == u3->first_out);
+  ASSERT_TRUE(u2   == u3->next);
+  ASSERT_TRUE(NULL == u3->prev);
+
+  ListDigraph::Node* head = NULL;
+  graph.getHead(head);
+  ASSERT_TRUE(head == u3);
+
+  graph.erase(*u2);
+
+  ASSERT_TRUE(NULL == u1->first_in);
+  ASSERT_TRUE(NULL == u1->first_out);
+  ASSERT_TRUE(u3   == u1->prev);
+  ASSERT_TRUE(NULL == u1->next);
+
+  ASSERT_TRUE(NULL == u3->first_in);
+  ASSERT_TRUE(NULL == u3->first_out);
+  ASSERT_TRUE(u1   == u3->next);
+  ASSERT_TRUE(NULL == u3->prev);
+
+  ASSERT_TRUE(NULL == u2->first_in);
+  ASSERT_TRUE(NULL == u2->first_out);
+  ASSERT_TRUE(NULL == u2->prev);
+  ASSERT_TRUE(NULL == u2->next);
+
+  graph.getHead(head);
+  ASSERT_TRUE(head == u3);
+}
+
+TEST_F(GraphTest, list_digraph_add_n_erase_nodes_2)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ASSERT_TRUE(NULL == u1->first_in);
+  ASSERT_TRUE(NULL == u1->first_out);
+  ASSERT_TRUE(u2   == u1->prev);
+  ASSERT_TRUE(NULL == u1->next);
+
+  ASSERT_TRUE(NULL == u2->first_in);
+  ASSERT_TRUE(NULL == u2->first_out);
+  ASSERT_TRUE(u3   == u2->prev);
+  ASSERT_TRUE(u1   == u2->next);
+
+  ASSERT_TRUE(NULL == u3->first_in);
+  ASSERT_TRUE(NULL == u3->first_out);
+  ASSERT_TRUE(u2   == u3->next);
+  ASSERT_TRUE(NULL == u3->prev);
+
+  ListDigraph::Node* head = NULL;
+  graph.getHead(head);
+  ASSERT_TRUE(head == u3);
+
+  graph.erase(*u1);
+
+  ASSERT_TRUE(NULL == u1->first_in);
+  ASSERT_TRUE(NULL == u1->first_out);
+  ASSERT_TRUE(NULL == u1->prev);
+  ASSERT_TRUE(NULL == u1->next);
+
+  ASSERT_TRUE(NULL == u2->first_in);
+  ASSERT_TRUE(NULL == u2->first_out);
+  ASSERT_TRUE(u3   == u2->prev);
+  ASSERT_TRUE(NULL == u2->next);
+
+  ASSERT_TRUE(NULL == u3->first_in);
+  ASSERT_TRUE(NULL == u3->first_out);
+  ASSERT_TRUE(u2   == u3->next);
+  ASSERT_TRUE(NULL == u3->prev);
+
+  graph.getHead(head);
+  ASSERT_TRUE(head == u3);
+}
+
+TEST_F(GraphTest, list_digraph_add_n_erase_nodes_3)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ASSERT_TRUE(NULL == u1->first_in);
+  ASSERT_TRUE(NULL == u1->first_out);
+  ASSERT_TRUE(u2   == u1->prev);
+  ASSERT_TRUE(NULL == u1->next);
+
+  ASSERT_TRUE(NULL == u2->first_in);
+  ASSERT_TRUE(NULL == u2->first_out);
+  ASSERT_TRUE(u3   == u2->prev);
+  ASSERT_TRUE(u1   == u2->next);
+
+  ASSERT_TRUE(NULL == u3->first_in);
+  ASSERT_TRUE(NULL == u3->first_out);
+  ASSERT_TRUE(u2   == u3->next);
+  ASSERT_TRUE(NULL == u3->prev);
+
+  ListDigraph::Node* head = NULL;
+  graph.getHead(head);
+  ASSERT_TRUE(head == u3);
+
+  graph.erase(*u3);
+
+  ASSERT_TRUE(NULL == u3->first_in);
+  ASSERT_TRUE(NULL == u3->first_out);
+  ASSERT_TRUE(NULL == u3->prev);
+  ASSERT_TRUE(NULL == u3->next);
+
+  ASSERT_TRUE(NULL == u1->first_in);
+  ASSERT_TRUE(NULL == u1->first_out);
+  ASSERT_TRUE(u2   == u1->prev);
+  ASSERT_TRUE(NULL == u1->next);
+
+  ASSERT_TRUE(NULL == u2->first_in);
+  ASSERT_TRUE(NULL == u2->first_out);
+  ASSERT_TRUE(u1   == u2->next);
+  ASSERT_TRUE(NULL == u2->prev);
+
+  graph.getHead(head);
+  ASSERT_TRUE(head == u2);
+
+}
+
+TEST_F(GraphTest, list_digraph_add_arcs_1)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ListDigraph::Arc* a1 = graph.addArc(*u1, *u2);
+  ListDigraph::Arc* a2 = graph.addArc(*u2, *u3);
+  ListDigraph::Arc* a3 = graph.addArc(*u3, *u1);
+
+  ASSERT_TRUE(u1 == a1->source && u2 == a1->target);
+  ASSERT_TRUE(u2 == a2->source && u3 == a2->target);
+  ASSERT_TRUE(u3 == a3->source && u1 == a3->target);
+
+  ASSERT_TRUE(u1->first_in == a3 && u1->first_out == a1);
+  ASSERT_TRUE(u2->first_in == a1 && u2->first_out == a2);
+  ASSERT_TRUE(u3->first_in == a2 && u3->first_out == a3);
+}
+
+TEST_F(GraphTest, list_digraph_add_arcs_2)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ListDigraph::Arc* a1 = graph.addArc(*u1, *u1);
+  ListDigraph::Arc* a2 = graph.addArc(*u1, *u2);
+  ListDigraph::Arc* a3 = graph.addArc(*u1, *u3);
+
+  ASSERT_TRUE(u1 == a1->source && u1 == a1->target);
+  ASSERT_TRUE(u1 == a2->source && u2 == a2->target);
+  ASSERT_TRUE(u1 == a3->source && u3 == a3->target);
+
+  ASSERT_TRUE(u1->first_in == a1 && u1->first_out == a3);
+  ASSERT_TRUE(u2->first_in == a2 && u2->first_out == NULL);
+  ASSERT_TRUE(u3->first_in == a3 && u3->first_out == NULL);
+}
+
+TEST_F(GraphTest, list_digraph_add_n_erase_arcs_1)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ListDigraph::Arc* a1 = graph.addArc(*u1, *u2);
+  ListDigraph::Arc* a2 = graph.addArc(*u2, *u3);
+  ListDigraph::Arc* a3 = graph.addArc(*u3, *u1);
+
+  graph.erase(*a2);
+  
+  ASSERT_TRUE(u1 == a1->source && u2 == a1->target);
+  ASSERT_TRUE(u3 == a3->source && u1 == a3->target);
+
+  // remove from the fan-out list
+  ASSERT_TRUE(u2->first_in == a1 && u2->first_out == NULL);
+
+  // remove from the fan-in list
+  ASSERT_TRUE(u3->first_in == NULL && u3->first_out == a3);
+
+  // put into free list
+  ASSERT_TRUE(NULL == a2->next_in);
+}
+
+
+TEST_F(GraphTest, list_digraph_add_n_erase_arcs_2)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ListDigraph::Arc* a1 = graph.addArc(*u1, *u2);
+  ListDigraph::Arc* a2 = graph.addArc(*u2, *u3);
+  ListDigraph::Arc* a3 = graph.addArc(*u3, *u1);
+
+  graph.erase(*a1);
+  
+  ASSERT_TRUE(u2 == a2->source && u3 == a2->target);
+  ASSERT_TRUE(u3 == a3->source && u1 == a3->target);
+
+  // remove from the fan-out list
+  ASSERT_TRUE(u1->first_in == a3 && u1->first_out == NULL);
+
+  // remove from the fan-in list
+  ASSERT_TRUE(u2->first_in == NULL && u2->first_out == a2);
+
+  // put into free list
+  ASSERT_TRUE(NULL == a1->next_in);
+}
+
+TEST_F(GraphTest, list_digraph_add_n_erase_arcs_3)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ListDigraph::Arc* a1 = graph.addArc(*u1, *u2);
+  ListDigraph::Arc* a2 = graph.addArc(*u2, *u3);
+  ListDigraph::Arc* a3 = graph.addArc(*u3, *u1);
+
+  graph.erase(*a3);
+  
+  ASSERT_TRUE(u1 == a1->source && u2 == a1->target);
+  ASSERT_TRUE(u2 == a2->source && u3 == a2->target);
+
+  // remove from the fan-out list
+  ASSERT_TRUE(u1->first_in == NULL && u1->first_out == a1);
+
+  // remove from the fan-in list
+  ASSERT_TRUE(u3->first_in == a2 && u3->first_out == NULL);
+
+  // put into free list
+  ASSERT_TRUE(NULL == a3->next_in);
+}
+
+TEST_F(GraphTest, list_digraph_add_n_erase_arcs_4)
+{
+  ListDigraph graph;
+
+  ListDigraph::Node* u1 = graph.addNode();
+  ListDigraph::Node* u2 = graph.addNode();
+  ListDigraph::Node* u3 = graph.addNode();
+
+  ListDigraph::Arc* a1 = graph.addArc(*u1, *u1);
+  graph.addArc(*u1, *u2);
+  graph.addArc(*u1, *u3);
+
+  graph.erase(*u1);
+
+  ASSERT_TRUE(u2->first_in == NULL);
+  ASSERT_TRUE(u3->first_in == NULL);
+  ASSERT_TRUE(a1->next_in == NULL);
+
+}
+
+TEST_F(GraphTest, api_test)
+{
+  Digraph graph;
+
+  Digraph::Node node = graph.addNode();
+  graph.addNode();
+  graph.addNode();
+  graph.addNode();
+
+  ASSERT_EQ(4, graph.numOfNodes());
+  ASSERT_EQ(0, graph.numOfArcs());
+}
diff --git a/unittests/GraphTest.h b/unittests/GraphTest.h
new file mode 100644
index 0000000..a71276b
--- /dev/null
+++ b/unittests/GraphTest.h
@@ -0,0 +1,38 @@
+//===- GraphTest.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_GRAPH_TEST_H
+#define MCLD_GRAPH_TEST_H
+
+#include <gtest.h>
+
+
+namespace mcld {
+namespace test {
+
+class GraphTest : public ::testing::Test
+{
+public:
+  // Constructor can do set-up work for all test here.
+  GraphTest();
+
+  // Destructor can do clean-up work that doesn't throw exceptions here.
+  virtual ~GraphTest();
+
+  // SetUp() will be called immediately before each test.
+  virtual void SetUp();
+
+  // TearDown() will be called immediately after each test.
+  virtual void TearDown();
+};
+
+} // namespace of test
+} // namespace of mcld
+
+#endif
+
diff --git a/unittests/HashTableTest.cpp b/unittests/HashTableTest.cpp
index 532c307..fe67e95 100644
--- a/unittests/HashTableTest.cpp
+++ b/unittests/HashTableTest.cpp
@@ -8,8 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "HashTableTest.h"
-#include "mcld/ADT/HashEntry.h"
-#include "mcld/ADT/HashTable.h"
+#include <mcld/ADT/HashEntry.h>
+#include <mcld/ADT/HashTable.h>
 #include <cstdlib>
 
 using namespace std;
diff --git a/unittests/LDSymbolTest.cpp b/unittests/LDSymbolTest.cpp
index c414fa0..e0e681d 100644
--- a/unittests/LDSymbolTest.cpp
+++ b/unittests/LDSymbolTest.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "mcld/LD/LDSymbol.h"
+#include <mcld/LD/LDSymbol.h>
 #include "LDSymbolTest.h"
 
 using namespace mcld;
diff --git a/unittests/LinearAllocatorTest.cpp b/unittests/LinearAllocatorTest.cpp
index fea135f..d38684a 100644
--- a/unittests/LinearAllocatorTest.cpp
+++ b/unittests/LinearAllocatorTest.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "LinearAllocatorTest.h"
-#include "mcld/Support/Allocators.h"
+#include <mcld/Support/Allocators.h>
 
 using namespace mcld;
 using namespace mcldtest;
diff --git a/unittests/LinkerTest.cpp b/unittests/LinkerTest.cpp
index 16c6448..479bbb9 100644
--- a/unittests/LinkerTest.cpp
+++ b/unittests/LinkerTest.cpp
@@ -14,6 +14,7 @@
 #include <mcld/IRBuilder.h>
 #include <mcld/Linker.h>
 #include <mcld/LinkerConfig.h>
+#include <mcld/LinkerScript.h>
 
 #include <mcld/Support/Path.h>
 
@@ -63,7 +64,7 @@
   //   builder.CreateInput("./test.o");
 
   if (linker.link(module, builder))
-    linker.emit("./test.so");
+    linker.emit(module, "./test.so");
 
   Finalize();
 }
@@ -123,7 +124,7 @@
   builder.ReadInput("crtend", crtend);
 
   if (linker.link(module, builder)) {
-    linker.emit("libplasma.so"); ///< -o libplasma.so
+    linker.emit(module, "libplasma.so"); ///< -o libplasma.so
   }
 
   Finalize();
@@ -181,7 +182,7 @@
   builder1.ReadInput("crtend", crtend);
 
   if (linker.link(module1, builder1)) {
-    linker.emit("libplasma.once.so"); ///< -o libplasma.so
+    linker.emit(module1, "libplasma.once.so"); ///< -o libplasma.so
   }
 
   Finalize();
@@ -224,7 +225,7 @@
   builder2.ReadInput("crtend", crtend);
 
   if (linker.link(module2, builder2)) {
-    linker.emit("libplasma.twice.so"); ///< -o libplasma.exe
+    linker.emit(module2, "libplasma.twice.so"); ///< -o libplasma.exe
   }
 
   Finalize();
@@ -278,7 +279,7 @@
   builder1->ReadInput("crtend", crtend);
 
   if (linker.link(module1, *builder1)) {
-    linker.emit("libplasma.once.so"); ///< -o libplasma.so
+    linker.emit(module1, "libplasma.once.so"); ///< -o libplasma.so
   }
 
   // Can not delete builder until emit the output. Dynamic string table
@@ -326,7 +327,7 @@
   builder2->ReadInput("crtend", crtend);
 
   if (linker.link(module2, *builder2)) {
-    linker.emit("libplasma.twice.so"); ///< -o libplasma.exe
+    linker.emit(module2, "libplasma.twice.so"); ///< -o libplasma.exe
   }
 
   delete builder2;
@@ -467,7 +468,7 @@
  builder.AddRelocation(*rel_text, llvm::ELF::R_ARM_PLT32, *z1gv, 0x4);
 
   if (linker.link(module, builder)) {
-    linker.emit("libgotplt.so"); ///< -o libgotplt.so
+    linker.emit(module, "libgotplt.so"); ///< -o libgotplt.so
   }
 
   Finalize();
diff --git a/unittests/MCRegionFragmentTest.cpp b/unittests/MCRegionFragmentTest.cpp
index 842ddf9..7d6c3b9 100644
--- a/unittests/MCRegionFragmentTest.cpp
+++ b/unittests/MCRegionFragmentTest.cpp
@@ -9,9 +9,9 @@
 
 #include "MCRegionFragmentTest.h"
 
-#include "mcld/MC/MCRegionFragment.h"
-#include "mcld/Support/MemoryAreaFactory.h"
-#include "mcld/Support/Path.h"
+#include <mcld/MC/MCRegionFragment.h>
+#include <mcld/Support/MemoryAreaFactory.h>
+#include <mcld/Support/Path.h>
 
 using namespace mcld;
 using namespace mcldtest;
diff --git a/unittests/MemoryAreaTest.cpp b/unittests/MemoryAreaTest.cpp
deleted file mode 100644
index 0499a0d..0000000
--- a/unittests/MemoryAreaTest.cpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//===- MemoryAreaTest.cpp -------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/Support/FileHandle.h>
-#include <mcld/Support/FileSystem.h>
-#include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/MemoryAreaFactory.h>
-#include <mcld/Support/Path.h>
-
-#include "MemoryAreaTest.h"
-#include <fcntl.h>
-#include <cstdio>
-
-using namespace mcld;
-using namespace mcld::sys::fs;
-using namespace mcldtest;
-
-
-// Constructor can do set-up work for all test here.
-MemoryAreaTest::MemoryAreaTest()
-{
-}
-
-// Destructor can do clean-up work that doesn't throw exceptions here.
-MemoryAreaTest::~MemoryAreaTest()
-{
-}
-
-// SetUp() will be called immediately before each test.
-void MemoryAreaTest::SetUp()
-{
-}
-
-// TearDown() will be called immediately after each test.
-void MemoryAreaTest::TearDown()
-{
-}
-
-//==========================================================================//
-// Testcases
-//
-TEST_F( MemoryAreaTest, read_by_malloc )
-{
-	Path path(TOPDIR);
-	path.append("unittests/test3.txt");
-
-	MemoryAreaFactory *AreaFactory = new MemoryAreaFactory(1);
-	MemoryArea* area = AreaFactory->produce(path, FileHandle::ReadOnly);
-	MemoryRegion* region = area->request(3, 2);
-	ASSERT_EQ('L', region->getBuffer()[0]);
-	ASSERT_EQ('O', region->getBuffer()[1]);
-	area->release(region);
-	AreaFactory->destruct(area);
-	//delete AreaFactory;;
-}
-
-TEST_F( MemoryAreaTest, write_by_malloc )
-{
-	Path path(TOPDIR);
-	path.append("unittests/test2.txt");
-	MemoryAreaFactory *AreaFactory = new MemoryAreaFactory(1);
-	MemoryArea* area = AreaFactory->produce(path, FileHandle::ReadOnly);
-        ASSERT_TRUE(area->handler()->isOpened());
-        ASSERT_TRUE(area->handler()->isGood());
-	MemoryRegion* region = area->request(3, 4);
-	region->getBuffer()[0] = 'L';
-	region->getBuffer()[1] = 'i';
-	region->getBuffer()[2] = 'n';
-	region->getBuffer()[3] = 'k';
-	area->release(region);
-	area->clear();
-	area->handler()->close();
-
-        area->handler()->open(path, FileHandle::ReadOnly);
-        ASSERT_TRUE(area->handler()->isOpened());
-        ASSERT_TRUE(area->handler()->isGood());
-        region = area->request(5, 2);
-        ASSERT_EQ('n', region->getBuffer()[0]);
-        ASSERT_EQ('k', region->getBuffer()[1]);
-	area->release(region);
-	AreaFactory->destruct(area);
-	//delete AreaFactory;;
-}
-
-TEST_F( MemoryAreaTest, read_one_page )
-{
-        Path path(TOPDIR) ;
-	path.append("unittests/test3.txt") ;
-	MemoryAreaFactory *AreaFactory = new MemoryAreaFactory(1) ;
-	MemoryArea* area = AreaFactory->produce(path, FileHandle::ReadOnly) ;
-	ASSERT_TRUE(area->handler()->isOpened()) ;
-	ASSERT_TRUE(area->handler()->isGood()) ;
-	MemoryRegion* region = area->request(0, 4096);
-	ASSERT_EQ('H', region->getBuffer()[0]);
-	ASSERT_EQ('E', region->getBuffer()[1]);
-	area->release(region);
-	AreaFactory->destruct(area);
-	//delete AreaFactory; ;
-}
-
-TEST_F( MemoryAreaTest, write_one_page )
-{
-        Path path(TOPDIR) ;
-	path.append("unittests/test2.txt") ;
-        MemoryAreaFactory *AreaFactory = new MemoryAreaFactory(1) ;
-	MemoryArea* area = AreaFactory->produce(path, FileHandle::ReadWrite);
-	ASSERT_TRUE(area->handler()->isOpened()) ;
-	ASSERT_TRUE(area->handler()->isGood()) ;
-	MemoryRegion* region = area->request(0, 4096) ;
-	region->getBuffer()[4000] = 'K' ;
-	region->getBuffer()[4001] = 'R' ;
-	ASSERT_EQ('K', region->getBuffer()[4000]);
-	ASSERT_EQ('R', region->getBuffer()[4001]);
-	area->release(region);
-	area->clear() ;
-	area->handler()->close();
-
-	area->handler()->open(path, FileHandle::ReadOnly);
-	region = area->request(4000, 4);
-	ASSERT_EQ('K', region->getBuffer()[0]);
-	ASSERT_EQ('R', region->getBuffer()[1]);
-	region->getBuffer()[0] = 'O' ;
-	region->getBuffer()[1] = 'H' ;
-        area->clear() ;
-	AreaFactory->destruct(area);
-	//delete AreaFactory; ;
-}
-
-TEST_F( MemoryAreaTest, write_sync )
-{
-        Path path(TOPDIR) ;
-	path.append("unittests/test2.txt") ;
-	MemoryAreaFactory *AreaFactory = new MemoryAreaFactory(1) ;
-	MemoryArea* area = AreaFactory->produce(path, FileHandle::ReadWrite) ;
-	ASSERT_TRUE(area->handler()->isOpened()) ;
-	ASSERT_TRUE(area->handler()->isGood()) ;
-	MemoryRegion* region1 = area->request(0, 4096) ;
-	MemoryRegion* region2 = area->request(512, 1024) ;
-	region1->getBuffer()[1000] = 'L' ;
-	region1->getBuffer()[1001] = 'L' ;
-	region2->getBuffer()[488] = 'V' ;
-	region2->getBuffer()[489] = 'M' ;
-	area->release(region1);
-	area->release(region2);
-	area->clear();
-	area->handler()->close();
-	area->handler()->open(path, FileHandle::ReadWrite);
-	region1 = area->request(0, 1024) ;
-	EXPECT_EQ('V', region1->getBuffer()[1000]) ;
-	EXPECT_EQ('M', region1->getBuffer()[1001]) ;
-	region1->getBuffer()[1000] = '@' ;
-	region1->getBuffer()[1001] = '@' ;
-	area->release(region1);
-	area->clear();
-	AreaFactory->destruct(area);
-	//delete AreaFactory; ;
-}
-
-
diff --git a/unittests/MemoryAreaTest.h b/unittests/MemoryAreaTest.h
deleted file mode 100644
index 86a5da0..0000000
--- a/unittests/MemoryAreaTest.h
+++ /dev/null
@@ -1,50 +0,0 @@
-//===- MemoryAreaTest.h ---------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MEMORYAREA_TEST_H
-#define MEMORYAREA_TEST_H
-
-#include <gtest.h>
-
-namespace mcld
-{
-class MemoryArea;
-
-} // namespace for mcld
-
-namespace mcldtest
-{
-
-/** \class MemoryAreaTest
- *  \brief 
- *
- *  \see MemoryArea 
- */
-class MemoryAreaTest : public ::testing::Test
-{
-public:
-	// Constructor can do set-up work for all test here.
-	MemoryAreaTest();
-
-	// Destructor can do clean-up work that doesn't throw exceptions here.
-	virtual ~MemoryAreaTest();
-
-	// SetUp() will be called immediately before each test.
-	virtual void SetUp();
-
-	// TearDown() will be called immediately after each test.
-	virtual void TearDown();
-
-protected:
-	mcld::MemoryArea* m_pTestee;
-};
-
-} // namespace of mcldtest
-
-#endif
-
diff --git a/unittests/PathTest.cpp b/unittests/PathTest.cpp
index 1a73de2..73e62cc 100644
--- a/unittests/PathTest.cpp
+++ b/unittests/PathTest.cpp
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "PathTest.h"
-#include "mcld/Support/FileSystem.h"
+#include <mcld/Support/FileSystem.h>
 #include <string>
 
 //
diff --git a/unittests/RTLinearAllocatorTest.cpp b/unittests/RTLinearAllocatorTest.cpp
index 7ed5dac..1e07f4a 100644
--- a/unittests/RTLinearAllocatorTest.cpp
+++ b/unittests/RTLinearAllocatorTest.cpp
@@ -6,8 +6,8 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "mcld/Support/Allocators.h"
-#include <RTLinearAllocatorTest.h>
+#include <mcld/Support/Allocators.h>
+#include "RTLinearAllocatorTest.h"
 
 using namespace mcld;
 using namespace mcldtest;
diff --git a/unittests/StaticResolverTest.cpp b/unittests/StaticResolverTest.cpp
index bd40cd5..eb3accc 100644
--- a/unittests/StaticResolverTest.cpp
+++ b/unittests/StaticResolverTest.cpp
@@ -59,7 +59,7 @@
   ASSERT_TRUE( mcld::ResolveInfo::define_flag == new_sym->info());
   ASSERT_TRUE( mcld::ResolveInfo::define_flag == old_sym->info());
   bool override = true;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_FALSE( override );
 }
@@ -85,7 +85,7 @@
   ASSERT_TRUE( mcld::ResolveInfo::Define    == old_sym->desc());
 
   bool override = false;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_FALSE( override );
   ASSERT_TRUE(1 == old_sym->size());
@@ -112,7 +112,7 @@
   ASSERT_TRUE( mcld::ResolveInfo::Define == old_sym->desc());
 
   bool override = false;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_FALSE( override );
   ASSERT_TRUE(1 == old_sym->size());
@@ -139,7 +139,7 @@
   ASSERT_TRUE( mcld::ResolveInfo::Undefined ==  old_sym->desc());
 
   bool override = false;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_FALSE( override );
   ASSERT_TRUE(1 == old_sym->size());
@@ -161,7 +161,7 @@
   ASSERT_TRUE( mcld::ResolveInfo::global_flag == new_sym->info());
   ASSERT_TRUE( mcld::ResolveInfo::weak_flag == old_sym->info());
   bool override = false;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_TRUE( override );
   ASSERT_TRUE(0 == old_sym->size());
@@ -190,7 +190,7 @@
   ASSERT_TRUE( mcld::ResolveInfo::Define == new_sym->desc());
 
   bool override = false;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_FALSE( override );
   ASSERT_TRUE(1 == old_sym->size());
@@ -212,7 +212,7 @@
   ASSERT_TRUE( mcld::ResolveInfo::common_flag == new_sym->info());
   ASSERT_TRUE( mcld::ResolveInfo::common_flag == old_sym->info());
   bool override = true;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_FALSE( override );
   ASSERT_TRUE(999 == old_sym->size());
@@ -237,7 +237,7 @@
   ASSERT_TRUE( (ResolveInfo::weak_flag | ResolveInfo::common_flag) == old_sym->info());
 
   bool override = false;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_TRUE( override );
   ASSERT_TRUE(999 == old_sym->size());
@@ -261,7 +261,7 @@
   ASSERT_TRUE( ResolveInfo::common_flag == old_sym->info());
 
   bool override = false;
-  bool result = m_pResolver->resolve(*old_sym, *new_sym, override);
+  bool result = m_pResolver->resolve(*old_sym, *new_sym, override, 0x0);
   ASSERT_TRUE(result);
   ASSERT_TRUE( override );
   ASSERT_TRUE(999 == old_sym->size());
diff --git a/unittests/SymbolTableTest.cpp b/unittests/SymbolTableTest.cpp
index 5b665f0..2dc5143 100644
--- a/unittests/SymbolTableTest.cpp
+++ b/unittests/SymbolTableTest.cpp
@@ -6,7 +6,7 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include "mcld/LD/SymbolTable.h"
+#include <mcld/LD/SymbolTable.h>
 #include "SymbolTableTest.h"
 
 using namespace mcld;
diff --git a/unittests/TargetMachineTest.cpp b/unittests/TargetMachineTest.cpp
index 6258906..85950a9 100644
--- a/unittests/TargetMachineTest.cpp
+++ b/unittests/TargetMachineTest.cpp
@@ -6,7 +6,7 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-#include <TargetMachineTest.h>
+#include "TargetMachineTest.h"
 
 using namespace mcld;
 using namespace mcldTEST;