diff --git a/include/mcld/ADT/SizeTraits.h b/include/mcld/ADT/SizeTraits.h
index 666d8c0..c8822cf 100644
--- a/include/mcld/ADT/SizeTraits.h
+++ b/include/mcld/ADT/SizeTraits.h
@@ -66,6 +66,16 @@
   return (pAddress + 0x3F) & (~0x3F);
 }
 
+#ifdef bswap16
+#undef bswap16
+#endif
+#ifdef bswap32
+#undef bswap32
+#endif
+#ifdef bswap64
+#undef bswap64
+#endif
+
 /// bswap16 - byte swap 16-bit version
 /// @ref binary utilities - elfcpp_swap
 inline uint16_t bswap16(uint16_t pData)
diff --git a/include/mcld/Config/Config.h b/include/mcld/Config/Config.h
index f604109..8cadee1 100644
--- a/include/mcld/Config/Config.h
+++ b/include/mcld/Config/Config.h
@@ -29,6 +29,7 @@
 #define MCLD_NUM_OF_INPUTS 32
 #define MCLD_SECTIONS_PER_INPUT 16
 #define MCLD_SYMBOLS_PER_INPUT 128
+#define MCLD_RELOCATIONS_PER_INPUT 1024
 
 #endif
 
diff --git a/include/mcld/Config/Config.h.in b/include/mcld/Config/Config.h.in
index f025393..7b55240 100644
--- a/include/mcld/Config/Config.h.in
+++ b/include/mcld/Config/Config.h.in
@@ -15,6 +15,7 @@
 #define MCLD_NUM_OF_INPUTS 32
 #define MCLD_SECTIONS_PER_INPUT 16
 #define MCLD_SYMBOLS_PER_INPUT 128
+#define MCLD_RELOCATIONS_PER_INPUT 1024
 
 #endif
 
diff --git a/include/mcld/Fragment/Fragment.h b/include/mcld/Fragment/Fragment.h
index b3d072d..3501341 100644
--- a/include/mcld/Fragment/Fragment.h
+++ b/include/mcld/Fragment/Fragment.h
@@ -33,7 +33,6 @@
     Alignment,
     Fillment,
     Region,
-    Relocation,
     Target,
     Stub,
     Null
@@ -48,7 +47,8 @@
 
   Type getKind() const { return m_Kind; }
 
-  SectionData *getParent() const { return m_pParent; }
+  const SectionData* getParent() const { return m_pParent; }
+  SectionData*       getParent()       { return m_pParent; }
 
   void setParent(SectionData *pValue) { m_pParent = pValue; }
 
diff --git a/include/mcld/Fragment/FragmentLinker.h b/include/mcld/Fragment/FragmentLinker.h
index 9fd70d0..17e80bd 100644
--- a/include/mcld/Fragment/FragmentLinker.h
+++ b/include/mcld/Fragment/FragmentLinker.h
@@ -65,17 +65,6 @@
   ~FragmentLinker();
 
   // ----- about symbols  ----- //
-  /// addDynSymbol - add a symbol and resolve it immediately
-  template<Input::Type FROM>
-  LDSymbol* addSymbol(const llvm::StringRef& pName,
-                      ResolveInfo::Type pType,
-                      ResolveInfo::Desc pDesc,
-                      ResolveInfo::Binding pBinding,
-                      ResolveInfo::SizeType pSize,
-                      LDSymbol::ValueType pValue,
-                      FragmentRef* pFragmentRef,
-                      ResolveInfo::Visibility pVisibility = ResolveInfo::Default);
-
   /// defineSymbol - add a symbol
   /// defineSymbol define a output symbol
   ///
@@ -108,20 +97,6 @@
 
   bool finalizeSymbols();
 
-  // -----  relocations  ----- //
-  /// addRelocation - add a relocation entry in FragmentLinker (only for object file)
-  /// @param pType - the type of the relocation
-  /// @param pSym  - the symbol should be the symbol in the input file. FragmentLinker
-  ///                  computes the real applied address by the output symbol.
-  /// @param pSection - the input relocation section
-  /// @param pOffset - the offset of target section.
-  /// @param pAddend - the addend value for applying relocation
-  Relocation* addRelocation(Relocation::Type pType,
-                            LDSymbol& pSym,
-                            LDSection& pSection,
-                            uint32_t pOffset,
-                            Relocation::Address pAddend = 0);
-
   /// applyRelocations - apply all relocation enties.
   bool applyRelocations();
 
@@ -182,24 +157,6 @@
 
   bool shouldForceLocal(const ResolveInfo& pInfo) const;
 
-  LDSymbol* addSymbolFromDynObj(const llvm::StringRef& pName,
-                                ResolveInfo::Type pType,
-                                ResolveInfo::Desc pDesc,
-                                ResolveInfo::Binding pBinding,
-                                ResolveInfo::SizeType pSize,
-                                LDSymbol::ValueType pValue,
-                                FragmentRef* pFragmentRef,
-                                ResolveInfo::Visibility pVisibility);
-
-  LDSymbol* addSymbolFromObject(const llvm::StringRef& pName,
-                                ResolveInfo::Type pType,
-                                ResolveInfo::Desc pDesc,
-                                ResolveInfo::Binding pBinding,
-                                ResolveInfo::SizeType pSize,
-                                LDSymbol::ValueType pValue,
-                                FragmentRef* pFragmentRef,
-                                ResolveInfo::Visibility pVisibility);
-
   /// checkIsOutputPIC - return whether the output is position-independent,
   /// called by isOutputPIC()
   bool checkIsOutputPIC() const;
diff --git a/include/mcld/Fragment/FragmentLinker.tcc b/include/mcld/Fragment/FragmentLinker.tcc
index 884a597..cc3fad6 100644
--- a/include/mcld/Fragment/FragmentLinker.tcc
+++ b/include/mcld/Fragment/FragmentLinker.tcc
@@ -6,53 +6,6 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
-/// addSymbol - add a symbol and resolve it immediately
-template<Input::Type FROM>
-LDSymbol* FragmentLinker::addSymbol(const llvm::StringRef& pName,
-                                    ResolveInfo::Type pType,
-                                    ResolveInfo::Desc pDesc,
-                                    ResolveInfo::Binding pBinding,
-                                    ResolveInfo::SizeType pSize,
-                                    LDSymbol::ValueType pValue,
-                                    FragmentRef* pFragmentRef,
-                                    ResolveInfo::Visibility pVisibility)
-{
-  llvm::StringRef symbol_name = pName;
-  if (!getLDInfo().scripts().renameMap().empty() &&
-      ResolveInfo::Undefined == pDesc) {
-    // If the renameMap is not empty, some symbols should be renamed.
-    // --wrap and --portable defines the symbol rename map.
-    ScriptOptions::SymbolRenameMap::const_iterator renameSym
-                                = getLDInfo().scripts().renameMap().find(pName);
-    if (renameSym != getLDInfo().scripts().renameMap().end())
-      symbol_name = renameSym.getEntry()->value();
-  }
-
-  if (FROM == Input::DynObj)
-    return addSymbolFromDynObj(symbol_name,
-                               pType,
-                               pDesc,
-                               pBinding,
-                               pSize,
-                               pValue,
-                               pFragmentRef,
-                               pVisibility);
-
-  if (FROM == Input::Object)
-    return addSymbolFromObject(symbol_name,
-                               pType,
-                               pDesc,
-                               pBinding,
-                               pSize,
-                               pValue,
-                               pFragmentRef,
-                               pVisibility);
-
-  llvm::report_fatal_error("add a symbol from unknown file type.\n");
-  return NULL;
-}
-
 // defineSymbol - define a new symbol
 template<FragmentLinker::DefinePolicy POLICY,
          FragmentLinker::ResolvePolicy RESOLVE>
diff --git a/include/mcld/Fragment/Relocation.h b/include/mcld/Fragment/Relocation.h
index c6584c4..37b32f6 100644
--- a/include/mcld/Fragment/Relocation.h
+++ b/include/mcld/Fragment/Relocation.h
@@ -11,20 +11,24 @@
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
-#include <llvm/Support/DataTypes.h>
-
-#include <mcld/Fragment/Fragment.h>
+#include <mcld/Config/Config.h>
 #include <mcld/Fragment/FragmentRef.h>
+#include <mcld/Support/GCFactoryListTraits.h>
+
+#include <llvm/ADT/ilist_node.h>
+#include <llvm/Support/DataTypes.h>
 
 namespace mcld {
 
 class ResolveInfo;
-class RelocationFactory;
+class Relocator;
 class LinkerConfig;
 
-class Relocation : public Fragment
+class Relocation : public llvm::ilist_node<Relocation>
 {
 friend class RelocationFactory;
+friend class GCFactoryListTraits<Relocation>;
+friend class Chunk<Relocation, MCLD_RELOCATIONS_PER_INPUT>;
 
 public:
   typedef uint64_t Address; // FIXME: use SizeTrait<T>::Address instead
@@ -33,14 +37,35 @@
   typedef uint8_t Type;
 
 private:
+  Relocation();
+
   Relocation(Type pType,
              FragmentRef* pTargetRef,
              Address pAddend,
              DWord pTargetData);
 
-public:
   ~Relocation();
 
+public:
+  /// Initialize - set up the relocation factory
+  static void SetUp(const LinkerConfig& pConfig);
+
+  /// Clear - Clean up the relocation factory
+  static void Clear();
+
+  /// Create - produce an empty relocation entry
+  static Relocation* Create();
+
+  /// Create - produce a relocation entry
+  /// @param pType    [in] the type of the relocation entry
+  /// @param pFragRef [in] the place to apply the relocation
+  /// @param pAddend  [in] the addend of the relocation entry
+  static Relocation* Create(Type pType, FragmentRef& pFragRef,
+                            Address pAddend = 0);
+
+  /// Destroy - destroy a relocation entry
+  static void Destroy(Relocation*& pRelocation);
+
   /// type - relocation type
   Type type() const
   { return m_Type; }
@@ -67,8 +92,7 @@
   const FragmentRef& targetRef() const { return m_TargetAddress; }
   FragmentRef&       targetRef()       { return m_TargetAddress; }
 
-
-  void apply(RelocationFactory& pRelocFactory);
+  void apply(Relocator& pRelocator);
 
   /// updateAddend - A relocation with a section symbol must update addend
   /// before reading its value.
@@ -81,13 +105,6 @@
 
   void setSymInfo(ResolveInfo* pSym);
 
-  // Relocation is a kind of Fragment with type of FT_Reloc
-  static bool classof(const Fragment *F)
-  { return F->getKind() == Fragment::Relocation; }
-
-  static bool classof(const Relocation *)
-  { return true; }
-
   size_t size() const;
 
 private:
diff --git a/include/mcld/GeneralOptions.h b/include/mcld/GeneralOptions.h
index 0b5c7a9..1468704 100644
--- a/include/mcld/GeneralOptions.h
+++ b/include/mcld/GeneralOptions.h
@@ -199,38 +199,56 @@
 
   // -n, --nmagic
   void setNMagic(bool pMagic = true)
-  { m_NMagic = pMagic; }
+  { m_bNMagic = pMagic; }
 
   bool nnagic() const
-  { return m_NMagic; }
+  { return m_bNMagic; }
 
   // -N, --omagic
   void setOMagic(bool pMagic = true)
-  { m_OMagic = pMagic; }
+  { m_bOMagic = pMagic; }
 
   bool omagic() const
-  { return m_OMagic; }
+  { return m_bOMagic; }
 
   // -S, --strip-debug
   void setStripDebug(bool pStripDebug = true)
-  { m_StripDebug = pStripDebug; }
+  { m_bStripDebug = pStripDebug; }
 
   bool stripDebug() const
-  { return m_StripDebug; }
+  { return m_bStripDebug; }
 
   // -E, --export-dynamic
   void setExportDynamic(bool pExportDynamic = true)
-  { m_ExportDynamic = pExportDynamic; }
+  { m_bExportDynamic = pExportDynamic; }
 
   bool exportDynamic() const
-  { return m_ExportDynamic; }
+  { return m_bExportDynamic; }
 
   // --warn-shared-textrel
   void setWarnSharedTextrel(bool pWarnSharedTextrel = true)
-  { m_WarnSharedTextrel = pWarnSharedTextrel; }
+  { m_bWarnSharedTextrel = pWarnSharedTextrel; }
 
   bool warnSharedTextrel() const
-  { return m_WarnSharedTextrel; }
+  { return m_bWarnSharedTextrel; }
+
+  void setBinaryInput(bool pBinaryInput = true)
+  { m_bBinaryInput = pBinaryInput; }
+
+  bool isBinaryInput() const
+  { return m_bBinaryInput; }
+
+  void setDefineCommon(bool pEnable = true)
+  { m_bDefineCommon = pEnable; }
+
+  bool isDefineCommon() const
+  { return m_bDefineCommon; }
+
+  void setFatalWarnings(bool pEnable = true)
+  { m_bFatalWarnings = pEnable; }
+
+  bool isFatalWarnings() const
+  { return m_bFatalWarnings; }
 
 private:
   enum status {
@@ -273,11 +291,14 @@
   bool m_bColor         : 1;   // --color[=true,false,auto]
   bool m_bAllowShlibUndefined : 1; // --[no-]allow-shlib-undefined and
   bool m_bCreateEhFrameHdr : 1;    // --eh-frame-hdr
-  bool m_NMagic; // -n, --nmagic
-  bool m_OMagic; // -N, --omagic
-  bool m_StripDebug; // -S, --strip-debug
-  bool m_ExportDynamic; //-E, --export-dynamic
-  bool m_WarnSharedTextrel; // --warn-shared-textrel
+  bool m_bNMagic : 1; // -n, --nmagic
+  bool m_bOMagic : 1; // -N, --omagic
+  bool m_bStripDebug : 1; // -S, --strip-debug
+  bool m_bExportDynamic :1; //-E, --export-dynamic
+  bool m_bWarnSharedTextrel : 1; // --warn-shared-textrel
+  bool m_bBinaryInput : 1; // -b [input-format], --format=[input-format]
+  bool m_bDefineCommon : 1; // -d, -dc, -dp
+  bool m_bFatalWarnings : 1; // --fatal-warnings
 };
 
 } // namespace of mcld
diff --git a/include/mcld/IRBuilder.h b/include/mcld/IRBuilder.h
index 1ebd153..3de292f 100644
--- a/include/mcld/IRBuilder.h
+++ b/include/mcld/IRBuilder.h
@@ -19,6 +19,7 @@
 
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/EhFrame.h>
+#include <mcld/LD/LDSymbol.h>
 
 #include <mcld/Fragment/Fragment.h>
 #include <mcld/Fragment/Relocation.h>
@@ -360,6 +361,68 @@
   /// @return Total size of the inserted fragments.
   static uint64_t AppendEhFrame(EhFrame::CIE& pCIE, EhFrame& pEhFrame);
 
+  /// AddSymbol - To add a symbol to the input file and module. The symbol is
+  /// resolved immediately.
+  ///
+  /// This is a general method for all kinds of symbol.
+  ///
+  /// @param [in, out] pInput   The input file. Either a relocatable or dynamic
+  ///                           object
+  /// @param [in]      pName    The name of the symbol
+  /// @param [in]      pType    What the symbol refers to
+  /// @param [in]      pDesc    { Undefined, Define, Common, Indirect }
+  /// @param [in]      pBind    { Global, Weak, Local, Absolute }
+  /// @param [in]      pSize    The size of the symbol. Bigger common symbols
+  ///                           overrides the smaller common symbols.
+  /// @param [in]      pValue   Common symbols' value are alignment constraints
+  ///                           Undefined symbols don't have value.
+  ///                           The rest symbols' value are relative section
+  ///                           offset.
+  /// @param [in]      pSection Absolute, undefined, common symbols do not have
+  ///                           pSection. Keep their pSection be NULL.
+  /// @oaram [in]      pVis     The visibility of the symbol
+  LDSymbol* AddSymbol(Input& pInput,
+                      const std::string& pName,
+                      ResolveInfo::Type pType,
+                      ResolveInfo::Desc pDesc,
+                      ResolveInfo::Binding pBind,
+                      ResolveInfo::SizeType pSize,
+                      LDSymbol::ValueType pValue = 0x0,
+                      LDSection* pSection = NULL,
+                      ResolveInfo::Visibility pVis = ResolveInfo::Default);
+
+  /// AddRelocation - To add a relocation entry
+  ///
+  /// @param [in] pSection The relocation section. pSection's link should point to
+  ///                      the target section.
+  /// @param [in] pType    The type of the relocation (target dependent)
+  /// @param [in] pSym     The symbol should be the symbol in the input file.
+  /// @param [in] pOffset  The offset of target section.
+  /// @param [in] pAddend  Tthe addend value for applying relocation
+  static Relocation* AddRelocation(LDSection& pSection,
+                                   Relocation::Type pType,
+                                   LDSymbol& pSym,
+                                   uint32_t pOffset,
+                                   Relocation::Address pAddend = 0);
+
+private:
+  LDSymbol* addSymbolFromObject(const std::string& pName,
+                                ResolveInfo::Type pType,
+                                ResolveInfo::Desc pDesc,
+                                ResolveInfo::Binding pBinding,
+                                ResolveInfo::SizeType pSize,
+                                LDSymbol::ValueType pValue,
+                                FragmentRef* pFragmentRef,
+                                ResolveInfo::Visibility pVisibility);
+
+  LDSymbol* addSymbolFromDynObj(const std::string& pName,
+                                ResolveInfo::Type pType,
+                                ResolveInfo::Desc pDesc,
+                                ResolveInfo::Binding pBinding,
+                                ResolveInfo::SizeType pSize,
+                                LDSymbol::ValueType pValue,
+                                ResolveInfo::Visibility pVisibility);
+
 private:
   Module& m_Module;
   const LinkerConfig& m_Config;
diff --git a/include/mcld/LD/BinaryReader.h b/include/mcld/LD/BinaryReader.h
new file mode 100644
index 0000000..e9c47db
--- /dev/null
+++ b/include/mcld/LD/BinaryReader.h
@@ -0,0 +1,45 @@
+//===- BinaryReader.h -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_Binary_READER_H
+#define MCLD_Binary_READER_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+#include "mcld/LD/LDReader.h"
+#include <llvm/Support/system_error.h>
+
+namespace mcld {
+
+class Module;
+class Input;
+
+/** \class BinaryReader
+ *  \brief BinaryReader provides an common interface for different Binary
+ *  formats.
+ */
+class BinaryReader : public LDReader
+{
+protected:
+  BinaryReader()
+  { }
+
+public:
+  virtual ~BinaryReader()
+  { }
+
+  virtual bool isMyFormat(Input& pInput) const
+  { return true; }
+
+  virtual bool readBinary(Input& pFile) = 0;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/BinaryWriter.h b/include/mcld/LD/BinaryWriter.h
new file mode 100644
index 0000000..d8133c4
--- /dev/null
+++ b/include/mcld/LD/BinaryWriter.h
@@ -0,0 +1,39 @@
+//===- BinaryWriter.h -----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_BINARY_WRITER_INTERFACE_H
+#define MCLD_BINARY_WRITER_INTERFACE_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+#include <llvm/Support/system_error.h>
+
+namespace mcld {
+
+class Module;
+class MemoryArea;
+class GNULDBackend;
+
+/** \class BinaryWriter
+ *  \brief BinaryWriter provides a common interface for Binary file writers.
+ */
+class BinaryWriter
+{
+protected:
+  BinaryWriter(GNULDBackend& pBackend);
+
+public:
+  virtual ~BinaryWriter();
+
+  virtual llvm::error_code writeBinary(Module& pModule, MemoryArea& pOutput) = 0;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/DiagRelocations.inc b/include/mcld/LD/DiagRelocations.inc
index 5d52dd8..7ada05f 100644
--- a/include/mcld/LD/DiagRelocations.inc
+++ b/include/mcld/LD/DiagRelocations.inc
@@ -1,3 +1,5 @@
+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(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")
diff --git a/include/mcld/LD/ELFBinaryReader.h b/include/mcld/LD/ELFBinaryReader.h
new file mode 100644
index 0000000..fc3a067
--- /dev/null
+++ b/include/mcld/LD/ELFBinaryReader.h
@@ -0,0 +1,48 @@
+//===- ELFBinaryReader.h --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_ELF_Binary_READER_H
+#define MCLD_ELF_Binary_READER_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/LD/BinaryReader.h>
+
+namespace mcld {
+
+class Module;
+class Input;
+class IRBuilder;
+class GNULDBackend;
+class LinkerConfig;
+
+/** \lclass ELFBinaryReader
+ *  \brief ELFBinaryReader reads target-independent parts of Binary file
+ */
+class ELFBinaryReader : public BinaryReader
+{
+public:
+  ELFBinaryReader(GNULDBackend& pBackend,
+                  IRBuilder& pBuilder,
+                  const LinkerConfig& pConfig);
+
+  ~ELFBinaryReader();
+
+  virtual bool readBinary(Input& pInput);
+
+private:
+  GNULDBackend& m_Backend;
+  IRBuilder& m_Builder;
+  const LinkerConfig& m_Config;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/ELFBinaryWriter.h b/include/mcld/LD/ELFBinaryWriter.h
new file mode 100644
index 0000000..593b54b
--- /dev/null
+++ b/include/mcld/LD/ELFBinaryWriter.h
@@ -0,0 +1,46 @@
+//===- ELFBinaryWriter.h --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_ELF_BINARY_WRITER_H
+#define MCLD_ELF_BINARY_WRITER_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+#include <llvm/Support/system_error.h>
+#include <mcld/LD/BinaryWriter.h>
+#include <mcld/LD/ELFWriter.h>
+
+namespace mcld {
+
+class Module;
+class LinkerConfig;
+class MemoryArea;
+class GNULDBackend;
+
+/** \class ELFBinaryWriter
+ *  \brief ELFBinaryWriter writes the target-independent parts of Binary files.
+ *  ELFBinaryWriter reads a MCLDFile and writes into raw_ostream
+ *
+ */
+class ELFBinaryWriter : public BinaryWriter, protected ELFWriter
+{
+public:
+  ELFBinaryWriter(GNULDBackend& pBackend, const LinkerConfig& pConfig);
+
+  ~ELFBinaryWriter();
+
+  llvm::error_code writeBinary(Module& pModule, MemoryArea& pOutput);
+
+private:
+  const LinkerConfig& m_Config;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/ELFDynObjReader.h b/include/mcld/LD/ELFDynObjReader.h
index b5d59a3..f6d2067 100644
--- a/include/mcld/LD/ELFDynObjReader.h
+++ b/include/mcld/LD/ELFDynObjReader.h
@@ -14,11 +14,11 @@
 #include <mcld/LD/DynObjReader.h>
 #include <llvm/Support/system_error.h>
 
-namespace mcld
-{
+namespace mcld {
 
 class Input;
-class FragmentLinker;
+class LinkerConfig;
+class IRBuilder;
 class GNULDBackend;
 class ELFReaderIF;
 
@@ -29,7 +29,9 @@
 class ELFDynObjReader : public DynObjReader
 {
 public:
-  ELFDynObjReader(GNULDBackend& pBackend, FragmentLinker& pLinker);
+  ELFDynObjReader(GNULDBackend& pBackend,
+                  IRBuilder& pBuilder,
+                  const LinkerConfig& pConfig);
   ~ELFDynObjReader();
 
   // -----  observers  ----- //
@@ -42,7 +44,7 @@
 
 private:
   ELFReaderIF *m_pELFReader;
-  FragmentLinker& m_Linker;
+  IRBuilder& m_Builder;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/ELFDynObjWriter.h b/include/mcld/LD/ELFDynObjWriter.h
index b5dd390..774943e 100644
--- a/include/mcld/LD/ELFDynObjWriter.h
+++ b/include/mcld/LD/ELFDynObjWriter.h
@@ -17,9 +17,9 @@
 namespace mcld {
 
 class Module;
+class LinkerConfig;
 class MemoryArea;
 class GNULDBackend;
-class FragmentLinker;
 
 /** \class ELFDynObjWriter
  *  \brief ELFDynObjWriter writes the dynamic sections.
@@ -30,13 +30,15 @@
   typedef ELFWriter::FileOffset FileOffset;
 
 public:
-  ELFDynObjWriter(GNULDBackend& pBackend, FragmentLinker& pLinker);
+  ELFDynObjWriter(GNULDBackend& pBackend,
+                  const LinkerConfig& pConfig);
+
   ~ELFDynObjWriter();
 
   llvm::error_code writeDynObj(Module& pModule, MemoryArea& pOutput);
 
 private:
-  FragmentLinker& m_Linker;
+  const LinkerConfig& m_Config;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/ELFExecWriter.h b/include/mcld/LD/ELFExecWriter.h
index dc731b9..ca69235 100644
--- a/include/mcld/LD/ELFExecWriter.h
+++ b/include/mcld/LD/ELFExecWriter.h
@@ -17,9 +17,9 @@
 namespace mcld {
 
 class Module;
+class LinkerConfig;
 class MemoryArea;
 class GNULDBackend;
-class FragmentLinker;
 
 /** \class ELFDynObjWriter
  *  \brief ELFDynObjWriter writes the dynamic sections.
@@ -30,13 +30,15 @@
   typedef ELFWriter::FileOffset FileOffset;
 
 public:
-  ELFExecWriter(GNULDBackend& pBackend, FragmentLinker& pLinker);
+  ELFExecWriter(GNULDBackend& pBackend,
+                const LinkerConfig& pConfig);
+
   ~ELFExecWriter();
 
   llvm::error_code writeExecutable(Module& pModule, MemoryArea& pOutput);
 
 private:
-  FragmentLinker& m_Linker;
+  const LinkerConfig& m_Config;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/ELFObjectReader.h b/include/mcld/LD/ELFObjectReader.h
index c1463fa..27e4489 100644
--- a/include/mcld/LD/ELFObjectReader.h
+++ b/include/mcld/LD/ELFObjectReader.h
@@ -19,10 +19,11 @@
 
 class Module;
 class Input;
-class FragmentLinker;
+class IRBuilder;
 class GNULDBackend;
 class ELFReaderIF;
 class EhFrameReader;
+class LinkerConfig;
 
 /** \lclass ELFObjectReader
  *  \brief ELFObjectReader reads target-independent parts of ELF object file
@@ -38,7 +39,9 @@
   typedef Flags<ReadFlagType> ReadFlag;
 
 public:
-  ELFObjectReader(GNULDBackend& pBackend, FragmentLinker& pLinker);
+  ELFObjectReader(GNULDBackend& pBackend,
+                  IRBuilder& pBuilder,
+                  const LinkerConfig& pConfig);
 
   ~ELFObjectReader();
 
@@ -60,9 +63,10 @@
 private:
   ELFReaderIF* m_pELFReader;
   EhFrameReader* m_pEhFrameReader;
-  FragmentLinker& m_Linker;
+  IRBuilder& m_Builder;
   ReadFlag m_ReadFlag;
   GNULDBackend& m_Backend;
+  const LinkerConfig& m_Config;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/ELFObjectWriter.h b/include/mcld/LD/ELFObjectWriter.h
index 31f7b12..28bbba8 100644
--- a/include/mcld/LD/ELFObjectWriter.h
+++ b/include/mcld/LD/ELFObjectWriter.h
@@ -11,15 +11,16 @@
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
-#include <llvm/Support/system_error.h>
 #include <mcld/LD/ObjectWriter.h>
 #include <mcld/LD/ELFWriter.h>
 
+#include <llvm/Support/system_error.h>
+
 namespace mcld {
 
 class Module;
+class LinkerConfig;
 class MemoryArea;
-class FragmentLinker;
 class GNULDBackend;
 
 /** \class ELFObjectWriter
@@ -30,14 +31,15 @@
 class ELFObjectWriter : public ObjectWriter, protected ELFWriter
 {
 public:
-  ELFObjectWriter(GNULDBackend& pBackend, FragmentLinker& pLinker);
+  ELFObjectWriter(GNULDBackend& pBackend,
+                  const LinkerConfig& pConfig);
 
   ~ELFObjectWriter();
 
   llvm::error_code writeObject(Module& pModule, MemoryArea& pOutput);
 
 private:
-  FragmentLinker& m_Linker;
+  const LinkerConfig& m_Config;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/ELFReader.h b/include/mcld/LD/ELFReader.h
index 941c8cd..146a00a 100644
--- a/include/mcld/LD/ELFReader.h
+++ b/include/mcld/LD/ELFReader.h
@@ -29,8 +29,8 @@
 namespace mcld {
 
 class Module;
+class IRBuilder;
 class FragmentRef;
-class FragmentLinker;
 class SectionData;
 class LDSection;
 
@@ -74,7 +74,7 @@
 
   /// readSymbols - read ELF symbols and create LDSymbol
   virtual bool readSymbols(Input& pInput,
-                           FragmentLinker& pLinker,
+                           IRBuilder& pBuilder,
                            const MemoryRegion& pRegion,
                            const char* StrTab) const = 0;
 
@@ -86,13 +86,11 @@
 
   /// readRela - read ELF rela and create Relocation
   virtual bool readRela(Input& pInput,
-                        FragmentLinker& pLinker,
                         LDSection& pSection,
                         const MemoryRegion& pRegion) const = 0;
 
   /// readRel - read ELF rel and create Relocation
   virtual bool readRel(Input& pInput,
-                       FragmentLinker& pLinker,
                        LDSection& pSection,
                        const MemoryRegion& pRegion) const = 0;
 
@@ -181,9 +179,9 @@
 
   /// readSymbols - read ELF symbols and create LDSymbol
   bool readSymbols(Input& pInput,
-                          FragmentLinker& pLinker,
-                          const MemoryRegion& pRegion,
-                          const char* StrTab) const;
+                   IRBuilder& pBuilder,
+                   const MemoryRegion& 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.
@@ -193,13 +191,11 @@
 
   /// readRela - read ELF rela and create Relocation
   bool readRela(Input& pInput,
-                FragmentLinker& pLinker,
                 LDSection& pSection,
                 const MemoryRegion& pRegion) const;
 
   /// readRel - read ELF rel and create Relocation
   bool readRel(Input& pInput,
-               FragmentLinker& pLinker,
                LDSection& pSection,
                const MemoryRegion& pRegion) const;
 
diff --git a/include/mcld/LD/Layout.h b/include/mcld/LD/Layout.h
deleted file mode 100644
index 7380b20..0000000
--- a/include/mcld/LD/Layout.h
+++ /dev/null
@@ -1,67 +0,0 @@
-//===- Layout.h -----------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_LD_LAYOUT_H
-#define MCLD_LD_LAYOUT_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-
-#include <vector>
-#include <map>
-
-#include <llvm/ADT/ilist.h>
-#include <llvm/ADT/ilist_node.h>
-#include <llvm/ADT/DenseMap.h>
-
-#include <mcld/LD/LDSection.h>
-#include <mcld/LD/SectionData.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/Support/GCFactory.h>
-
-namespace mcld {
-
-class Module;
-class FragmentRef;
-class FragmentLinker;
-class TargetLDBackend;
-
-/** \class Layout
- *  \brief Layout maintains the mapping between sections and fragments.
- *
- *  FragmentLinker is a fragment-based linker. But readers and target backends
- *  still need section information. Layout is used to maintain the mapping
- *  between sections and fragments. Layout helps readers and target backends
- *  get the input or output section information from a fragment.
- */
-class Layout
-{
-public:
-  // -----  modifiers  ----- //
-  bool layout(Module& pModule,
-              const TargetLDBackend& pBackend,
-              const LinkerConfig& pConfig);
-
-private:
-  /// sortSectionOrder - perform sorting on m_SectionOrder to get final layout
-  /// ordering
-  void sortSectionOrder(const TargetLDBackend& pBackend,
-                        const LinkerConfig& pConfig);
-
-private:
-  typedef std::vector<LDSection*> SectionOrder;
-
-private:
-  /// a vector to describe the order of sections
-  SectionOrder m_SectionOrder;
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/LD/RelocData.h b/include/mcld/LD/RelocData.h
index 6061544..b53151a 100644
--- a/include/mcld/LD/RelocData.h
+++ b/include/mcld/LD/RelocData.h
@@ -12,81 +12,85 @@
 #include <gtest.h>
 #endif
 
-#include <llvm/ADT/ilist.h>
-#include <llvm/ADT/ilist_node.h>
-#include <llvm/Support/DataTypes.h>
-
 #include <mcld/Config/Config.h>
-#include <mcld/Fragment/Fragment.h>
+#include <mcld/Fragment/Relocation.h>
 #include <mcld/Support/Allocators.h>
 #include <mcld/Support/GCFactoryListTraits.h>
 
+#include <llvm/ADT/ilist.h>
+#include <llvm/ADT/ilist_node.h>
+#include <llvm/Support/DataTypes.h>
 
 namespace mcld {
 
 class LDSection;
 
 /** \class RelocData
- *  \brief RelocData is the special SectionData to store Relocation fragments.
+ *  \brief RelocData stores Relocation.
+ *
  *  Since Relocations are created by GCFactory, we use GCFactoryListTraits for the
- *  FragmentList here to avoid iplist to delete Relocations.
+ *  RelocationList here to avoid iplist to delete Relocations.
  */
 class RelocData
 {
 private:
+  friend class Chunk<RelocData, MCLD_SECTIONS_PER_INPUT>;
+
   RelocData();
-  explicit RelocData(const LDSection &pSection);
+  explicit RelocData(LDSection &pSection);
 
   RelocData(const RelocData &);            // DO NOT IMPLEMENT
   RelocData& operator=(const RelocData &); // DO NOT IMPLEMENT
 
 public:
-  typedef llvm::iplist<Fragment,
-                       GCFactoryListTraits<Fragment> > FragmentListType;
+  typedef llvm::iplist<Relocation,
+                       GCFactoryListTraits<Relocation> > RelocationListType;
 
-  typedef FragmentListType::reference reference;
-  typedef FragmentListType::const_reference const_reference;
+  typedef RelocationListType::reference reference;
+  typedef RelocationListType::const_reference const_reference;
 
-  typedef FragmentListType::iterator iterator;
-  typedef FragmentListType::const_iterator const_iterator;
+  typedef RelocationListType::iterator iterator;
+  typedef RelocationListType::const_iterator const_iterator;
 
-  typedef FragmentListType::reverse_iterator reverse_iterator;
-  typedef FragmentListType::const_reverse_iterator const_reverse_iterator;
+  typedef RelocationListType::reverse_iterator reverse_iterator;
+  typedef RelocationListType::const_reverse_iterator const_reverse_iterator;
 
 public:
-  static RelocData* Create(const LDSection& pSection);
-
-  static RelocData* Create();
+  static RelocData* Create(LDSection& pSection);
 
   static void Destroy(RelocData*& pSection);
 
-  const LDSection &getSection() const
-  { assert(NULL != m_pSection ); return *m_pSection; }
+  static void Clear();
 
-  FragmentListType &getFragmentList() { return m_Fragments; }
-  const FragmentListType &getFragmentList() const { return m_Fragments; }
+  const LDSection& getSection() const { return *m_pSection; }
+  LDSection&       getSection()       { return *m_pSection; }
 
-  size_t size() const { return m_Fragments.size(); }
+  const RelocationListType& getRelocationList() const { return m_Relocations; }
+  RelocationListType&       getRelocationList()       { return m_Relocations; }
 
-  bool empty() const { return m_Fragments.empty(); }
+  size_t size() const { return m_Relocations.size(); }
 
-  reference              front ()       { return m_Fragments.front();  }
-  const_reference        front () const { return m_Fragments.front();  }
-  reference              back  ()       { return m_Fragments.back();   }
-  const_reference        back  () const { return m_Fragments.back();   }
+  bool empty() const { return m_Relocations.empty(); }
 
-  const_iterator         begin () const { return m_Fragments.begin();  }
-  iterator               begin ()       { return m_Fragments.begin();  }
-  const_iterator         end   () const { return m_Fragments.end();    }
-  iterator               end   ()       { return m_Fragments.end();    }
-  const_reverse_iterator rbegin() const { return m_Fragments.rbegin(); }
-  reverse_iterator       rbegin()       { return m_Fragments.rbegin(); }
-  const_reverse_iterator rend  () const { return m_Fragments.rend();   }
-  reverse_iterator       rend  ()       { return m_Fragments.rend();   }
+  RelocData& append(Relocation& pRelocation);
+
+  reference              front ()       { return m_Relocations.front();  }
+  const_reference        front () const { return m_Relocations.front();  }
+  reference              back  ()       { return m_Relocations.back();   }
+  const_reference        back  () const { return m_Relocations.back();   }
+
+  const_iterator         begin () const { return m_Relocations.begin();  }
+  iterator               begin ()       { return m_Relocations.begin();  }
+  const_iterator         end   () const { return m_Relocations.end();    }
+  iterator               end   ()       { return m_Relocations.end();    }
+  const_reverse_iterator rbegin() const { return m_Relocations.rbegin(); }
+  reverse_iterator       rbegin()       { return m_Relocations.rbegin(); }
+  const_reverse_iterator rend  () const { return m_Relocations.rend();   }
+  reverse_iterator       rend  ()       { return m_Relocations.rend();   }
 
 private:
-  FragmentListType m_Fragments;
-  const LDSection* m_pSection;
+  RelocationListType m_Relocations;
+  LDSection* m_pSection;
 
 };
 
diff --git a/include/mcld/LD/RelocationFactory.h b/include/mcld/LD/RelocationFactory.h
index c9f0d64..bd590a5 100644
--- a/include/mcld/LD/RelocationFactory.h
+++ b/include/mcld/LD/RelocationFactory.h
@@ -11,18 +11,13 @@
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
+#include <mcld/Config/Config.h>
 #include <mcld/Support/GCFactory.h>
 #include <mcld/Fragment/Relocation.h>
 
 namespace mcld {
 
-class LDSymbol;
-class ResolveInfo;
 class FragmentRef;
-class FragmentLinker;
-class Layout;
-class GOT;
-class TargetLDBackend;
 class LinkerConfig;
 
 /** \class RelocationFactory
@@ -30,7 +25,7 @@
  *  relocation
  *
  */
-class RelocationFactory : public GCFactory<Relocation, 0>
+class RelocationFactory : public GCFactory<Relocation, MCLD_RELOCATIONS_PER_INPUT>
 {
 public:
   typedef Relocation::Type Type;
@@ -38,21 +33,10 @@
   typedef Relocation::DWord DWord;
   typedef Relocation::SWord SWord;
 
-  enum Result {
-    OK,
-    BadReloc,
-    Overflow,
-    Unsupport,
-    Unknown
-  };
-
 public:
-  explicit RelocationFactory(size_t pNum);
+  explicit RelocationFactory();
 
-  virtual ~RelocationFactory();
-
-  /// apply - general apply function
-  virtual Result applyRelocation(Relocation& pRelocation) = 0;
+  void setConfig(const LinkerConfig& pConfig);
 
   // ----- production ----- //
   /// produce - produce a relocation entry
@@ -69,22 +53,8 @@
 
   void destroy(Relocation* pRelocation);
 
-  void setFragmentLinker(const FragmentLinker& pLinker);
-
-  // ------ observers -----//
-  const FragmentLinker& getFragmentLinker() const;
-
-  bool hasFragmentLinker() const;
-
-  virtual TargetLDBackend& getTarget() = 0;
-
-  virtual const TargetLDBackend& getTarget() const = 0;
-
-  virtual const char* getName(Type pType) const = 0;
-
 private:
-  const FragmentLinker* m_pLinker;
-
+  const LinkerConfig* m_pConfig;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/LD/Relocator.h b/include/mcld/LD/Relocator.h
new file mode 100644
index 0000000..6fd431e
--- /dev/null
+++ b/include/mcld/LD/Relocator.h
@@ -0,0 +1,76 @@
+//===- Relocator.h --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_RELOCATOR_H
+#define MCLD_RELOCATOR_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/Fragment/Relocation.h>
+
+namespace mcld
+{
+
+class FragmentLinker;
+class TargetLDBackend;
+
+/** \class Relocator
+ *  \brief Relocator provides the interface of performing relocations
+ */
+class Relocator
+{
+public:
+  typedef Relocation::Type Type;
+  typedef Relocation::Address Address;
+  typedef Relocation::DWord DWord;
+  typedef Relocation::SWord SWord;
+
+public:
+  enum Result {
+    OK,
+    BadReloc,
+    Overflow,
+    Unsupport,
+    Unknown
+  };
+
+public:
+  virtual ~Relocator() {}
+
+  /// apply - general apply function
+  virtual Result applyRelocation(Relocation& pRelocation) = 0;
+
+  void setFragmentLinker(const FragmentLinker& pLinker)
+  { m_pLinker = &pLinker; }
+
+  // ------ observers -----//
+  const FragmentLinker& getFragmentLinker() const
+  {
+    assert(NULL != m_pLinker);
+    return *m_pLinker;
+  }
+
+  bool hasFragmentLinker() const
+  { return (NULL != m_pLinker); }
+
+  virtual TargetLDBackend& getTarget() = 0;
+
+  virtual const TargetLDBackend& getTarget() const = 0;
+
+  virtual const char* getName(Type pType) const = 0;
+
+private:
+  const FragmentLinker* m_pLinker;
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/ResolveInfo.h b/include/mcld/LD/ResolveInfo.h
index 2cff57e..aaf74e1 100644
--- a/include/mcld/LD/ResolveInfo.h
+++ b/include/mcld/LD/ResolveInfo.h
@@ -26,7 +26,7 @@
  *  - Desc - Defined, Reference, Common or Indirect
  *  - Binding - Global, Local, Weak
  *  - IsDyn - appear in dynamic objects or regular objects
- *  - Type - what the symbol points to
+ *  - Type - what the symbol refers to
  *  - Size  - the size of the symbol point to
  *  - Value - the pointer to another LDSymbol
  *  In order to save the memory and speed up the performance, FragmentLinker uses
@@ -37,6 +37,7 @@
 class ResolveInfo
 {
 friend class FragmentLinker;
+friend class IRBuilder;
 public:
   typedef uint64_t SizeType;
 
diff --git a/include/mcld/LD/SectionData.h b/include/mcld/LD/SectionData.h
index 316d92f..4f58afa 100644
--- a/include/mcld/LD/SectionData.h
+++ b/include/mcld/LD/SectionData.h
@@ -55,6 +55,8 @@
 
   static void Destroy(SectionData*& pSection);
 
+  static void Clear();
+
   const LDSection& getSection() const { return *m_pSection; }
   LDSection&       getSection()       { return *m_pSection; }
 
diff --git a/include/mcld/LD/StubFactory.h b/include/mcld/LD/StubFactory.h
index 00a65ec..b38a96f 100644
--- a/include/mcld/LD/StubFactory.h
+++ b/include/mcld/LD/StubFactory.h
@@ -6,7 +6,6 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
 #ifndef MCLD_LD_STUB_FACTORY_H
 #define MCLD_LD_STUB_FACTORY_H
 #ifdef ENABLE_UNITTEST
@@ -16,12 +15,10 @@
 #include <llvm/Support/DataTypes.h>
 #include <vector>
 
-namespace mcld
-{
+namespace mcld {
 
 class Stub;
 class Relocation;
-class RelocationFactory;
 class BranchIslandFactory;
 class FragmentLinker;
 
@@ -32,8 +29,6 @@
 class StubFactory
 {
 public:
-  StubFactory();
-
   ~StubFactory();
 
   /// addPrototype - register a stub prototype
@@ -43,7 +38,6 @@
   Stub* create(Relocation& pReloc,
                uint64_t pTargetSymValue,
                FragmentLinker& pLinker,
-               RelocationFactory& pRelocFactory,
                BranchIslandFactory& pBRIslandFactory);
 
 private:
diff --git a/include/mcld/LinkerConfig.h b/include/mcld/LinkerConfig.h
index 7d52819..9e70ecf 100644
--- a/include/mcld/LinkerConfig.h
+++ b/include/mcld/LinkerConfig.h
@@ -16,6 +16,7 @@
 
 #include <mcld/GeneralOptions.h>
 #include <mcld/ScriptOptions.h>
+#include <mcld/TargetOptions.h>
 #include <mcld/BitcodeOption.h>
 #include <mcld/AttributeOption.h>
 #include <mcld/Support/Path.h>
@@ -39,7 +40,8 @@
     Object,
     DynObj,
     Exec,
-    External
+    External,
+    Binary
   };
 
 public:
@@ -55,6 +57,9 @@
   const ScriptOptions&  scripts() const { return m_Scripts; }
   ScriptOptions&        scripts()       { return m_Scripts; }
 
+  const TargetOptions&  targets() const { return m_Targets; }
+  TargetOptions&        targets()       { return m_Targets; }
+
   const BitcodeOption&  bitcode() const { return m_Bitcode; }
   BitcodeOption&        bitcode()       { return m_Bitcode; }
 
@@ -65,22 +70,16 @@
 
   void setCodeGenType(CodeGenType pType) { m_CodeGenType = pType; }
 
-  const llvm::Triple& triple() const { return m_Triple; }
-
-  void setTriple(const std::string& pTriple);
-
-  void setTriple(const llvm::Triple& pTriple);
-
   static const char* version();
 
 private:
   // -----  General Options  ----- //
   GeneralOptions m_Options;
   ScriptOptions m_Scripts;
+  TargetOptions m_Targets;
   BitcodeOption m_Bitcode;
   AttributeOption m_Attribute;
 
-  llvm::Triple m_Triple;
   CodeGenType m_CodeGenType;
 };
 
diff --git a/include/mcld/Object/ObjectLinker.h b/include/mcld/Object/ObjectLinker.h
index 4d9f642..515bc58 100644
--- a/include/mcld/Object/ObjectLinker.h
+++ b/include/mcld/Object/ObjectLinker.h
@@ -22,7 +22,7 @@
 
 class Module;
 class LinkerConfig;
-class InputBuilder;
+class IRBuilder;
 class FragmentLinker;
 class TargetLDBackend;
 class MemoryArea;
@@ -31,9 +31,11 @@
 class DynObjReader;
 class ArchiveReader;
 class GroupReader;
+class BinaryReader;
 class ObjectWriter;
 class DynObjWriter;
 class ExecWriter;
+class BinaryWriter;
 
 /** \class ObjectLinker
  *  \brief ObjectLinker prepares parameters for FragmentLinker.
@@ -43,7 +45,7 @@
 public:
   ObjectLinker(const LinkerConfig& pConfig,
                Module& pModule,
-               InputBuilder& pInputBuilder,
+               IRBuilder& pBuilder,
                TargetLDBackend& pLDBackend);
 
   ~ObjectLinker();
@@ -132,8 +134,11 @@
   const ArchiveReader* getArchiveReader() const { return m_pArchiveReader; }
   ArchiveReader*       getArchiveReader()       { return m_pArchiveReader; }
 
-  const GroupReader* getGroupReader() const { return m_pGroupReader; }
-  GroupReader*       getGroupReader()       { return m_pGroupReader; }
+  const GroupReader*   getGroupReader  () const { return m_pGroupReader;   }
+  GroupReader*         getGroupReader  ()       { return m_pGroupReader;   }
+
+  const BinaryReader*  getBinaryReader () const { return m_pBinaryReader;  }
+  BinaryReader*        getBinaryReader ()       { return m_pBinaryReader;  }
 
   const ObjectWriter*  getObjectWriter () const { return m_pObjectWriter;  }
   ObjectWriter*        getObjectWriter ()       { return m_pObjectWriter;  }
@@ -144,24 +149,28 @@
   const ExecWriter*    getExecWriter   () const { return m_pExecWriter;    }
   ExecWriter*          getExecWriter   ()       { return m_pExecWriter;    }
 
+  const BinaryWriter*  getBinaryWriter () const { return m_pBinaryWriter;  }
+  BinaryWriter*        getBinaryWriter ()       { return m_pBinaryWriter;  }
+
 private:
   const LinkerConfig& m_Config;
   Module& m_Module;
 
-  // we pass in InputBuilder for Archive and GroupReader.
-  InputBuilder& m_InputBuilder; 
+  IRBuilder& m_Builder; 
 
   FragmentLinker* m_pLinker;
   TargetLDBackend &m_LDBackend;
 
   // -----  readers and writers  ----- //
-  ObjectReader* m_pObjectReader;
-  DynObjReader* m_pDynObjReader;
+  ObjectReader*  m_pObjectReader;
+  DynObjReader*  m_pDynObjReader;
   ArchiveReader* m_pArchiveReader;
-  ObjectWriter* m_pObjectWriter;
-  DynObjWriter* m_pDynObjWriter;
-  ExecWriter* m_pExecWriter;
-  GroupReader* m_pGroupReader;
+  GroupReader*   m_pGroupReader;
+  BinaryReader*  m_pBinaryReader;
+  ObjectWriter*  m_pObjectWriter;
+  DynObjWriter*  m_pDynObjWriter;
+  ExecWriter*    m_pExecWriter;
+  BinaryWriter*  m_pBinaryWriter;
 };
 
 } // end namespace mcld
diff --git a/include/mcld/Support/CommandLine.h b/include/mcld/Support/CommandLine.h
index 6a90309..2bb9904 100644
--- a/include/mcld/Support/CommandLine.h
+++ b/include/mcld/Support/CommandLine.h
@@ -11,18 +11,42 @@
 #ifdef ENABLE_UNITTEST
 #include <gtest.h>
 #endif
-#include <llvm/ADT/StringRef.h>
-#include <llvm/Support/CommandLine.h>
 #include <mcld/Support/FileSystem.h>
-#include <mcld/MC/MCLDDirectory.h>
 #include <mcld/MC/ZOption.h>
 
-//--------------------------------------------------
-// parser<mcld::sys::fs::Path>
-//
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/CommandLine.h>
+
+#include <string>
+
 namespace llvm {
 namespace cl {
 
+//===----------------------------------------------------------------------===//
+// SearchDirParser
+//===----------------------------------------------------------------------===//
+class SearchDirParser : public llvm::cl::basic_parser<std::string>
+{
+public:
+  // parse - Return true on error.
+  bool parse(Option &pOption,
+             StringRef pArgName,
+             StringRef pArg,
+             std::string &pValue);
+
+  const char *getValueName() const { return "searchdir"; }
+
+  void printOptionDiff(const Option &pOption,
+                       StringRef pValue,
+                       OptVal pDefault,
+                       size_t pGlobalWidth) const;
+
+  void anchor();
+};
+
+//===----------------------------------------------------------------------===//
+// parser<mcld::sys::fs::Path>
+//===----------------------------------------------------------------------===//
 template<>
 class parser<mcld::sys::fs::Path> : public basic_parser<mcld::sys::fs::Path>
 {
@@ -40,26 +64,9 @@
   virtual void anchor();
 };
 
-//--------------------------------------------------
-// parser<mcld::MCLDDirectory>
-//
-template<>
-class parser<mcld::MCLDDirectory> : public llvm::cl::basic_parser<mcld::MCLDDirectory>
-{
-public:
-  bool parse(Option &O, StringRef ArgName, StringRef Arg, mcld::MCLDDirectory &Val);
-
-  virtual const char *getValueName() const { return "directory"; }
-  void printOptionDiff(const Option &O,
-                       const mcld::MCLDDirectory &V,
-                       OptVal Default,
-                       size_t GlobalWidth) const;
-  virtual void anchor();
-};
-
-//--------------------------------------------------
+//===----------------------------------------------------------------------===//
 // parser<mcld::ZOption>
-//
+//===----------------------------------------------------------------------===//
 template<>
 class parser<mcld::ZOption> : public llvm::cl::basic_parser<mcld::ZOption>
 {
diff --git a/include/mcld/Support/GCFactoryListTraits.h b/include/mcld/Support/GCFactoryListTraits.h
index 8a768c8..986f6f6 100644
--- a/include/mcld/Support/GCFactoryListTraits.h
+++ b/include/mcld/Support/GCFactoryListTraits.h
@@ -17,8 +17,7 @@
 
 #include <assert.h>
 
-namespace mcld
-{
+namespace mcld {
 
 /** \class GCFactoryListTraits
  *  \brief GCFactoryListTraits provides trait class for llvm::iplist when
diff --git a/include/mcld/Target/ELFDynamic.h b/include/mcld/Target/ELFDynamic.h
index 2298bfd..7102226 100644
--- a/include/mcld/Target/ELFDynamic.h
+++ b/include/mcld/Target/ELFDynamic.h
@@ -17,11 +17,10 @@
 #include <vector>
 #include <cstring>
 
-namespace mcld
-{
+namespace mcld {
 
-class GNULDBackend;
 class ELFFileFormat;
+class GNULDBackend;
 class LinkerConfig;
 class MemoryRegion;
 
@@ -105,7 +104,7 @@
   typedef EntryListType::const_iterator const_iterator;
 
 public:
-  ELFDynamic(const GNULDBackend& pParent);
+  ELFDynamic(const GNULDBackend& pBackend, const LinkerConfig& pConfig);
 
   virtual ~ELFDynamic();
 
@@ -116,29 +115,21 @@
   size_t numOfBytes() const;
 
   /// reserveEntries - reserve entries
-  void reserveEntries(const LinkerConfig& pConfig,
-                      const ELFFileFormat& pFormat);
+  void reserveEntries(const ELFFileFormat& pFormat);
 
   /// reserveNeedEntry - reserve on DT_NEED entry.
   void reserveNeedEntry();
 
   /// applyEntries - apply entries
-  void applyEntries(const LinkerConfig& pConfig,
-                    const ELFFileFormat& pFormat);
+  void applyEntries(const ELFFileFormat& pFormat);
 
   void applySoname(uint64_t pStrTabIdx);
 
-  iterator needBegin()
-  { return m_NeedList.begin(); }
+  const_iterator needBegin() const { return m_NeedList.begin(); }
+  iterator       needBegin()       { return m_NeedList.begin(); }
 
-  iterator needEnd()
-  { return m_NeedList.end(); }
-
-  const_iterator needBegin() const
-  { return m_NeedList.begin(); }
-
-  const_iterator needEnd() const
-  { return m_NeedList.end(); }
+  const_iterator needEnd() const { return m_NeedList.end(); }
+  iterator       needEnd()       { return m_NeedList.end(); }
 
   /// emit
   void emit(const LDSection& pSection, MemoryRegion& pRegion) const;
@@ -162,6 +153,7 @@
   EntryListType m_NeedList;
   elf_dynamic::EntryIF* m_pEntryFactory;
   const GNULDBackend& m_Backend;
+  const LinkerConfig& m_Config;
 
   // The entry reserved and the entry being applied are not must matched.
   // For better performance, we use a simple counter and apply entry one-by-one
diff --git a/include/mcld/Target/GNUInfo.h b/include/mcld/Target/GNUInfo.h
new file mode 100644
index 0000000..f918431
--- /dev/null
+++ b/include/mcld/Target/GNUInfo.h
@@ -0,0 +1,48 @@
+//===- GNUInfo.h ----------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_GNU_INFO_H
+#define MCLD_TARGET_GNU_INFO_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+#include <llvm/ADT/Triple.h>
+#include <llvm/Support/ELF.h>
+
+namespace mcld {
+
+/** \class GNUInfo
+ *  \brief GNUInfo records ELF-dependent and target-dependnet data fields
+ */
+class GNUInfo
+{
+public:
+  GNUInfo(const llvm::Triple& pTriple);
+
+  virtual ~GNUInfo() { }
+
+  /// ELFVersion - the value of e_ident[EI_VERSION]
+  virtual uint8_t ELFVersion() const { return llvm::ELF::EV_CURRENT; }
+
+  /// The return value of machine() it the same as e_machine in the ELF header
+  virtual uint32_t machine() const = 0;
+
+  /// OSABI - the value of e_ident[EI_OSABI]
+  uint8_t OSABI() const;
+
+  /// ABIVersion - the value of e_ident[EI_ABIVRESION]
+  uint8_t ABIVersion() const { return 0x0; }
+
+private:
+  const llvm::Triple& m_Triple;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/Target/GNULDBackend.h b/include/mcld/Target/GNULDBackend.h
index 4623e33..d20b8ac 100644
--- a/include/mcld/Target/GNULDBackend.h
+++ b/include/mcld/Target/GNULDBackend.h
@@ -22,12 +22,15 @@
 #include <mcld/LD/GNUArchiveReader.h>
 #include <mcld/LD/ELFObjectReader.h>
 #include <mcld/LD/ELFDynObjReader.h>
+#include <mcld/LD/ELFBinaryReader.h>
 #include <mcld/LD/ELFDynObjWriter.h>
 #include <mcld/LD/ELFExecWriter.h>
 #include <mcld/LD/ELFObjectWriter.h>
+#include <mcld/LD/ELFBinaryWriter.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>
@@ -36,11 +39,13 @@
 
 class Module;
 class LinkerConfig;
+class IRBuilder;
 class Layout;
 class EhFrame;
 class EhFrameHdr;
 class BranchIslandFactory;
 class StubFactory;
+class GNUInfo;
 
 /** \class GNULDBackend
  *  \brief GNULDBackend provides a common interface for all GNU Unix-OS
@@ -49,18 +54,20 @@
 class GNULDBackend : public TargetLDBackend
 {
 protected:
-  GNULDBackend(const LinkerConfig& pConfig);
+  GNULDBackend(const LinkerConfig& pConfig, GNUInfo* pInfo);
 
 public:
   virtual ~GNULDBackend();
 
   // -----  readers/writers  ----- //
   GNUArchiveReader* createArchiveReader(Module& pModule);
-  ELFObjectReader* createObjectReader(FragmentLinker& pLinker);
-  ELFDynObjReader* createDynObjReader(FragmentLinker& pLinker);
-  ELFObjectWriter* createObjectWriter(FragmentLinker& pLinker);
-  ELFDynObjWriter* createDynObjWriter(FragmentLinker& pLinker);
-  ELFExecWriter*   createExecWriter(FragmentLinker& pLinker);
+  ELFObjectReader* createObjectReader(IRBuilder& pBuilder);
+  ELFDynObjReader* createDynObjReader(IRBuilder& pBuilder);
+  ELFBinaryReader* createBinaryReader(IRBuilder& pBuilder);
+  ELFObjectWriter* createObjectWriter();
+  ELFDynObjWriter* createDynObjWriter();
+  ELFExecWriter*   createExecWriter();
+  ELFBinaryWriter* createBinaryWriter();
 
   // -----  output sections  ----- //
   /// initStdSections - initialize standard sections of the output file.
@@ -100,18 +107,8 @@
 
   size_t sectionStartOffset() const;
 
-  /// The return value of machine() it the same as e_machine in the ELF header*/
-  virtual uint32_t machine() const = 0;
-
-  /// ELFVersion - the value of e_ident[EI_VERSION]
-  virtual uint8_t ELFVersion() const
-  { return llvm::ELF::EV_CURRENT; }
-
-  /// OSABI - the value of e_ident[EI_OSABI]
-  virtual uint8_t OSABI() const = 0;
-
-  /// ABIVersion - the value of e_ident[EI_ABIVRESION]
-  virtual uint8_t ABIVersion() const = 0;
+  const GNUInfo& getInfo() const { return *m_pInfo; }
+  GNUInfo&       getInfo()       { return *m_pInfo; }
 
   /// flags - the value of ElfXX_Ehdr::e_flags
   virtual uint64_t flags() const = 0;
@@ -364,6 +361,9 @@
                                Module::iterator pSectBegin,
                                Module::iterator pSectEnd);
 
+  /// layout - layout method
+  void layout(Module& pModule, FragmentLinker& pLinker);
+
   /// preLayout - Backend can do any needed modification before layout
   void preLayout(Module& pModule, FragmentLinker& pLinker);
 
@@ -436,6 +436,14 @@
     SHO_STRTAB               // .strtab
   };
 
+  typedef std::pair<LDSection*, unsigned int> SHOEntry;
+
+  struct SHOCompare
+  {
+    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
@@ -465,6 +473,9 @@
   ELFExecFileFormat*   m_pExecFileFormat;
   ELFObjectFileFormat* m_pObjectFileFormat;
 
+  // GNUInfo
+  GNUInfo* m_pInfo;
+
   // ELF segment factory
   ELFSegmentFactory m_ELFSegmentTable;
 
diff --git a/include/mcld/Target/GOT.h b/include/mcld/Target/GOT.h
index 6dfa9b1..732e98f 100644
--- a/include/mcld/Target/GOT.h
+++ b/include/mcld/Target/GOT.h
@@ -28,41 +28,44 @@
 class GOT
 {
 protected:
-  GOT(LDSection& pSection, size_t pEntrySize);
+  GOT(LDSection& pSection);
 
 public:
   typedef SectionData::iterator iterator;
   typedef SectionData::const_iterator const_iterator;
 
+  template<size_t SIZE>
   class Entry : public TargetFragment
   {
   public:
-    Entry(uint64_t pContent, size_t pEntrySize, SectionData* pParent);
+    enum { EntrySize = SIZE };
 
-    virtual ~Entry();
+  public:
+    Entry(uint64_t pValue, SectionData* pParent)
+      : TargetFragment(Fragment::Target, pParent),
+        f_Value(pValue) {
+    }
 
-    uint64_t getContent() const
-    { return f_Content; }
+    virtual ~Entry() {}
 
-    void setContent(uint64_t pValue)
-    { f_Content = pValue; }
+    uint64_t getValue() const
+    { return f_Value; }
+
+    void setValue(uint64_t pValue)
+    { f_Value = pValue; }
 
     // Override pure virtual function
     size_t size() const
-    { return m_EntrySize; }
+    { return EntrySize; }
 
   protected:
-    uint64_t f_Content;
-    size_t m_EntrySize;
+    uint64_t f_Value;
   };
 
 public:
   virtual ~GOT();
 
   // ----- observers -----//
-  /// entrySize - the number of bytes per entry
-  size_t getEntrySize() const;
-
   uint64_t addr() const { return m_Section.addr(); }
 
   const_iterator begin() const { return m_SectionData->begin(); }
@@ -81,17 +84,11 @@
   /// 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);
-
-  /// consume - consume and return an empty entry
-  virtual Entry* consume();
+  virtual void reserve(size_t pNum = 1) = 0;
 
 protected:
   LDSection& m_Section;
   SectionData* m_SectionData;
-  size_t f_EntrySize;
-
-  Entry* m_pLast; ///< the last consumed entry
 };
 
 } // namespace of mcld
diff --git a/include/mcld/Target/OutputRelocSection.h b/include/mcld/Target/OutputRelocSection.h
index ace0c71..b0f8f2d 100644
--- a/include/mcld/Target/OutputRelocSection.h
+++ b/include/mcld/Target/OutputRelocSection.h
@@ -28,18 +28,14 @@
 class OutputRelocSection
 {
 public:
-  OutputRelocSection(Module& pModule,
-                     LDSection& pSection,
-                     unsigned int pEntrySize);
+  OutputRelocSection(Module& pModule, LDSection& pSection);
 
   ~OutputRelocSection();
 
-  void reserveEntry(RelocationFactory& pRelFactory, size_t pNum=1);
+  void reserveEntry(size_t pNum=1);
 
   Relocation* consumeEntry();
 
-  void finalizeSectionSize();
-
   /// addSymbolToDynSym - add local symbol to TLS category so that it'll be
   /// emitted into .dynsym
   bool addSymbolToDynSym(LDSymbol& pSymbol);
@@ -48,27 +44,23 @@
   bool empty()
   { return m_pRelocData->empty(); }
 
+  size_t numOfRelocs();
+
 private:
-  typedef RelocData::iterator FragmentIterator;
+  typedef RelocData::iterator RelocIterator;
 
 private:
   Module& m_Module;
 
-  /// m_pSection - LDSection of this Section
-  LDSection* m_pSection;
-
   /// m_RelocData - the output RelocData which contains the dynamic
   /// relocations
   RelocData* m_pRelocData;
 
-  /// m_EntryBytes - size of a relocation entry
-  unsigned int m_EntryBytes;
-
   /// m_isVisit - First time visit the function getEntry() or not
   bool m_isVisit;
 
   /// m_ValidEntryIterator - point to the first valid entry
-  FragmentIterator m_ValidEntryIterator;
+  RelocIterator m_ValidEntryIterator;
 };
 
 } // namespace of mcld
diff --git a/include/mcld/Target/PLT.h b/include/mcld/Target/PLT.h
index bd5936a..5d91446 100644
--- a/include/mcld/Target/PLT.h
+++ b/include/mcld/Target/PLT.h
@@ -21,6 +21,35 @@
 class LDSection;
 class ResolveInfo;
 
+/** \class PLTEntryDefaultBase
+ *  \brief PLTEntryDefaultBase provides the default interface for PLE Entry
+ */
+class PLTEntryBase : public TargetFragment
+{
+public:
+  PLTEntryBase(SectionData& pParent)
+    : TargetFragment(Fragment::Target, &pParent), m_pValue(NULL)
+  {}
+
+  virtual ~PLTEntryBase()
+  {
+    delete m_pValue;
+  }
+
+  void setValue(unsigned char* pValue)
+  { m_pValue = pValue; }
+
+  const unsigned char* getValue() const
+  { return m_pValue; }
+
+  //Used by llvm::cast<>.
+  static bool classof(const Fragment *O)
+  { return true; }
+
+protected:
+  unsigned char* m_pValue;
+};
+
 /** \class PLT
  *  \brief Procedure linkage table
  */
@@ -30,31 +59,21 @@
   typedef SectionData::iterator iterator;
   typedef SectionData::const_iterator const_iterator;
 
-  class Entry : public TargetFragment
+  template<size_t SIZE, typename EntryBase = PLTEntryBase>
+  class Entry : public EntryBase
   {
   public:
-    Entry(size_t pSize, SectionData& pParent);
-    virtual ~Entry();
+    enum { EntrySize = SIZE };
 
-    size_t getEntrySize() const
-    { return m_EntrySize; }
+  public:
+    Entry(SectionData& pParent)
+      : EntryBase(pParent)
+    {}
 
-    void setContent(unsigned char* pContent)
-    { m_pContent = pContent; }
-
-    const unsigned char* getContent() const
-    { return m_pContent; }
-
-    //Used by llvm::cast<>.
-    static bool classof(const Fragment *O)
-    { return true; }
+    virtual ~Entry() {}
 
     size_t size() const
-    { return m_EntrySize; }
-
-  protected:
-    size_t m_EntrySize;
-    unsigned char* m_pContent;
+    { return EntrySize; }
   };
 
 public:
diff --git a/include/mcld/Target/TargetLDBackend.h b/include/mcld/Target/TargetLDBackend.h
index c18bc79..10cf280 100644
--- a/include/mcld/Target/TargetLDBackend.h
+++ b/include/mcld/Target/TargetLDBackend.h
@@ -15,16 +15,20 @@
 
 class Module;
 class LinkerConfig;
+class IRBuilder;
 class FragmentLinker;
 class Relocation;
 class RelocationFactory;
+class Relocator;
 class Layout;
 class ArchiveReader;
 class ObjectReader;
 class DynObjReader;
+class BinaryReader;
 class ObjectWriter;
 class DynObjWriter;
 class ExecWriter;
+class BinaryWriter;
 class LDFileFormat;
 class LDSymbol;
 class LDSection;
@@ -57,9 +61,10 @@
   virtual void initTargetSymbols(FragmentLinker& pLinker) { }
   virtual void initTargetRelocation(FragmentLinker& pLinker) { }
   virtual bool initStandardSymbols(FragmentLinker& pLinker, Module& pModule) = 0;
-  virtual bool initRelocFactory(const FragmentLinker& pLinker) = 0;
 
-  virtual RelocationFactory* getRelocFactory() = 0;
+  virtual bool initRelocator(const FragmentLinker& pLinker) = 0;
+
+  virtual Relocator* getRelocator() = 0;
 
   /// scanRelocation - When read in relocations, backend can do any modification
   /// to relocation and generate empty entries, such as GOT, dynamic relocation
@@ -86,14 +91,19 @@
 
   // -----  format dependent  ----- //
   virtual ArchiveReader* createArchiveReader(Module&) = 0;
-  virtual ObjectReader*  createObjectReader(FragmentLinker&) = 0;
-  virtual DynObjReader*  createDynObjReader(FragmentLinker&) = 0;
-  virtual ObjectWriter*  createObjectWriter(FragmentLinker&) = 0;
-  virtual DynObjWriter*  createDynObjWriter(FragmentLinker&) = 0;
-  virtual ExecWriter*    createExecWriter(FragmentLinker&) = 0;
+  virtual ObjectReader*  createObjectReader(IRBuilder&) = 0;
+  virtual DynObjReader*  createDynObjReader(IRBuilder&) = 0;
+  virtual BinaryReader*  createBinaryReader(IRBuilder&) = 0;
+  virtual ObjectWriter*  createObjectWriter() = 0;
+  virtual DynObjWriter*  createDynObjWriter() = 0;
+  virtual ExecWriter*    createExecWriter() = 0;
+  virtual BinaryWriter*  createBinaryWriter() = 0;
 
   virtual bool initStdSections(ObjectBuilder& pBuilder) = 0;
 
+  /// layout - layout method
+  virtual void layout(Module& pModule, FragmentLinker& pLinker) = 0;
+
   /// preLayout - Backend can do any needed modification before layout
   virtual void preLayout(Module& pModule, FragmentLinker& pLinker) = 0;
 
@@ -104,12 +114,6 @@
   virtual void postProcessing(FragmentLinker& pLinker,
                               MemoryArea& pOutput) = 0;
 
-  /// Is the target machine little endian? **/
-  virtual bool isLittleEndian() const = 0;
-
-  /// bit class. the bit length of the target machine, 32 or 64 **/
-  virtual unsigned int bitclass() const = 0;
-
   /// the common page size of the target machine
   virtual uint64_t commonPageSize() const = 0;
 
diff --git a/include/mcld/Target/TargetMachine.h b/include/mcld/Target/TargetMachine.h
index 1b167ab..1c2ad99 100644
--- a/include/mcld/Target/TargetMachine.h
+++ b/include/mcld/Target/TargetMachine.h
@@ -39,6 +39,7 @@
   CGFT_DSOFile,
   CGFT_EXEFile,
   CGFT_PARTIAL,
+  CGFT_BINARY,
   CGFT_NULLFile
 };
 
diff --git a/include/mcld/TargetOptions.h b/include/mcld/TargetOptions.h
new file mode 100644
index 0000000..21f65cf
--- /dev/null
+++ b/include/mcld/TargetOptions.h
@@ -0,0 +1,71 @@
+//===- TargetOptions.h ----------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_OPTIONS_H
+#define MCLD_TARGET_OPTIONS_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <llvm/ADT/Triple.h>
+
+#include <string>
+
+namespace mcld {
+
+/** \class TargetOptions
+ *  \brief TargetOptions collects the options that dependent on a target
+ *  backend.
+ */
+class TargetOptions
+{
+public:
+  enum Endian {
+    Little,
+    Big,
+    Unknown
+  };
+
+public:
+  TargetOptions();
+
+  TargetOptions(const std::string& pTriple);
+
+  ~TargetOptions();
+
+  const llvm::Triple& triple() const { return m_Triple; }
+
+  void setTriple(const std::string& pTriple);
+
+  void setTriple(const llvm::Triple& pTriple);
+
+  Endian endian() const { return m_Endian; }
+
+  void setEndian(Endian pEndian) { m_Endian = pEndian; }
+
+  bool isLittleEndian() const { return (Little == m_Endian); }
+  bool isBigEndian   () const { return (Big    == m_Endian); }
+
+  unsigned int bitclass() const { return m_BitClass; }
+
+  void setBitClass(unsigned int pBitClass) { m_BitClass = pBitClass; }
+
+  bool is32Bits() const { return (32 == m_BitClass); }
+  bool is64Bits() const { return (64 == m_BitClass); }
+
+private:
+  llvm::Triple m_Triple;
+  Endian m_Endian;
+  unsigned int m_BitClass;
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/lib/CodeGen/MCLDTargetMachine.cpp b/lib/CodeGen/MCLDTargetMachine.cpp
index e0eeb63..1a2cfff 100644
--- a/lib/CodeGen/MCLDTargetMachine.cpp
+++ b/lib/CodeGen/MCLDTargetMachine.cpp
@@ -241,6 +241,16 @@
       return true;
     break;
   }
+  case CGFT_BINARY: {
+    pConfig.setCodeGenType(LinkerConfig::Binary);
+    if (addLinkerPasses(pPM,
+                        pConfig,
+                        pModule,
+                        pOutput.memory(),
+                        Context))
+      return true;
+    break;
+  }
   case CGFT_DSOFile: {
     pConfig.setCodeGenType(LinkerConfig::DynObj);
     if (addLinkerPasses(pPM,
diff --git a/lib/Core/Android.mk b/lib/Core/Android.mk
index c30d80c..2fd5781 100644
--- a/lib/Core/Android.mk
+++ b/lib/Core/Android.mk
@@ -10,7 +10,8 @@
   LinkerConfig.cpp  \
   Linker.cpp \
   Module.cpp \
-  ScriptOptions.cpp
+  ScriptOptions.cpp \
+  TargetOptions.cpp
 
 # For the host
 # =====================================================
diff --git a/lib/Core/Environment.cpp b/lib/Core/Environment.cpp
index 5755fe7..0aa7536 100644
--- a/lib/Core/Environment.cpp
+++ b/lib/Core/Environment.cpp
@@ -9,6 +9,8 @@
 #include <mcld/Environment.h>
 #include <mcld/Support/TargetSelect.h>
 
+#include <llvm/Support/TargetSelect.h>
+
 void mcld::Initialize()
 {
   static bool is_initialized = false;
@@ -16,6 +18,7 @@
   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 902f753..d762237 100644
--- a/lib/Core/GeneralOptions.cpp
+++ b/lib/Core/GeneralOptions.cpp
@@ -43,11 +43,14 @@
     m_bColor(true),
     m_bAllowShlibUndefined(true),
     m_bCreateEhFrameHdr(false),
-    m_NMagic(false),
-    m_OMagic(false),
-    m_StripDebug(false),
-    m_ExportDynamic(false),
-    m_WarnSharedTextrel(false)
+    m_bNMagic(false),
+    m_bOMagic(false),
+    m_bStripDebug(false),
+    m_bExportDynamic(false),
+    m_bWarnSharedTextrel(false),
+    m_bBinaryInput(false),
+    m_bDefineCommon(false),
+    m_bFatalWarnings(false)
 {
 }
 
diff --git a/lib/Core/IRBuilder.cpp b/lib/Core/IRBuilder.cpp
index 58c1360..5472db0 100644
--- a/lib/Core/IRBuilder.cpp
+++ b/lib/Core/IRBuilder.cpp
@@ -13,6 +13,7 @@
 #include <mcld/LD/EhFrame.h>
 #include <mcld/LD/RelocData.h>
 #include <mcld/Support/MsgHandling.h>
+#include <mcld/Fragment/FragmentRef.h>
 
 using namespace mcld;
 
@@ -82,6 +83,22 @@
   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
 //===----------------------------------------------------------------------===//
@@ -382,7 +399,7 @@
 /// AppendRelocation - To append an relocation to the given RelocData pRD.
 void IRBuilder::AppendRelocation(Relocation& pRelocation, RelocData& pRD)
 {
-  pRD.getFragmentList().push_back(&pRelocation);
+  pRD.append(pRelocation);
 }
 
 /// AppendEhFrame - To append a fragment to EhFrame.
@@ -411,3 +428,249 @@
   return pCIE.size();
 }
 
+/// AddSymbol - To add a symbol in the input file and resolve the symbol
+/// immediately
+LDSymbol* IRBuilder::AddSymbol(Input& pInput,
+                               const std::string& pName,
+                               ResolveInfo::Type pType,
+                               ResolveInfo::Desc pDesc,
+                               ResolveInfo::Binding pBind,
+                               ResolveInfo::SizeType pSize,
+                               LDSymbol::ValueType pValue,
+                               LDSection* pSection,
+                               ResolveInfo::Visibility pVis)
+{
+  // rename symbols
+  std::string name = pName;
+  if (!m_Config.scripts().renameMap().empty() &&
+      ResolveInfo::Undefined == pDesc) {
+    // If the renameMap is not empty, some symbols should be renamed.
+    // --wrap and --portable defines the symbol rename map.
+    ScriptOptions::SymbolRenameMap::const_iterator renameSym =
+                                    m_Config.scripts().renameMap().find(pName);
+    if (renameSym != m_Config.scripts().renameMap().end())
+      name = renameSym.getEntry()->value();
+  }
+
+  switch (pInput.type()) {
+    case Input::Object: {
+
+      FragmentRef* frag = NULL;
+      if (NULL == pSection ||
+          ResolveInfo::Undefined == pDesc ||
+          ResolveInfo::Common    == pDesc ||
+          ResolveInfo::Absolute  == pBind ||
+          LDFileFormat::Ignore   == pSection->kind() ||
+          LDFileFormat::Group    == pSection->kind())
+        frag = FragmentRef::Null();
+      else
+        frag = FragmentRef::Create(*pSection, pValue);
+
+      LDSymbol* input_sym = addSymbolFromObject(name, pType, pDesc, pBind, pSize, pValue, frag, pVis);
+      pInput.context()->addSymbol(input_sym);
+      return input_sym;
+    }
+    case Input::DynObj: {
+      return addSymbolFromDynObj(name, pType, pDesc, pBind, pSize, pValue, pVis);
+    }
+    default: {
+      return NULL;
+      break;
+    }
+  }
+}
+
+LDSymbol* IRBuilder::addSymbolFromObject(const std::string& pName,
+                                         ResolveInfo::Type pType,
+                                         ResolveInfo::Desc pDesc,
+                                         ResolveInfo::Binding pBinding,
+                                         ResolveInfo::SizeType pSize,
+                                         LDSymbol::ValueType pValue,
+                                         FragmentRef* pFragmentRef,
+                                         ResolveInfo::Visibility pVisibility)
+{
+  // Step 1. calculate a Resolver::Result
+  // resolved_result is a triple <resolved_info, existent, override>
+  Resolver::Result resolved_result;
+  ResolveInfo old_info; // used for arrange output symbols
+
+  if (pBinding == ResolveInfo::Local) {
+    // if the symbol is a local symbol, create a LDSymbol for input, but do not
+    // resolve them.
+    resolved_result.info     = m_Module.getNamePool().createSymbol(pName,
+                                                                   false,
+                                                                   pType,
+                                                                   pDesc,
+                                                                   pBinding,
+                                                                   pSize,
+                                                                   pVisibility);
+
+    // No matter if there is a symbol with the same name, insert the symbol
+    // into output symbol table. So, we let the existent false.
+    resolved_result.existent  = false;
+    resolved_result.overriden = true;
+  }
+  else {
+    // if the symbol is not local, insert and resolve it immediately
+    m_Module.getNamePool().insertSymbol(pName, false, pType, pDesc, pBinding,
+                                        pSize, pVisibility,
+                                        &old_info, resolved_result);
+  }
+
+  // the return ResolveInfo should not NULL
+  assert(NULL != resolved_result.info);
+
+  /// Step 2. create an input LDSymbol.
+  // create a LDSymbol for the input file.
+  LDSymbol* input_sym = LDSymbol::Create(*resolved_result.info);
+  input_sym->setFragmentRef(pFragmentRef);
+  input_sym->setValue(pValue);
+
+  // Step 3. Set up corresponding output LDSymbol
+  LDSymbol* output_sym = resolved_result.info->outSymbol();
+  bool has_output_sym = (NULL != output_sym);
+  if (!resolved_result.existent || !has_output_sym) {
+    // it is a new symbol, the output_sym should be NULL.
+    assert(NULL == output_sym);
+
+    if (pType == ResolveInfo::Section) {
+      // if it is a section symbol, its output LDSymbol is the input LDSymbol.
+      output_sym = input_sym;
+    }
+    else {
+      // if it is a new symbol, create a LDSymbol for the output
+      output_sym = LDSymbol::Create(*resolved_result.info);
+    }
+    resolved_result.info->setSymPtr(output_sym);
+  }
+
+  if (resolved_result.overriden || !has_output_sym) {
+    // symbol can be overriden only if it exists.
+    assert(output_sym != NULL);
+
+    // should override output LDSymbol
+    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;
+}
+
+LDSymbol* IRBuilder::addSymbolFromDynObj(const std::string& pName,
+                                         ResolveInfo::Type pType,
+                                         ResolveInfo::Desc pDesc,
+                                         ResolveInfo::Binding pBinding,
+                                         ResolveInfo::SizeType pSize,
+                                         LDSymbol::ValueType pValue,
+                                         ResolveInfo::Visibility pVisibility)
+{
+  // We don't need sections of dynamic objects. So we ignore section symbols.
+  if (pType == ResolveInfo::Section)
+    return NULL;
+
+  // ignore symbols with local binding or that have internal or hidden
+  // visibility
+  if (pBinding == ResolveInfo::Local ||
+      pVisibility == ResolveInfo::Internal ||
+      pVisibility == ResolveInfo::Hidden)
+    return NULL;
+
+  // A protected symbol in a shared library must be treated as a
+  // normal symbol when viewed from outside the shared library.
+  if (pVisibility == ResolveInfo::Protected)
+    pVisibility = ResolveInfo::Default;
+
+  // insert symbol and resolve it immediately
+  // resolved_result is a triple <resolved_info, existent, override>
+  Resolver::Result resolved_result;
+  m_Module.getNamePool().insertSymbol(pName, true, pType, pDesc,
+                                      pBinding, pSize, pVisibility,
+                                      NULL, resolved_result);
+
+  // the return ResolveInfo should not NULL
+  assert(NULL != resolved_result.info);
+
+  // create a LDSymbol for the input file.
+  LDSymbol* input_sym = LDSymbol::Create(*resolved_result.info);
+  input_sym->setFragmentRef(FragmentRef::Null());
+  input_sym->setValue(pValue);
+
+  LDSymbol* output_sym = NULL;
+  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;
+}
+
+/// AddRelocation - add a relocation entry
+///
+/// All symbols should be read and resolved before calling this function.
+Relocation* IRBuilder::AddRelocation(LDSection& pSection,
+                                     Relocation::Type pType,
+                                     LDSymbol& pSym,
+                                     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);
+  pSection.getRelocData()->append(*relocation);
+
+  return relocation;
+}
+
diff --git a/lib/Core/Linker.cpp b/lib/Core/Linker.cpp
index 7262537..9f6449e 100644
--- a/lib/Core/Linker.cpp
+++ b/lib/Core/Linker.cpp
@@ -22,6 +22,9 @@
 #include <mcld/Target/TargetLDBackend.h>
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/LDSymbol.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/LD/RelocData.h>
+#include <mcld/Fragment/Relocation.h>
 #include <mcld/Fragment/FragmentRef.h>
 
 #include <cassert>
@@ -64,7 +67,7 @@
   m_pIRBuilder = &pBuilder;
   m_pObjLinker = new ObjectLinker(*m_pConfig,
                                   pModule,
-                                  m_pIRBuilder->getInputBuilder(),
+                                  *m_pIRBuilder,
                                   *m_pBackend);
 
   // 2. - initialize FragmentLinker
@@ -203,6 +206,11 @@
   m_pIRBuilder = NULL;
   m_pTarget = NULL;
 
+  // Because llvm::iplist will touch the removed node, we must clear
+  // RelocData before deleting target backend.
+  RelocData::Clear();
+  SectionData::Clear();
+
   delete m_pBackend;
   m_pBackend = NULL;
 
@@ -212,6 +220,7 @@
   LDSection::Clear();
   LDSymbol::Clear();
   FragmentRef::Clear();
+  Relocation::Clear();
   return true;
 }
 
@@ -220,9 +229,9 @@
   assert(NULL != m_pConfig);
 
   std::string error;
-  m_pTarget = TargetRegistry::lookupTarget(m_pConfig->triple().str(), error);
+  m_pTarget = mcld::TargetRegistry::lookupTarget(m_pConfig->targets().triple().str(), error);
   if (NULL == m_pTarget) {
-    fatal(diag::fatal_cannot_init_target) << m_pConfig->triple().str() << error;
+    fatal(diag::fatal_cannot_init_target) << m_pConfig->targets().triple().str() << error;
     return false;
   }
   return true;
@@ -233,7 +242,7 @@
   assert(NULL != m_pTarget);
   m_pBackend = m_pTarget->createLDBackend(*m_pConfig);
   if (NULL == m_pBackend) {
-    fatal(diag::fatal_cannot_init_backend) << m_pConfig->triple().str();
+    fatal(diag::fatal_cannot_init_backend) << m_pConfig->targets().triple().str();
     return false;
   }
   return true;
@@ -242,7 +251,12 @@
 bool Linker::initEmulator()
 {
   assert(NULL != m_pTarget && NULL != m_pConfig);
-  return m_pTarget->emulate(m_pConfig->triple().str(), *m_pConfig);
+  bool result = m_pTarget->emulate(m_pConfig->targets().triple().str(),
+                                   *m_pConfig);
+
+  // Relocation should be set up after emulation.
+  Relocation::SetUp(*m_pConfig);
+  return result;
 }
 
 bool Linker::initOStream()
diff --git a/lib/Core/LinkerConfig.cpp b/lib/Core/LinkerConfig.cpp
index d94bbe2..cbdb7a7 100644
--- a/lib/Core/LinkerConfig.cpp
+++ b/lib/Core/LinkerConfig.cpp
@@ -19,9 +19,9 @@
 LinkerConfig::LinkerConfig()
   : m_Options(),
     m_Scripts(),
+    m_Targets(),
     m_Bitcode(),
     m_Attribute(),
-    m_Triple(),
     m_CodeGenType(Unknown)
 {
   // FIXME: is here the right place to hold this?
@@ -31,9 +31,9 @@
 LinkerConfig::LinkerConfig(const std::string& pTripleString)
   : m_Options(),
     m_Scripts(),
+    m_Targets(pTripleString),
     m_Bitcode(),
     m_Attribute(),
-    m_Triple(pTripleString),
     m_CodeGenType(Unknown)
 {
   // FIXME: is here the right place to hold this?
@@ -46,16 +46,6 @@
   FinalizeDiagnosticEngine();
 }
 
-void LinkerConfig::setTriple(const llvm::Triple& pTriple)
-{
-  m_Triple = pTriple;
-}
-
-void LinkerConfig::setTriple(const std::string& pTriple)
-{
-  m_Triple.setTriple(pTriple);
-}
-
 const char* LinkerConfig::version()
 {
   return MCLD_VERSION;
diff --git a/lib/Core/TargetOptions.cpp b/lib/Core/TargetOptions.cpp
new file mode 100644
index 0000000..db723b6
--- /dev/null
+++ b/lib/Core/TargetOptions.cpp
@@ -0,0 +1,40 @@
+//===- TargetOptions.cpp --------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/TargetOptions.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// TargetOptions
+//===----------------------------------------------------------------------===//
+TargetOptions::TargetOptions()
+  : m_Endian(Unknown),
+    m_BitClass(0) {
+}
+
+TargetOptions::TargetOptions(const std::string& pTriple)
+  : m_Triple(pTriple),
+    m_Endian(Unknown),
+    m_BitClass(0) {
+}
+
+TargetOptions::~TargetOptions()
+{
+}
+
+void TargetOptions::setTriple(const llvm::Triple& pTriple)
+{
+  m_Triple = pTriple;
+}
+
+void TargetOptions::setTriple(const std::string& pTriple)
+{
+  m_Triple.setTriple(pTriple);
+}
+
diff --git a/lib/Fragment/FragmentLinker.cpp b/lib/Fragment/FragmentLinker.cpp
index 4ad3d90..0398834 100644
--- a/lib/Fragment/FragmentLinker.cpp
+++ b/lib/Fragment/FragmentLinker.cpp
@@ -20,7 +20,6 @@
 #include <mcld/Module.h>
 #include <mcld/MC/MCLDInput.h>
 #include <mcld/LD/BranchIslandFactory.h>
-#include <mcld/LD/Layout.h>
 #include <mcld/LD/Resolver.h>
 #include <mcld/LD/LDContext.h>
 #include <mcld/LD/RelocationFactory.h>
@@ -31,9 +30,13 @@
 #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,
@@ -52,178 +55,6 @@
 //===----------------------------------------------------------------------===//
 // Symbol Operations
 //===----------------------------------------------------------------------===//
-/// addSymbolFromObject - add a symbol from object file and resolve it
-/// immediately
-LDSymbol* FragmentLinker::addSymbolFromObject(const llvm::StringRef& pName,
-                                        ResolveInfo::Type pType,
-                                        ResolveInfo::Desc pDesc,
-                                        ResolveInfo::Binding pBinding,
-                                        ResolveInfo::SizeType pSize,
-                                        LDSymbol::ValueType pValue,
-                                        FragmentRef* pFragmentRef,
-                                        ResolveInfo::Visibility pVisibility)
-{
-
-  // Step 1. calculate a Resolver::Result
-  // resolved_result is a triple <resolved_info, existent, override>
-  Resolver::Result resolved_result;
-  ResolveInfo old_info; // used for arrange output symbols
-
-  if (pBinding == ResolveInfo::Local) {
-    // if the symbol is a local symbol, create a LDSymbol for input, but do not
-    // resolve them.
-    resolved_result.info     = m_Module.getNamePool().createSymbol(pName,
-                                                                   false,
-                                                                   pType,
-                                                                   pDesc,
-                                                                   pBinding,
-                                                                   pSize,
-                                                                   pVisibility);
-
-    // No matter if there is a symbol with the same name, insert the symbol
-    // into output symbol table. So, we let the existent false.
-    resolved_result.existent  = false;
-    resolved_result.overriden = true;
-  }
-  else {
-    // if the symbol is not local, insert and resolve it immediately
-    m_Module.getNamePool().insertSymbol(pName, false, pType, pDesc, pBinding,
-                                        pSize, pVisibility,
-                                        &old_info, resolved_result);
-  }
-
-  // the return ResolveInfo should not NULL
-  assert(NULL != resolved_result.info);
-
-  /// Step 2. create an input LDSymbol.
-  // create a LDSymbol for the input file.
-  LDSymbol* input_sym = LDSymbol::Create(*resolved_result.info);
-  input_sym->setFragmentRef(pFragmentRef);
-  input_sym->setValue(pValue);
-
-  // Step 3. Set up corresponding output LDSymbol
-  LDSymbol* output_sym = resolved_result.info->outSymbol();
-  bool has_output_sym = (NULL != output_sym);
-  if (!resolved_result.existent || !has_output_sym) {
-    // it is a new symbol, the output_sym should be NULL.
-    assert(NULL == output_sym);
-
-    if (pType == ResolveInfo::Section) {
-      // if it is a section symbol, its output LDSymbol is the input LDSymbol.
-      output_sym = input_sym;
-    }
-    else {
-      // if it is a new symbol, create a LDSymbol for the output
-      output_sym = LDSymbol::Create(*resolved_result.info);
-    }
-    resolved_result.info->setSymPtr(output_sym);
-  }
-
-  if (resolved_result.overriden || !has_output_sym) {
-    // symbol can be overriden only if it exists.
-    assert(output_sym != NULL);
-
-    // should override output LDSymbol
-    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_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) ||
-          !shouldForceLocal(*resolved_result.info)) {
-        // 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;
-}
-
-/// addSymbolFromDynObj - add a symbol from object file and resolve it
-/// immediately
-LDSymbol* FragmentLinker::addSymbolFromDynObj(const llvm::StringRef& pName,
-                                        ResolveInfo::Type pType,
-                                        ResolveInfo::Desc pDesc,
-                                        ResolveInfo::Binding pBinding,
-                                        ResolveInfo::SizeType pSize,
-                                        LDSymbol::ValueType pValue,
-                                        FragmentRef* pFragmentRef,
-                                        ResolveInfo::Visibility pVisibility)
-{
-  // We don't need sections of dynamic objects. So we ignore section symbols.
-  if (pType == ResolveInfo::Section)
-    return NULL;
-
-  // ignore symbols with local binding or that have internal or hidden
-  // visibility
-  if (pBinding == ResolveInfo::Local ||
-      pVisibility == ResolveInfo::Internal ||
-      pVisibility == ResolveInfo::Hidden)
-    return NULL;
-
-  // A protected symbol in a shared library must be treated as a
-  // normal symbol when viewed from outside the shared library.
-  if (pVisibility == ResolveInfo::Protected)
-    pVisibility = ResolveInfo::Default;
-
-  // insert symbol and resolve it immediately
-  // resolved_result is a triple <resolved_info, existent, override>
-  Resolver::Result resolved_result;
-  m_Module.getNamePool().insertSymbol(pName, true, pType, pDesc,
-                                      pBinding, pSize, pVisibility,
-                                      NULL, resolved_result);
-
-  // the return ResolveInfo should not NULL
-  assert(NULL != resolved_result.info);
-
-  // create a LDSymbol for the input file.
-  LDSymbol* input_sym = LDSymbol::Create(*resolved_result.info);
-  input_sym->setFragmentRef(pFragmentRef);
-  input_sym->setValue(pValue);
-
-  LDSymbol* output_sym = NULL;
-  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_Module.getSymbolTable().forceLocal(*output_sym);
-    }
-  }
-
-  return input_sym;
-}
-
 /// defineSymbolForcefully - define an output symbol and override it immediately
 LDSymbol* FragmentLinker::defineSymbolForcefully(const llvm::StringRef& pName,
                                            bool pIsDyn,
@@ -462,36 +293,6 @@
 //===----------------------------------------------------------------------===//
 // Relocation Operations
 //===----------------------------------------------------------------------===//
-/// addRelocation - add a relocation entry in FragmentLinker (only for object file)
-///
-/// All symbols should be read and resolved before calling this function.
-Relocation* FragmentLinker::addRelocation(Relocation::Type pType,
-                                          LDSymbol& pSym,
-                                          LDSection& pSection,
-                                          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() &&
-      resolve_info->type() == ResolveInfo::Section &&
-      resolve_info->desc() == ResolveInfo::Undefined)
-    return NULL;
-
-  FragmentRef* frag_ref = FragmentRef::Create(*pSection.getLink(), pOffset);
-
-  Relocation* relocation = m_Backend.getRelocFactory()->produce(pType,
-                                                                *frag_ref,
-                                                                pAddend);
-
-  relocation->setSymInfo(resolve_info);
-  pSection.getRelocData()->getFragmentList().push_back(relocation);
-
-  return relocation;
-}
-
 bool FragmentLinker::applyRelocations()
 {
   // when producing relocatables, no need to apply relocation
@@ -513,7 +314,7 @@
       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.getRelocFactory());
+        relocation->apply(*m_Backend.getRelocator());
       } // for all relocations
     } // for all relocation section
   } // for all inputs
@@ -525,7 +326,7 @@
     BranchIsland& island = *facIter;
     BranchIsland::reloc_iterator iter, iterEnd = island.reloc_end();
     for (iter = island.reloc_begin(); iter != iterEnd; ++iter)
-      (*iter)->apply(*m_Backend.getRelocFactory());
+      (*iter)->apply(*m_Backend.getRelocator());
   }
   return true;
 }
@@ -630,17 +431,17 @@
 
   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_Backend.isLittleEndian()) {
+  if(llvm::sys::isLittleEndianHost() != m_Config.targets().isLittleEndian()) {
      uint64_t tmp_data = 0;
 
-     switch(m_Backend.bitclass()) {
+     switch(m_Config.targets().bitclass()) {
        case 32u:
-         tmp_data = bswap32(pReloc.target());
+         tmp_data = mcld::bswap32(pReloc.target());
          std::memcpy(target_addr, &tmp_data, 4);
          break;
 
        case 64u:
-         tmp_data = bswap64(pReloc.target());
+         tmp_data = mcld::bswap64(pReloc.target());
          std::memcpy(target_addr, &tmp_data, 8);
          break;
 
@@ -649,7 +450,7 @@
     }
   }
   else
-    std::memcpy(target_addr, &pReloc.target(), m_Backend.bitclass()/8);
+    std::memcpy(target_addr, &pReloc.target(), m_Config.targets().bitclass()/8);
 }
 
 /// isOutputPIC - return whether the output is position-independent
diff --git a/lib/Fragment/Relocation.cpp b/lib/Fragment/Relocation.cpp
index bae49af..293b1c9 100644
--- a/lib/Fragment/Relocation.cpp
+++ b/lib/Fragment/Relocation.cpp
@@ -7,21 +7,69 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/Fragment/Relocation.h>
-#include <mcld/LD/RelocationFactory.h>
+#include <mcld/LD/Relocator.h>
 #include <mcld/LD/ResolveInfo.h>
 #include <mcld/LD/LDSymbol.h>
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/SectionData.h>
 #include <mcld/Support/MsgHandling.h>
+#include <mcld/LD/RelocationFactory.h>
+
+#include <llvm/Support/ManagedStatic.h>
 
 using namespace mcld;
 
+static llvm::ManagedStatic<RelocationFactory> g_RelocationFactory;
+
+//===----------------------------------------------------------------------===//
+// Relocation Factory Methods
+//===----------------------------------------------------------------------===//
+/// Initialize - set up the relocation factory
+void Relocation::SetUp(const LinkerConfig& pConfig)
+{
+  g_RelocationFactory->setConfig(pConfig);
+}
+
+/// Clear - Clean up the relocation factory
+void Relocation::Clear()
+{
+  g_RelocationFactory->clear();
+}
+
+/// Create - produce an empty relocation entry
+Relocation* Relocation::Create()
+{
+  return g_RelocationFactory->produceEmptyEntry();
+}
+
+/// Create - produce a relocation entry
+/// @param pType    [in] the type of the relocation entry
+/// @param pFragRef [in] the place to apply the relocation
+/// @param pAddend  [in] the addend of the relocation entry
+Relocation* Relocation::Create(Type pType, FragmentRef& pFragRef, Address pAddend)
+{
+  return g_RelocationFactory->produce(pType, pFragRef, pAddend);
+}
+
+/// Destroy - destroy a relocation entry
+void Relocation::Destroy(Relocation*& pRelocation)
+{
+  g_RelocationFactory->destroy(pRelocation);
+  pRelocation = NULL;
+}
+
+//===----------------------------------------------------------------------===//
+// Relocation
+//===----------------------------------------------------------------------===//
+Relocation::Relocation()
+  : m_Type(0x0), m_TargetData(0x0), m_pSymInfo(NULL), m_Addend(0x0) {
+}
+
 Relocation::Relocation(Relocation::Type pType,
                        FragmentRef* pTargetRef,
                        Relocation::Address pAddend,
                        Relocation::DWord pTargetData)
-  : Fragment(Fragment::Relocation),
-    m_Type(pType),
+  : m_Type(pType),
     m_TargetData(pTargetData),
     m_pSymInfo(NULL),
     m_Addend(pAddend)
@@ -49,31 +97,31 @@
   return m_pSymInfo->outSymbol()->value();
 }
 
-void Relocation::apply(RelocationFactory& pRelocFactory)
+void Relocation::apply(Relocator& pRelocator)
 {
-  RelocationFactory::Result result = pRelocFactory.applyRelocation(*this);
+  Relocator::Result result = pRelocator.applyRelocation(*this);
 
   switch (result) {
-    case RelocationFactory::OK: {
+    case Relocator::OK: {
       // do nothing
       return;
     }
-    case RelocationFactory::Overflow: {
-      error(diag::result_overflow) << pRelocFactory.getName(type())
+    case Relocator::Overflow: {
+      error(diag::result_overflow) << pRelocator.getName(type())
                                    << symInfo()->name();
       return;
     }
-    case RelocationFactory::BadReloc: {
-      error(diag::result_badreloc) << pRelocFactory.getName(type())
+    case Relocator::BadReloc: {
+      error(diag::result_badreloc) << pRelocator.getName(type())
                                    << symInfo()->name();
       return;
     }
-    case RelocationFactory::Unsupport: {
+    case Relocator::Unsupport: {
       fatal(diag::unsupported_relocation) << type()
                                           << "mclinker@googlegroups.com";
       return;
     }
-    case RelocationFactory::Unknown: {
+    case Relocator::Unknown: {
       fatal(diag::unknown_relocation) << type() << symInfo()->name();
       return;
     }
diff --git a/lib/LD/Android.mk b/lib/LD/Android.mk
index 21e452e..53c1f10 100644
--- a/lib/LD/Android.mk
+++ b/lib/LD/Android.mk
@@ -7,6 +7,7 @@
 mcld_ld_SRC_FILES := \
   Archive.cpp \
   ArchiveReader.cpp \
+  BinaryWriter.cpp \
   BranchIsland.cpp  \
   BranchIslandFactory.cpp  \
   DWARFLineInfo.cpp \
@@ -17,6 +18,8 @@
   DiagnosticPrinter.cpp \
   DynObjReader.cpp  \
   DynObjWriter.cpp  \
+  ELFBinaryReader.cpp  \
+  ELFBinaryWriter.cpp  \
   ELFSegment.cpp  \
   ELFSegmentFactory.cpp \
   EhFrame.cpp \
@@ -24,7 +27,6 @@
   EhFrameReader.cpp  \
   ExecWriter.cpp  \
   GroupReader.cpp \
-  Layout.cpp  \
   LDContext.cpp \
   LDFileFormat.cpp  \
   LDReader.cpp  \
diff --git a/lib/LD/BinaryWriter.cpp b/lib/LD/BinaryWriter.cpp
new file mode 100644
index 0000000..00dd169
--- /dev/null
+++ b/lib/LD/BinaryWriter.cpp
@@ -0,0 +1,24 @@
+//===- BinaryWriter.cpp ---------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/LD/BinaryWriter.h>
+#include <mcld/MC/MCLDInput.h>
+#include <mcld/Target/GNULDBackend.h>
+
+using namespace mcld;
+
+//==========================
+// BinaryWriter
+BinaryWriter::BinaryWriter(GNULDBackend& pBackend)
+{
+}
+
+BinaryWriter::~BinaryWriter()
+{
+}
+
diff --git a/lib/LD/DiagnosticInfos.cpp b/lib/LD/DiagnosticInfos.cpp
index 6639d0a..130fd9a 100644
--- a/lib/LD/DiagnosticInfos.cpp
+++ b/lib/LD/DiagnosticInfos.cpp
@@ -146,6 +146,14 @@
       break;
   } // end of switch
 
+  // If --fatal-warnings is turned on, then switch warnings and errors to fatal
+  if (m_Config.options().isFatalWarnings()) {
+    if (severity == DiagnosticEngine::Warning ||
+        severity == DiagnosticEngine::Error) {
+      severity = DiagnosticEngine::Fatal;
+    }
+  }
+
   // finally, report it.
   pEngine.getPrinter()->handleDiagnostic(severity, info);
   return true;
diff --git a/lib/LD/DiagnosticPrinter.cpp b/lib/LD/DiagnosticPrinter.cpp
index 245555f..6eee86a 100644
--- a/lib/LD/DiagnosticPrinter.cpp
+++ b/lib/LD/DiagnosticPrinter.cpp
@@ -10,8 +10,9 @@
 
 using namespace mcld;
 
-//==========================
+//===----------------------------------------------------------------------===//
 // DiagnosticPrinter
+//===----------------------------------------------------------------------===//
 DiagnosticPrinter::DiagnosticPrinter()
   : m_NumErrors(0), m_NumWarnings(0) {
 }
diff --git a/lib/LD/ELFBinaryReader.cpp b/lib/LD/ELFBinaryReader.cpp
new file mode 100644
index 0000000..c291544
--- /dev/null
+++ b/lib/LD/ELFBinaryReader.cpp
@@ -0,0 +1,124 @@
+//===- ELFBinaryReader.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/IRBuilder.h>
+#include <mcld/LinkerConfig.h>
+#include <mcld/MC/MCLDInput.h>
+#include <mcld/Support/MemoryArea.h>
+#include <mcld/Target/GNULDBackend.h>
+
+#include <llvm/Support/ELF.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// ELFBinaryReader
+//===----------------------------------------------------------------------===//
+/// constructor
+ELFBinaryReader::ELFBinaryReader(GNULDBackend& pBackend,
+                                 IRBuilder& pBuilder,
+                                 const LinkerConfig& pConfig)
+  : BinaryReader(),
+    m_Backend(pBackend),
+    m_Builder(pBuilder),
+    m_Config(pConfig) {
+}
+
+/// destructor
+ELFBinaryReader::~ELFBinaryReader()
+{
+}
+
+bool ELFBinaryReader::readBinary(Input& pInput)
+{
+  // section: NULL
+  m_Builder.CreateELFHeader(pInput,
+                            "",
+                            LDFileFormat::Null,
+                            llvm::ELF::SHT_NULL,
+                            0x0);
+
+  // section: .data
+  LDSection* data_sect =
+    m_Builder.CreateELFHeader(pInput,
+                              ".data",
+                              LDFileFormat::Regular,
+                              llvm::ELF::SHF_WRITE | llvm::ELF::SHF_ALLOC,
+                              0x1);
+
+
+  SectionData* data = m_Builder.CreateSectionData(*data_sect);
+  size_t data_size = pInput.memArea()->handler()->size();
+  Fragment* frag = m_Builder.CreateRegion(pInput, 0x0, data_size);
+  m_Builder.AppendFragment(*frag, *data);
+
+  // section: .shstrtab
+  m_Builder.CreateELFHeader(pInput,
+                            ".shstrtab",
+                            LDFileFormat::NamePool,
+                            llvm::ELF::SHT_STRTAB,
+                            0x1);
+
+  // section: .symtab
+  m_Builder.CreateELFHeader(pInput,
+                            ".symtab",
+                            LDFileFormat::NamePool,
+                            llvm::ELF::SHT_SYMTAB,
+                            m_Config.targets().bitclass() / 8);
+
+  // symbol: .data
+  m_Builder.AddSymbol(pInput,
+                      ".data",
+                      ResolveInfo::Section,
+                      ResolveInfo::Define,
+                      ResolveInfo::Local,
+                      0x0,
+                      0x0,
+                      data_sect);
+
+  // symbol: _start
+  m_Builder.AddSymbol(pInput,
+                      "_binary_" + pInput.path().filename().string() + "_start",
+                      ResolveInfo::NoType,
+                      ResolveInfo::Define,
+                      ResolveInfo::Global,
+                      0x0,
+                      0x0,
+                      data_sect);
+
+  // symbol: _end
+  m_Builder.AddSymbol(pInput,
+                      "_binary_" + pInput.path().filename().string() + "_end",
+                      ResolveInfo::NoType,
+                      ResolveInfo::Define,
+                      ResolveInfo::Global,
+                      0x0,
+                      data_size,
+                      data_sect);
+
+  // symbol: _size
+  m_Builder.AddSymbol(pInput,
+                      "_binary_" + pInput.path().filename().string() + "_size",
+                      ResolveInfo::NoType,
+                      ResolveInfo::Define,
+                      ResolveInfo::Global,
+                      0x0,
+                      data_size,
+                      data_sect);
+
+  // section: .strtab
+  m_Builder.CreateELFHeader(pInput,
+                            ".strtab",
+                            LDFileFormat::NamePool,
+                            llvm::ELF::SHT_STRTAB,
+                            0x1);
+
+  return true;
+}
diff --git a/lib/LD/ELFBinaryWriter.cpp b/lib/LD/ELFBinaryWriter.cpp
new file mode 100644
index 0000000..28ef553
--- /dev/null
+++ b/lib/LD/ELFBinaryWriter.cpp
@@ -0,0 +1,110 @@
+//===- ELFBinaryWriter.cpp ------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/LD/ELFBinaryWriter.h>
+
+#include <mcld/Module.h>
+#include <mcld/Target/GNULDBackend.h>
+#include <mcld/Fragment/FragmentLinker.h>
+#include <mcld/Support/MemoryArea.h>
+#include <mcld/LD/ELFSegmentFactory.h>
+#include <mcld/LD/ELFSegment.h>
+
+#include <llvm/Support/system_error.h>
+using namespace llvm;
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// ELFBinaryWriter
+//===----------------------------------------------------------------------===//
+ELFBinaryWriter::ELFBinaryWriter(GNULDBackend& pBackend,
+                                 const LinkerConfig& pConfig)
+  : BinaryWriter(pBackend), ELFWriter(pBackend), m_Config(pConfig) {
+}
+
+ELFBinaryWriter::~ELFBinaryWriter()
+{
+}
+
+llvm::error_code ELFBinaryWriter::writeBinary(Module& pModule,
+                                              MemoryArea& pOutput)
+{
+  // Write out regular ELF sections
+  for (ELFSegmentFactory::iterator seg = target().elfSegmentTable().begin(),
+         segEnd = target().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) {
+      MemoryRegion* region = NULL;
+      // request output region
+      switch((*sect)->kind()) {
+        case LDFileFormat::Note:
+          if ((*sect)->getSectionData() == NULL)
+            continue;
+          // Fall through
+        case LDFileFormat::Regular:
+        case LDFileFormat::Relocation:
+        case LDFileFormat::Target:
+        case LDFileFormat::Debug:
+        case LDFileFormat::GCCExceptTable:
+        case LDFileFormat::EhFrame: {
+          region = pOutput.request((*sect)->offset(), (*sect)->size());
+          if (NULL == region) {
+            llvm::report_fatal_error(llvm::Twine("cannot get enough memory region for output section `") +
+                                     llvm::Twine((*sect)->name()) +
+                                     llvm::Twine("'.\n"));
+          }
+          break;
+        }
+        case LDFileFormat::Null:
+        case LDFileFormat::NamePool:
+        case LDFileFormat::BSS:
+        case LDFileFormat::MetaData:
+        case LDFileFormat::Version:
+        case LDFileFormat::EhFrameHdr:
+        case LDFileFormat::StackNote:
+          // ignore these sections
+          continue;
+        default: {
+          llvm::errs() << "WARNING: unsupported section kind: "
+                       << (*sect)->kind()
+                       << " of section "
+                       << (*sect)->name()
+                       << ".\n";
+          continue;
+        }
+      }
+
+      // write out sections with data
+      switch((*sect)->kind()) {
+        case LDFileFormat::Regular:
+        case LDFileFormat::Debug:
+        case LDFileFormat::GCCExceptTable:
+        case LDFileFormat::Note:
+        case LDFileFormat::EhFrame: {
+          // FIXME: if optimization of exception handling sections is enabled,
+          // then we should emit these sections by the other way.
+          emitSectionData(**sect, *region);
+          break;
+        }
+        case LDFileFormat::Relocation:
+          emitRelocation(m_Config, **sect, *region);
+          break;
+        case LDFileFormat::Target:
+          target().emitSectionData(**sect, *region);
+          break;
+        default:
+          continue;
+      }
+    } // end of section for loop
+  } // end of segment for loop
+  return llvm::make_error_code(llvm::errc::success);
+}
+
diff --git a/lib/LD/ELFDynObjReader.cpp b/lib/LD/ELFDynObjReader.cpp
index 740577c..e52e863 100644
--- a/lib/LD/ELFDynObjReader.cpp
+++ b/lib/LD/ELFDynObjReader.cpp
@@ -6,17 +6,19 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include <mcld/LD/ELFDynObjReader.h>
+
+#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/Target/GNULDBackend.h>
+
 #include <llvm/ADT/Twine.h>
 #include <llvm/ADT/OwningPtr.h>
 #include <llvm/Support/ErrorHandling.h>
 
-#include <mcld/LD/ELFDynObjReader.h>
-#include <mcld/LD/ELFReader.h>
-#include <mcld/MC/MCLDInput.h>
-#include <mcld/Fragment/FragmentLinker.h>
-#include <mcld/Target/GNULDBackend.h>
-#include <mcld/Support/MemoryRegion.h>
-
 #include <string>
 
 using namespace mcld;
@@ -24,11 +26,13 @@
 //===----------------------------------------------------------------------===//
 // ELFDynObjReader
 //===----------------------------------------------------------------------===//
-ELFDynObjReader::ELFDynObjReader(GNULDBackend& pBackend, FragmentLinker& pLinker)
+ELFDynObjReader::ELFDynObjReader(GNULDBackend& pBackend,
+                                 IRBuilder& pBuilder,
+                                 const LinkerConfig& pConfig)
   : DynObjReader(),
     m_pELFReader(0),
-    m_Linker(pLinker) {
-  if (32 == pBackend.bitclass() && pBackend.isLittleEndian())
+    m_Builder(pBuilder) {
+  if (pConfig.targets().is32Bits() && pConfig.targets().isLittleEndian())
     m_pELFReader = new ELFReader<32, true>(pBackend);
 }
 
@@ -108,8 +112,8 @@
   MemoryRegion* strtab_region = pInput.memArea()->request(
               pInput.fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
   char* strtab = reinterpret_cast<char*>(strtab_region->start());
-  bool result = m_pELFReader->readSymbols(pInput, m_Linker, *symtab_region,
-                                            strtab);
+  bool result = m_pELFReader->readSymbols(pInput, m_Builder,
+                                          *symtab_region, strtab);
   pInput.memArea()->release(symtab_region);
   pInput.memArea()->release(strtab_region);
 
diff --git a/lib/LD/ELFDynObjWriter.cpp b/lib/LD/ELFDynObjWriter.cpp
index 48ce0a3..2e903ce 100644
--- a/lib/LD/ELFDynObjWriter.cpp
+++ b/lib/LD/ELFDynObjWriter.cpp
@@ -13,7 +13,6 @@
 #include <mcld/LD/LDSymbol.h>
 #include <mcld/Target/GNULDBackend.h>
 #include <mcld/MC/MCLDInput.h>
-#include <mcld/Fragment/FragmentLinker.h>
 #include <mcld/Support/MemoryArea.h>
 
 #include <llvm/Support/ELF.h>
@@ -26,10 +25,10 @@
 //===----------------------------------------------------------------------===//
 // ELFDynObjWriter
 //===----------------------------------------------------------------------===//
-ELFDynObjWriter::ELFDynObjWriter(GNULDBackend& pBackend, FragmentLinker& pLinker)
-  : DynObjWriter(pBackend),
-    ELFWriter(pBackend),
-    m_Linker(pLinker) {
+ELFDynObjWriter::ELFDynObjWriter(GNULDBackend& pBackend,
+                                 const LinkerConfig& pConfig)
+  : DynObjWriter(pBackend), ELFWriter(pBackend),
+    m_Config(pConfig) {
 
 }
 
@@ -54,6 +53,10 @@
     MemoryRegion* region = NULL;
     // request output region
     switch((*sect)->kind()) {
+      case LDFileFormat::Note:
+        if ((*sect)->getSectionData() == NULL)
+          continue;
+        // Fall through
       case LDFileFormat::Regular:
       case LDFileFormat::Relocation:
       case LDFileFormat::Target:
@@ -71,7 +74,6 @@
       case LDFileFormat::Null:
       case LDFileFormat::NamePool:
       case LDFileFormat::BSS:
-      case LDFileFormat::Note:
       case LDFileFormat::MetaData:
       case LDFileFormat::Version:
       case LDFileFormat::EhFrameHdr:
@@ -93,6 +95,7 @@
       case LDFileFormat::Regular:
       case LDFileFormat::Debug:
       case LDFileFormat::GCCExceptTable:
+      case LDFileFormat::Note:
       case LDFileFormat::EhFrame: {
         // FIXME: if optimization of exception handling sections is enabled,
         // then we should emit these sections by the other way.
@@ -100,7 +103,7 @@
         break;
       }
       case LDFileFormat::Relocation:
-        emitRelocation(m_Linker.getLDInfo(), **sect, *region);
+        emitRelocation(m_Config, **sect, *region);
         break;
       case LDFileFormat::Target:
         target().emitSectionData(**sect, *region);
@@ -115,27 +118,23 @@
                   pModule,
                   pOutput);
 
-  if (32 == target().bitclass()) {
+  if (m_Config.targets().is32Bits()) {
     // Write out ELF header
     // Write out section header table
-    writeELF32Header(m_Linker.getLDInfo(),
-                     pModule,
-                     pOutput);
+    writeELF32Header(m_Config, pModule, pOutput);
 
     emitELF32ProgramHeader(pOutput);
 
-    emitELF32SectionHeader(pModule, m_Linker.getLDInfo(), pOutput);
+    emitELF32SectionHeader(pModule, m_Config, pOutput);
   }
-  else if (64 == target().bitclass()) {
+  else if (m_Config.targets().is64Bits()) {
     // Write out ELF header
     // Write out section header table
-    writeELF64Header(m_Linker.getLDInfo(),
-                     pModule,
-                     pOutput);
+    writeELF64Header(m_Config, pModule, pOutput);
 
     emitELF64ProgramHeader(pOutput);
 
-    emitELF64SectionHeader(pModule, m_Linker.getLDInfo(), pOutput);
+    emitELF64SectionHeader(pModule, m_Config, pOutput);
   }
   else
     return make_error_code(errc::not_supported);
diff --git a/lib/LD/ELFExecWriter.cpp b/lib/LD/ELFExecWriter.cpp
index dec5e26..a9af584 100644
--- a/lib/LD/ELFExecWriter.cpp
+++ b/lib/LD/ELFExecWriter.cpp
@@ -12,7 +12,6 @@
 #include <mcld/LinkerConfig.h>
 #include <mcld/LD/LDSymbol.h>
 #include <mcld/Target/GNULDBackend.h>
-#include <mcld/Fragment/FragmentLinker.h>
 #include <mcld/Support/MemoryArea.h>
 
 #include <llvm/Support/ELF.h>
@@ -25,10 +24,10 @@
 //===----------------------------------------------------------------------===//
 // ELFExecWriter
 //===----------------------------------------------------------------------===//
-ELFExecWriter::ELFExecWriter(GNULDBackend& pBackend, FragmentLinker& pLinker)
-  : ExecWriter(pBackend),
-    ELFWriter(pBackend),
-    m_Linker(pLinker) {
+ELFExecWriter::ELFExecWriter(GNULDBackend& pBackend,
+                             const LinkerConfig& pConfig)
+  : ExecWriter(pBackend), ELFWriter(pBackend),
+    m_Config(pConfig) {
 
 }
 
@@ -54,6 +53,10 @@
     MemoryRegion* region = NULL;
     // request output region
     switch((*sect)->kind()) {
+      case LDFileFormat::Note:
+        if ((*sect)->getSectionData() == NULL)
+          continue;
+        // Fall through
       case LDFileFormat::Regular:
       case LDFileFormat::Relocation:
       case LDFileFormat::Target:
@@ -71,7 +74,6 @@
       case LDFileFormat::Null:
       case LDFileFormat::NamePool:
       case LDFileFormat::BSS:
-      case LDFileFormat::Note:
       case LDFileFormat::MetaData:
       case LDFileFormat::Version:
       case LDFileFormat::EhFrameHdr:
@@ -93,6 +95,7 @@
       case LDFileFormat::Regular:
       case LDFileFormat::Debug:
       case LDFileFormat::GCCExceptTable:
+      case LDFileFormat::Note:
       case LDFileFormat::EhFrame: {
         // FIXME: if optimization of exception handling sections is enabled,
         // then we should emit these sections by the other way.
@@ -100,7 +103,7 @@
         break;
       }
       case LDFileFormat::Relocation:
-        emitRelocation(m_Linker.getLDInfo(), **sect, *region);
+        emitRelocation(m_Config, **sect, *region);
         break;
       case LDFileFormat::Target:
         target().emitSectionData(**sect, *region);
@@ -114,27 +117,23 @@
                   pModule,
                   pOutput);
 
-  if (32 == target().bitclass()) {
+  if (m_Config.targets().is32Bits()) {
     // Write out ELF header
     // Write out section header table
-    writeELF32Header(m_Linker.getLDInfo(),
-                     pModule,
-                     pOutput);
+    writeELF32Header(m_Config, pModule, pOutput);
 
     emitELF32ProgramHeader(pOutput);
 
-    emitELF32SectionHeader(pModule, m_Linker.getLDInfo(), pOutput);
+    emitELF32SectionHeader(pModule, m_Config, pOutput);
   }
-  else if (64 == target().bitclass()) {
+  else if (m_Config.targets().is64Bits()) {
     // Write out ELF header
     // Write out section header table
-    writeELF64Header(m_Linker.getLDInfo(),
-                     pModule,
-                     pOutput);
+    writeELF64Header(m_Config, pModule, pOutput);
 
     emitELF64ProgramHeader(pOutput);
 
-    emitELF64SectionHeader(pModule, m_Linker.getLDInfo(), pOutput);
+    emitELF64SectionHeader(pModule, m_Config, pOutput);
   }
   else
     return make_error_code(errc::not_supported);
diff --git a/lib/LD/ELFFileFormat.cpp b/lib/LD/ELFFileFormat.cpp
index 7512e38..b4792b5 100644
--- a/lib/LD/ELFFileFormat.cpp
+++ b/lib/LD/ELFFileFormat.cpp
@@ -155,6 +155,7 @@
                                               llvm::ELF::SHT_SYMTAB,
                                               0x0,
                                               pBitClass / 8);
+
   f_pStrTab          = pBuilder.CreateSection(".strtab",
                                               LDFileFormat::NamePool,
                                               llvm::ELF::SHT_STRTAB,
diff --git a/lib/LD/ELFObjectReader.cpp b/lib/LD/ELFObjectReader.cpp
index 4124098..a87b5b8 100644
--- a/lib/LD/ELFObjectReader.cpp
+++ b/lib/LD/ELFObjectReader.cpp
@@ -16,7 +16,6 @@
 
 #include <mcld/IRBuilder.h>
 #include <mcld/MC/MCLDInput.h>
-#include <mcld/Fragment/FragmentLinker.h>
 #include <mcld/LD/ELFReader.h>
 #include <mcld/LD/EhFrameReader.h>
 #include <mcld/LD/EhFrame.h>
@@ -30,14 +29,17 @@
 // ELFObjectReader
 //===----------------------------------------------------------------------===//
 /// constructor
-ELFObjectReader::ELFObjectReader(GNULDBackend& pBackend, FragmentLinker& pLinker)
+ELFObjectReader::ELFObjectReader(GNULDBackend& pBackend,
+                                 IRBuilder& pBuilder,
+                                 const LinkerConfig& pConfig)
   : ObjectReader(),
     m_pELFReader(NULL),
     m_pEhFrameReader(NULL),
-    m_Linker(pLinker),
+    m_Builder(pBuilder),
     m_ReadFlag(ParseEhFrame),
-    m_Backend(pBackend) {
-  if (32 == pBackend.bitclass() && pBackend.isLittleEndian()) {
+    m_Backend(pBackend),
+    m_Config(pConfig) {
+  if (pConfig.targets().is32Bits() && pConfig.targets().isLittleEndian()) {
     m_pELFReader = new ELFReader<32, true>(pBackend);
   }
 
@@ -166,7 +168,7 @@
         break;
       }
       case LDFileFormat::Debug: {
-        if (m_Linker.getLDInfo().options().stripDebug()) {
+        if (m_Config.options().stripDebug()) {
           (*section)->setKind(LDFileFormat::Ignore);
         }
         else {
@@ -180,7 +182,7 @@
       case LDFileFormat::EhFrame: {
         EhFrame* eh_frame = IRBuilder::CreateEhFrame(**section);
 
-        if (m_Linker.getLDInfo().options().hasEhFrameHdr() &&
+        if (m_Config.options().hasEhFrameHdr() &&
             (m_ReadFlag & ParseEhFrame)) {
 
           // if --eh-frame-hdr option is given, parse .eh_frame.
@@ -231,7 +233,7 @@
   return true;
 }
 
-/// readSymbols - read symbols into FragmentLinker from the input relocatable object.
+/// readSymbols - read symbols from the input relocatable object.
 bool ELFObjectReader::readSymbols(Input& pInput)
 {
   assert(pInput.hasMemArea());
@@ -258,7 +260,7 @@
              pInput.fileOffset() + strtab_shdr->offset(), strtab_shdr->size());
   char* strtab = reinterpret_cast<char*>(strtab_region->start());
   bool result = m_pELFReader->readSymbols(pInput,
-                                          m_Linker,
+                                          m_Builder,
                                           *symtab_region,
                                           strtab);
   pInput.memArea()->release(symtab_region);
@@ -282,14 +284,14 @@
     IRBuilder::CreateRelocData(**rs); ///< create relocation data for the header
     switch ((*rs)->type()) {
       case llvm::ELF::SHT_RELA: {
-        if (!m_pELFReader->readRela(pInput, m_Linker, **rs, *region)) {
+        if (!m_pELFReader->readRela(pInput, **rs, *region)) {
           mem->release(region);
           return false;
         }
         break;
       }
       case llvm::ELF::SHT_REL: {
-        if (!m_pELFReader->readRel(pInput, m_Linker, **rs, *region)) {
+        if (!m_pELFReader->readRel(pInput, **rs, *region)) {
           mem->release(region);
           return false;
         }
diff --git a/lib/LD/ELFObjectWriter.cpp b/lib/LD/ELFObjectWriter.cpp
index ee9a7ac..e9b7b99 100644
--- a/lib/LD/ELFObjectWriter.cpp
+++ b/lib/LD/ELFObjectWriter.cpp
@@ -9,11 +9,12 @@
 #include <mcld/LD/ELFObjectWriter.h>
 
 #include <mcld/Module.h>
+#include <mcld/LinkerConfig.h>
 #include <mcld/Target/GNULDBackend.h>
-#include <mcld/Fragment/FragmentLinker.h>
 #include <mcld/Support/MemoryArea.h>
 
 #include <llvm/Support/system_error.h>
+
 using namespace llvm;
 using namespace mcld;
 
@@ -21,8 +22,9 @@
 // ELFObjectWriter
 //===----------------------------------------------------------------------===//
 ELFObjectWriter::ELFObjectWriter(GNULDBackend& pBackend,
-                                 FragmentLinker& pLinker)
-  : ObjectWriter(pBackend), ELFWriter(pBackend), m_Linker(pLinker) {
+                                 const LinkerConfig& pConfig)
+  : ObjectWriter(pBackend), ELFWriter(pBackend),
+    m_Config(pConfig) {
 }
 
 ELFObjectWriter::~ELFObjectWriter()
@@ -41,6 +43,10 @@
     MemoryRegion* region = NULL;
     // request output region
     switch((*sect)->kind()) {
+      case LDFileFormat::Note:
+        if ((*sect)->getSectionData() == NULL)
+          continue;
+        // Fall through
       case LDFileFormat::Regular:
       case LDFileFormat::Relocation:
       case LDFileFormat::Target:
@@ -58,7 +64,6 @@
       case LDFileFormat::Null:
       case LDFileFormat::NamePool:
       case LDFileFormat::BSS:
-      case LDFileFormat::Note:
       case LDFileFormat::MetaData:
       case LDFileFormat::Version:
       case LDFileFormat::EhFrameHdr:
@@ -80,6 +85,7 @@
       case LDFileFormat::Regular:
       case LDFileFormat::Debug:
       case LDFileFormat::GCCExceptTable:
+      case LDFileFormat::Note:
       case LDFileFormat::EhFrame: {
         // FIXME: if optimization of exception handling sections is enabled,
         // then we should emit these sections by the other way.
@@ -87,7 +93,7 @@
         break;
       }
       case LDFileFormat::Relocation:
-        emitRelocation(m_Linker.getLDInfo(), **sect, *region);
+        emitRelocation(m_Config, **sect, *region);
         break;
       case LDFileFormat::Target:
         target().emitSectionData(**sect, *region);
@@ -101,23 +107,23 @@
                   pModule,
                   pOutput);
 
-  if (32 == target().bitclass()) {
+  if (m_Config.targets().is32Bits()) {
     // Write out ELF header
     // Write out section header table
-    writeELF32Header(m_Linker.getLDInfo(),
+    writeELF32Header(m_Config,
                      pModule,
                      pOutput);
 
-    emitELF32SectionHeader(pModule, m_Linker.getLDInfo(), pOutput);
+    emitELF32SectionHeader(pModule, m_Config, pOutput);
   }
-  else if (64 == target().bitclass()) {
+  else if (m_Config.targets().is64Bits()) {
     // Write out ELF header
     // Write out section header table
-    writeELF64Header(m_Linker.getLDInfo(),
+    writeELF64Header(m_Config,
                      pModule,
                      pOutput);
 
-    emitELF64SectionHeader(pModule, m_Linker.getLDInfo(), pOutput);
+    emitELF64SectionHeader(pModule, m_Config, pOutput);
   }
   else
     return make_error_code(errc::not_supported);
diff --git a/lib/LD/ELFReader.cpp b/lib/LD/ELFReader.cpp
index 7f105b3..84ad17b 100644
--- a/lib/LD/ELFReader.cpp
+++ b/lib/LD/ELFReader.cpp
@@ -9,7 +9,6 @@
 #include <mcld/LD/ELFReader.h>
 
 #include <mcld/IRBuilder.h>
-#include <mcld/Fragment/FragmentLinker.h>
 #include <mcld/Fragment/FillFragment.h>
 #include <mcld/LD/EhFrame.h>
 #include <mcld/LD/SectionData.h>
@@ -105,7 +104,10 @@
   if (Input::DynObj == pInput.type())
     return FragmentRef::Null();
 
-  if (pShndx == llvm::ELF::SHN_UNDEF || pShndx >= llvm::ELF::SHN_LORESERVE)
+  if (pShndx == llvm::ELF::SHN_UNDEF)
+    return FragmentRef::Null();
+
+  if (pShndx >= llvm::ELF::SHN_LORESERVE) // including ABS and COMMON
     return FragmentRef::Null();
 
   LDSection* sect_hdr = pInput.context()->getSection(pShndx);
@@ -193,7 +195,7 @@
 
 /// readSymbols - read ELF symbols and create LDSymbol
 bool ELFReader<32, true>::readSymbols(Input& pInput,
-                                      FragmentLinker& pLinker,
+                                      IRBuilder& pBuilder,
                                       const MemoryRegion& pRegion,
                                       const char* pStrTab) const
 {
@@ -223,10 +225,10 @@
       st_shndx = symtab[idx].st_shndx;
     }
     else {
-      st_name  = bswap32(symtab[idx].st_name);
-      st_value = bswap32(symtab[idx].st_value);
-      st_size  = bswap32(symtab[idx].st_size);
-      st_shndx = bswap16(symtab[idx].st_shndx);
+      st_name  = mcld::bswap32(symtab[idx].st_name);
+      st_value = mcld::bswap32(symtab[idx].st_value);
+      st_size  = mcld::bswap32(symtab[idx].st_size);
+      st_shndx = mcld::bswap16(symtab[idx].st_shndx);
     }
 
     // If the section should not be included, set the st_shndx SHN_UNDEF
@@ -250,55 +252,33 @@
     // get ld_value - ld_value must be section relative.
     uint64_t ld_value = getSymValue(st_value, st_shndx, pInput);
 
-    // get the input fragment
-    FragmentRef* ld_frag_ref = getSymFragmentRef(pInput,
-                                                 st_shndx,
-                                                 ld_value);
-
     // get ld_vis
     ResolveInfo::Visibility ld_vis = getSymVisibility(st_other);
 
+    // get section
+    LDSection* section = NULL;
+    if (st_shndx < llvm::ELF::SHN_LORESERVE) // including ABS and COMMON
+      section = pInput.context()->getSection(st_shndx);
+
     // get ld_name
-    llvm::StringRef ld_name;
+    std::string ld_name;
     if (ResolveInfo::Section == ld_type) {
       // Section symbol's st_name is the section index.
-      LDSection* section = pInput.context()->getSection(st_shndx);
       assert(NULL != section && "get a invalid section");
-      ld_name = llvm::StringRef(section->name());
+      ld_name = section->name();
     }
     else {
-      ld_name = llvm::StringRef(pStrTab + st_name);
+      ld_name = std::string(pStrTab + st_name);
     }
 
-
-    // push into FragmentLinker
-    LDSymbol* input_sym = NULL;
-
-    if (pInput.type() == Input::Object) {
-      input_sym = pLinker.addSymbol<Input::Object>(ld_name,
-                                                   ld_type,
-                                                   ld_desc,
-                                                   ld_binding,
-                                                   st_size,
-                                                   ld_value,
-                                                   ld_frag_ref,
-                                                   ld_vis);
-      // push into the input file
-      pInput.context()->addSymbol(input_sym);
-      continue;
-    }
-    else if (pInput.type() == Input::DynObj) {
-      input_sym = pLinker.addSymbol<Input::DynObj>(ld_name,
-                                                   ld_type,
-                                                   ld_desc,
-                                                   ld_binding,
-                                                   st_size,
-                                                   ld_value,
-                                                   ld_frag_ref,
-                                                   ld_vis);
-      continue;
-    }
-
+    pBuilder.AddSymbol(pInput,
+                       ld_name,
+                       ld_type,
+                       ld_desc,
+                       ld_binding,
+                       st_size,
+                       ld_value,
+                       section, ld_vis);
   } // end of for loop
   return true;
 }
@@ -308,7 +288,6 @@
 //===----------------------------------------------------------------------===//
 /// ELFReader::readRela - read ELF rela and create Relocation
 bool ELFReader<32, true>::readRela(Input& pInput,
-                                   FragmentLinker& pLinker,
                                    LDSection& pSection,
                                    const MemoryRegion& pRegion) const
 {
@@ -327,9 +306,9 @@
       r_addend = relaTab[idx].r_addend;
     }
     else {
-      r_offset = bswap32(relaTab[idx].r_offset);
-      r_info   = bswap32(relaTab[idx].r_info);
-      r_addend = bswap32(relaTab[idx].r_addend);
+      r_offset = mcld::bswap32(relaTab[idx].r_offset);
+      r_info   = mcld::bswap32(relaTab[idx].r_info);
+      r_addend = mcld::bswap32(relaTab[idx].r_addend);
     }
 
     uint8_t  r_type = static_cast<unsigned char>(r_info);
@@ -339,14 +318,13 @@
       fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
     }
 
-    pLinker.addRelocation(r_type, *symbol, pSection, r_offset, r_addend);
+    IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset, r_addend);
   } // end of for
   return true;
 }
 
 /// readRel - read ELF rel and create Relocation
 bool ELFReader<32, true>::readRel(Input& pInput,
-                                  FragmentLinker& pLinker,
                                   LDSection& pSection,
                                   const MemoryRegion& pRegion) const
 {
@@ -363,8 +341,8 @@
       r_info   = relTab[idx].r_info;
     }
     else {
-      r_offset = bswap32(relTab[idx].r_offset);
-      r_info   = bswap32(relTab[idx].r_info);
+      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);
@@ -375,7 +353,7 @@
       fatal(diag::err_cannot_read_symbol) << r_sym << pInput.path();
     }
 
-    pLinker.addRelocation(r_type, *symbol, pSection, r_offset);
+    IRBuilder::AddRelocation(pSection, r_type, *symbol, r_offset);
   } // end of for
   return true;
 }
@@ -396,8 +374,8 @@
                           reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(pELFHeader);
 
   if (llvm::sys::isLittleEndianHost())
-    return (hdr->e_machine == target().machine());
-  return (bswap16(hdr->e_machine) == target().machine());
+    return (hdr->e_machine == target().getInfo().machine());
+  return (mcld::bswap16(hdr->e_machine) == target().getInfo().machine());
 }
 
 /// fileType - return the file type
@@ -409,7 +387,7 @@
   if (llvm::sys::isLittleEndianHost())
     type = hdr->e_type;
   else
-    type = bswap16(hdr->e_type);
+    type = mcld::bswap16(hdr->e_type);
 
   switch(type) {
   case llvm::ELF::ET_REL:
@@ -445,10 +423,10 @@
     shstrtab  = ehdr->e_shstrndx;
   }
   else {
-    shoff     = bswap32(ehdr->e_shoff);
-    shentsize = bswap16(ehdr->e_shentsize);
-    shnum     = bswap16(ehdr->e_shnum);
-    shstrtab  = bswap16(ehdr->e_shstrndx);
+    shoff     = mcld::bswap32(ehdr->e_shoff);
+    shentsize = mcld::bswap16(ehdr->e_shentsize);
+    shnum     = mcld::bswap16(ehdr->e_shnum);
+    shstrtab  = mcld::bswap16(ehdr->e_shstrndx);
   }
 
   // If the file has no section header table, e_shoff holds zero.
@@ -476,8 +454,8 @@
     sh_size   = shdr->sh_size;
   }
   else {
-    sh_offset = bswap32(shdr->sh_offset);
-    sh_size   = bswap32(shdr->sh_size);
+    sh_offset = mcld::bswap32(shdr->sh_offset);
+    sh_size   = mcld::bswap32(shdr->sh_size);
   }
 
   MemoryRegion* sect_name_region = pInput.memArea()->request(
@@ -500,14 +478,14 @@
       sh_addralign = shdrTab[idx].sh_addralign;
     }
     else {
-      sh_name      = bswap32(shdrTab[idx].sh_name);
-      sh_type      = bswap32(shdrTab[idx].sh_type);
-      sh_flags     = bswap32(shdrTab[idx].sh_flags);
-      sh_offset    = bswap32(shdrTab[idx].sh_offset);
-      sh_size      = bswap32(shdrTab[idx].sh_size);
-      sh_link      = bswap32(shdrTab[idx].sh_link);
-      sh_info      = bswap32(shdrTab[idx].sh_info);
-      sh_addralign = bswap32(shdrTab[idx].sh_addralign);
+      sh_name      = mcld::bswap32(shdrTab[idx].sh_name);
+      sh_type      = mcld::bswap32(shdrTab[idx].sh_type);
+      sh_flags     = mcld::bswap32(shdrTab[idx].sh_flags);
+      sh_offset    = mcld::bswap32(shdrTab[idx].sh_offset);
+      sh_size      = mcld::bswap32(shdrTab[idx].sh_size);
+      sh_link      = mcld::bswap32(shdrTab[idx].sh_link);
+      sh_info      = mcld::bswap32(shdrTab[idx].sh_info);
+      sh_addralign = mcld::bswap32(shdrTab[idx].sh_addralign);
     }
 
     LDSection* section = IRBuilder::CreateELFHeader(pInput,
@@ -574,8 +552,8 @@
     st_shndx = entry->st_shndx;
   }
   else {
-    st_name  = bswap32(entry->st_name);
-    st_shndx = bswap16(entry->st_shndx);
+    st_name  = mcld::bswap32(entry->st_name);
+    st_shndx = mcld::bswap16(entry->st_shndx);
   }
 
   MemoryRegion* strtab_region = pInput.memArea()->request(
@@ -635,8 +613,8 @@
       d_tag = dynamic[idx].d_tag;
       d_val = dynamic[idx].d_un.d_val;
     } else {
-      d_tag = bswap32(dynamic[idx].d_tag);
-      d_val = bswap32(dynamic[idx].d_un.d_val);
+      d_tag = mcld::bswap32(dynamic[idx].d_tag);
+      d_val = mcld::bswap32(dynamic[idx].d_un.d_val);
     }
 
     switch (d_tag) {
diff --git a/lib/LD/ELFWriter.cpp b/lib/LD/ELFWriter.cpp
index 93fc4b9..a37e654 100644
--- a/lib/LD/ELFWriter.cpp
+++ b/lib/LD/ELFWriter.cpp
@@ -49,11 +49,11 @@
   memcpy(header->e_ident, ElfMagic, EI_MAG3+1);
 
   header->e_ident[EI_CLASS]      = ELFCLASS32;
-  header->e_ident[EI_DATA]       = target().isLittleEndian()?
+  header->e_ident[EI_DATA]       = pConfig.targets().isLittleEndian()?
                                        ELFDATA2LSB : ELFDATA2MSB;
-  header->e_ident[EI_VERSION]    = target().ELFVersion();
-  header->e_ident[EI_OSABI]      = target().OSABI();
-  header->e_ident[EI_ABIVERSION] = target().ABIVersion();
+  header->e_ident[EI_VERSION]    = target().getInfo().ELFVersion();
+  header->e_ident[EI_OSABI]      = target().getInfo().OSABI();
+  header->e_ident[EI_ABIVERSION] = target().getInfo().ABIVersion();
 
   // FIXME: add processor-specific and core file types.
   switch(pConfig.codeGenType()) {
@@ -70,7 +70,7 @@
       llvm::errs() << "unspported output file type: " << pConfig.codeGenType() << ".\n";
       header->e_type = ET_NONE;
   }
-  header->e_machine   = target().machine();
+  header->e_machine   = target().getInfo().machine();
   header->e_version   = header->e_ident[EI_VERSION];
   header->e_entry     = getEntryPoint(pConfig, pModule);
 
@@ -101,11 +101,11 @@
   memcpy(header->e_ident, ElfMagic, EI_MAG3+1);
 
   header->e_ident[EI_CLASS]      = ELFCLASS64;
-  header->e_ident[EI_DATA]       = target().isLittleEndian()?
+  header->e_ident[EI_DATA]       = pConfig.targets().isLittleEndian()?
                                        ELFDATA2LSB : ELFDATA2MSB;
-  header->e_ident[EI_VERSION]    = target().ELFVersion();
-  header->e_ident[EI_OSABI]      = target().OSABI();
-  header->e_ident[EI_ABIVERSION] = target().ABIVersion();
+  header->e_ident[EI_VERSION]    = target().getInfo().ELFVersion();
+  header->e_ident[EI_OSABI]      = target().getInfo().OSABI();
+  header->e_ident[EI_ABIVERSION] = target().getInfo().ABIVersion();
 
   // FIXME: add processor-specific and core file types.
   switch(pConfig.codeGenType()) {
@@ -122,7 +122,7 @@
       llvm::errs() << "unspported output file type: " << pConfig.codeGenType() << ".\n";
       header->e_type = ET_NONE;
   }
-  header->e_machine   = target().machine();
+  header->e_machine   = target().getInfo().machine();
   header->e_version   = header->e_ident[EI_VERSION];
   header->e_entry     = getEntryPoint(pConfig, pModule);
 
@@ -500,10 +500,18 @@
 /// getSectInfo - compute ElfXX_Shdr::sh_info
 uint64_t ELFWriter::getSectInfo(const LDSection& pSection) const
 {
-  const LDSection* info_link = pSection.getLink();
-  if (NULL == info_link)
-    return 0x0;
-  return info_link->index();
+  if (llvm::ELF::SHT_SYMTAB == pSection.type() ||
+      llvm::ELF::SHT_DYNSYM == pSection.type())
+    return pSection.getInfo();
+
+  if (llvm::ELF::SHT_REL == pSection.type() ||
+      llvm::ELF::SHT_RELA == pSection.type()) {
+    const LDSection* info_link = pSection.getLink();
+    if (NULL != info_link)
+      return info_link->index();
+  }
+
+  return 0x0;
 }
 
 /// getELF32LastStartOffset
@@ -579,9 +587,6 @@
         assert(0x0 == size);
         break;
       }
-      case Fragment::Relocation:
-        llvm::report_fatal_error("relocation fragment should not be in a regular section.\n");
-        break;
       case Fragment::Target:
         llvm::report_fatal_error("Target fragment should not be in a regular section.\n");
         break;
diff --git a/lib/LD/GNUArchiveReader.cpp b/lib/LD/GNUArchiveReader.cpp
index 9aeaa6b..82e4fec 100644
--- a/lib/LD/GNUArchiveReader.cpp
+++ b/lib/LD/GNUArchiveReader.cpp
@@ -262,7 +262,7 @@
     // read the number of symbols
     uint32_t number = 0;
     if (llvm::sys::isLittleEndianHost())
-      number = bswap32(*data);
+      number = mcld::bswap32(*data);
     else
       number = *data;
 
@@ -273,7 +273,7 @@
     // add the archive symbols
     for (uint32_t i = 0; i < number; ++i) {
       if (llvm::sys::isLittleEndianHost())
-        pArchive.addSymbol(name, bswap32(*data));
+        pArchive.addSymbol(name, mcld::bswap32(*data));
       else
         pArchive.addSymbol(name, *data);
       name += strlen(name) + 1;
diff --git a/lib/LD/GroupReader.cpp b/lib/LD/GroupReader.cpp
index 91e79c0..a407c3d 100644
--- a/lib/LD/GroupReader.cpp
+++ b/lib/LD/GroupReader.cpp
@@ -94,7 +94,7 @@
     }
     else {
       fatal(diag::err_unrecognized_input_file) << (*input)->path()
-                                               << pConfig.triple().str();
+                                               << pConfig.targets().triple().str();
     }
     ++input;
   }
diff --git a/lib/LD/Layout.cpp b/lib/LD/Layout.cpp
deleted file mode 100644
index a2a1028..0000000
--- a/lib/LD/Layout.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-//===- Layout.cpp ---------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/LD/Layout.h>
-
-#include <mcld/Module.h>
-#include <mcld/LinkerConfig.h>
-#include <mcld/ADT/SizeTraits.h>
-#include <mcld/LD/LDFileFormat.h>
-#include <mcld/LD/LDSection.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Target/TargetLDBackend.h>
-
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// Layout
-//===----------------------------------------------------------------------===//
-void Layout::sortSectionOrder(const TargetLDBackend& pBackend,
-                              const LinkerConfig& pConfig)
-{
-  typedef std::pair<LDSection*, unsigned int> SectOrder;
-  typedef std::vector<SectOrder > SectListTy;
-  SectListTy sect_list;
-  // get section order from backend
-  for (size_t index = 0; index < m_SectionOrder.size(); ++index) {
-    sect_list.push_back(
-            std::make_pair(
-                    m_SectionOrder[index],
-                    pBackend.getSectionOrder(*m_SectionOrder[index])
-            ));
-  }
-
-  // simple insertion sort should be fine for general cases such as so and exec
-  for (unsigned int i = 1; i < sect_list.size(); ++i) {
-    SectOrder order = sect_list[i];
-    int j = i - 1;
-    while (j >= 0 && sect_list[j].second > order.second) {
-      sect_list[j + 1] = sect_list[j];
-      --j;
-    }
-    sect_list[j + 1] = order;
-  }
-
-  // update the sorted ordering to m_SectionOrder
-  m_SectionOrder.clear();
-  for (size_t index = 0; index < sect_list.size(); ++index) {
-    m_SectionOrder.push_back(sect_list[index].first);
-  }
-}
-
-/// layout - layout the sections
-///   1. finalize fragment offset
-///   2. compute section order
-///   3. finalize section offset
-bool Layout::layout(Module& pModule,
-                    const TargetLDBackend& pBackend,
-                    const LinkerConfig& pConfig)
-{
-  // determine what sections in output context will go into final output, and
-  // push the needed sections into m_SectionOrder for later processing
-  Module::iterator it, itEnd = pModule.end();
-  for (it = pModule.begin(); it != itEnd; ++it) {
-    // calculate 1. all fragment offset, and 2. the section order
-    LDSection* sect = *it;
-
-    switch (sect->kind()) {
-      // take NULL and StackNote directly
-      case LDFileFormat::Null:
-      case LDFileFormat::StackNote:
-        m_SectionOrder.push_back(sect);
-        break;
-      // ignore if section size is 0
-      case LDFileFormat::Regular:
-      case LDFileFormat::Target:
-      case LDFileFormat::MetaData:
-      case LDFileFormat::BSS:
-      case LDFileFormat::Debug:
-      case LDFileFormat::EhFrame:
-      case LDFileFormat::GCCExceptTable:
-      case LDFileFormat::NamePool:
-      case LDFileFormat::Relocation:
-      case LDFileFormat::Note:
-      case LDFileFormat::EhFrameHdr:
-        if (0 != sect->size()) {
-          m_SectionOrder.push_back(sect);
-        }
-        break;
-      case LDFileFormat::Group:
-        if (LinkerConfig::Object == pConfig.codeGenType()) {
-          //TODO: support incremental linking
-          ;
-        }
-        break;
-      case LDFileFormat::Version:
-        if (0 != sect->size()) {
-          m_SectionOrder.push_back(sect);
-          warning(diag::warn_unsupported_symbolic_versioning) << sect->name();
-        }
-        break;
-      default:
-        if (0 != sect->size()) {
-          error(diag::err_unsupported_section) << sect->name() << sect->kind();
-        }
-        break;
-    }
-  } // end of for
-
-  // perform sorting on m_SectionOrder to get a ordering for final layout
-  sortSectionOrder(pBackend, pConfig);
-
-  // Backend defines the section start offset for section 1.
-  uint64_t offset = pBackend.sectionStartOffset();
-
-  // compute the section offset and handle alignment also. And ignore section 0
-  // (NULL in ELF/COFF), and MachO starts from section 1.
-  // always set NULL section's offset to 0
-  m_SectionOrder[0]->setOffset(0);
-  for (size_t index = 1; index < m_SectionOrder.size(); ++index) {
-
-    if (LDFileFormat::BSS != m_SectionOrder[index - 1]->kind()) {
-      // we should not preserve file space for the BSS section.
-      offset += m_SectionOrder[index - 1]->size();
-    }
-
-    alignAddress(offset, m_SectionOrder[index]->align());
-    m_SectionOrder[index]->setOffset(offset);
-  }
-
-  // FIXME: Currently Writer bases on the section table in output context to
-  // write out sections, so we have to update its content..
-  pModule.getSectionTable().clear();
-  for (size_t index = 0; index < m_SectionOrder.size(); ++index) {
-    pModule.getSectionTable().push_back(m_SectionOrder[index]);
-    // after sorting, update the correct output section indices
-    m_SectionOrder[index]->setIndex(index);
-  }
-  return true;
-}
-
diff --git a/lib/LD/NamePool.cpp b/lib/LD/NamePool.cpp
index 9e4755d..6af1f7d 100644
--- a/lib/LD/NamePool.cpp
+++ b/lib/LD/NamePool.cpp
@@ -93,7 +93,7 @@
     pOldInfo->override(*old_symbol);
   }
 
-  // exit and is a symbol
+  // exist and is a symbol
   // symbol resolution
   bool override = false;
   unsigned int action = Resolver::LastAction;
diff --git a/lib/LD/RelocData.cpp b/lib/LD/RelocData.cpp
index 92192e6..1c9411d 100644
--- a/lib/LD/RelocData.cpp
+++ b/lib/LD/RelocData.cpp
@@ -7,9 +7,16 @@
 //
 //===----------------------------------------------------------------------===//
 #include <mcld/LD/RelocData.h>
+#include <mcld/Support/GCFactory.h>
+
+#include <llvm/Support/ManagedStatic.h>
 
 using namespace mcld;
 
+typedef GCFactory<RelocData, MCLD_SECTIONS_PER_INPUT> RelocDataFactory;
+
+static llvm::ManagedStatic<RelocDataFactory> g_RelocDataFactory;
+
 //===----------------------------------------------------------------------===//
 // RelocData
 //===----------------------------------------------------------------------===//
@@ -17,23 +24,32 @@
   : m_pSection(NULL) {
 }
 
-RelocData::RelocData(const LDSection &pSection)
+RelocData::RelocData(LDSection &pSection)
   : m_pSection(&pSection) {
 }
 
-RelocData* RelocData::Create(const LDSection& pSection)
+RelocData* RelocData::Create(LDSection& pSection)
 {
-  return new RelocData(pSection);
-}
-
-RelocData* RelocData::Create()
-{
-  return new RelocData();
+  RelocData* result = g_RelocDataFactory->allocate();
+  new (result) RelocData(pSection);
+  return result;
 }
 
 void RelocData::Destroy(RelocData*& pSection)
 {
-  delete pSection;
+  pSection->~RelocData();
+  g_RelocDataFactory->deallocate(pSection);
   pSection = NULL;
 }
 
+void RelocData::Clear()
+{
+  g_RelocDataFactory->clear();
+}
+
+RelocData& RelocData::append(Relocation& pRelocation)
+{
+  m_Relocations.push_back(&pRelocation);
+  return *this;
+}
+
diff --git a/lib/LD/RelocationFactory.cpp b/lib/LD/RelocationFactory.cpp
index 6fb6cb2..52bf45c 100644
--- a/lib/LD/RelocationFactory.cpp
+++ b/lib/LD/RelocationFactory.cpp
@@ -6,62 +6,69 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
 #include <mcld/LD/RelocationFactory.h>
-
-#include <cstring>
-#include <cassert>
+#include <mcld/LinkerConfig.h>
+#include <mcld/Target/TargetLDBackend.h>
+#include <mcld/Support/MsgHandling.h>
 
 #include <llvm/Support/Host.h>
 
-#include <mcld/Target/GOT.h>
-#include <mcld/Target/TargetLDBackend.h>
+#include <cstring>
+#include <cassert>
 
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
 // RelocationFactory
 //===----------------------------------------------------------------------===//
-RelocationFactory::RelocationFactory(size_t pNum)
-  : GCFactory<Relocation, 0>(pNum),
-    m_pLinker(NULL) {
+RelocationFactory::RelocationFactory()
+  : GCFactory<Relocation, MCLD_RELOCATIONS_PER_INPUT>(), m_pConfig(NULL) {
 }
 
-RelocationFactory::~RelocationFactory()
+void RelocationFactory::setConfig(const LinkerConfig& pConfig)
 {
+  m_pConfig = &pConfig;
 }
 
 Relocation* RelocationFactory::produce(RelocationFactory::Type pType,
                                        FragmentRef& pFragRef,
                                        Address pAddend)
 {
+  if (NULL == m_pConfig) {
+    fatal(diag::reloc_factory_has_not_config);
+    return NULL;
+  }
+
   // target_data is the place where the relocation applys to.
   // Use TargetDataFactory to generate temporary data, and copy the
   // content of the fragment into this data.
   DWord target_data = 0;
 
   // byte swapping if the host and target have different endian
-  if(llvm::sys::isLittleEndianHost() != getTarget().isLittleEndian()) {
+  if(llvm::sys::isLittleEndianHost() != m_pConfig->targets().isLittleEndian()) {
      uint32_t tmp_data;
 
-     switch(getTarget().bitclass()) {
-      case 32u:
-        pFragRef.memcpy(&tmp_data, 4);
-        tmp_data = bswap32(tmp_data);
-        target_data = tmp_data;
-        break;
-
-      case 64u:
-        pFragRef.memcpy(&target_data, 8);
-        target_data = bswap64(target_data);
-        break;
-
-      default:
-        break;
-    }
+     switch (m_pConfig->targets().bitclass()) {
+       case 32: {
+         pFragRef.memcpy(&tmp_data, 4);
+         tmp_data = mcld::bswap32(tmp_data);
+         target_data = tmp_data;
+         break;
+       }
+       case 64: {
+         pFragRef.memcpy(&target_data, 8);
+         target_data = mcld::bswap64(target_data);
+         break;
+       }
+       default: {
+         fatal(diag::unsupported_bitclass) << m_pConfig->targets().triple().str()
+                                         << m_pConfig->targets().bitclass();
+         return NULL;
+       }
+     } // end of switch
   }
   else {
-    pFragRef.memcpy(&target_data, (getTarget().bitclass()/8));
+    pFragRef.memcpy(&target_data, (m_pConfig->targets().bitclass()/8));
   }
 
   Relocation *result = allocate();
@@ -83,19 +90,3 @@
    /** GCFactory will recycle the relocation **/
 }
 
-void RelocationFactory::setFragmentLinker(const FragmentLinker& pLinker)
-{
-  m_pLinker = &pLinker;
-}
-
-const FragmentLinker& RelocationFactory::getFragmentLinker() const
-{
-  assert(NULL != m_pLinker);
-  return *m_pLinker;
-}
-
-bool RelocationFactory::hasFragmentLinker() const
-{
-  return (NULL != m_pLinker);
-}
-
diff --git a/lib/LD/SectionData.cpp b/lib/LD/SectionData.cpp
index 43800ff..bb73724 100644
--- a/lib/LD/SectionData.cpp
+++ b/lib/LD/SectionData.cpp
@@ -44,3 +44,8 @@
   pSection = NULL;
 }
 
+void SectionData::Clear()
+{
+  g_SectDataFactory->clear();
+}
+
diff --git a/lib/LD/SectionSymbolSet.cpp b/lib/LD/SectionSymbolSet.cpp
index 79f4d78..e369412 100644
--- a/lib/LD/SectionSymbolSet.cpp
+++ b/lib/LD/SectionSymbolSet.cpp
@@ -64,13 +64,16 @@
 bool SectionSymbolSet::finalize(LDSection& pOutSect,
                                 SymbolTable& pSymTab)
 {
+  if (0x0 == pOutSect.size())
+    return true;
+
   LDSymbol* sym = get(pOutSect);
   assert(NULL != sym);
   FragmentRef* frag_ref = NULL;
   switch (pOutSect.kind()) {
     case LDFileFormat::Relocation:
-      frag_ref = FragmentRef::Create(pOutSect.getRelocData()->front(), 0x0);
-      break;
+      // Relocation section should not have section symbol.
+      return true;
 
     case LDFileFormat::EhFrame:
       frag_ref = FragmentRef::Create(
diff --git a/lib/LD/StubFactory.cpp b/lib/LD/StubFactory.cpp
index 1fc43dd..cbe14b2 100644
--- a/lib/LD/StubFactory.cpp
+++ b/lib/LD/StubFactory.cpp
@@ -6,25 +6,23 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
 #include <mcld/LD/StubFactory.h>
 #include <mcld/LD/BranchIslandFactory.h>
 #include <mcld/LD/BranchIsland.h>
 #include <mcld/LD/LDSymbol.h>
 #include <mcld/LD/ResolveInfo.h>
-#include <mcld/LD/RelocationFactory.h>
 #include <mcld/Fragment/Stub.h>
 #include <mcld/Fragment/Relocation.h>
 #include <mcld/Fragment/FragmentLinker.h>
 #include <mcld/Fragment/FragmentRef.h>
 
 #include <string>
+
 using namespace mcld;
 
-StubFactory::StubFactory()
-{
-}
-
+//===----------------------------------------------------------------------===//
+// StubFactory
+//===----------------------------------------------------------------------===//
 StubFactory::~StubFactory()
 {
   for (StubPoolType::iterator it = m_StubPool.begin(), ie = m_StubPool.end();
@@ -42,7 +40,6 @@
 Stub* StubFactory::create(Relocation& pReloc,
                           uint64_t pTargetSymValue,
                           FragmentLinker& pLinker,
-                          RelocationFactory& pRelocFactory,
                           BranchIslandFactory& pBRIslandFactory)
 {
   // find if there is a prototype stub for the input relocation
@@ -93,8 +90,7 @@
       for (Stub::fixup_iterator it = stub->fixup_begin(),
              ie = stub->fixup_end(); it != ie; ++it) {
 
-        Relocation* reloc = pRelocFactory.produce(
-                                 (*it)->type(),
+        Relocation* reloc = Relocation::Create((*it)->type(),
                                  *(FragmentRef::Create(*stub, (*it)->offset())),
                                  (*it)->addend());
         reloc->setSymInfo(pReloc.symInfo());
diff --git a/lib/Object/ObjectLinker.cpp b/lib/Object/ObjectLinker.cpp
index 93fdb20..1e2ccb4 100644
--- a/lib/Object/ObjectLinker.cpp
+++ b/lib/Object/ObjectLinker.cpp
@@ -11,7 +11,7 @@
 #include <mcld/LinkerConfig.h>
 #include <mcld/Module.h>
 #include <mcld/InputTree.h>
-#include <mcld/MC/InputBuilder.h>
+#include <mcld/IRBuilder.h>
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/LDContext.h>
 #include <mcld/LD/Archive.h>
@@ -19,11 +19,12 @@
 #include <mcld/LD/ObjectReader.h>
 #include <mcld/LD/DynObjReader.h>
 #include <mcld/LD/GroupReader.h>
+#include <mcld/LD/BinaryReader.h>
 #include <mcld/LD/ObjectWriter.h>
 #include <mcld/LD/DynObjWriter.h>
 #include <mcld/LD/ExecWriter.h>
+#include <mcld/LD/BinaryWriter.h>
 #include <mcld/LD/ResolveInfo.h>
-#include <mcld/LD/Layout.h>
 #include <mcld/LD/RelocData.h>
 #include <mcld/Support/RealPath.h>
 #include <mcld/Support/MemoryArea.h>
@@ -39,20 +40,22 @@
 
 ObjectLinker::ObjectLinker(const LinkerConfig& pConfig,
                            Module& pModule,
-                           InputBuilder& pInputBuilder,
+                           IRBuilder& pBuilder,
                            TargetLDBackend& pLDBackend)
   : m_Config(pConfig),
     m_Module(pModule),
-    m_InputBuilder(pInputBuilder),
+    m_Builder(pBuilder),
     m_pLinker(NULL),
     m_LDBackend(pLDBackend),
     m_pObjectReader(NULL),
     m_pDynObjReader(NULL),
     m_pArchiveReader(NULL),
+    m_pGroupReader(NULL),
+    m_pBinaryReader(NULL),
     m_pObjectWriter(NULL),
     m_pDynObjWriter(NULL),
     m_pExecWriter(NULL),
-    m_pGroupReader(NULL)
+    m_pBinaryWriter(NULL)
 {
   // set up soname
   if (!m_Config.options().soname().empty()) {
@@ -66,10 +69,12 @@
   delete m_pObjectReader;
   delete m_pDynObjReader;
   delete m_pArchiveReader;
+  delete m_pGroupReader;
+  delete m_pBinaryReader;
   delete m_pObjectWriter;
   delete m_pDynObjWriter;
   delete m_pExecWriter;
-  delete m_pGroupReader;
+  delete m_pBinaryWriter;
 }
 
 /// initFragmentLinker - initialize FragmentLinker
@@ -85,17 +90,19 @@
   // 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_pLinker);
+  m_pObjectReader  = m_LDBackend.createObjectReader(m_Builder);
   m_pArchiveReader = m_LDBackend.createArchiveReader(m_Module);
-  m_pDynObjReader  = m_LDBackend.createDynObjReader(*m_pLinker);
-  m_pObjectWriter  = m_LDBackend.createObjectWriter(*m_pLinker);
-  m_pDynObjWriter  = m_LDBackend.createDynObjWriter(*m_pLinker);
-  m_pExecWriter    = m_LDBackend.createExecWriter(*m_pLinker);
+  m_pDynObjReader  = m_LDBackend.createDynObjReader(m_Builder);
   m_pGroupReader   = new GroupReader(m_Module, *m_pObjectReader,
                                      *m_pDynObjReader, *m_pArchiveReader);
+  m_pBinaryReader  = m_LDBackend.createBinaryReader(m_Builder);
+  m_pObjectWriter  = m_LDBackend.createObjectWriter();
+  m_pDynObjWriter  = m_LDBackend.createDynObjWriter();
+  m_pExecWriter    = m_LDBackend.createExecWriter();
+  m_pBinaryWriter  = m_LDBackend.createBinaryWriter();
 
-  // initialize RelocationFactory
-  m_LDBackend.initRelocFactory(*m_pLinker);
+  // initialize Relocator
+  m_LDBackend.initRelocator(*m_pLinker);
 
   // initialize BranchIslandFactory
   m_LDBackend.initBRIslandFactory();
@@ -130,7 +137,7 @@
   for (input = m_Module.input_begin(); input!=inEnd; ++input) {
     // is a group node
     if (isGroup(input)) {
-      getGroupReader()->readGroup(input, m_InputBuilder, m_Config);
+      getGroupReader()->readGroup(input, m_Builder.getInputBuilder(), m_Config);
       continue;
     }
 
@@ -151,8 +158,14 @@
       continue;
     }
 
+    // read input as a binary file
+    if (m_Config.options().isBinaryInput()) {
+      (*input)->setType(Input::Object);
+      getBinaryReader()->readBinary(**input);
+      m_Module.getObjectList().push_back(*input);
+    }
     // is a relocatable object file
-    if (getObjectReader()->isMyFormat(**input)) {
+    else if (getObjectReader()->isMyFormat(**input)) {
       (*input)->setType(Input::Object);
       getObjectReader()->readHeader(**input);
       getObjectReader()->readSections(**input);
@@ -169,7 +182,7 @@
     // is an archive
     else if (getArchiveReader()->isMyFormat(**input)) {
       (*input)->setType(Input::Archive);
-      Archive archive(**input, m_InputBuilder);
+      Archive archive(**input, m_Builder.getInputBuilder());
       getArchiveReader()->readArchive(archive);
       if(archive.numOfObjectMember() > 0) {
         m_Module.getInputTree().merge<InputTree::Inclusive>(input,
@@ -178,7 +191,7 @@
     }
     else {
       fatal(diag::err_unrecognized_input_file) << (*input)->path()
-                                               << m_Config.triple().str();
+                                          << m_Config.targets().triple().str();
     }
   } // end of for
 }
@@ -342,18 +355,16 @@
 {
   // finalize the section symbols, set their fragment reference and push them
   // into output symbol table
-  Module::iterator iter, iterEnd = m_Module.end();
-  for (iter = m_Module.begin(); iter != iterEnd; ++iter) {
-    LDSection* section = *iter;
-    if (0x0 == section->size() || LDFileFormat::Relocation == section->kind())
-      continue;
-    m_Module.getSectionSymbolSet().finalize(
-                                           *section, m_Module.getSymbolTable());
+  Module::iterator sect, sEnd = m_Module.end();
+  for (sect = m_Module.begin(); sect != sEnd; ++sect) {
+    m_Module.getSectionSymbolSet().finalize(**sect, m_Module.getSymbolTable());
   }
 
   m_LDBackend.preLayout(m_Module, *m_pLinker);
 
-  m_LDBackend.allocateCommonSymbols(m_Module);
+  if (LinkerConfig::Object != m_Config.codeGenType() ||
+      m_Config.options().isDefineCommon())
+    m_LDBackend.allocateCommonSymbols(m_Module);
 
   /// check program interpreter - computer the name size of the runtime dyld
   if (!m_pLinker->isStaticLink() &&
@@ -380,8 +391,8 @@
 ///   directly
 bool ObjectLinker::layout()
 {
-  Layout layout;
-  return layout.layout(m_Module, m_LDBackend, m_Config);
+  m_LDBackend.layout(m_Module, *m_pLinker);
+  return true;
 }
 
 /// prelayout - help backend to do some modification after layout
@@ -422,6 +433,9 @@
     case LinkerConfig::Exec:
       getExecWriter()->writeExecutable(m_Module, pOutput);
       return true;
+    case LinkerConfig::Binary:
+      getBinaryWriter()->writeBinary(m_Module, pOutput);
+      return true;
     default:
       fatal(diag::unrecognized_output_file) << m_Config.codeGenType();
   }
diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp
index 891b2bb..15cd816 100644
--- a/lib/Support/CommandLine.cpp
+++ b/lib/Support/CommandLine.cpp
@@ -16,6 +16,45 @@
 
 using namespace mcld;
 
+static const size_t MaxOptWidth = 8;  // arbitrary spacing for printOptionDiff
+
+//===----------------------------------------------------------------------===//
+// SearchDirParser
+//===----------------------------------------------------------------------===//
+// parse - Return true on error.
+bool SearchDirParser::parse(Option &pOption,
+                            StringRef pArgName,
+                            StringRef pArg,
+                            std::string &pValue)
+{
+  char separator = *(pArgName.data() + 1);
+  if ('=' == separator)
+    pValue = '=';
+  pValue += pArg.str();
+  return false;
+}
+
+void SearchDirParser::printOptionDiff(const Option &pOption,
+                                      StringRef pValue,
+                                      OptVal pDefault,
+                                      size_t pGlobalWidth) const
+{
+  printOptionName(pOption, pGlobalWidth);
+  outs() << "= " << pValue;
+  size_t NumSpaces = MaxOptWidth > pValue.size()?MaxOptWidth - pValue.size():0;
+  outs().indent(NumSpaces) << " (default: ";
+  if (pDefault.hasValue())
+    outs() << pDefault.getValue();
+  else
+    outs() << "*no default*";
+  outs() << ")\n";
+}
+
+void SearchDirParser::anchor()
+{
+  // do nothing
+}
+
 //===----------------------------------------------------------------------===//
 // parser<mcld::sys::fs::Path>
 //===----------------------------------------------------------------------===//
@@ -28,8 +67,6 @@
   return false;
 }
 
-static const size_t MaxOptWidth = 8;  // arbitrary spacing for printOptionDiff
-
 void parser<mcld::sys::fs::Path>::printOptionDiff(const llvm::cl::Option &O,
                                                   const mcld::sys::fs::Path &V,
                                                   parser<mcld::sys::fs::Path>::OptVal Default,
@@ -53,40 +90,6 @@
 }
 
 //===----------------------------------------------------------------------===//
-// parser<mcld::MCLDDirectory>
-//===----------------------------------------------------------------------===//
-bool parser<mcld::MCLDDirectory>::parse(llvm::cl::Option &O,
-                                llvm::StringRef ArgName,
-                                llvm::StringRef Arg,
-                                mcld::MCLDDirectory &Val)
-{
-  Val.assign(Arg);
-  return false;
-}
-
-void parser<mcld::MCLDDirectory>::printOptionDiff(const llvm::cl::Option &O,
-                                                  const mcld::MCLDDirectory &V,
-                                                  parser<mcld::MCLDDirectory>::OptVal Default,
-                                                  size_t GlobalWidth) const
-{
-  printOptionName(O, GlobalWidth);
-  outs() << "= " << V.name();
-  size_t VSize = V.name().size();
-  size_t NumSpaces = MaxOptWidth > VSize ? MaxOptWidth - VSize : 0;
-  outs().indent(NumSpaces) << " (default: ";
-  if (Default.hasValue())
-    outs() << Default.getValue().name();
-  else
-    outs() << "*no default*";
-  outs() << ")\n";
-}
-
-void parser<mcld::MCLDDirectory>::anchor()
-{
-  // do nothing
-}
-
-//===----------------------------------------------------------------------===//
 // parser<mcld::ZOption>
 //===----------------------------------------------------------------------===//
 bool parser<mcld::ZOption>::parse(llvm::cl::Option &O,
diff --git a/lib/Support/RegionFactory.cpp b/lib/Support/RegionFactory.cpp
index 7ed87f1..a52921b 100644
--- a/lib/Support/RegionFactory.cpp
+++ b/lib/Support/RegionFactory.cpp
@@ -9,6 +9,8 @@
 #include <mcld/Support/RegionFactory.h>
 #include <mcld/Support/Space.h>
 
+#include <new>
+
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/Support/TargetRegistry.cpp b/lib/Support/TargetRegistry.cpp
index 8bfa235..38074d5 100644
--- a/lib/Support/TargetRegistry.cpp
+++ b/lib/Support/TargetRegistry.cpp
@@ -16,7 +16,8 @@
   s_TargetList.push_back(&T);
 }
 
-const mcld::Target* mcld::TargetRegistry::lookupTarget(const llvm::Target &pTarget)
+const mcld::Target*
+mcld::TargetRegistry::lookupTarget(const llvm::Target &pTarget)
 {
   mcld::Target *result = 0;
   TargetListTy::const_iterator TIter, TEnd = s_TargetList.end();
@@ -29,12 +30,14 @@
   return result;
 }
 
-const mcld::Target *mcld::TargetRegistry::lookupTarget(const std::string &pTriple,
-                                                       std::string &pError) 
+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 0;
+    return NULL;
+
   return lookupTarget( *target );
 }
 
diff --git a/lib/Target/ARM/ARMELFDynamic.cpp b/lib/Target/ARM/ARMELFDynamic.cpp
index c81a6f3..cbec6e8 100644
--- a/lib/Target/ARM/ARMELFDynamic.cpp
+++ b/lib/Target/ARM/ARMELFDynamic.cpp
@@ -6,14 +6,15 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include "ARMELFDynamic.h"
 
 #include <mcld/LD/ELFFileFormat.h>
-#include "ARMELFDynamic.h"
 
 using namespace mcld;
 
-ARMELFDynamic::ARMELFDynamic(const GNULDBackend& pParent)
-  : ELFDynamic(pParent)
+ARMELFDynamic::ARMELFDynamic(const GNULDBackend& pParent,
+                             const LinkerConfig& pConfig)
+  : ELFDynamic(pParent, pConfig)
 {
 }
 
diff --git a/lib/Target/ARM/ARMELFDynamic.h b/lib/Target/ARM/ARMELFDynamic.h
index 914dcc4..826070b 100644
--- a/lib/Target/ARM/ARMELFDynamic.h
+++ b/lib/Target/ARM/ARMELFDynamic.h
@@ -18,7 +18,7 @@
 
 class ARMELFDynamic : public ELFDynamic {
 public:
-  ARMELFDynamic(const GNULDBackend& pParent);
+  ARMELFDynamic(const GNULDBackend& pParent, const LinkerConfig& pConfig);
   ~ARMELFDynamic();
 
 private:
diff --git a/lib/Target/ARM/ARMEmulation.cpp b/lib/Target/ARM/ARMEmulation.cpp
index 875d229..3995618 100644
--- a/lib/Target/ARM/ARMEmulation.cpp
+++ b/lib/Target/ARM/ARMEmulation.cpp
@@ -18,6 +18,10 @@
   if (!MCLDEmulateELF(pConfig))
     return false;
 
+  // set up bitclass and endian
+  pConfig.targets().setEndian(TargetOptions::Little);
+  pConfig.targets().setBitClass(32);
+
   // set up target-dependent constraints of attributes
   pConfig.attribute().constraint().enableWholeArchive();
   pConfig.attribute().constraint().enableAsNeeded();
diff --git a/lib/Target/ARM/ARMGNUInfo.h b/lib/Target/ARM/ARMGNUInfo.h
new file mode 100644
index 0000000..9091dce
--- /dev/null
+++ b/lib/Target/ARM/ARMGNUInfo.h
@@ -0,0 +1,29 @@
+//===- ARMGNUInfo.h -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_ARM_GNU_INFO_H
+#define MCLD_TARGET_ARM_GNU_INFO_H
+#include <mcld/Target/GNUInfo.h>
+
+#include <llvm/Support/ELF.h>
+
+namespace mcld {
+
+class ARMGNUInfo : public GNUInfo
+{
+public:
+  ARMGNUInfo(const llvm::Triple& pTriple) : GNUInfo(pTriple) { }
+
+  uint32_t machine() const { return llvm::ELF::EM_ARM; }
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/lib/Target/ARM/ARMGOT.cpp b/lib/Target/ARM/ARMGOT.cpp
index 3d2d07a..1796635 100644
--- a/lib/Target/ARM/ARMGOT.cpp
+++ b/lib/Target/ARM/ARMGOT.cpp
@@ -8,8 +8,6 @@
 //===----------------------------------------------------------------------===//
 #include "ARMGOT.h"
 
-#include <new>
-
 #include <llvm/Support/Casting.h>
 
 #include <mcld/LD/LDSection.h>
@@ -18,7 +16,6 @@
 #include <mcld/Support/MsgHandling.h>
 
 namespace {
-  const size_t ARMGOTEntrySize = 4;
   const unsigned int ARMGOT0Num = 3;
 } // end of anonymous namespace
 
@@ -27,7 +24,7 @@
 //===----------------------------------------------------------------------===//
 // ARMGOT
 ARMGOT::ARMGOT(LDSection& pSection)
-  : GOT(pSection, ARMGOTEntrySize)
+  : GOT(pSection), m_pLast(NULL)
 {
   // Create GOT0 entries.
   reserve(ARMGOT0Num);
@@ -47,9 +44,28 @@
   return (m_SectionData->size() > ARMGOT0Num);
 }
 
+void ARMGOT::reserve(size_t pNum)
+{
+  for (size_t i = 0; i < pNum; i++) {
+    new ARMGOTEntry(0, m_SectionData);
+  }
+}
+
+ARMGOTEntry* ARMGOT::consume()
+{
+  if (NULL == m_pLast) {
+    assert(!empty() && "Consume empty GOT entry!");
+    m_pLast = llvm::cast<ARMGOTEntry>(&m_SectionData->front());
+    return m_pLast;
+  }
+
+  m_pLast = llvm::cast<ARMGOTEntry>(m_pLast->getNextNode());
+  return m_pLast;
+}
+
 void ARMGOT::reserveGOTPLT()
 {
-  Entry* entry = new Entry(0, getEntrySize(), m_SectionData);
+  ARMGOTEntry* entry = new ARMGOTEntry(0, m_SectionData);
   if (NULL == m_GOTPLT.front) {
     // GOTPLT is empty
     if (NULL == m_GOT.front) {
@@ -60,26 +76,26 @@
     else {
       // GOTn is not empty. Shift GOTn backward by one entry.
       m_GOTPLT.front = m_GOT.front;
-      m_GOT.front = llvm::cast<GOT::Entry>(m_GOT.front->getNextNode());
+      m_GOT.front = llvm::cast<ARMGOTEntry>(m_GOT.front->getNextNode());
     }
   }
   else {
     // GOTPLT is not empty
     if (NULL != m_GOT.front)
-      m_GOT.front = llvm::cast<GOT::Entry>(m_GOT.front->getNextNode());
+      m_GOT.front = llvm::cast<ARMGOTEntry>(m_GOT.front->getNextNode());
   }
 }
 
 void ARMGOT::reserveGOT()
 {
-  Entry* entry = new Entry(0, getEntrySize(), m_SectionData);
+  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;
   }
 }
 
-GOT::Entry* ARMGOT::consumeGOTPLT()
+ARMGOTEntry* ARMGOT::consumeGOTPLT()
 {
   assert(NULL != m_GOTPLT.front && "Consuming empty GOTPLT section!");
 
@@ -87,13 +103,13 @@
     m_GOTPLT.last_used = m_GOTPLT.front;
   }
   else {
-    m_GOTPLT.last_used = llvm::cast<GOT::Entry>(m_GOTPLT.last_used->getNextNode());
+    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;
 }
 
-GOT::Entry* ARMGOT::consumeGOT()
+ARMGOTEntry* ARMGOT::consumeGOT()
 {
   assert(NULL != m_GOT.front && "Consuming empty GOT section!");
 
@@ -101,7 +117,7 @@
     m_GOT.last_used = m_GOT.front;
   }
   else {
-    m_GOT.last_used = llvm::cast<GOT::Entry>(m_GOT.last_used->getNextNode());
+    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;
@@ -109,8 +125,8 @@
 
 void ARMGOT::applyGOT0(uint64_t pAddress)
 {
-  llvm::cast<Entry>
-    (*(m_SectionData->getFragmentList().begin())).setContent(pAddress);
+  llvm::cast<ARMGOTEntry>
+    (*(m_SectionData->getFragmentList().begin())).setValue(pAddress);
 }
 
 void ARMGOT::applyGOTPLT(uint64_t pPLTBase)
@@ -126,7 +142,7 @@
     e_end = SectionData::iterator(m_GOT.front);
 
   while (entry != e_end) {
-    llvm::cast<GOT::Entry>(entry)->setContent(pPLTBase);
+    llvm::cast<ARMGOTEntry>(entry)->setValue(pPLTBase);
     ++entry;
   }
 }
@@ -135,13 +151,12 @@
 {
   uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
 
-  Entry* got = 0;
-  unsigned int entry_size = getEntrySize();
+  ARMGOTEntry* got = NULL;
   uint64_t result = 0x0;
   for (iterator it = begin(), ie = end(); it != ie; ++it, ++buffer) {
-      got = &(llvm::cast<Entry>((*it)));
-      *buffer = static_cast<uint32_t>(got->getContent());
-      result += entry_size;
+      got = &(llvm::cast<ARMGOTEntry>((*it)));
+      *buffer = static_cast<uint32_t>(got->getValue());
+      result += ARMGOTEntry::EntrySize;
   }
   return result;
 }
diff --git a/lib/Target/ARM/ARMGOT.h b/lib/Target/ARM/ARMGOT.h
index 1e8f383..be22c67 100644
--- a/lib/Target/ARM/ARMGOT.h
+++ b/lib/Target/ARM/ARMGOT.h
@@ -21,6 +21,17 @@
 class LDSection;
 class MemoryRegion;
 
+/** \class ARMGOTEntry
+ *  \brief GOT Entry with size of 4 bytes
+ */
+class ARMGOTEntry : public GOT::Entry<4>
+{
+public:
+  ARMGOTEntry(uint64_t pContent, SectionData* pParent)
+   : GOT::Entry<4>(pContent, pParent)
+  {}
+};
+
 /** \class ARMGOT
  *  \brief ARM Global Offset Table.
  *
@@ -45,13 +56,17 @@
 
   ~ARMGOT();
 
+  void reserve(size_t pNum = 1);
+
   void reserveGOTPLT();
 
   void reserveGOT();
 
-  GOT::Entry* consumeGOT();
+  ARMGOTEntry* consume();
 
-  GOT::Entry* consumeGOTPLT();
+  ARMGOTEntry* consumeGOT();
+
+  ARMGOTEntry* consumeGOTPLT();
 
   uint64_t emit(MemoryRegion& pRegion);
 
@@ -67,14 +82,15 @@
     Part() : front(NULL), last_used(NULL) { }
 
   public:
-    GOT::Entry* front;
-    GOT::Entry* last_used;
+    ARMGOTEntry* front;
+    ARMGOTEntry* last_used;
   };
 
 private:
   Part m_GOTPLT;
   Part m_GOT;
 
+  ARMGOTEntry* m_pLast; ///< the last consumed entry
 };
 
 } // namespace of mcld
diff --git a/lib/Target/ARM/ARMLDBackend.cpp b/lib/Target/ARM/ARMLDBackend.cpp
index a90ae63..2fd7e64 100644
--- a/lib/Target/ARM/ARMLDBackend.cpp
+++ b/lib/Target/ARM/ARMLDBackend.cpp
@@ -7,9 +7,10 @@
 //
 //===----------------------------------------------------------------------===//
 #include "ARM.h"
+#include "ARMGNUInfo.h"
 #include "ARMELFDynamic.h"
 #include "ARMLDBackend.h"
-#include "ARMRelocationFactory.h"
+#include "ARMRelocator.h"
 #include "ARMToARMStub.h"
 #include "ARMToTHMStub.h"
 #include "THMToTHMStub.h"
@@ -38,15 +39,16 @@
 #include <mcld/Object/ObjectBuilder.h>
 #include <mcld/Fragment/NullFragment.h>
 #include <mcld/LD/LDContext.h>
+#include <mcld/Target/GNUInfo.h>
 
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
 // ARMGNULDBackend
 //===----------------------------------------------------------------------===//
-ARMGNULDBackend::ARMGNULDBackend(const LinkerConfig& pConfig)
-  : GNULDBackend(pConfig),
-    m_pRelocFactory(NULL),
+ARMGNULDBackend::ARMGNULDBackend(const LinkerConfig& pConfig, GNUInfo* pInfo)
+  : GNULDBackend(pConfig, pInfo),
+    m_pRelocator(NULL),
     m_pGOT(NULL),
     m_pPLT(NULL),
     m_pRelDyn(NULL),
@@ -62,7 +64,7 @@
 
 ARMGNULDBackend::~ARMGNULDBackend()
 {
-  delete m_pRelocFactory;
+  delete m_pRelocator;
   delete m_pGOT;
   delete m_pPLT;
   delete m_pRelDyn;
@@ -70,21 +72,6 @@
   delete m_pDynamic;
 }
 
-bool ARMGNULDBackend::initRelocFactory(const FragmentLinker& pLinker)
-{
-  if (NULL == m_pRelocFactory) {
-    m_pRelocFactory = new ARMRelocationFactory(1024, *this);
-    m_pRelocFactory->setFragmentLinker(pLinker);
-  }
-  return true;
-}
-
-RelocationFactory* ARMGNULDBackend::getRelocFactory()
-{
-  assert(NULL != m_pRelocFactory);
-  return m_pRelocFactory;
-}
-
 void ARMGNULDBackend::initTargetSections(Module& pModule, ObjectBuilder& pBuilder)
 {
  // FIXME: Currently we set exidx and extab to "Exception" and directly emit
@@ -93,7 +80,7 @@
                                            LDFileFormat::Target,
                                            llvm::ELF::SHT_ARM_EXIDX,
                                            llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_LINK_ORDER,
-                                           bitclass() / 8);
+                                           config().targets().bitclass() / 8);
   m_pEXTAB        = pBuilder.CreateSection(".ARM.extab",
                                            LDFileFormat::Target,
                                            llvm::ELF::SHT_PROGBITS,
@@ -120,15 +107,11 @@
     LDSection& relplt = file_format->getRelPlt();
     relplt.setLink(&plt);
     // create SectionData and ARMRelDynSection
-    m_pRelPLT = new OutputRelocSection(pModule,
-                                       relplt,
-                                       getRelEntrySize());
+    m_pRelPLT = new OutputRelocSection(pModule, relplt);
 
     // initialize .rel.dyn
     LDSection& reldyn = file_format->getRelDyn();
-    m_pRelDyn = new OutputRelocSection(pModule,
-                                       reldyn,
-                                       getRelEntrySize());
+    m_pRelDyn = new OutputRelocSection(pModule, reldyn);
   }
 }
 
@@ -184,6 +167,21 @@
                                                   ResolveInfo::Hidden);
 }
 
+bool ARMGNULDBackend::initRelocator(const FragmentLinker& pLinker)
+{
+  if (NULL == m_pRelocator) {
+    m_pRelocator = new ARMRelocator(*this);
+    m_pRelocator->setFragmentLinker(pLinker);
+  }
+  return true;
+}
+
+Relocator* ARMGNULDBackend::getRelocator()
+{
+  assert(NULL != m_pRelocator);
+  return m_pRelocator;
+}
+
 void ARMGNULDBackend::doPreLayout(FragmentLinker& pLinker)
 {
   // set .got size
@@ -200,13 +198,16 @@
     if (m_pPLT->hasPLT1())
       m_pPLT->finalizeSectionSize();
 
+    ELFFileFormat* file_format = getOutputFormat();
     // set .rel.dyn size
     if (!m_pRelDyn->empty())
-      m_pRelDyn->finalizeSectionSize();
+      file_format->getRelDyn().setSize(
+                                  m_pRelDyn->numOfRelocs() * getRelEntrySize());
 
     // set .rel.plt size
     if (!m_pRelPLT->empty())
-      m_pRelPLT->finalizeSectionSize();
+      file_format->getRelPlt().setSize(
+                                  m_pRelPLT->numOfRelocs() * getRelEntrySize());
   }
 }
 
@@ -242,7 +243,7 @@
 ARMELFDynamic& ARMGNULDBackend::dynamic()
 {
   if (NULL == m_pDynamic)
-    m_pDynamic = new ARMELFDynamic(*this);
+    m_pDynamic = new ARMELFDynamic(*this, config());
 
   return *m_pDynamic;
 }
@@ -320,7 +321,7 @@
 
   // Determine the alignment by the symbol value
   // FIXME: here we use the largest alignment
-  uint32_t addralign = bitclass() / 8;
+  uint32_t addralign = config().targets().bitclass() / 8;
 
   // allocate space in BSS for the copy symbol
   Fragment* frag = new FillFragment(0x0, 1, pSym.size());
@@ -398,7 +399,7 @@
       // a dynamic relocations with RELATIVE type to this location is needed.
       // Reserve an entry in .rel.dyn
       if (pLinker.isOutputPIC()) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         // set Rel bit
         rsym->setReserved(rsym->reserved() | ReserveRel);
         }
@@ -444,7 +445,7 @@
       // Reserve an entry in .rel.dyn
       if (pLinker.isOutputPIC()) {
         // create .rel.dyn section if not exist
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         // set GOTRel bit
         rsym->setReserved(rsym->reserved() | 0x4u);
         return;
@@ -512,7 +513,7 @@
           // in .got and .rel.plt. (GOT entry will be reserved simultaneously
           // when calling ARMPLT->reserveEntry())
           m_pPLT->reserveEntry();
-          m_pRelPLT->reserveEntry(*m_pRelocFactory);
+          m_pRelPLT->reserveEntry();
           // set PLT bit
           rsym->setReserved(rsym->reserved() | ReservePLT);
         }
@@ -521,7 +522,7 @@
       if (symbolNeedsDynRel(
                       pLinker, *rsym, (rsym->reserved() & ReservePLT), true)) {
         // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         if (symbolNeedsCopyReloc(pLinker, pReloc, *rsym)) {
           LDSymbol& cpy_sym = defineSymbolforCopyReloc(pLinker, *rsym);
           addCopyReloc(*cpy_sym.resolveInfo());
@@ -596,7 +597,7 @@
       if (symbolNeedsDynRel(
                      pLinker, *rsym, (rsym->reserved() & ReservePLT), false)) {
         // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         if (symbolNeedsCopyReloc(pLinker, pReloc, *rsym)) {
           LDSymbol& cpy_sym = defineSymbolforCopyReloc(pLinker, *rsym);
           addCopyReloc(*cpy_sym.resolveInfo());
@@ -644,7 +645,7 @@
       // in .got and .rel.plt. (GOT entry will be reserved simultaneously
       // when calling ARMPLT->reserveEntry())
       m_pPLT->reserveEntry();
-      m_pRelPLT->reserveEntry(*m_pRelocFactory);
+      m_pRelPLT->reserveEntry();
       // set PLT bit
       rsym->setReserved(rsym->reserved() | ReservePLT);
       return;
@@ -666,7 +667,7 @@
       // if the symbol cannot be fully resolved at link time, then we need a
       // dynamic relocation
       if (!symbolFinalValueIsKnown(pLinker, *rsym)) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         // set GOTRel bit
         rsym->setReserved(rsym->reserved() | GOTRel);
         return;
@@ -718,7 +719,7 @@
 
   // check if we shoule issue undefined reference for the relocation target
   // symbol
-  if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak())
+  if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
     fatal(diag::undefined_reference) << rsym->name();
 
   if ((rsym->reserved() & ReserveRel) != 0x0) {
@@ -984,14 +985,13 @@
             Stub* stub = getStubFactory()->create(*relocation, // relocation
                                                   sym_value, // symbol value
                                                   pLinker,
-                                                  *getRelocFactory(),
                                                   *getBRIslandFactory());
             if (NULL != stub) {
               assert(NULL != stub->symInfo());
               // increase the size of .symtab and .strtab
               LDSection& symtab = file_format->getSymTab();
               LDSection& strtab = file_format->getStrTab();
-              if (32 == bitclass())
+              if (config().targets().is32Bits())
                 symtab.setSize(symtab.size() + sizeof(llvm::ELF::Elf32_Sym));
               else
                 symtab.setSize(symtab.size() + sizeof(llvm::ELF::Elf64_Sym));
@@ -1079,7 +1079,7 @@
 TargetLDBackend* createARMLDBackend(const llvm::Target& pTarget,
                                     const LinkerConfig& pConfig)
 {
-  if (pConfig.triple().isOSDarwin()) {
+  if (pConfig.targets().triple().isOSDarwin()) {
     assert(0 && "MachO linker is not supported yet");
     /**
     return new ARMMachOLDBackend(createARMMachOArchiveReader,
@@ -1087,7 +1087,7 @@
                                createARMMachOObjectWriter);
     **/
   }
-  if (pConfig.triple().isOSWindows()) {
+  if (pConfig.targets().triple().isOSWindows()) {
     assert(0 && "COFF linker is not supported yet");
     /**
     return new ARMCOFFLDBackend(createARMCOFFArchiveReader,
@@ -1095,7 +1095,7 @@
                                createARMCOFFObjectWriter);
     **/
   }
-  return new ARMGNULDBackend(pConfig);
+  return new ARMGNULDBackend(pConfig, new ARMGNUInfo(pConfig.targets().triple()));
 }
 
 } // namespace of mcld
diff --git a/lib/Target/ARM/ARMLDBackend.h b/lib/Target/ARM/ARMLDBackend.h
index 6cf531b..6110b1c 100644
--- a/lib/Target/ARM/ARMLDBackend.h
+++ b/lib/Target/ARM/ARMLDBackend.h
@@ -19,6 +19,7 @@
 namespace mcld {
 
 class LinkerConfig;
+class GNUInfo;
 class FragmentLinker;
 class SectionMap;
 
@@ -38,7 +39,7 @@
   static const int32_t THM2_MAX_BWD_BRANCH_OFFSET = (-(1 << 24) + 4);
 
 public:
-  ARMGNULDBackend(const LinkerConfig& pConfig);
+  ARMGNULDBackend(const LinkerConfig& pConfig, GNUInfo* pInfo);
   ~ARMGNULDBackend();
 
 public:
@@ -94,11 +95,11 @@
   /// initTargetSymbols - initialize target dependent symbols in output.
   void initTargetSymbols(FragmentLinker& pLinker);
 
-  /// initRelocFactory - create and initialize RelocationFactory
-  bool initRelocFactory(const FragmentLinker& pLinker);
+  /// initRelocator - create and initialize Relocator.
+  bool initRelocator(const FragmentLinker& pLinker);
 
-  /// getRelocFactory
-  RelocationFactory* getRelocFactory();
+  /// getRelocator - return relocator.
+  Relocator* getRelocator();
 
   /// scanRelocation - determine the empty entries are needed or not and create
   /// the empty entries if needed.
@@ -111,27 +112,10 @@
                       Module& pModule,
                       const LDSection& pSection);
 
-  uint32_t machine() const
-  { return llvm::ELF::EM_ARM; }
-
-  /// OSABI - the value of e_ident[EI_OSABI]
-  virtual uint8_t OSABI() const
-  { return llvm::ELF::ELFOSABI_NONE; }
-
-  /// ABIVersion - the value of e_ident[EI_ABIVRESION]
-  virtual uint8_t ABIVersion() const
-  { return 0x0; }
-
   /// flags - the value of ElfXX_Ehdr::e_flags
   virtual uint64_t flags() const
   { return (llvm::ELF::EF_ARM_EABIMASK & 0x05000000); }
 
-  bool isLittleEndian() const
-  { return true; }
-
-  unsigned int bitclass() const
-  { return 32; }
-
   uint64_t defaultTextSegmentAddr() const
   { return 0x8000; }
 
@@ -246,7 +230,8 @@
                                    const FragmentLinker& pLinker);
 
 private:
-  RelocationFactory* m_pRelocFactory;
+  Relocator* m_pRelocator;
+
   ARMGOT* m_pGOT;
   ARMPLT* m_pPLT;
   /// m_RelDyn - dynamic relocation table of .rel.dyn
diff --git a/lib/Target/ARM/ARMPLT.cpp b/lib/Target/ARM/ARMPLT.cpp
index a5f4733..d7342ab 100644
--- a/lib/Target/ARM/ARMPLT.cpp
+++ b/lib/Target/ARM/ARMPLT.cpp
@@ -17,31 +17,13 @@
 #include <mcld/Support/MemoryRegion.h>
 #include <mcld/Support/MsgHandling.h>
 
-namespace {
-
-const uint32_t arm_plt0[] = {
-  0xe52de004, // str   lr, [sp, #-4]!
-  0xe59fe004, // ldr   lr, [pc, #4]
-  0xe08fe00e, // add   lr, pc, lr
-  0xe5bef008, // ldr   pc, [lr, #8]!
-  0x00000000, // &GOT[0] - .
-};
-
-const uint32_t arm_plt1[] = {
-  0xe28fc600, // add   ip, pc, #0xNN00000
-  0xe28cca00, // add   ip, ip, #0xNN000
-  0xe5bcf000, // ldr   pc, [ip, #0xNNN]!
-};
-
-} // anonymous namespace
-
 using namespace mcld;
 
 ARMPLT0::ARMPLT0(SectionData& pParent)
-  : PLT::Entry(sizeof(arm_plt0), pParent) {}
+  : PLT::Entry<sizeof(arm_plt0)>(pParent) {}
 
 ARMPLT1::ARMPLT1(SectionData& pParent)
-  : PLT::Entry(sizeof(arm_plt1), pParent) {}
+  : PLT::Entry<sizeof(arm_plt1)>(pParent) {}
 
 //===----------------------------------------------------------------------===//
 // ARMPLT
@@ -134,15 +116,15 @@
   ARMPLT0* plt0 = &(llvm::cast<ARMPLT0>(*first));
 
   uint32_t* data = 0;
-  data = static_cast<uint32_t*>(malloc(plt0->getEntrySize()));
+  data = static_cast<uint32_t*>(malloc(ARMPLT0::EntrySize));
 
   if (!data)
     fatal(diag::fail_allocate_memory_plt);
 
-  memcpy(data, arm_plt0, plt0->getEntrySize());
+  memcpy(data, arm_plt0, ARMPLT0::EntrySize);
   data[4] = offset;
 
-  plt0->setContent(reinterpret_cast<unsigned char*>(data));
+  plt0->setValue(reinterpret_cast<unsigned char*>(data));
 }
 
 void ARMPLT::applyPLT1() {
@@ -157,21 +139,21 @@
   ARMPLT::iterator ie = m_SectionData->end();
   assert(it != ie && "FragmentList is empty, applyPLT1 failed!");
 
-  uint32_t GOTEntrySize = m_GOT.getEntrySize();
+  uint32_t GOTEntrySize = ARMGOTEntry::EntrySize;
   uint32_t GOTEntryAddress =
     got_base +  GOTEntrySize * 3;
 
   uint64_t PLTEntryAddress =
-    plt_base + llvm::cast<ARMPLT0>((*it)).getEntrySize(); //Offset of PLT0
+    plt_base + ARMPLT0::EntrySize; //Offset of PLT0
 
   ++it; //skip PLT0
-  uint64_t PLT1EntrySize = llvm::cast<ARMPLT1>((*it)).getEntrySize();
+  uint64_t PLT1EntrySize = ARMPLT1::EntrySize;
   ARMPLT1* plt1 = NULL;
 
   uint32_t* Out = NULL;
   while (it != ie) {
     plt1 = &(llvm::cast<ARMPLT1>(*it));
-    Out = static_cast<uint32_t*>(malloc(plt1->getEntrySize()));
+    Out = static_cast<uint32_t*>(malloc(ARMPLT1::EntrySize));
 
     if (!Out)
       fatal(diag::fail_allocate_memory_plt);
@@ -184,7 +166,7 @@
     Out[1] = arm_plt1[1] | ((Offset >> 12) & 0xFF);
     Out[2] = arm_plt1[2] | (Offset & 0xFFF);
 
-    plt1->setContent(reinterpret_cast<unsigned char*>(Out));
+    plt1->setValue(reinterpret_cast<unsigned char*>(Out));
     ++it;
 
     GOTEntryAddress += GOTEntrySize;
@@ -198,21 +180,18 @@
 {
   uint64_t result = 0x0;
   iterator it = begin();
-  unsigned int plt0_size = llvm::cast<ARMPLT0>((*it)).getEntrySize();
 
   unsigned char* buffer = pRegion.getBuffer();
-  memcpy(buffer, llvm::cast<ARMPLT0>((*it)).getContent(), plt0_size);
-  result += plt0_size;
+  memcpy(buffer, llvm::cast<ARMPLT0>((*it)).getValue(), ARMPLT0::EntrySize);
+  result += ARMPLT0::EntrySize;
   ++it;
 
   ARMPLT1* plt1 = 0;
   ARMPLT::iterator ie = end();
-  unsigned int entry_size = 0;
   while (it != ie) {
     plt1 = &(llvm::cast<ARMPLT1>(*it));
-    entry_size = plt1->getEntrySize();
-    memcpy(buffer + result, plt1->getContent(), entry_size);
-    result += entry_size;
+    memcpy(buffer + result, plt1->getValue(), ARMPLT1::EntrySize);
+    result += ARMPLT1::EntrySize;
     ++it;
   }
   return result;
diff --git a/lib/Target/ARM/ARMPLT.h b/lib/Target/ARM/ARMPLT.h
index 67b6f4e..9554f0c 100644
--- a/lib/Target/ARM/ARMPLT.h
+++ b/lib/Target/ARM/ARMPLT.h
@@ -12,17 +12,37 @@
 #include <mcld/Target/GOT.h>
 #include <mcld/Target/PLT.h>
 
+namespace {
+
+const uint32_t arm_plt0[] = {
+  0xe52de004, // str   lr, [sp, #-4]!
+  0xe59fe004, // ldr   lr, [pc, #4]
+  0xe08fe00e, // add   lr, pc, lr
+  0xe5bef008, // ldr   pc, [lr, #8]!
+  0x00000000, // &GOT[0] - .
+};
+
+const uint32_t arm_plt1[] = {
+  0xe28fc600, // add   ip, pc, #0xNN00000
+  0xe28cca00, // add   ip, ip, #0xNN000
+  0xe5bcf000, // ldr   pc, [ip, #0xNNN]!
+};
+
+} // anonymous namespace
+
 namespace mcld {
 
 class ARMGOT;
 class MemoryRegion;
 
-class ARMPLT0 : public PLT::Entry {
+class ARMPLT0 : public PLT::Entry<sizeof(arm_plt0)>
+{
 public:
   ARMPLT0(SectionData& pParent);
 };
 
-class ARMPLT1 : public PLT::Entry {
+class ARMPLT1 : public PLT::Entry<sizeof(arm_plt1)>
+{
 public:
   ARMPLT1(SectionData& pParent);
 };
diff --git a/lib/Target/ARM/ARMRelocationFunctions.h b/lib/Target/ARM/ARMRelocationFunctions.h
index 3f8b90e..cd25e2c 100644
--- a/lib/Target/ARM/ARMRelocationFunctions.h
+++ b/lib/Target/ARM/ARMRelocationFunctions.h
@@ -8,8 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #define DECL_ARM_APPLY_RELOC_FUNC(Name) \
-static ARMRelocationFactory::Result Name    (Relocation& pEntry, \
-                                             ARMRelocationFactory& pParent);
+static ARMRelocator::Result Name    (Relocation& pEntry, \
+                                     ARMRelocator& pParent);
 
 #define DECL_ARM_APPLY_RELOC_FUNCS \
 DECL_ARM_APPLY_RELOC_FUNC(none)             \
diff --git a/lib/Target/ARM/ARMRelocationFactory.cpp b/lib/Target/ARM/ARMRelocator.cpp
similarity index 63%
rename from lib/Target/ARM/ARMRelocationFactory.cpp
rename to lib/Target/ARM/ARMRelocator.cpp
index d668fc5..d613d66 100644
--- a/lib/Target/ARM/ARMRelocationFactory.cpp
+++ b/lib/Target/ARM/ARMRelocator.cpp
@@ -1,4 +1,4 @@
-//===- ARMRelocationFactory.cpp  ----------------------------------------===//
+//===- ARMRelocator.cpp  ----------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -12,9 +12,8 @@
 #include <llvm/Support/ELF.h>
 #include <llvm/Support/Host.h>
 #include <mcld/Fragment/FragmentLinker.h>
-#include <mcld/LinkerConfig.h>
 #include <mcld/Support/MsgHandling.h>
-#include "ARMRelocationFactory.h"
+#include "ARMRelocator.h"
 #include "ARMRelocationFunctions.h"
 
 using namespace mcld;
@@ -25,9 +24,8 @@
 DECL_ARM_APPLY_RELOC_FUNCS
 
 /// the prototype of applying function
-typedef RelocationFactory::Result (*ApplyFunctionType)(
-                                               Relocation& pReloc,
-                                               ARMRelocationFactory& pParent);
+typedef Relocator::Result (*ApplyFunctionType)(Relocation& pReloc,
+                                               ARMRelocator& pParent);
 
 // the table entry of applying functions
 struct ApplyFunctionTriple
@@ -43,41 +41,40 @@
 };
 
 //===--------------------------------------------------------------------===//
-// ARMRelocationFactory
+// ARMRelocator
 //===--------------------------------------------------------------------===//
-ARMRelocationFactory::ARMRelocationFactory(size_t pNum,
-                                           ARMGNULDBackend& pParent)
-  : RelocationFactory(pNum),
+ARMRelocator::ARMRelocator(ARMGNULDBackend& pParent)
+  : Relocator(),
     m_Target(pParent) {
 }
 
-ARMRelocationFactory::~ARMRelocationFactory()
+ARMRelocator::~ARMRelocator()
 {
 }
 
-RelocationFactory::Result
-ARMRelocationFactory::applyRelocation(Relocation& pRelocation)
+Relocator::Result
+ARMRelocator::applyRelocation(Relocation& pRelocation)
 {
   Relocation::Type type = pRelocation.type();
   if (type > 130) { // 131-255 doesn't noted in ARM spec
-    return RelocationFactory::Unknown;
+    return Relocator::Unknown;
   }
 
   return ApplyFunctions[type].func(pRelocation, *this);
 }
 
-const char* ARMRelocationFactory::getName(RelocationFactory::Type pType) const
+const char* ARMRelocator::getName(Relocator::Type pType) const
 {
   return ApplyFunctions[pType].name;
 }
 
 //===--------------------------------------------------------------------===//
 // non-member functions
-static RelocationFactory::DWord getThumbBit(const Relocation& pReloc)
+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
-  RelocationFactory::DWord thumbBit =
+  Relocator::DWord thumbBit =
        ((!pReloc.symInfo()->isUndef() || pReloc.symInfo()->isDyn()) &&
         (pReloc.symInfo()->type() == ResolveInfo::Function) &&
         ((pReloc.symValue() & 0x1) != 0))?
@@ -112,7 +109,7 @@
 // Check if symbol can use relocation R_ARM_RELATIVE
 static bool
 helper_use_relative_reloc(const ResolveInfo& pSym,
-                          const ARMRelocationFactory& pFactory)
+                          const ARMRelocator& pFactory)
 {
   // if symbol is dynamic or undefine or preemptible
   if (pSym.isDyn() ||
@@ -123,21 +120,21 @@
 }
 
 static
-GOT::Entry& helper_get_GOT_and_init(Relocation& pReloc,
-                                    ARMRelocationFactory& pParent)
+ARMGOTEntry& helper_get_GOT_and_init(Relocation& pReloc,
+                                     ARMRelocator& pParent)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
   ARMGNULDBackend& ld_backend = pParent.getTarget();
 
-  GOT::Entry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
+  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() & ARMGNULDBackend::ReserveGOT) {
       // No corresponding dynamic relocation, initialize to the symbol value.
-      got_entry->setContent(pReloc.symValue());
+      got_entry->setValue(pReloc.symValue());
     }
     else if (rsym->reserved() & ARMGNULDBackend::GOTRel) {
 
@@ -146,13 +143,13 @@
       if ( rsym->isLocal() ||
           helper_use_relative_reloc(*rsym, pParent)) {
         // Initialize got entry to target symbol address
-        got_entry->setContent(pReloc.symValue());
+        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->setContent(0);
+        got_entry->setValue(0);
         rel_entry.setType(llvm::ELF::R_ARM_GLOB_DAT);
         rel_entry.setSymInfo(rsym);
       }
@@ -166,30 +163,28 @@
 }
 
 static
-ARMRelocationFactory::Address helper_GOT_ORG(ARMRelocationFactory& pParent)
+ARMRelocator::Address helper_GOT_ORG(ARMRelocator& pParent)
 {
   return pParent.getTarget().getGOT().addr();
 }
 
 
 static
-ARMRelocationFactory::Address helper_GOT(Relocation& pReloc,
-                                         ARMRelocationFactory& pParent)
+ARMRelocator::Address helper_GOT(Relocation& pReloc, ARMRelocator& pParent)
 {
-  GOT::Entry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
+  ARMGOTEntry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
   return helper_GOT_ORG(pParent) + got_entry.getOffset();
 }
 
 
 static
-PLT::Entry& helper_get_PLT_and_init(Relocation& pReloc,
-                                    ARMRelocationFactory& pParent)
+ARMPLT1& helper_get_PLT_and_init(Relocation& pReloc, ARMRelocator& pParent)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
   ARMGNULDBackend& ld_backend = pParent.getTarget();
 
-  PLT::Entry* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
+  ARMPLT1* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
   if (NULL != plt_entry)
     return *plt_entry;
 
@@ -198,7 +193,7 @@
 
   // If we first get this PLT entry, we should initialize it.
   if (rsym->reserved() & ARMGNULDBackend::ReservePLT) {
-    GOT::Entry* gotplt_entry = pParent.getSymGOTPLTMap().lookUp(*rsym);
+    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);
@@ -217,26 +212,26 @@
 }
 
 static
-ARMRelocationFactory::Address helper_PLT_ORG(ARMRelocationFactory& pParent)
+ARMRelocator::Address helper_PLT_ORG(ARMRelocator& pParent)
 {
   return pParent.getTarget().getPLT().addr();
 }
 
 
 static
-ARMRelocationFactory::Address helper_PLT(Relocation& pReloc,
-                                         ARMRelocationFactory& pParent)
+ARMRelocator::Address helper_PLT(Relocation& pReloc, ARMRelocator& pParent)
 {
-  PLT::Entry& plt_entry = helper_get_PLT_and_init(pReloc, 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()
+// its FragmentRef to pReloc->targetFrag() and its ResolveInfo to
+// pReloc->symInfo()
 static
 void helper_DynRel(Relocation& pReloc,
-                   ARMRelocationFactory::Type pType,
-                   ARMRelocationFactory& pParent)
+                   ARMRelocator::Type pType,
+                   ARMRelocator& pParent)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
@@ -252,17 +247,17 @@
     rel_entry.setSymInfo(rsym);
 }
 
-static ARMRelocationFactory::DWord
-helper_extract_movw_movt_addend(ARMRelocationFactory::DWord pTarget)
+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 ARMRelocationFactory::DWord
-helper_insert_val_movw_movt_inst(ARMRelocationFactory::DWord pTarget,
-                                 ARMRelocationFactory::DWord pImm)
+static ARMRelocator::DWord
+helper_insert_val_movw_movt_inst(ARMRelocator::DWord pTarget,
+                                 ARMRelocator::DWord pImm)
 {
   // imm16: [19-16][11-0]
   pTarget &= 0xfff0f000U;
@@ -271,8 +266,8 @@
   return pTarget;
 }
 
-static ARMRelocationFactory::DWord
-helper_extract_thumb_movw_movt_addend(ARMRelocationFactory::DWord pValue)
+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) |
@@ -282,9 +277,9 @@
                             16);
 }
 
-static ARMRelocationFactory::DWord
-helper_insert_val_thumb_movw_movt_inst(ARMRelocationFactory::DWord pValue,
-                                       ARMRelocationFactory::DWord pImm)
+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;
@@ -295,16 +290,16 @@
   return pValue;
 }
 
-static ARMRelocationFactory::DWord
-helper_thumb32_branch_offset(ARMRelocationFactory::DWord pUpper16,
-                             ARMRelocationFactory::DWord pLower16)
+static ARMRelocator::DWord
+helper_thumb32_branch_offset(ARMRelocator::DWord pUpper16,
+                             ARMRelocator::DWord pLower16)
 {
-  ARMRelocationFactory::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
-  ARMRelocationFactory::DWord i1 = j1 ^ s? 0: 1,
+  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]
@@ -314,17 +309,17 @@
                             25);
 }
 
-static ARMRelocationFactory::DWord
-helper_thumb32_branch_upper(ARMRelocationFactory::DWord pUpper16,
-                            ARMRelocationFactory::DWord pOffset)
+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 ARMRelocationFactory::DWord
-helper_thumb32_branch_lower(ARMRelocationFactory::DWord pLower16,
-                            ARMRelocationFactory::DWord pOffset)
+static ARMRelocator::DWord
+helper_thumb32_branch_lower(ARMRelocator::DWord pLower16,
+                            ARMRelocator::DWord pOffset)
 {
   uint32_t sign = ((pOffset & 0x80000000U) >> 31);
   return ((pLower16 & ~0x2fffU) |
@@ -335,7 +330,7 @@
 
 // Return true if overflow
 static bool
-helper_check_signed_overflow(ARMRelocationFactory::DWord pValue,
+helper_check_signed_overflow(ARMRelocator::DWord pValue,
                              unsigned bits)
 {
   int32_t signed_val = static_cast<int32_t>(pValue);
@@ -354,20 +349,18 @@
 //=========================================//
 
 // R_ARM_NONE
-ARMRelocationFactory::Result none(Relocation& pReloc,
-                                  ARMRelocationFactory& pParent)
+ARMRelocator::Result none(Relocation& pReloc, ARMRelocator& pParent)
 {
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_ABS32: (S + A) | T
-ARMRelocationFactory::Result abs32(Relocation& pReloc,
-                                   ARMRelocationFactory& pParent)
+ARMRelocator::Result abs32(Relocation& pReloc, ARMRelocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord A = pReloc.target() + pReloc.addend();
-  ARMRelocationFactory::DWord S = pReloc.symValue();
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
+  ARMRelocator::DWord S = pReloc.symValue();
 
   LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
 
@@ -375,14 +368,14 @@
   // but perform static relocation. (e.g., applying .debug section)
   if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
     pReloc.target() = (S + A) | T;
-    return ARMRelocationFactory::OK;
+    return ARMRelocator::OK;
   }
 
   // A local symbol may need REL Type dynamic relocation
   if (rsym->isLocal() && (rsym->reserved() & ARMGNULDBackend::ReserveRel)) {
     helper_DynRel(pReloc, llvm::ELF::R_ARM_RELATIVE, pParent);
     pReloc.target() = (S + A) | T ;
-    return ARMRelocationFactory::OK;
+    return ARMRelocator::OK;
   }
 
   // An external symbol may need PLT and dynamic relocation
@@ -400,7 +393,7 @@
       }
       else {
         helper_DynRel(pReloc, pReloc.type(), pParent);
-        return ARMRelocationFactory::OK;
+        return ARMRelocator::OK;
       }
     }
   }
@@ -408,17 +401,16 @@
 
   // perform static relocation
   pReloc.target() = (S + A) | T;
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_REL32: ((S + A) | T) - P
-ARMRelocationFactory::Result rel32(Relocation& pReloc,
-                                   ARMRelocationFactory& pParent)
+ARMRelocator::Result rel32(Relocation& pReloc, ARMRelocator& pParent)
 {
   // perform static relocation
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord   T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord   A = pReloc.target() + pReloc.addend();
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord   T = getThumbBit(pReloc);
+  ARMRelocator::DWord   A = pReloc.target() + pReloc.addend();
 
   // An external symbol may need PLT (this reloc is from stub)
   if (!pReloc.symInfo()->isLocal()) {
@@ -431,70 +423,65 @@
   // perform relocation
   pReloc.target() = ((S + A) | T) - pReloc.place();
 
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_BASE_PREL: B(S) + A - P
-ARMRelocationFactory::Result base_prel(Relocation& pReloc,
-                                       ARMRelocationFactory& pParent)
+ARMRelocator::Result base_prel(Relocation& pReloc, ARMRelocator& pParent)
 {
   // perform static relocation
-  ARMRelocationFactory::DWord A = pReloc.target() + pReloc.addend();
+  ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
   pReloc.target() = pReloc.symValue() + A - pReloc.place();
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_GOTOFF32: ((S + A) | T) - GOT_ORG
-ARMRelocationFactory::Result gotoff32(Relocation& pReloc,
-                                      ARMRelocationFactory& pParent)
+ARMRelocator::Result gotoff32(Relocation& pReloc, ARMRelocator& pParent)
 {
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord A = pReloc.target() + pReloc.addend();
-  ARMRelocationFactory::Address GOT_ORG = helper_GOT_ORG(pParent);
-  ARMRelocationFactory::Address S = pReloc.symValue();
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord A = pReloc.target() + pReloc.addend();
+  ARMRelocator::Address GOT_ORG = helper_GOT_ORG(pParent);
+  ARMRelocator::Address S = pReloc.symValue();
 
   pReloc.target() = ((S + A) | T) - GOT_ORG;
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_GOT_BREL: GOT(S) + A - GOT_ORG
-ARMRelocationFactory::Result got_brel(Relocation& pReloc,
-                                      ARMRelocationFactory& pParent)
+ARMRelocator::Result got_brel(Relocation& pReloc, ARMRelocator& pParent)
 {
   if (!(pReloc.symInfo()->reserved() &
       (ARMGNULDBackend::ReserveGOT | ARMGNULDBackend::GOTRel))) {
-    return ARMRelocationFactory::BadReloc;
+    return ARMRelocator::BadReloc;
   }
-  ARMRelocationFactory::Address GOT_S   = helper_GOT(pReloc, pParent);
-  ARMRelocationFactory::DWord   A       = pReloc.target() + pReloc.addend();
-  ARMRelocationFactory::Address GOT_ORG = helper_GOT_ORG(pParent);
+  ARMRelocator::Address GOT_S   = helper_GOT(pReloc, 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;
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_GOT_PREL: GOT(S) + A - P
-ARMRelocationFactory::Result got_prel(Relocation& pReloc,
-                                      ARMRelocationFactory& pParent)
+ARMRelocator::Result got_prel(Relocation& pReloc, ARMRelocator& pParent)
 {
   if (!(pReloc.symInfo()->reserved() &
       (ARMGNULDBackend::ReserveGOT | ARMGNULDBackend::GOTRel))) {
-    return ARMRelocationFactory::BadReloc;
+    return ARMRelocator::BadReloc;
   }
-  ARMRelocationFactory::Address GOT_S   = helper_GOT(pReloc, pParent);
-  ARMRelocationFactory::DWord   A       = pReloc.target() + pReloc.addend();
-  ARMRelocationFactory::Address P = pReloc.place();
+  ARMRelocator::Address GOT_S   = helper_GOT(pReloc, pParent);
+  ARMRelocator::DWord   A       = pReloc.target() + pReloc.addend();
+  ARMRelocator::Address P = pReloc.place();
 
   // Apply relocation.
   pReloc.target() = GOT_S + A - P;
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_PLT32: ((S + A) | T) - P
 // R_ARM_JUMP24: ((S + A) | T) - P
 // R_ARM_CALL: ((S + A) | T) - P
-ARMRelocationFactory::Result call(Relocation& pReloc,
-                                  ARMRelocationFactory& pParent)
+ARMRelocator::Result call(Relocation& pReloc, ARMRelocator& pParent)
 {
   // If target is undefined weak symbol, we only need to jump to the
   // next instruction unless it has PLT entry. Rewrite instruction
@@ -505,15 +492,15 @@
       !(pReloc.symInfo()->reserved() & ARMGNULDBackend::ReservePLT)) {
     // change target to NOP : mov r0, r0
     pReloc.target() = (pReloc.target() & 0xf0000000U) | 0x01a00000;
-    return ARMRelocationFactory::OK;
+    return ARMRelocator::OK;
   }
 
-  ARMRelocationFactory::Address S; // S depends on PLT exists or not.
-  ARMRelocationFactory::DWord   T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord   A =
+  ARMRelocator::Address S; // S depends on PLT exists or not.
+  ARMRelocator::DWord   T = getThumbBit(pReloc);
+  ARMRelocator::DWord   A =
     helper_sign_extend((pReloc.target() & 0x00FFFFFFu) << 2, 26)
     + pReloc.addend();
-  ARMRelocationFactory::Address P = pReloc.place();
+  ARMRelocator::Address P = pReloc.place();
 
   S = pReloc.symValue();
   if (pReloc.symInfo()->reserved() & ARMGNULDBackend::ReservePLT) {
@@ -528,26 +515,25 @@
   if (T != 0) {
     // cannot rewrite to blx for R_ARM_JUMP24
     if (pReloc.type() == llvm::ELF::R_ARM_JUMP24)
-      return ARMRelocationFactory::BadReloc;
+      return ARMRelocator::BadReloc;
 
     pReloc.target() = (pReloc.target() & 0xffffff) |
                       0xfa000000 |
                       (((S + A - P) & 2) << 23);
   }
 
-  ARMRelocationFactory::DWord X = ((S + A) | T) - P;
+  ARMRelocator::DWord X = ((S + A) | T) - P;
   // Check X is 24bit sign int. If not, we should use stub or PLT before apply.
   if (helper_check_signed_overflow(X, 26))
-    return ARMRelocationFactory::Overflow;
+    return ARMRelocator::Overflow;
   //                    Make sure the Imm is 0.          Result Mask.
   pReloc.target() = (pReloc.target() & 0xFF000000u) | ((X & 0x03FFFFFEu) >> 2);
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_THM_CALL: ((S + A) | T) - P
 // R_ARM_THM_JUMP24: (((S + A) | T) - P)
-ARMRelocationFactory::Result thm_call(Relocation& pReloc,
-                                      ARMRelocationFactory& pParent)
+ARMRelocator::Result thm_call(Relocation& pReloc, ARMRelocator& pParent)
 {
   // If target is undefined weak symbol, we only need to jump to the
   // next instruction unless it has PLT entry. Rewrite instruction
@@ -557,18 +543,18 @@
       !pReloc.symInfo()->isDyn() &&
       !(pReloc.symInfo()->reserved() & ARMGNULDBackend::ReservePLT)) {
     pReloc.target() = (0xe000U << 16) | 0xbf00U;
-    return ARMRelocationFactory::OK;
+    return ARMRelocator::OK;
   }
 
   // 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);
 
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord A = helper_thumb32_branch_offset(upper_inst,
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord A = helper_thumb32_branch_offset(upper_inst,
                                                                lower_inst);
-  ARMRelocationFactory::Address P = pReloc.place();
-  ARMRelocationFactory::Address S;
+  ARMRelocator::Address P = pReloc.place();
+  ARMRelocator::Address S;
 
   // if symbol has plt
   if (pReloc.symInfo()->reserved() & ARMGNULDBackend::ReservePLT) {
@@ -588,7 +574,7 @@
   if (T == 0) {
     // cannot rewrite to blx for R_ARM_THM_JUMP24
     if (pReloc.type() == llvm::ELF::R_ARM_THM_JUMP24)
-      return ARMRelocationFactory::BadReloc;
+      return ARMRelocator::BadReloc;
 
     // for BLX, select bit 1 from relocation base address to jump target
     // address
@@ -601,11 +587,11 @@
     lower_inst |= 0x1000U;
   }
 
-  ARMRelocationFactory::DWord X = (S | T) - P;
+  ARMRelocator::DWord X = (S | T) - P;
 
   // FIXME: Check bit size is 24(thumb2) or 22?
   if (helper_check_signed_overflow(X, 25)) {
-    return ARMRelocationFactory::Overflow;
+    return ARMRelocator::Overflow;
   }
 
   upper_inst = helper_thumb32_branch_upper(upper_inst, X);
@@ -614,19 +600,18 @@
   *(reinterpret_cast<uint16_t*>(&pReloc.target())) = upper_inst;
   *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = lower_inst;
 
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_MOVW_ABS_NC: (S + A) | T
-ARMRelocationFactory::Result movw_abs_nc(Relocation& pReloc,
-                                         ARMRelocationFactory& pParent)
+ARMRelocator::Result movw_abs_nc(Relocation& pReloc, ARMRelocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord A =
       helper_extract_movw_movt_addend(pReloc.target()) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
 
@@ -644,39 +629,37 @@
   X = (S + A) | T;
   pReloc.target() = helper_insert_val_movw_movt_inst(
                                          pReloc.target() + pReloc.addend(), X);
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_MOVW_PREL_NC: ((S + A) | T) - P
-ARMRelocationFactory::Result movw_prel_nc(Relocation& pReloc,
-                                          ARMRelocationFactory& pParent)
+ARMRelocator::Result movw_prel_nc(Relocation& pReloc, ARMRelocator& pParent)
 {
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord P = pReloc.place();
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord P = pReloc.place();
+  ARMRelocator::DWord A =
       helper_extract_movw_movt_addend(pReloc.target()) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   X = ((S + A) | T) - P;
 
   if (helper_check_signed_overflow(X, 16)) {
-    return ARMRelocationFactory::Overflow;
+    return ARMRelocator::Overflow;
   } else {
     pReloc.target() = helper_insert_val_movw_movt_inst(pReloc.target(), X);
-    return ARMRelocationFactory::OK;
+    return ARMRelocator::OK;
   }
 }
 
 // R_ARM_MOVT_ABS: S + A
-ARMRelocationFactory::Result movt_abs(Relocation& pReloc,
-                                      ARMRelocationFactory& pParent)
+ARMRelocator::Result movt_abs(Relocation& pReloc, ARMRelocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord A =
     helper_extract_movw_movt_addend(pReloc.target()) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
 
@@ -693,41 +676,39 @@
   X >>= 16;
   // perform static relocation
   pReloc.target() = helper_insert_val_movw_movt_inst(pReloc.target(), X);
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_MOVT_PREL: S + A - P
-ARMRelocationFactory::Result movt_prel(Relocation& pReloc,
-                                       ARMRelocationFactory& pParent)
+ARMRelocator::Result movt_prel(Relocation& pReloc, ARMRelocator& pParent)
 {
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord P = pReloc.place();
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord P = pReloc.place();
+  ARMRelocator::DWord A =
             helper_extract_movw_movt_addend(pReloc.target()) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   X = S + A - P;
   X >>= 16;
 
   pReloc.target() = helper_insert_val_movw_movt_inst(pReloc.target(), X);
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_THM_MOVW_ABS_NC: (S + A) | T
-ARMRelocationFactory::Result thm_movw_abs_nc(Relocation& pReloc,
-                                             ARMRelocationFactory& pParent)
+ARMRelocator::Result thm_movw_abs_nc(Relocation& pReloc, ARMRelocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord T = getThumbBit(pReloc);
 
   // 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);
-  ARMRelocationFactory::DWord val = ((upper_inst) << 16) | (lower_inst);
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
+  ARMRelocator::DWord A =
       helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
   // If the flag of target section is not ALLOC, we will not scan this relocation
@@ -745,24 +726,23 @@
   *(reinterpret_cast<uint16_t*>(&pReloc.target())) = upper_inst;
   *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = lower_inst;
 
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_THM_MOVW_PREL_NC: ((S + A) | T) - P
-ARMRelocationFactory::Result thm_movw_prel_nc(Relocation& pReloc,
-                                              ARMRelocationFactory& pParent)
+ARMRelocator::Result thm_movw_prel_nc(Relocation& pReloc, ARMRelocator& pParent)
 {
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord P = pReloc.place();
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord P = pReloc.place();
 
   // 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);
-  ARMRelocationFactory::DWord val = ((upper_inst) << 16) | (lower_inst);
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
+  ARMRelocator::DWord A =
       helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   X = ((S + A) | T) - P;
 
@@ -770,25 +750,24 @@
   *(reinterpret_cast<uint16_t*>(&pReloc.target())) = upper_inst;
   *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = lower_inst;
 
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_THM_MOVW_BREL_NC: ((S + A) | T) - B(S)
 // R_ARM_THM_MOVW_BREL: ((S + A) | T) - B(S)
-ARMRelocationFactory::Result thm_movw_brel(Relocation& pReloc,
-                                              ARMRelocationFactory& pParent)
+ARMRelocator::Result thm_movw_brel(Relocation& pReloc, ARMRelocator& pParent)
 {
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord P = pReloc.place();
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord P = pReloc.place();
 
   // 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);
-  ARMRelocationFactory::DWord val = ((upper_inst) << 16) | (lower_inst);
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
+  ARMRelocator::DWord A =
       helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   X = ((S + A) | T) - P;
 
@@ -796,23 +775,22 @@
   *(reinterpret_cast<uint16_t*>(&pReloc.target())) = upper_inst;
   *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = lower_inst;
 
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_THM_MOVT_ABS: S + A
-ARMRelocationFactory::Result thm_movt_abs(Relocation& pReloc,
-                                          ARMRelocationFactory& pParent)
+ARMRelocator::Result thm_movt_abs(Relocation& pReloc, ARMRelocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  ARMRelocationFactory::Address S = pReloc.symValue();
+  ARMRelocator::Address S = pReloc.symValue();
 
   // 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);
-  ARMRelocationFactory::DWord val = ((upper_inst) << 16) | (lower_inst);
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
+  ARMRelocator::DWord A =
       helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   LDSection& target_sect = pReloc.targetRef().frag()->getParent()->getSection();
   // If the flag of target section is not ALLOC, we will not scan this relocation
@@ -829,30 +807,29 @@
 
   // check 16-bit overflow
   if (helper_check_signed_overflow(X, 16)) {
-    return ARMRelocationFactory::Overflow;
+    return ARMRelocator::Overflow;
   } else {
     val = helper_insert_val_thumb_movw_movt_inst(val, X);
     *(reinterpret_cast<uint16_t*>(&pReloc.target())) = upper_inst;
     *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = lower_inst;
-    return ARMRelocationFactory::OK;
+    return ARMRelocator::OK;
   }
 }
 
 // R_ARM_THM_MOVT_PREL: S + A - P
 // R_ARM_THM_MOVT_BREL: S + A - B(S)
-ARMRelocationFactory::Result thm_movt_prel(Relocation& pReloc,
-                                           ARMRelocationFactory& pParent)
+ARMRelocator::Result thm_movt_prel(Relocation& pReloc, ARMRelocator& pParent)
 {
-  ARMRelocationFactory::Address S = pReloc.symValue();
-  ARMRelocationFactory::DWord P = pReloc.place();
+  ARMRelocator::Address S = pReloc.symValue();
+  ARMRelocator::DWord P = pReloc.place();
 
   // 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);
-  ARMRelocationFactory::DWord val = ((upper_inst) << 16) | (lower_inst);
-  ARMRelocationFactory::DWord A =
+  ARMRelocator::DWord val = ((upper_inst) << 16) | (lower_inst);
+  ARMRelocator::DWord A =
       helper_extract_thumb_movw_movt_addend(val) + pReloc.addend();
-  ARMRelocationFactory::DWord X;
+  ARMRelocator::DWord X;
 
   X = S + A - P;
   X >>= 16;
@@ -861,19 +838,18 @@
   *(reinterpret_cast<uint16_t*>(&pReloc.target())) = upper_inst;
   *(reinterpret_cast<uint16_t*>(&pReloc.target()) + 1) = lower_inst;
 
-  return ARMRelocationFactory::OK;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_PREL31: ((S + A) | T) - P
-ARMRelocationFactory::Result prel31(Relocation& pReloc,
-                                    ARMRelocationFactory& pParent)
+ARMRelocator::Result prel31(Relocation& pReloc, ARMRelocator& pParent)
 {
-  ARMRelocationFactory::DWord target = pReloc.target();
-  ARMRelocationFactory::DWord T = getThumbBit(pReloc);
-  ARMRelocationFactory::DWord A = helper_sign_extend(target, 31) +
+  ARMRelocator::DWord target = pReloc.target();
+  ARMRelocator::DWord T = getThumbBit(pReloc);
+  ARMRelocator::DWord A = helper_sign_extend(target, 31) +
                                   pReloc.addend();
-  ARMRelocationFactory::DWord P = pReloc.place();
-  ARMRelocationFactory::Address S;
+  ARMRelocator::DWord P = pReloc.place();
+  ARMRelocator::Address S;
 
   S = pReloc.symValue();
   // if symbol has plt
@@ -882,24 +858,22 @@
     T = 0;  // PLT is not thumb.
   }
 
-  ARMRelocationFactory::DWord X = ((S + A) | T) - P;
+  ARMRelocator::DWord X = ((S + A) | T) - P;
   pReloc.target() = helper_bit_select(target, X, 0x7fffffffU);
   if (helper_check_signed_overflow(X, 31))
-    return ARMRelocationFactory::Overflow;
-  return ARMRelocationFactory::OK;
+    return ARMRelocator::Overflow;
+  return ARMRelocator::OK;
 }
 
 // R_ARM_TLS_GD32: GOT(S) + A - P
 // R_ARM_TLS_IE32: GOT(S) + A - P
 // R_ARM_TLS_LE32: S + A - tp
-ARMRelocationFactory::Result tls(Relocation& pReloc,
-                                 ARMRelocationFactory& pParent)
+ARMRelocator::Result tls(Relocation& pReloc, ARMRelocator& pParent)
 {
-  return ARMRelocationFactory::Unsupport;
+  return ARMRelocator::Unsupport;
 }
 
-ARMRelocationFactory::Result unsupport(Relocation& pReloc,
-                                       ARMRelocationFactory& pParent)
+ARMRelocator::Result unsupport(Relocation& pReloc, ARMRelocator& pParent)
 {
-  return ARMRelocationFactory::Unsupport;
+  return ARMRelocator::Unsupport;
 }
diff --git a/lib/Target/ARM/ARMRelocationFactory.h b/lib/Target/ARM/ARMRelocator.h
similarity index 74%
rename from lib/Target/ARM/ARMRelocationFactory.h
rename to lib/Target/ARM/ARMRelocator.h
index 25135ed..0bf3653 100644
--- a/lib/Target/ARM/ARMRelocationFactory.h
+++ b/lib/Target/ARM/ARMRelocator.h
@@ -1,4 +1,4 @@
-//===-  ARMRelocationFactory.h --------------------------------------------===//
+//===-  ARMRelocator.h ----------------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -12,26 +12,26 @@
 #include <gtest.h>
 #endif
 
-#include <mcld/LD/RelocationFactory.h>
+#include <mcld/LD/Relocator.h>
 #include <mcld/Target/GOT.h>
 #include <mcld/Target/SymbolEntryMap.h>
 #include "ARMLDBackend.h"
 
 namespace mcld {
 
-/** \class ARMRelocationFactory
- *  \brief ARMRelocationFactory creates and destroys the ARM relocations.
+/** \class ARMRelocator
+ *  \brief ARMRelocator creates and destroys the ARM relocations.
  *
  */
-class ARMRelocationFactory : public RelocationFactory
+class ARMRelocator : public Relocator
 {
 public:
-  typedef SymbolEntryMap<GOT::Entry> SymGOTMap;
-  typedef SymbolEntryMap<PLT::Entry> SymPLTMap;
+  typedef SymbolEntryMap<ARMGOTEntry> SymGOTMap;
+  typedef SymbolEntryMap<ARMPLT1> SymPLTMap;
 
 public:
-  ARMRelocationFactory(size_t pNum, ARMGNULDBackend& pParent);
-  ~ARMRelocationFactory();
+  ARMRelocator(ARMGNULDBackend& pParent);
+  ~ARMRelocator();
 
   Result applyRelocation(Relocation& pRelocation);
 
diff --git a/lib/Target/ARM/Android.mk b/lib/Target/ARM/Android.mk
index f9cb356..525ac4e 100644
--- a/lib/Target/ARM/Android.mk
+++ b/lib/Target/ARM/Android.mk
@@ -9,7 +9,7 @@
   ARMLDBackend.cpp  \
   ARMMCLinker.cpp  \
   ARMPLT.cpp  \
-  ARMRelocationFactory.cpp  \
+  ARMRelocator.cpp  \
   ARMTargetMachine.cpp \
   ARMToARMStub.cpp \
   ARMToTHMStub.cpp \
diff --git a/lib/Target/ARM/README b/lib/Target/ARM/README
deleted file mode 100644
index ea88bfe..0000000
--- a/lib/Target/ARM/README
+++ /dev/null
@@ -1,2 +0,0 @@
-ARMLDBackend stands like ARMAsmBackend. It's a backend of linker, 
-and all target-dependent behavior and data are here.
diff --git a/lib/Target/Android.mk b/lib/Target/Android.mk
index e70b467..77ab932 100644
--- a/lib/Target/Android.mk
+++ b/lib/Target/Android.mk
@@ -4,6 +4,7 @@
   ELFDynamic.cpp  \
   ELFEmulation.cpp  \
   ELFMCLinker.cpp  \
+  GNUInfo.cpp \
   GNULDBackend.cpp  \
   GOT.cpp \
   OutputRelocSection.cpp  \
diff --git a/lib/Target/ELFDynamic.cpp b/lib/Target/ELFDynamic.cpp
index 25b21f0..89917cc 100644
--- a/lib/Target/ELFDynamic.cpp
+++ b/lib/Target/ELFDynamic.cpp
@@ -20,6 +20,7 @@
 
 //===----------------------------------------------------------------------===//
 // elf_dynamic::EntryIF
+//===----------------------------------------------------------------------===//
 EntryIF::EntryIF()
 {
 }
@@ -30,9 +31,11 @@
 
 //===----------------------------------------------------------------------===//
 // ELFDynamic
-ELFDynamic::ELFDynamic(const GNULDBackend& pParent)
-  : m_pEntryFactory(NULL), m_Backend(pParent), m_Idx(0) {
-  if (32 == pParent.bitclass() && pParent.isLittleEndian()) {
+//===----------------------------------------------------------------------===//
+ELFDynamic::ELFDynamic(const GNULDBackend& pParent,
+                       const LinkerConfig& pConfig)
+  : m_pEntryFactory(NULL), m_Backend(pParent), m_Config(pConfig), m_Idx(0) {
+  if (m_Config.targets().is32Bits() && m_Config.targets().isLittleEndian()) {
     m_pEntryFactory = new Entry<32, true>();
   }
   // FIXME: support big-endian and 64-bit machine.
@@ -86,13 +89,12 @@
 }
 
 /// reserveEntries - reserve entries
-void ELFDynamic::reserveEntries(const LinkerConfig& pConfig,
-                                const ELFFileFormat& pFormat)
+void ELFDynamic::reserveEntries(const ELFFileFormat& pFormat)
 {
-  if (LinkerConfig::DynObj == pConfig.codeGenType()) {
+  if (LinkerConfig::DynObj == m_Config.codeGenType()) {
     reserveOne(llvm::ELF::DT_SONAME); // DT_SONAME
 
-    if (pConfig.options().Bsymbolic())
+    if (m_Config.options().Bsymbolic())
       reserveOne(llvm::ELF::DT_SYMBOLIC); // DT_SYMBOLIC
   }
 
@@ -147,29 +149,29 @@
     reserveOne(llvm::ELF::DT_RELAENT); // DT_RELAENT
   }
 
-  if (pConfig.options().hasOrigin() ||
-      pConfig.options().Bsymbolic() ||
-      pConfig.options().hasNow()    ||
+  if (m_Config.options().hasOrigin() ||
+      m_Config.options().Bsymbolic() ||
+      m_Config.options().hasNow()    ||
       m_Backend.hasTextRel()        ||
       (m_Backend.hasStaticTLS() &&
-        (LinkerConfig::DynObj == pConfig.codeGenType()))) {
+        (LinkerConfig::DynObj == m_Config.codeGenType()))) {
     reserveOne(llvm::ELF::DT_FLAGS); // DT_FLAGS
   }
 
   if (m_Backend.hasTextRel())
     reserveOne(llvm::ELF::DT_TEXTREL); // DT_TEXTREL
 
-  if (pConfig.options().hasNow()          ||
-      pConfig.options().hasLoadFltr()     ||
-      pConfig.options().hasOrigin()       ||
-      pConfig.options().hasInterPose()    ||
-      pConfig.options().hasNoDefaultLib() ||
-      pConfig.options().hasNoDump()       ||
-      pConfig.options().Bgroup()          ||
-      ((LinkerConfig::DynObj == pConfig.codeGenType()) &&
-       (pConfig.options().hasNoDelete()  ||
-        pConfig.options().hasInitFirst() ||
-        pConfig.options().hasNoDLOpen()))) {
+  if (m_Config.options().hasNow()          ||
+      m_Config.options().hasLoadFltr()     ||
+      m_Config.options().hasOrigin()       ||
+      m_Config.options().hasInterPose()    ||
+      m_Config.options().hasNoDefaultLib() ||
+      m_Config.options().hasNoDump()       ||
+      m_Config.options().Bgroup()          ||
+      ((LinkerConfig::DynObj == m_Config.codeGenType()) &&
+       (m_Config.options().hasNoDelete()  ||
+        m_Config.options().hasInitFirst() ||
+        m_Config.options().hasNoDLOpen()))) {
     reserveOne(llvm::ELF::DT_FLAGS_1); // DT_FLAGS_1
   }
 
@@ -177,11 +179,10 @@
 }
 
 /// applyEntries - apply entries
-void ELFDynamic::applyEntries(const LinkerConfig& pConfig,
-                              const ELFFileFormat& pFormat)
+void ELFDynamic::applyEntries(const ELFFileFormat& pFormat)
 {
-  if (LinkerConfig::DynObj == pConfig.codeGenType() &&
-      pConfig.options().Bsymbolic()) {
+  if (LinkerConfig::DynObj == m_Config.codeGenType() &&
+      m_Config.options().Bsymbolic()) {
       applyOne(llvm::ELF::DT_SYMBOLIC, 0x0); // DT_SYMBOLIC
   }
 
@@ -247,48 +248,48 @@
   if (m_Backend.hasTextRel()) {
     applyOne(llvm::ELF::DT_TEXTREL, 0x0); // DT_TEXTREL
 
-    if (pConfig.options().warnSharedTextrel() &&
-        LinkerConfig::DynObj == pConfig.codeGenType())
+    if (m_Config.options().warnSharedTextrel() &&
+        LinkerConfig::DynObj == m_Config.codeGenType())
       mcld::warning(mcld::diag::warn_shared_textrel);
   }
 
   uint64_t dt_flags = 0x0;
-  if (pConfig.options().hasOrigin())
+  if (m_Config.options().hasOrigin())
     dt_flags |= llvm::ELF::DF_ORIGIN;
-  if (pConfig.options().Bsymbolic())
+  if (m_Config.options().Bsymbolic())
     dt_flags |= llvm::ELF::DF_SYMBOLIC;
-  if (pConfig.options().hasNow())
+  if (m_Config.options().hasNow())
     dt_flags |= llvm::ELF::DF_BIND_NOW;
   if (m_Backend.hasTextRel())
     dt_flags |= llvm::ELF::DF_TEXTREL;
   if (m_Backend.hasStaticTLS() &&
-      (LinkerConfig::DynObj == pConfig.codeGenType()))
+      (LinkerConfig::DynObj == m_Config.codeGenType()))
     dt_flags |= llvm::ELF::DF_STATIC_TLS;
   if (0x0 != dt_flags) {
     applyOne(llvm::ELF::DT_FLAGS, dt_flags); // DT_FLAGS
   }
 
   uint64_t dt_flags_1 = 0x0;
-  if (pConfig.options().hasNow())
+  if (m_Config.options().hasNow())
     dt_flags_1 |= llvm::ELF::DF_1_NOW;
-  if (pConfig.options().hasLoadFltr())
+  if (m_Config.options().hasLoadFltr())
     dt_flags_1 |= llvm::ELF::DF_1_LOADFLTR;
-  if (pConfig.options().hasOrigin())
+  if (m_Config.options().hasOrigin())
     dt_flags_1 |= llvm::ELF::DF_1_ORIGIN;
-  if (pConfig.options().hasInterPose())
+  if (m_Config.options().hasInterPose())
     dt_flags_1 |= llvm::ELF::DF_1_INTERPOSE;
-  if (pConfig.options().hasNoDefaultLib())
+  if (m_Config.options().hasNoDefaultLib())
     dt_flags_1 |= llvm::ELF::DF_1_NODEFLIB;
-  if (pConfig.options().hasNoDump())
+  if (m_Config.options().hasNoDump())
     dt_flags_1 |= llvm::ELF::DF_1_NODUMP;
-  if (pConfig.options().Bgroup())
+  if (m_Config.options().Bgroup())
     dt_flags_1 |= llvm::ELF::DF_1_GROUP;
-  if (LinkerConfig::DynObj == pConfig.codeGenType()) {
-    if (pConfig.options().hasNoDelete())
+  if (LinkerConfig::DynObj == m_Config.codeGenType()) {
+    if (m_Config.options().hasNoDelete())
       dt_flags_1 |= llvm::ELF::DF_1_NODELETE;
-    if (pConfig.options().hasInitFirst())
+    if (m_Config.options().hasInitFirst())
       dt_flags_1 |= llvm::ELF::DF_1_INITFIRST;
-    if (pConfig.options().hasNoDLOpen())
+    if (m_Config.options().hasNoDLOpen())
       dt_flags_1 |= llvm::ELF::DF_1_NOOPEN;
   }
   if (0x0 != dt_flags_1)
diff --git a/lib/Target/GNUInfo.cpp b/lib/Target/GNUInfo.cpp
new file mode 100644
index 0000000..75234b0
--- /dev/null
+++ b/lib/Target/GNUInfo.cpp
@@ -0,0 +1,31 @@
+//===- GNUInfo.cpp --------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Target/GNUInfo.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// GNUInfo
+//===----------------------------------------------------------------------===//
+GNUInfo::GNUInfo(const llvm::Triple& pTriple)
+  : m_Triple(pTriple) {
+}
+
+uint8_t GNUInfo::OSABI() const
+{
+  switch (m_Triple.getOS()) {
+    case llvm::Triple::FreeBSD:
+      return llvm::ELF::ELFOSABI_FREEBSD;
+    case llvm::Triple::Linux:
+      return llvm::ELF::ELFOSABI_LINUX;
+    default:
+      return llvm::ELF::ELFOSABI_NONE;
+  }
+}
+
diff --git a/lib/Target/GNULDBackend.cpp b/lib/Target/GNULDBackend.cpp
index 950ac43..590c14f 100644
--- a/lib/Target/GNULDBackend.cpp
+++ b/lib/Target/GNULDBackend.cpp
@@ -11,11 +11,14 @@
 #include <string>
 #include <cstring>
 #include <cassert>
+#include <vector>
+#include <algorithm>
 
 #include <mcld/Module.h>
 #include <mcld/LinkerConfig.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>
@@ -23,6 +26,7 @@
 #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/Fragment/FragmentLinker.h>
 #include <mcld/Support/MemoryArea.h>
@@ -52,12 +56,13 @@
 //===----------------------------------------------------------------------===//
 // GNULDBackend
 //===----------------------------------------------------------------------===//
-GNULDBackend::GNULDBackend(const LinkerConfig& pConfig)
+GNULDBackend::GNULDBackend(const LinkerConfig& pConfig, GNUInfo* pInfo)
   : TargetLDBackend(pConfig),
     m_pObjectReader(NULL),
     m_pDynObjFileFormat(NULL),
     m_pExecFileFormat(NULL),
     m_pObjectFileFormat(NULL),
+    m_pInfo(pInfo),
     m_ELFSegmentTable(9), // magic number
     m_pBRIslandFactory(NULL),
     m_pStubFactory(NULL),
@@ -89,6 +94,7 @@
 
 GNULDBackend::~GNULDBackend()
 {
+  delete m_pInfo;
   delete m_pDynObjFileFormat;
   delete m_pExecFileFormat;
   delete m_pSymIndexMap;
@@ -103,8 +109,21 @@
 
 size_t GNULDBackend::sectionStartOffset() const
 {
-  // FIXME: use fixed offset, we need 10 segments by default
-  return sizeof(llvm::ELF::Elf64_Ehdr)+10*sizeof(llvm::ELF::Elf64_Phdr);
+  if (LinkerConfig::Binary == config().codeGenType())
+    return 0x0;
+
+  switch (config().targets().bitclass()) {
+    case 32u:
+      return sizeof(llvm::ELF::Elf32_Ehdr) +
+             numOfSegments() * sizeof(llvm::ELF::Elf32_Phdr);
+    case 64u:
+      return sizeof(llvm::ELF::Elf64_Ehdr) +
+             numOfSegments() * sizeof(llvm::ELF::Elf64_Phdr);
+    default:
+      fatal(diag::unsupported_bitclass) << config().targets().triple().str()
+                                        << config().targets().bitclass();
+      return 0;
+  }
 }
 
 uint64_t GNULDBackend::segmentStartAddr(const FragmentLinker& pLinker) const
@@ -126,30 +145,40 @@
   return new GNUArchiveReader(pModule, *m_pObjectReader);
 }
 
-ELFObjectReader* GNULDBackend::createObjectReader(FragmentLinker& pLinker)
+ELFObjectReader* GNULDBackend::createObjectReader(IRBuilder& pBuilder)
 {
-  m_pObjectReader = new ELFObjectReader(*this, pLinker);
+  m_pObjectReader = new ELFObjectReader(*this, pBuilder, config());
   return m_pObjectReader;
 }
 
-ELFDynObjReader* GNULDBackend::createDynObjReader(FragmentLinker& pLinker)
+ELFDynObjReader* GNULDBackend::createDynObjReader(IRBuilder& pBuilder)
 {
-  return new ELFDynObjReader(*this, pLinker);
+  return new ELFDynObjReader(*this, pBuilder, config());
 }
 
-ELFObjectWriter* GNULDBackend::createObjectWriter(FragmentLinker& pLinker)
+ELFBinaryReader* GNULDBackend::createBinaryReader(IRBuilder& pBuilder)
 {
-  return new ELFObjectWriter(*this, pLinker);
+  return new ELFBinaryReader(*this, pBuilder, config());
 }
 
-ELFDynObjWriter* GNULDBackend::createDynObjWriter(FragmentLinker& pLinker)
+ELFObjectWriter* GNULDBackend::createObjectWriter()
 {
-  return new ELFDynObjWriter(*this, pLinker);
+  return new ELFObjectWriter(*this, config());
 }
 
-ELFExecWriter* GNULDBackend::createExecWriter(FragmentLinker& pLinker)
+ELFDynObjWriter* GNULDBackend::createDynObjWriter()
 {
-  return new ELFExecWriter(*this, pLinker);
+  return new ELFDynObjWriter(*this, config());
+}
+
+ELFExecWriter* GNULDBackend::createExecWriter()
+{
+  return new ELFExecWriter(*this, config());
+}
+
+ELFBinaryWriter* GNULDBackend::createBinaryWriter()
+{
+  return new ELFBinaryWriter(*this, config());
 }
 
 bool GNULDBackend::initStdSections(ObjectBuilder& pBuilder)
@@ -158,19 +187,23 @@
     case LinkerConfig::DynObj: {
       if (NULL == m_pDynObjFileFormat)
         m_pDynObjFileFormat = new ELFDynObjFileFormat();
-      m_pDynObjFileFormat->initStdSections(pBuilder, bitclass());
+      m_pDynObjFileFormat->initStdSections(pBuilder,
+                                           config().targets().bitclass());
       return true;
     }
-    case LinkerConfig::Exec: {
+    case LinkerConfig::Exec:
+    case LinkerConfig::Binary: {
       if (NULL == m_pExecFileFormat)
         m_pExecFileFormat = new ELFExecFileFormat();
-      m_pExecFileFormat->initStdSections(pBuilder, bitclass());
+      m_pExecFileFormat->initStdSections(pBuilder,
+                                         config().targets().bitclass());
       return true;
     }
     case LinkerConfig::Object: {
       if (NULL == m_pObjectFileFormat)
         m_pObjectFileFormat = new ELFObjectFileFormat();
-      m_pObjectFileFormat->initStdSections(pBuilder, bitclass());
+      m_pObjectFileFormat->initStdSections(pBuilder,
+                                           config().targets().bitclass());
       return true;
     }
     default:
@@ -687,6 +720,7 @@
       assert(NULL != m_pDynObjFileFormat);
       return m_pDynObjFileFormat;
     case LinkerConfig::Exec:
+    case LinkerConfig::Binary:
       assert(NULL != m_pExecFileFormat);
       return m_pExecFileFormat;
     case LinkerConfig::Object:
@@ -705,6 +739,7 @@
       assert(NULL != m_pDynObjFileFormat);
       return m_pDynObjFileFormat;
     case LinkerConfig::Exec:
+    case LinkerConfig::Binary:
       assert(NULL != m_pExecFileFormat);
       return m_pExecFileFormat;
     case LinkerConfig::Object:
@@ -758,6 +793,9 @@
   size_t shstrtab = 1;
   size_t hash   = 0;
 
+  // number of local symbol in the .dynsym
+  size_t dynsym_local_cnt = 0;
+
   /// compute the size of .symtab, .dynsym and .strtab
   /// @{
   Module::const_sym_iterator symbol;
@@ -789,6 +827,7 @@
     if (ResolveInfo::Section != (*symbol)->type())
       strtab += str_size;
   }
+  dynsym_local_cnt = dynsym;
   // compute the size of the reset of symbols
   symEnd = pModule.sym_end();
   for (symbol = symbols.tlsEnd(); symbol != symEnd; ++symbol) {
@@ -813,7 +852,8 @@
         dynstr += pModule.name().size() + 1;
     }
     /** fall through **/
-    case LinkerConfig::Exec: {
+    case LinkerConfig::Exec:
+    case LinkerConfig::Binary: {
       // add DT_NEED strings into .dynstr and .dynamic
       // Rules:
       //   1. ignore --no-add-needed
@@ -844,21 +884,28 @@
       }
 
       // set size
-      if (32 == bitclass())
+      if (config().targets().is32Bits())
         file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf32_Sym));
       else
         file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf64_Sym));
       file_format->getDynStrTab().setSize(dynstr);
       file_format->getHashTab().setSize(hash);
 
+      // set .dynsym sh_info to one greater than the symbol table
+      // index of the last local symbol
+      file_format->getDynSymTab().setInfo(dynsym_local_cnt);
     }
     /* fall through */
     case LinkerConfig::Object: {
-      if (32 == bitclass())
+      if (config().targets().is32Bits())
         file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf32_Sym));
       else
         file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf64_Sym));
       file_format->getStrTab().setSize(strtab);
+
+      // set .symtab sh_info to one greater than the symbol table
+      // index of the last local symbol
+      file_format->getSymTab().setInfo(symbols.numOfLocals() + 1);
       break;
     }
     default:
@@ -870,12 +917,13 @@
   /// reserve fixed entries in the .dynamic section.
   /// @{
   if (LinkerConfig::DynObj == config().codeGenType() ||
-      LinkerConfig::Exec == config().codeGenType()) {
+      LinkerConfig::Exec   == config().codeGenType() ||
+      LinkerConfig::Binary == config().codeGenType()) {
     // Because some entries in .dynamic section need information of .dynsym,
     // .dynstr, .symtab, .strtab and .hash, we can not reserve non-DT_NEEDED
     // entries until we get the size of the sections mentioned above
     if (!pIsStaticLink)
-      dynamic().reserveEntries(config(), *file_format);
+      dynamic().reserveEntries(*file_format);
     file_format->getDynamic().setSize(dynamic().numOfBytes());
   }
   /// @}
@@ -956,20 +1004,21 @@
   // set up symtab_region
   llvm::ELF::Elf32_Sym* symtab32 = NULL;
   llvm::ELF::Elf64_Sym* symtab64 = NULL;
-  if (32 == bitclass())
+  if (config().targets().is32Bits())
     symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start();
-  else if (64 == bitclass())
+  else if (config().targets().is64Bits())
     symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start();
-  else
-    llvm::report_fatal_error(llvm::Twine("unsupported bitclass ") +
-                             llvm::Twine(bitclass()) +
-                             llvm::Twine(".\n"));
+  else {
+    fatal(diag::unsupported_bitclass) << config().targets().triple().str()
+                                      << config().targets().bitclass();
+  }
+
   // set up strtab_region
   char* strtab = (char*)strtab_region->start();
   strtab[0] = '\0';
 
   // initialize the first ELF symbol
-  if (32 == bitclass()) {
+  if (config().targets().is32Bits()) {
     symtab32[0].st_name  = 0;
     symtab32[0].st_value = 0;
     symtab32[0].st_size  = 0;
@@ -1005,7 +1054,7 @@
       entry->setValue(symtabIdx);
     }
 
-    if (32 == bitclass())
+    if (config().targets().is32Bits())
       emitSymbol32(symtab32[symtabIdx], **symbol, strtab, strtabsize,
                    symtabIdx);
     else
@@ -1052,17 +1101,17 @@
   // set up symtab_region
   llvm::ELF::Elf32_Sym* symtab32 = NULL;
   llvm::ELF::Elf64_Sym* symtab64 = NULL;
-  if (32 == bitclass())
+  if (config().targets().is32Bits())
     symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start();
-  else if (64 == bitclass())
+  else if (config().targets().is64Bits())
     symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start();
-  else
-    llvm::report_fatal_error(llvm::Twine("unsupported bitclass ") +
-                             llvm::Twine(bitclass()) +
-                             llvm::Twine(".\n"));
+  else {
+    fatal(diag::unsupported_bitclass) << config().targets().triple().str()
+                                      << config().targets().bitclass();
+  }
 
   // initialize the first ELF symbol
-  if (32 == bitclass()) {
+  if (config().targets().is32Bits()) {
     symtab32[0].st_name  = 0;
     symtab32[0].st_value = 0;
     symtab32[0].st_size  = 0;
@@ -1098,7 +1147,7 @@
     if (!isDynamicSymbol(**symbol))
       continue;
 
-    if (32 == bitclass())
+    if (config().targets().is32Bits())
       emitSymbol32(symtab32[symtabIdx], **symbol, strtab, strtabsize,
                    symtabIdx);
     else
@@ -1117,7 +1166,7 @@
   // emit symbols in TLS category, all symbols in TLS category shold be emitited
   symEnd = symbols.tlsEnd();
   for (symbol = symbols.tlsBegin(); symbol != symEnd; ++symbol) {
-    if (32 == bitclass())
+    if (config().targets().is32Bits())
       emitSymbol32(symtab32[symtabIdx], **symbol, strtab, strtabsize,
                    symtabIdx);
     else
@@ -1139,7 +1188,7 @@
     if (!isDynamicSymbol(**symbol))
       continue;
 
-    if (32 == bitclass())
+    if (config().targets().is32Bits())
       emitSymbol32(symtab32[symtabIdx], **symbol, strtab, strtabsize,
                    symtabIdx);
     else
@@ -1188,7 +1237,7 @@
     // set pointer to SONAME entry in dynamic string table.
     dynamic().applySoname(strtabsize);
   }
-  dynamic().applyEntries(config(), *file_format);
+  dynamic().applyEntries(*file_format);
   dynamic().emit(dyn_sect, *dyn_region);
 
   // emit soname
@@ -1217,7 +1266,7 @@
 
   StringHash<ELF> hash_func;
 
-  if (32 == bitclass()) {
+  if (config().targets().is32Bits()) {
     for (size_t sym_idx=0; sym_idx < symtabIdx; ++sym_idx) {
       llvm::StringRef name(strtab + symtab32[sym_idx].st_name);
       size_t bucket_pos = hash_func(name) % nbucket;
@@ -1225,7 +1274,7 @@
       bucket[bucket_pos] = sym_idx;
     }
   }
-  else if (64 == bitclass()) {
+  else if (config().targets().is64Bits()) {
     for (size_t sym_idx=0; sym_idx < symtabIdx; ++sym_idx) {
       llvm::StringRef name(strtab + symtab64[sym_idx].st_name);
       size_t bucket_pos = hash_func(name) % nbucket;
@@ -1301,9 +1350,9 @@
               &pSectHdr == &file_format->getCtors() ||
               &pSectHdr == &file_format->getDtors() ||
               &pSectHdr == &file_format->getJCR() ||
-              0 == pSectHdr.name().compare(".data.rel.ro"))
+              &pSectHdr == &file_format->getDataRelRo())
             return SHO_RELRO;
-          if (0 == pSectHdr.name().compare(".data.rel.ro.local"))
+          if (&pSectHdr == &file_format->getDataRelRoLocal())
             return SHO_RELRO_LOCAL;
         }
         if ((pSectHdr.flag() & llvm::ELF::SHF_TLS) != 0x0) {
@@ -1374,8 +1423,9 @@
     bind = llvm::ELF::STB_GLOBAL;
   }
 
-  if (pSymbol.visibility() == llvm::ELF::STV_INTERNAL ||
-      pSymbol.visibility() == llvm::ELF::STV_HIDDEN)
+  if (config().codeGenType() != LinkerConfig::Object &&
+      (pSymbol.visibility() == llvm::ELF::STV_INTERNAL ||
+      pSymbol.visibility() == llvm::ELF::STV_HIDDEN))
     bind = llvm::ELF::STB_LOCAL;
 
   uint32_t type = pSymbol.resolveInfo()->type();
@@ -1660,7 +1710,7 @@
     // update PT_PHDR
     if (llvm::ELF::PT_PHDR == segment.type()) {
       uint64_t offset, phdr_size;
-      if (32 == bitclass()) {
+      if (config().targets().is32Bits()) {
         offset = sizeof(llvm::ELF::Elf32_Ehdr);
         phdr_size = sizeof(llvm::ELF::Elf32_Phdr);
       }
@@ -1673,7 +1723,7 @@
       segment.setPaddr(segment.vaddr());
       segment.setFilesz(numOfSegments() * phdr_size);
       segment.setMemsz(numOfSegments() * phdr_size);
-      segment.setAlign(bitclass() / 8);
+      segment.setAlign(config().targets().bitclass() / 8);
       continue;
     }
 
@@ -1859,16 +1909,18 @@
     if (mapping != config().scripts().addressMap().end()) {
       // check address mapping
       start_addr = mapping.getEntry()->value();
-      const uint64_t remainder = start_addr % abiPageSize();
-      if (remainder != (*seg).front()->offset() % abiPageSize()) {
-        uint64_t padding = abiPageSize() + remainder -
-                           (*seg).front()->offset() % abiPageSize();
-        setOutputSectionOffset(pModule,
-                               pModule.begin() + (*seg).front()->index(),
-                               pModule.end(),
-                               (*seg).front()->offset() + padding);
-        if (config().options().hasRelro())
-          setupRelro(pModule);
+      if ((*seg).front()->kind() != LDFileFormat::Null) {
+        const uint64_t remainder = start_addr % abiPageSize();
+        if (remainder != (*seg).front()->offset() % abiPageSize()) {
+          uint64_t padding = abiPageSize() + remainder -
+                             (*seg).front()->offset() % abiPageSize();
+          setOutputSectionOffset(pModule,
+                                 pModule.begin() + (*seg).front()->index(),
+                                 pModule.end(),
+                                 (*seg).front()->offset() + padding);
+          if (config().options().hasRelro())
+            setupRelro(pModule);
+        }
       }
     }
     else {
@@ -1910,6 +1962,75 @@
   }
 }
 
+/// layout - layout method
+void GNULDBackend::layout(Module& pModule, FragmentLinker& pLinker)
+{
+  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
+  for (Module::iterator it = pModule.begin(), ie = pModule.end(); it != ie;
+       ++it) {
+    switch ((*it)->kind()) {
+      // take NULL and StackNote directly
+      case LDFileFormat::Null:
+      case LDFileFormat::StackNote:
+        output_list.push_back(std::make_pair(*it, getSectionOrder(**it)));
+        break;
+      // ignore if section size is 0
+      case LDFileFormat::Regular:
+      case LDFileFormat::Target:
+      case LDFileFormat::MetaData:
+      case LDFileFormat::BSS:
+      case LDFileFormat::Debug:
+      case LDFileFormat::EhFrame:
+      case LDFileFormat::GCCExceptTable:
+      case LDFileFormat::NamePool:
+      case LDFileFormat::Relocation:
+      case LDFileFormat::Note:
+      case LDFileFormat::EhFrameHdr:
+        if (0 != (*it)->size()) {
+          output_list.push_back(std::make_pair(*it, getSectionOrder(**it)));
+        }
+        break;
+      case LDFileFormat::Group:
+        if (LinkerConfig::Object == config().codeGenType()) {
+          //TODO: support incremental linking
+          ;
+        }
+        break;
+      case LDFileFormat::Version:
+        if (0 != (*it)->size()) {
+          output_list.push_back(std::make_pair(*it, getSectionOrder(**it)));
+          warning(diag::warn_unsupported_symbolic_versioning) << (*it)->name();
+        }
+        break;
+      default:
+        if (0 != (*it)->size()) {
+          error(diag::err_unsupported_section) << (*it)->name() << (*it)->kind();
+        }
+        break;
+    }
+  } // end of for
+
+  // 2. sort output section orders
+  std::stable_sort(output_list.begin(), output_list.end(), SHOCompare());
+
+  // 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);
+  }
+
+  // 4. create program headers
+  if (LinkerConfig::Object != config().codeGenType()) {
+    createProgramHdrs(pModule, pLinker);
+  }
+
+  // 5. set output section offset
+  setOutputSectionOffset(pModule, pModule.begin(), pModule.end(), 0x0);
+}
+
 /// preLayout - Backend can do any needed modification before layout
 void GNULDBackend::preLayout(Module& pModule, FragmentLinker& pLinker)
 {
@@ -1970,10 +2091,10 @@
         RelocData* out_reloc_data = output_sect->getRelocData();
 
         // move relocations from input's to output's RelcoationData
-        RelocData::FragmentListType& out_list =
-                                             out_reloc_data->getFragmentList();
-        RelocData::FragmentListType& in_list =
-                                      (*rs)->getRelocData()->getFragmentList();
+        RelocData::RelocationListType& out_list =
+                                             out_reloc_data->getRelocationList();
+        RelocData::RelocationListType& in_list =
+                                      (*rs)->getRelocData()->getRelocationList();
         out_list.splice(out_list.end(), in_list);
 
         // size output
@@ -1997,25 +2118,20 @@
 void GNULDBackend::postLayout(Module& pModule,
                               FragmentLinker& pLinker)
 {
-  // 1. emit program headers
-  if (LinkerConfig::Object != config().codeGenType()) {
-    // 1.1 create program headers
-    createProgramHdrs(pModule, pLinker);
-  }
-
+  // 1. set up section address and segment attributes
   if (LinkerConfig::Object != config().codeGenType()) {
     if (config().options().hasRelro()) {
-      // 1.2 set up the offset constraint of PT_RELRO
+      // 1.1 set up the offset constraint of PT_RELRO
       setupRelro(pModule);
     }
 
-    // 1.3 set up the output sections' address
+    // 1.2 set up the output sections' address
     setOutputSectionAddress(pLinker, pModule, pModule.begin(), pModule.end());
 
-    // 1.4 do relaxation
+    // 1.3 do relaxation
     relax(pModule, pLinker);
 
-    // 1.5 set up the attributes of program headers
+    // 1.4 set up the attributes of program headers
     setupProgramHdrs(pLinker);
   }
 
@@ -2027,7 +2143,7 @@
 {
   if (config().options().hasEhFrameHdr() && getOutputFormat()->hasEhFrame()) {
     // emit eh_frame_hdr
-    if (bitclass() == 32)
+    if (config().targets().is32Bits())
       m_pEhFrameHdr->emitOutput<32>(pOutput);
   }
 }
@@ -2070,9 +2186,11 @@
   // If we are building shared object, and the visibility is external, we
   // need to add it.
   if (LinkerConfig::DynObj == config().codeGenType() ||
-      LinkerConfig::Exec == config().codeGenType()) {
+      LinkerConfig::Exec   == config().codeGenType() ||
+      LinkerConfig::Binary == config().codeGenType()) {
     if (pSymbol.resolveInfo()->visibility() == ResolveInfo::Default ||
-        pSymbol.resolveInfo()->visibility() == ResolveInfo::Protected) {
+        pSymbol.resolveInfo()->visibility() == ResolveInfo::Protected ||
+        pSymbol.resolveInfo()->type() == ResolveInfo::ThreadLocal) {
       return true;
     }
   }
@@ -2091,9 +2209,11 @@
   // If we are building shared object, and the visibility is external, we
   // need to add it.
   if (LinkerConfig::DynObj == config().codeGenType() ||
-      LinkerConfig::Exec == config().codeGenType()) {
+      LinkerConfig::Exec   == config().codeGenType() ||
+      LinkerConfig::Binary == config().codeGenType()) {
     if (pResolveInfo.visibility() == ResolveInfo::Default ||
-        pResolveInfo.visibility() == ResolveInfo::Protected) {
+        pResolveInfo.visibility() == ResolveInfo::Protected ||
+        pResolveInfo.type() == ResolveInfo::ThreadLocal) {
       return true;
     }
   }
@@ -2160,7 +2280,8 @@
   // resolved to 0 and no need a dynamic relocation
   if (pSym.isUndef() &&
       !pSym.isDyn() &&
-      LinkerConfig::Exec == config().codeGenType())
+      (LinkerConfig::Exec   == config().codeGenType() ||
+       LinkerConfig::Binary == config().codeGenType()))
     return false;
 
   if (pSym.isAbsolute())
@@ -2214,7 +2335,9 @@
 {
   // if the output is pic code or if not executables, symbols' value may change
   // at runtime
-  if (pLinker.isOutputPIC() || LinkerConfig::Exec != config().codeGenType())
+  if (pLinker.isOutputPIC() ||
+      (LinkerConfig::Exec != config().codeGenType() &&
+       LinkerConfig::Binary != config().codeGenType()))
     return false;
 
   // if the symbol is from dynamic object, then its value is unknown
diff --git a/lib/Target/GOT.cpp b/lib/Target/GOT.cpp
index 32afdff..a441775 100644
--- a/lib/Target/GOT.cpp
+++ b/lib/Target/GOT.cpp
@@ -19,25 +19,10 @@
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
-// GOT::Entry
-//===----------------------------------------------------------------------===//
-GOT::Entry::Entry(uint64_t pContent, size_t pEntrySize, SectionData* pParent)
-  : TargetFragment(Fragment::Target, pParent),
-    f_Content(pContent),
-    m_EntrySize(pEntrySize) {
-}
-
-GOT::Entry::~Entry()
-{
-}
-
-//===----------------------------------------------------------------------===//
 // GOT
 //===----------------------------------------------------------------------===//
-GOT::GOT(LDSection& pSection, size_t pEntrySize)
-  : m_Section(pSection),
-    f_EntrySize(pEntrySize),
-    m_pLast(NULL) {
+GOT::GOT(LDSection& pSection)
+  : m_Section(pSection) {
   m_SectionData = IRBuilder::CreateSectionData(pSection);
 }
 
@@ -45,39 +30,15 @@
 {
 }
 
-size_t GOT::getEntrySize() const
-{
-  return f_EntrySize;
-}
-
-void GOT::reserve(size_t pNum)
-{
-  for (size_t i = 0; i < pNum; i++) {
-    new Entry(0, f_EntrySize, m_SectionData);
-  }
-}
-
-GOT::Entry* GOT::consume()
-{
-  if (NULL == m_pLast) {
-    assert(!empty() && "Consume empty GOT entry!");
-    m_pLast = llvm::cast<Entry>(&m_SectionData->front());
-    return m_pLast;
-  }
-
-  m_pLast = llvm::cast<Entry>(m_pLast->getNextNode());
-  return m_pLast;
-}
-
 void GOT::finalizeSectionSize()
 {
-  m_Section.setSize(m_SectionData->size() * f_EntrySize);
-
   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();
   }
+
+  m_Section.setSize(offset);
 }
 
diff --git a/lib/Target/Mips/Android.mk b/lib/Target/Mips/Android.mk
index dd3905d..2410f6f 100644
--- a/lib/Target/Mips/Android.mk
+++ b/lib/Target/Mips/Android.mk
@@ -8,7 +8,7 @@
   MipsGOT.cpp \
   MipsLDBackend.cpp \
   MipsMCLinker.cpp \
-  MipsRelocationFactory.cpp \
+  MipsRelocator.cpp \
   MipsTargetMachine.cpp
 
 # For the host
diff --git a/lib/Target/Mips/MipsELFDynamic.cpp b/lib/Target/Mips/MipsELFDynamic.cpp
index fd779f3..58ed7a5 100644
--- a/lib/Target/Mips/MipsELFDynamic.cpp
+++ b/lib/Target/Mips/MipsELFDynamic.cpp
@@ -6,11 +6,11 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include "MipsELFDynamic.h"
 
+#include "MipsLDBackend.h"
 #include <mcld/LD/ELFFileFormat.h>
 #include <mcld/Target/GNULDBackend.h>
-#include "MipsELFDynamic.h"
-#include "MipsLDBackend.h"
 
 using namespace mcld;
 
@@ -24,8 +24,9 @@
   MIPS_GOTSYM       = 0x70000013
 };
 
-MipsELFDynamic::MipsELFDynamic(const MipsGNULDBackend& pParent)
-  : ELFDynamic(pParent),
+MipsELFDynamic::MipsELFDynamic(const MipsGNULDBackend& pParent,
+                               const LinkerConfig& pConfig)
+  : ELFDynamic(pParent, pConfig),
     m_pParent(pParent)
 {
 }
diff --git a/lib/Target/Mips/MipsELFDynamic.h b/lib/Target/Mips/MipsELFDynamic.h
index 118e4f9..6efbf71 100644
--- a/lib/Target/Mips/MipsELFDynamic.h
+++ b/lib/Target/Mips/MipsELFDynamic.h
@@ -21,7 +21,7 @@
 class MipsELFDynamic : public ELFDynamic
 {
 public:
-  MipsELFDynamic(const MipsGNULDBackend& pParent);
+  MipsELFDynamic(const MipsGNULDBackend& pParent, const LinkerConfig& pConfig);
   ~MipsELFDynamic();
 
 private:
diff --git a/lib/Target/Mips/MipsEmulation.cpp b/lib/Target/Mips/MipsEmulation.cpp
index 74f2637..845e1a5 100644
--- a/lib/Target/Mips/MipsEmulation.cpp
+++ b/lib/Target/Mips/MipsEmulation.cpp
@@ -18,6 +18,10 @@
   if (!MCLDEmulateELF(pConfig))
     return false;
 
+  // set up bitclass and endian
+  pConfig.targets().setEndian(TargetOptions::Little);
+  pConfig.targets().setBitClass(32);
+
   // set up target-dependent constraints of attributes
   pConfig.attribute().constraint().enableWholeArchive();
   pConfig.attribute().constraint().enableAsNeeded();
diff --git a/lib/Target/Mips/MipsGNUInfo.h b/lib/Target/Mips/MipsGNUInfo.h
new file mode 100644
index 0000000..9bbc548
--- /dev/null
+++ b/lib/Target/Mips/MipsGNUInfo.h
@@ -0,0 +1,29 @@
+//===- MipsGNUInfo.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_GNU_INFO_H
+#define MCLD_TARGET_MIPS_GNU_INFO_H
+#include <mcld/Target/GNUInfo.h>
+
+#include <llvm/Support/ELF.h>
+
+namespace mcld {
+
+class MipsGNUInfo : public GNUInfo
+{
+public:
+  MipsGNUInfo(const llvm::Triple& pTriple) : GNUInfo(pTriple) { }
+
+  uint32_t machine() const { return llvm::ELF::EM_MIPS; }
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/lib/Target/Mips/MipsGOT.cpp b/lib/Target/Mips/MipsGOT.cpp
index b4eb1cd..d18eebf 100644
--- a/lib/Target/Mips/MipsGOT.cpp
+++ b/lib/Target/Mips/MipsGOT.cpp
@@ -16,7 +16,6 @@
 #include <mcld/Support/MsgHandling.h>
 
 namespace {
-  const size_t MipsGOTEntrySize = 4;
   const size_t MipsGOT0Num = 1;
 }
 
@@ -26,8 +25,9 @@
 // MipsGOT
 //===----------------------------------------------------------------------===//
 MipsGOT::MipsGOT(LDSection& pSection)
-  : GOT(pSection, MipsGOTEntrySize),
-    m_pLocalNum(0)
+  : GOT(pSection),
+    m_pLocalNum(0),
+    m_pLast(NULL)
 {
   // Create GOT0 entries.
   reserve(MipsGOT0Num);
@@ -47,6 +47,25 @@
   m_pLocalNum = MipsGOT0Num;
 }
 
+void MipsGOT::reserve(size_t pNum)
+{
+  for (size_t i = 0; i < pNum; i++) {
+    new MipsGOTEntry(0, m_SectionData);
+  }
+}
+
+MipsGOTEntry* MipsGOT::consume()
+{
+  if (NULL == m_pLast) {
+    assert(!empty() && "Consume empty GOT entry!");
+    m_pLast = llvm::cast<MipsGOTEntry>(&m_SectionData->front());
+    return m_pLast;
+  }
+
+  m_pLast = llvm::cast<MipsGOTEntry>(m_pLast->getNextNode());
+  return m_pLast;
+}
+
 bool MipsGOT::hasGOT1() const
 {
   return (m_SectionData->size() > MipsGOT0Num);
@@ -56,14 +75,12 @@
 {
   uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
 
-  size_t entry_size = getEntrySize();
-
   uint64_t result = 0;
   for (iterator it = begin(), ie = end();
        it != ie; ++it, ++buffer) {
-    GOT::Entry* got = &(llvm::cast<GOT::Entry>((*it)));
-    *buffer = static_cast<uint32_t>(got->getContent());
-    result += entry_size;
+    MipsGOTEntry* got = &(llvm::cast<MipsGOTEntry>((*it)));
+    *buffer = static_cast<uint32_t>(got->getValue());
+    result += got->size();
   }
   return result;
 }
@@ -83,22 +100,22 @@
   reserve(1);
 }
 
-GOT::Entry* MipsGOT::consumeLocal()
+MipsGOTEntry* MipsGOT::consumeLocal()
 {
   iterator& it = m_LocalGOTIterator;
   ++it;
   assert(it != m_SectionData->getFragmentList().end() &&
          "The number of GOT Entries and ResolveInfo doesn't match");
-  return llvm::cast<GOT::Entry>(&(*it));
+  return llvm::cast<MipsGOTEntry>(&(*it));
 }
 
-GOT::Entry* MipsGOT::consumeGlobal()
+MipsGOTEntry* MipsGOT::consumeGlobal()
 {
   iterator& it = m_GlobalGOTIterator;
   ++it;
   assert(it != m_SectionData->getFragmentList().end() &&
          "The number of GOT Entries and ResolveInfo doesn't match");
-  return llvm::cast<GOT::Entry>(&(*it));
+  return llvm::cast<MipsGOTEntry>(&(*it));
 }
 
 size_t MipsGOT::getTotalNum() const
diff --git a/lib/Target/Mips/MipsGOT.h b/lib/Target/Mips/MipsGOT.h
index 6ec4926..fa46e91 100644
--- a/lib/Target/Mips/MipsGOT.h
+++ b/lib/Target/Mips/MipsGOT.h
@@ -21,6 +21,17 @@
 class LDSection;
 class MemoryRegion;
 
+/** \class MipsGOTEntry
+ *  \brief GOT Entry with size of 4 bytes
+ */
+class MipsGOTEntry : public GOT::Entry<4>
+{
+public:
+  MipsGOTEntry(uint64_t pContent, SectionData* pParent)
+   : GOT::Entry<4>(pContent, pParent)
+  {}
+};
+
 /** \class MipsGOT
  *  \brief Mips Global Offset Table.
  */
@@ -31,14 +42,16 @@
 
   uint64_t emit(MemoryRegion& pRegion);
 
+  void reserve(size_t pNum = 1);
   void reserveLocalEntry();
   void reserveGlobalEntry();
 
   size_t getTotalNum() const;
   size_t getLocalNum() const;
 
-  GOT::Entry* consumeLocal();
-  GOT::Entry* consumeGlobal();
+  MipsGOTEntry* consume();
+  MipsGOTEntry* consumeLocal();
+  MipsGOTEntry* consumeGlobal();
 
   void setLocal(const ResolveInfo* pInfo) {
     m_GOTTypeMap[pInfo] = false;
@@ -68,6 +81,8 @@
   iterator m_LocalGOTIterator;  // last local GOT entries
   iterator m_GlobalGOTIterator; // last global GOT entries
   size_t m_pLocalNum;
+
+  MipsGOTEntry* m_pLast; ///< the last consumed entry
 };
 
 } // namespace of mcld
diff --git a/lib/Target/Mips/MipsLDBackend.cpp b/lib/Target/Mips/MipsLDBackend.cpp
index da2399e..59b8d18 100644
--- a/lib/Target/Mips/MipsLDBackend.cpp
+++ b/lib/Target/Mips/MipsLDBackend.cpp
@@ -7,9 +7,10 @@
 //
 //===----------------------------------------------------------------------===//
 #include "Mips.h"
+#include "MipsGNUInfo.h"
 #include "MipsELFDynamic.h"
 #include "MipsLDBackend.h"
-#include "MipsRelocationFactory.h"
+#include "MipsRelocator.h"
 
 #include <llvm/ADT/Triple.h>
 #include <llvm/Support/ELF.h>
@@ -43,9 +44,10 @@
 //===----------------------------------------------------------------------===//
 // MipsGNULDBackend
 //===----------------------------------------------------------------------===//
-MipsGNULDBackend::MipsGNULDBackend(const LinkerConfig& pConfig)
-  : GNULDBackend(pConfig),
-    m_pRelocFactory(NULL),
+MipsGNULDBackend::MipsGNULDBackend(const LinkerConfig& pConfig,
+                                   MipsGNUInfo* pInfo)
+  : GNULDBackend(pConfig, pInfo),
+    m_pRelocator(NULL),
     m_pGOT(NULL),
     m_pRelDyn(NULL),
     m_pDynamic(NULL),
@@ -56,7 +58,7 @@
 
 MipsGNULDBackend::~MipsGNULDBackend()
 {
-  delete m_pRelocFactory;
+  delete m_pRelocator;
   delete m_pGOT;
   delete m_pRelDyn;
   delete m_pDynamic;
@@ -73,9 +75,7 @@
 
     // initialize .rel.dyn
     LDSection& reldyn = file_format->getRelDyn();
-    m_pRelDyn = new OutputRelocSection(pModule,
-                                       reldyn,
-                                       getRelEntrySize());
+    m_pRelDyn = new OutputRelocSection(pModule, reldyn);
   }
 }
 
@@ -110,19 +110,19 @@
   }
 }
 
-bool MipsGNULDBackend::initRelocFactory(const FragmentLinker& pLinker)
+bool MipsGNULDBackend::initRelocator(const FragmentLinker& pLinker)
 {
-  if (NULL == m_pRelocFactory) {
-    m_pRelocFactory = new MipsRelocationFactory(1024, *this);
-    m_pRelocFactory->setFragmentLinker(pLinker);
+  if (NULL == m_pRelocator) {
+    m_pRelocator = new MipsRelocator(*this);
+    m_pRelocator->setFragmentLinker(pLinker);
   }
   return true;
 }
 
-RelocationFactory* MipsGNULDBackend::getRelocFactory()
+Relocator* MipsGNULDBackend::getRelocator()
 {
-  assert(NULL != m_pRelocFactory);
-  return m_pRelocFactory;
+  assert(NULL != m_pRelocator);
+  return m_pRelocator;
 }
 
 void MipsGNULDBackend::scanRelocation(Relocation& pReloc,
@@ -156,7 +156,7 @@
 
   // check if we shoule issue undefined reference for the relocation target
   // symbol
-  if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak())
+  if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
     fatal(diag::undefined_reference) << rsym->name();
 
   if ((rsym->reserved() & ReserveRel) != 0x0) {
@@ -165,21 +165,6 @@
   }
 }
 
-uint32_t MipsGNULDBackend::machine() const
-{
-  return llvm::ELF::EM_MIPS;
-}
-
-uint8_t MipsGNULDBackend::OSABI() const
-{
-  return llvm::ELF::ELFOSABI_NONE;
-}
-
-uint8_t MipsGNULDBackend::ABIVersion() const
-{
-  return 0;
-}
-
 uint64_t MipsGNULDBackend::flags() const
 {
   // TODO: (simon) The correct flag's set depend on command line
@@ -191,17 +176,6 @@
          E_MIPS_ABI_O32;
 }
 
-bool MipsGNULDBackend::isLittleEndian() const
-{
-  // Now we support little endian (mipsel) target only.
-  return true;
-}
-
-unsigned int MipsGNULDBackend::bitclass() const
-{
-  return 32;
-}
-
 uint64_t MipsGNULDBackend::defaultTextSegmentAddr() const
 {
   return 0x80000;
@@ -227,9 +201,11 @@
       defineGOTSymbol(pLinker);
     }
 
+    ELFFileFormat* file_format = getOutputFormat();
     // set .rel.dyn size
     if (!m_pRelDyn->empty())
-      m_pRelDyn->finalizeSectionSize();
+      file_format->getRelDyn().setSize(
+                                  m_pRelDyn->numOfRelocs() * getRelEntrySize());
   }
 }
 void MipsGNULDBackend::doPostLayout(Module& pModule,
@@ -242,7 +218,7 @@
 MipsELFDynamic& MipsGNULDBackend::dynamic()
 {
   if (NULL == m_pDynamic)
-    m_pDynamic = new MipsELFDynamic(*this);
+    m_pDynamic = new MipsELFDynamic(*this, config());
 
   return *m_pDynamic;
 }
@@ -298,6 +274,9 @@
   size_t shstrtab = 1;
   size_t hash   = 0;
 
+  // number of local symbol in the .dynsym
+  size_t dynsym_local_cnt = 0;
+
   /// compute the size of .symtab, .dynsym and .strtab
   /// @{
   Module::const_sym_iterator symbol;
@@ -329,6 +308,7 @@
     if (ResolveInfo::Section != (*symbol)->type() || *symbol == m_pGpDispSymbol)
       strtab += str_size;
   }
+  dynsym_local_cnt = dynsym;
   // compute the size of the reset of symbols
   symEnd = pModule.sym_end();
   for (symbol = symbols.tlsEnd(); symbol != symEnd; ++symbol) {
@@ -384,21 +364,28 @@
       }
 
       // set size
-      if (32 == bitclass())
+      if (config().targets().is32Bits())
         file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf32_Sym));
       else
         file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf64_Sym));
       file_format->getDynStrTab().setSize(dynstr);
       file_format->getHashTab().setSize(hash);
 
+      // set .dynsym sh_info to one greater than the symbol table
+      // index of the last local symbol
+      file_format->getDynSymTab().setInfo(dynsym_local_cnt);
     }
     /* fall through */
     case LinkerConfig::Object: {
-      if (32 == bitclass())
+      if (config().targets().is32Bits())
         file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf32_Sym));
       else
         file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf64_Sym));
       file_format->getStrTab().setSize(strtab);
+
+      // set .symtab sh_info to one greater than the symbol table
+      // index of the last local symbol
+      file_format->getSymTab().setInfo(symbols.numOfLocals() + 1);
       break;
     }
     default: {
@@ -415,7 +402,7 @@
     // Because some entries in .dynamic section need information of .dynsym,
     // .dynstr, .symtab, .strtab and .hash, we can not reserve non-DT_NEEDED
     // entries until we get the size of the sections mentioned above
-    dynamic().reserveEntries(config(), *file_format);
+    dynamic().reserveEntries(*file_format);
     file_format->getDynamic().setSize(dynamic().numOfBytes());
   }
   /// @}
@@ -630,7 +617,7 @@
   // initialize value of ELF .dynamic section
   if (LinkerConfig::DynObj == config().codeGenType())
     dynamic().applySoname(strtabsize);
-  dynamic().applyEntries(config(), *file_format);
+  dynamic().applyEntries(*file_format);
   dynamic().emit(dyn_sect, *dyn_region);
 
   strcpy((strtab + strtabsize), pModule.name().c_str());
@@ -823,7 +810,7 @@
         // section if the symbol section flags contains SHF_EXECINSTR.
         // 1. Find the reason of this condition.
         // 2. Check this condition here.
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         rsym->setReserved(rsym->reserved() | ReserveRel);
 
         // Remeber this rsym is a local GOT entry (as if it needs an entry).
@@ -927,7 +914,7 @@
     case llvm::ELF::R_MIPS_HI16:
     case llvm::ELF::R_MIPS_LO16:
       if (symbolNeedsDynRel(pLinker, *rsym, false, true)) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         rsym->setReserved(rsym->reserved() | ReserveRel);
 
         // Remeber this rsym is a global GOT entry (as if it needs an entry).
@@ -1038,13 +1025,13 @@
 static TargetLDBackend* createMipsLDBackend(const llvm::Target& pTarget,
                                             const LinkerConfig& pConfig)
 {
-  if (pConfig.triple().isOSDarwin()) {
+  if (pConfig.targets().triple().isOSDarwin()) {
     assert(0 && "MachO linker is not supported yet");
   }
-  if (pConfig.triple().isOSWindows()) {
+  if (pConfig.targets().triple().isOSWindows()) {
     assert(0 && "COFF linker is not supported yet");
   }
-  return new MipsGNULDBackend(pConfig);
+  return new MipsGNULDBackend(pConfig, new MipsGNUInfo(pConfig.targets().triple()));
 }
 
 //===----------------------------------------------------------------------===//
diff --git a/lib/Target/Mips/MipsLDBackend.h b/lib/Target/Mips/MipsLDBackend.h
index b6adb93..b9db410 100644
--- a/lib/Target/Mips/MipsLDBackend.h
+++ b/lib/Target/Mips/MipsLDBackend.h
@@ -19,6 +19,7 @@
 class OutputRelocSection;
 class SectionMap;
 class MemoryArea;
+class MipsGNUInfo;
 
 //===----------------------------------------------------------------------===//
 /// MipsGNULDBackend - linker backend of Mips target of GNU ELF format
@@ -34,7 +35,7 @@
   };
 
 public:
-  MipsGNULDBackend(const LinkerConfig& pConfig);
+  MipsGNULDBackend(const LinkerConfig& pConfig, MipsGNUInfo* pInfo);
   ~MipsGNULDBackend();
 
 public:
@@ -44,11 +45,11 @@
   /// initTargetSymbols - initialize target dependent symbols in output.
   void initTargetSymbols(FragmentLinker& pLinker);
 
-  /// initRelocFactory - create and initialize RelocationFactory.
-  bool initRelocFactory(const FragmentLinker& pLinker);
+  /// initRelocator - create and initialize Relocator.
+  bool initRelocator(const FragmentLinker& pLinker);
 
-  /// getRelocFactory - return relocation factory.
-  RelocationFactory* getRelocFactory();
+  /// getRelocator - return relocator.
+  Relocator* getRelocator();
 
   /// scanRelocation - determine the empty entries are needed or not and
   /// create the empty entries if needed.
@@ -58,21 +59,9 @@
                       Module& pModule,
                       const LDSection& pSection);
 
-  uint32_t machine() const;
-
-  /// OSABI - the value of e_ident[EI_OSABI]
-  uint8_t OSABI() const;
-
-  /// ABIVersion - the value of e_ident[EI_ABIVRESION]
-  uint8_t ABIVersion() const;
-
   /// flags - the value of ElfXX_Ehdr::e_flags
   uint64_t flags() const;
 
-  bool isLittleEndian() const;
-
-  unsigned int bitclass() const;
-
   uint64_t defaultTextSegmentAddr() const;
 
   /// abiPageSize - the abi page size of the target machine
@@ -159,7 +148,7 @@
                                    const FragmentLinker& pLinker);
 
 private:
-  RelocationFactory* m_pRelocFactory;
+  Relocator* m_pRelocator;
 
   MipsGOT* m_pGOT;                      // .got
   OutputRelocSection* m_pRelDyn;        // .rel.dyn
diff --git a/lib/Target/Mips/MipsRelocationFunctions.h b/lib/Target/Mips/MipsRelocationFunctions.h
index adff43f..aad708e 100644
--- a/lib/Target/Mips/MipsRelocationFunctions.h
+++ b/lib/Target/Mips/MipsRelocationFunctions.h
@@ -8,8 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #define DECL_MIPS_APPLY_RELOC_FUNC(Name) \
-static MipsRelocationFactory::Result Name(Relocation& pEntry, \
-                                          MipsRelocationFactory& pParent);
+static MipsRelocator::Result Name(Relocation& pEntry, \
+                                  MipsRelocator& pParent);
 
 #define DECL_MIPS_APPLY_RELOC_FUNCS \
 DECL_MIPS_APPLY_RELOC_FUNC(none) \
@@ -18,7 +18,9 @@
 DECL_MIPS_APPLY_RELOC_FUNC(lo16) \
 DECL_MIPS_APPLY_RELOC_FUNC(got16) \
 DECL_MIPS_APPLY_RELOC_FUNC(call16) \
-DECL_MIPS_APPLY_RELOC_FUNC(gprel32)
+DECL_MIPS_APPLY_RELOC_FUNC(gprel32) \
+DECL_MIPS_APPLY_RELOC_FUNC(gothi16) \
+DECL_MIPS_APPLY_RELOC_FUNC(gotlo16)
 
 #define DECL_MIPS_APPLY_RELOC_FUNC_PTRS \
   { &none,     0, "R_MIPS_NONE"            }, \
@@ -43,16 +45,16 @@
   { &none,    19, "R_MIPS_GOT_DISP"        }, \
   { &none,    20, "R_MIPS_GOT_PAGE"        }, \
   { &none,    21, "R_MIPS_GOT_OFST"        }, \
-  { &none,    22, "R_MIPS_GOT_HI16"        }, \
-  { &none,    23, "R_MIPS_GOT_LO16"        }, \
+  { &gothi16, 22, "R_MIPS_GOT_HI16"        }, \
+  { &gotlo16, 23, "R_MIPS_GOT_LO16"        }, \
   { &none,    24, "R_MIPS_SUB"             }, \
   { &none,    25, "R_MIPS_INSERT_A"        }, \
   { &none,    26, "R_MIPS_INSERT_B"        }, \
   { &none,    27, "R_MIPS_DELETE"          }, \
   { &none,    28, "R_MIPS_HIGHER"          }, \
   { &none,    29, "R_MIPS_HIGHEST"         }, \
-  { &none,    30, "R_MIPS_CALL_HI16"       }, \
-  { &none,    31, "R_MIPS_CALL_LO16"       }, \
+  { &gothi16, 30, "R_MIPS_CALL_HI16"       }, \
+  { &gotlo16, 31, "R_MIPS_CALL_LO16"       }, \
   { &none,    32, "R_MIPS_SCN_DISP"        }, \
   { &none,    33, "R_MIPS_REL16"           }, \
   { &none,    34, "R_MIPS_ADD_IMMEDIATE"   }, \
diff --git a/lib/Target/Mips/MipsRelocationFactory.cpp b/lib/Target/Mips/MipsRelocator.cpp
similarity index 72%
rename from lib/Target/Mips/MipsRelocationFactory.cpp
rename to lib/Target/Mips/MipsRelocator.cpp
index 09041be..ad5de22 100644
--- a/lib/Target/Mips/MipsRelocationFactory.cpp
+++ b/lib/Target/Mips/MipsRelocator.cpp
@@ -1,4 +1,4 @@
-//===- MipsRelocationFactory.cpp  -----------------------------------------===//
+//===- MipsRelocator.cpp  -----------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -13,7 +13,7 @@
 #include <mcld/Support/MsgHandling.h>
 #include <mcld/Target/OutputRelocSection.h>
 
-#include "MipsRelocationFactory.h"
+#include "MipsRelocator.h"
 #include "MipsRelocationFunctions.h"
 
 using namespace mcld;
@@ -24,8 +24,7 @@
 DECL_MIPS_APPLY_RELOC_FUNCS
 
 /// the prototype of applying function
-typedef RelocationFactory::Result (*ApplyFunctionType)(Relocation&,
-                                                       MipsRelocationFactory&);
+typedef Relocator::Result (*ApplyFunctionType)(Relocation&, MipsRelocator&);
 
 // the table entry of applying functions
 struct ApplyFunctionTriple
@@ -41,18 +40,17 @@
 };
 
 //===----------------------------------------------------------------------===//
-// MipsRelocationFactory
+// MipsRelocator
 //===----------------------------------------------------------------------===//
-MipsRelocationFactory::MipsRelocationFactory(size_t pNum,
-                                             MipsGNULDBackend& pParent)
-  : RelocationFactory(pNum),
+MipsRelocator::MipsRelocator(MipsGNULDBackend& pParent)
+  : Relocator(),
     m_Target(pParent),
     m_AHL(0)
 {
 }
 
-RelocationFactory::Result
-MipsRelocationFactory::applyRelocation(Relocation& pRelocation)
+Relocator::Result
+MipsRelocator::applyRelocation(Relocation& pRelocation)
 
 {
   Relocation::Type type = pRelocation.type();
@@ -65,7 +63,7 @@
   return ApplyFunctions[type].func(pRelocation, *this);
 }
 
-const char* MipsRelocationFactory::getName(Relocation::Type pType) const
+const char* MipsRelocator::getName(Relocation::Type pType) const
 {
   return ApplyFunctions[pType].name;
 }
@@ -101,15 +99,15 @@
 }
 
 static
-RelocationFactory::Address helper_GetGP(MipsRelocationFactory& pParent)
+Relocator::Address helper_GetGP(MipsRelocator& pParent)
 {
   return pParent.getTarget().getGOT().addr() + 0x7FF0;
 }
 
 static
-GOT::Entry& helper_GetGOTEntry(Relocation& pReloc,
-                             MipsRelocationFactory& pParent,
-                             bool& pExist, int32_t value)
+MipsGOTEntry& helper_GetGOTEntry(Relocation& pReloc,
+                                 MipsRelocator& pParent,
+                                 bool& pExist, int32_t value)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
@@ -121,7 +119,7 @@
     return *got.consumeLocal();
   }
 
-  GOT::Entry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
+  MipsGOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
   if (NULL != got_entry) {
     // found a mapping, then return the mapped entry immediately
     return *got_entry;
@@ -137,7 +135,7 @@
 
   // If we first get this GOT entry, we should initialize it.
   if (rsym->reserved() & MipsGNULDBackend::ReserveGot) {
-    got_entry->setContent(pReloc.symValue());
+    got_entry->setValue(pReloc.symValue());
   }
   else {
     fatal(diag::reserve_entry_number_mismatch_got);
@@ -147,11 +145,11 @@
 }
 
 static
-RelocationFactory::Address helper_GetGOTOffset(Relocation& pReloc,
-                                               MipsRelocationFactory& pParent)
+Relocator::Address helper_GetGOTOffset(Relocation& pReloc,
+                                       MipsRelocator& pParent)
 {
   bool exist;
-  GOT::Entry& got_entry = helper_GetGOTEntry(pReloc, pParent, exist, 0);
+  MipsGOTEntry& got_entry = helper_GetGOTEntry(pReloc, pParent, exist, 0);
   return got_entry.getOffset() - 0x7FF0;
 }
 
@@ -174,8 +172,7 @@
 }
 
 static
-void helper_DynRel(Relocation& pReloc,
-                   MipsRelocationFactory& pParent)
+void helper_DynRel(Relocation& pReloc, MipsRelocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
   MipsGNULDBackend& ld_backend = pParent.getTarget();
@@ -186,8 +183,8 @@
   rel_entry.setType(llvm::ELF::R_MIPS_REL32);
   rel_entry.targetRef() = pReloc.targetRef();
 
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
-  RelocationFactory::DWord S = pReloc.symValue();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
+  Relocator::DWord S = pReloc.symValue();
 
   if (got.isLocal(rsym)) {
     rel_entry.setSymInfo(NULL);
@@ -206,47 +203,44 @@
 
 // R_MIPS_NONE and those unsupported/deprecated relocation type
 static
-MipsRelocationFactory::Result none(Relocation& pReloc,
-                                   MipsRelocationFactory& pParent)
+MipsRelocator::Result none(Relocation& pReloc, MipsRelocator& pParent)
 {
-  return MipsRelocationFactory::OK;
+  return MipsRelocator::OK;
 }
 
 // R_MIPS_32: S + A
 static
-MipsRelocationFactory::Result abs32(Relocation& pReloc,
-                                    MipsRelocationFactory& pParent)
+MipsRelocator::Result abs32(Relocation& pReloc, MipsRelocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
 
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
-  RelocationFactory::DWord S = pReloc.symValue();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
+  Relocator::DWord S = pReloc.symValue();
 
   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())) {
     pReloc.target() = S + A;
-    return MipsRelocationFactory::OK;
+    return MipsRelocator::OK;
   }
 
   if (rsym->reserved() & MipsGNULDBackend::ReserveRel) {
     helper_DynRel(pReloc, pParent);
 
-    return MipsRelocationFactory::OK;
+    return MipsRelocator::OK;
   }
 
   pReloc.target() = (S + A);
 
-  return MipsRelocationFactory::OK;
+  return MipsRelocator::OK;
 }
 
 // R_MIPS_HI16:
 //   local/external: ((AHL + S) - (short)(AHL + S)) >> 16
 //   _gp_disp      : ((AHL + GP - P) - (short)(AHL + GP - P)) >> 16
 static
-MipsRelocationFactory::Result hi16(Relocation& pReloc,
-                                   MipsRelocationFactory& pParent)
+MipsRelocator::Result hi16(Relocation& pReloc, MipsRelocator& pParent)
 {
   Relocation* lo_reloc = helper_FindLo16Reloc(pReloc);
   assert(NULL != lo_reloc && "There is no paired R_MIPS_LO16 for R_MIPS_HI16");
@@ -269,15 +263,14 @@
   pReloc.target() &= 0xFFFF0000;
   pReloc.target() |= (res & 0xFFFF);
 
-  return MipsRelocationFactory::OK;
+  return MipsRelocator::OK;
 }
 
 // R_MIPS_LO16:
 //   local/external: AHL + S
 //   _gp_disp      : AHL + GP - P + 4
 static
-MipsRelocationFactory::Result lo16(Relocation& pReloc,
-                                   MipsRelocationFactory& pParent)
+MipsRelocator::Result lo16(Relocation& pReloc, MipsRelocator& pParent)
 {
   int32_t res = 0;
 
@@ -299,18 +292,17 @@
   pReloc.target() &= 0xFFFF0000;
   pReloc.target() |= (res & 0xFFFF);
 
-  return MipsRelocationFactory::OK;
+  return MipsRelocator::OK;
 }
 
 // R_MIPS_GOT16:
 //   local   : G (calculate AHL and put high 16 bit to GOT)
 //   external: G
 static
-MipsRelocationFactory::Result got16(Relocation& pReloc,
-                                    MipsRelocationFactory& pParent)
+MipsRelocator::Result got16(Relocation& pReloc, MipsRelocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  RelocationFactory::Address G = 0;
+  Relocator::Address G = 0;
 
   if (rsym->isLocal()) {
     Relocation* lo_reloc = helper_FindLo16Reloc(pReloc);
@@ -323,9 +315,9 @@
 
     int32_t res = (AHL + S + 0x8000) & 0xFFFF0000;
     bool exist;
-    GOT::Entry& got_entry = helper_GetGOTEntry(pReloc, pParent, exist, res);
+    MipsGOTEntry& got_entry = helper_GetGOTEntry(pReloc, pParent, exist, res);
 
-    got_entry.setContent(res);
+    got_entry.setValue(res);
     G = got_entry.getOffset() - 0x7FF0;
   }
   else {
@@ -335,26 +327,55 @@
   pReloc.target() &= 0xFFFF0000;
   pReloc.target() |= (G & 0xFFFF);
 
-  return MipsRelocationFactory::OK;
+  return MipsRelocator::OK;
 }
 
-// R_MIPS_CALL16: G
+// R_MIPS_GOTHI16:
+//   external: (G - (short)G) >> 16 + A
 static
-MipsRelocationFactory::Result call16(Relocation& pReloc,
-                                     MipsRelocationFactory& pParent)
+MipsRelocator::Result gothi16(Relocation& pReloc, MipsRelocator& pParent)
 {
-  RelocationFactory::Address G = helper_GetGOTOffset(pReloc, pParent);
+  int32_t res = 0;
+
+  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);
+
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_GOTLO16:
+//   external: G & 0xffff
+static
+MipsRelocator::Result gotlo16(Relocation& pReloc, MipsRelocator& pParent)
+{
+  Relocator::Address G = helper_GetGOTOffset(pReloc, pParent);
 
   pReloc.target() &= 0xFFFF0000;
   pReloc.target() |= (G & 0xFFFF);
 
-  return MipsRelocationFactory::OK;
+  return MipsRelocator::OK;
+}
+
+// R_MIPS_CALL16: G
+static
+MipsRelocator::Result call16(Relocation& pReloc, MipsRelocator& pParent)
+{
+  Relocator::Address G = helper_GetGOTOffset(pReloc, pParent);
+
+  pReloc.target() &= 0xFFFF0000;
+  pReloc.target() |= (G & 0xFFFF);
+
+  return MipsRelocator::OK;
 }
 
 // R_MIPS_GPREL32: A + S + GP0 - GP
 static
-MipsRelocationFactory::Result gprel32(Relocation& pReloc,
-                                      MipsRelocationFactory& pParent)
+MipsRelocator::Result gprel32(Relocation& pReloc, MipsRelocator& pParent)
 {
   // Remember to add the section offset to A.
   int32_t A = pReloc.target() + pReloc.addend();
@@ -365,5 +386,6 @@
   // Assume that GP0 is zero.
   pReloc.target() = (A + S - GP) & 0xFFFFFFFF;
 
-  return MipsRelocationFactory::OK;
+  return MipsRelocator::OK;
 }
+
diff --git a/lib/Target/Mips/MipsRelocationFactory.h b/lib/Target/Mips/MipsRelocator.h
similarity index 73%
rename from lib/Target/Mips/MipsRelocationFactory.h
rename to lib/Target/Mips/MipsRelocator.h
index 6076416..836b7d2 100644
--- a/lib/Target/Mips/MipsRelocationFactory.h
+++ b/lib/Target/Mips/MipsRelocator.h
@@ -1,4 +1,4 @@
-//===- MipsRelocationFactory.h --------------------------------------------===//
+//===- MipsRelocator.h --------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -12,23 +12,23 @@
 #include <gtest.h>
 #endif
 
-#include <mcld/LD/RelocationFactory.h>
+#include <mcld/LD/Relocator.h>
 #include <mcld/Support/GCFactory.h>
 #include <mcld/Target/SymbolEntryMap.h>
 #include "MipsLDBackend.h"
 
 namespace mcld {
 
-/** \class MipsRelocationFactory
- *  \brief MipsRelocationFactory creates and destroys the Mips relocations.
+/** \class MipsRelocator
+ *  \brief MipsRelocator creates and destroys the Mips relocations.
  */
-class MipsRelocationFactory : public RelocationFactory
+class MipsRelocator : public Relocator
 {
 public:
-  typedef SymbolEntryMap<GOT::Entry> SymGOTMap;
+  typedef SymbolEntryMap<MipsGOTEntry> SymGOTMap;
 
 public:
-  MipsRelocationFactory(size_t pNum, MipsGNULDBackend& pParent);
+  MipsRelocator(MipsGNULDBackend& pParent);
 
   Result applyRelocation(Relocation& pRelocation);
 
diff --git a/lib/Target/OutputRelocSection.cpp b/lib/Target/OutputRelocSection.cpp
index 593bdb9..3c1a0ce 100644
--- a/lib/Target/OutputRelocSection.cpp
+++ b/lib/Target/OutputRelocSection.cpp
@@ -6,28 +6,24 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
-
-#include <llvm/Support/Casting.h>
+#include <mcld/Target/OutputRelocSection.h>
 
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/RelocationFactory.h>
 #include <mcld/Module.h>
 #include <mcld/Support/MsgHandling.h>
-#include <mcld/Target/OutputRelocSection.h>
 #include <mcld/IRBuilder.h>
 
+#include <llvm/Support/Casting.h>
+
 using namespace mcld;
 
 //===----------------------------------------------------------------------===//
 // OutputRelocSection
 //===----------------------------------------------------------------------===//
-OutputRelocSection::OutputRelocSection(Module& pModule,
-                                       LDSection& pSection,
-                                       unsigned int pEntrySize)
+OutputRelocSection::OutputRelocSection(Module& pModule, LDSection& pSection)
   : m_Module(pModule),
-    m_pSection(&pSection),
     m_pRelocData(NULL),
-    m_EntryBytes(pEntrySize),
     m_isVisit(false),
     m_ValidEntryIterator(){
   assert(!pSection.hasRelocData() && "Given section is not a relocation section");
@@ -38,15 +34,10 @@
 {
 }
 
-void OutputRelocSection::reserveEntry(RelocationFactory& pRelFactory,
-                                      size_t pNum)
+void OutputRelocSection::reserveEntry(size_t pNum)
 {
-  for(size_t i=0; i<pNum; i++) {
-    m_pRelocData->getFragmentList().push_back(
-                                              pRelFactory.produceEmptyEntry());
-    // update section size
-    m_pSection->setSize(m_pSection->size() + m_EntryBytes);
-  }
+  for(size_t i=0; i<pNum; i++)
+    m_pRelocData->append(*Relocation::Create());
 }
 
 Relocation* OutputRelocSection::consumeEntry()
@@ -54,9 +45,9 @@
   // first time visit this function, set m_ValidEntryIterator to
   // Fragments.begin()
   if(!m_isVisit) {
-    assert(!m_pRelocData->getFragmentList().empty() &&
+    assert(!m_pRelocData->getRelocationList().empty() &&
              "DynRelSection contains no entries.");
-    m_ValidEntryIterator = m_pRelocData->getFragmentList().begin();
+    m_ValidEntryIterator = m_pRelocData->begin();
     m_isVisit = true;
   }
   else {
@@ -70,13 +61,12 @@
   assert(m_ValidEntryIterator != m_pRelocData->end() &&
          "No empty relocation entry for the incoming symbol.");
 
-  Relocation* result = &llvm::cast<Relocation>(*m_ValidEntryIterator);
-  return result;
+  return &(*m_ValidEntryIterator);
 }
 
-void OutputRelocSection::finalizeSectionSize()
+size_t OutputRelocSection::numOfRelocs()
 {
-  m_pSection->setSize(m_pRelocData->size() * m_EntryBytes);
+  return m_pRelocData->size();
 }
 
 bool OutputRelocSection::addSymbolToDynSym(LDSymbol& pSymbol)
@@ -84,3 +74,4 @@
   m_Module.getSymbolTable().changeLocalToTLS(pSymbol);
   return true;
 }
+
diff --git a/lib/Target/PLT.cpp b/lib/Target/PLT.cpp
index a8b515c..60e219e 100644
--- a/lib/Target/PLT.cpp
+++ b/lib/Target/PLT.cpp
@@ -15,23 +15,6 @@
 class GOT;
 
 //===----------------------------------------------------------------------===//
-// PLT::Entry
-//===----------------------------------------------------------------------===//
-PLT::Entry::Entry(size_t pSize, SectionData& pParent)
-  : TargetFragment(Fragment::Target, &pParent),
-    m_EntrySize(pSize), m_pContent(NULL)
-{
-}
-
-PLT::Entry::~Entry()
-{
-  if (m_pContent) {
-    free(m_pContent);
-    m_pContent = NULL;
-  }
-}
-
-//===----------------------------------------------------------------------===//
 // PLT
 //===----------------------------------------------------------------------===//
 PLT::PLT(LDSection& pSection)
diff --git a/lib/Target/X86/Android.mk b/lib/Target/X86/Android.mk
index cf7ea17..94b2f0f 100644
--- a/lib/Target/X86/Android.mk
+++ b/lib/Target/X86/Android.mk
@@ -10,7 +10,7 @@
   X86LDBackend.cpp  \
   X86MCLinker.cpp  \
   X86PLT.cpp  \
-  X86RelocationFactory.cpp  \
+  X86Relocator.cpp  \
   X86TargetMachine.cpp
 
 # For the host
diff --git a/lib/Target/X86/X86ELFDynamic.cpp b/lib/Target/X86/X86ELFDynamic.cpp
index af86b2c..c74cc13 100644
--- a/lib/Target/X86/X86ELFDynamic.cpp
+++ b/lib/Target/X86/X86ELFDynamic.cpp
@@ -6,14 +6,15 @@
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
+#include "X86ELFDynamic.h"
 
 #include <mcld/LD/ELFFileFormat.h>
-#include "X86ELFDynamic.h"
 
 using namespace mcld;
 
-X86ELFDynamic::X86ELFDynamic(const GNULDBackend& pParent)
-  : ELFDynamic(pParent)
+X86ELFDynamic::X86ELFDynamic(const GNULDBackend& pParent,
+                             const LinkerConfig& pConfig)
+  : ELFDynamic(pParent, pConfig)
 {
 }
 
diff --git a/lib/Target/X86/X86ELFDynamic.h b/lib/Target/X86/X86ELFDynamic.h
index 7053a0b..e3d5338 100644
--- a/lib/Target/X86/X86ELFDynamic.h
+++ b/lib/Target/X86/X86ELFDynamic.h
@@ -19,7 +19,7 @@
 class X86ELFDynamic : public ELFDynamic
 {
 public:
-  X86ELFDynamic(const GNULDBackend& pParent);
+  X86ELFDynamic(const GNULDBackend& pParent, const LinkerConfig& pConfig);
   ~X86ELFDynamic();
 
 private:
diff --git a/lib/Target/X86/X86Emulation.cpp b/lib/Target/X86/X86Emulation.cpp
index 74b7e47..9343583 100644
--- a/lib/Target/X86/X86Emulation.cpp
+++ b/lib/Target/X86/X86Emulation.cpp
@@ -18,6 +18,10 @@
   if (!MCLDEmulateELF(pConfig))
     return false;
 
+  // set up bitclass and endian
+  pConfig.targets().setEndian(TargetOptions::Little);
+  pConfig.targets().setBitClass(32);
+
   // set up target-dependent constraints of attributes
   pConfig.attribute().constraint().enableWholeArchive();
   pConfig.attribute().constraint().enableAsNeeded();
diff --git a/lib/Target/X86/X86GNUInfo.h b/lib/Target/X86/X86GNUInfo.h
new file mode 100644
index 0000000..af548f0
--- /dev/null
+++ b/lib/Target/X86/X86GNUInfo.h
@@ -0,0 +1,29 @@
+//===- X86GNUInfo.h -------------------------------------------------------===//
+//
+//                     The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_TARGET_X86_GNU_INFO_H
+#define MCLD_TARGET_X86_GNU_INFO_H
+#include <mcld/Target/GNUInfo.h>
+
+#include <llvm/Support/ELF.h>
+
+namespace mcld {
+
+class X86GNUInfo : public GNUInfo
+{
+public:
+  X86GNUInfo(const llvm::Triple& pTriple) : GNUInfo(pTriple) { }
+
+  uint32_t machine() const { return llvm::ELF::EM_386; }
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/lib/Target/X86/X86GOT.cpp b/lib/Target/X86/X86GOT.cpp
index ae28ea7..e734bb3 100644
--- a/lib/Target/X86/X86GOT.cpp
+++ b/lib/Target/X86/X86GOT.cpp
@@ -11,9 +11,7 @@
 #include <mcld/LD/LDFileFormat.h>
 #include <mcld/LD/SectionData.h>
 
-namespace {
-  const size_t X86GOTEntrySize = 4;
-}
+#include <llvm/Support/Casting.h>
 
 using namespace mcld;
 
@@ -21,7 +19,7 @@
 // X86GOT
 //===----------------------------------------------------------------------===//
 X86GOT::X86GOT(LDSection& pSection)
-             : GOT(pSection, X86GOTEntrySize)
+  : GOT(pSection), m_pLast(NULL)
 {
 }
 
@@ -29,3 +27,22 @@
 {
 }
 
+void X86GOT::reserve(size_t pNum)
+{
+  for (size_t i = 0; i < pNum; i++) {
+    new X86GOTEntry(0, m_SectionData);
+  }
+}
+
+X86GOTEntry* X86GOT::consume()
+{
+  if (NULL == m_pLast) {
+    assert(!empty() && "Consume empty GOT entry!");
+    m_pLast = llvm::cast<X86GOTEntry>(&m_SectionData->front());
+    return m_pLast;
+  }
+
+  m_pLast = llvm::cast<X86GOTEntry>(m_pLast->getNextNode());
+  return m_pLast;
+}
+
diff --git a/lib/Target/X86/X86GOT.h b/lib/Target/X86/X86GOT.h
index a027dc7..66967e1 100644
--- a/lib/Target/X86/X86GOT.h
+++ b/lib/Target/X86/X86GOT.h
@@ -19,6 +19,17 @@
 class LDSection;
 class SectionData;
 
+/** \class X86GOTEntry
+ *  \brief GOT Entry with size of 4 bytes
+ */
+class X86GOTEntry : public GOT::Entry<4>
+{
+public:
+  X86GOTEntry(uint64_t pContent, SectionData* pParent)
+   : GOT::Entry<4>(pContent, pParent)
+  {}
+};
+
 /** \class X86GOT
  *  \brief X86 Global Offset Table.
  */
@@ -29,6 +40,13 @@
   X86GOT(LDSection& pSection);
 
   ~X86GOT();
+
+  void reserve(size_t pNum = 1);
+
+  X86GOTEntry* consume();
+
+private:
+  X86GOTEntry* m_pLast; ///< the last consumed entry
 };
 
 } // namespace of mcld
diff --git a/lib/Target/X86/X86GOTPLT.cpp b/lib/Target/X86/X86GOTPLT.cpp
index b4e0ffe..b72487e 100644
--- a/lib/Target/X86/X86GOTPLT.cpp
+++ b/lib/Target/X86/X86GOTPLT.cpp
@@ -9,25 +9,19 @@
 #include "X86GOTPLT.h"
 #include "X86PLT.h"
 
-#include <new>
-
 #include <llvm/Support/Casting.h>
 
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/LDFileFormat.h>
 #include <mcld/Support/MsgHandling.h>
 
-namespace {
-  const uint64_t X86GOTPLTEntrySize = 4;
-}
-
 namespace mcld {
 
 //===----------------------------------------------------------------------===//
 // X86GOTPLT
 //===----------------------------------------------------------------------===//
 X86GOTPLT::X86GOTPLT(LDSection& pSection)
-  : GOT(pSection, X86GOTPLTEntrySize)
+  : GOT(pSection), m_pLast(NULL)
 {
   // Create GOT0 entries
   reserve(X86GOTPLT0Num);
@@ -42,6 +36,25 @@
 {
 }
 
+void X86GOTPLT::reserve(size_t pNum)
+{
+  for (size_t i = 0; i < pNum; i++) {
+    new X86GOTPLTEntry(0, m_SectionData);
+  }
+}
+
+X86GOTPLTEntry* X86GOTPLT::consume()
+{
+  if (NULL == m_pLast) {
+    assert(!empty() && "Consume empty GOT entry!");
+    m_pLast = llvm::cast<X86GOTPLTEntry>(&m_SectionData->front());
+    return m_pLast;
+  }
+
+  m_pLast = llvm::cast<X86GOTPLTEntry>(m_pLast->getNextNode());
+  return m_pLast;
+}
+
 bool X86GOTPLT::hasGOT1() const
 {
   return (m_SectionData->size() > X86GOTPLT0Num);
@@ -49,8 +62,8 @@
 
 void X86GOTPLT::applyGOT0(uint64_t pAddress)
 {
-  llvm::cast<Entry>
-    (*(m_SectionData->getFragmentList().begin())).setContent(pAddress);
+  llvm::cast<X86GOTPLTEntry>
+    (*(m_SectionData->getFragmentList().begin())).setValue(pAddress);
 }
 
 void X86GOTPLT::applyAllGOTPLT(const X86PLT& pPLT)
@@ -62,7 +75,7 @@
   // address of corresponding plt entry
   uint64_t plt_addr = pPLT.addr() + pPLT.getPLT0Size();
   for (; it != end() ; ++it) {
-    llvm::cast<Entry>(*it).setContent(plt_addr + 6);
+    llvm::cast<X86GOTPLTEntry>(*it).setValue(plt_addr + 6);
     plt_addr += pPLT.getPLT1Size();
   }
 }
diff --git a/lib/Target/X86/X86GOTPLT.h b/lib/Target/X86/X86GOTPLT.h
index b2fa65a..f288fa4 100644
--- a/lib/Target/X86/X86GOTPLT.h
+++ b/lib/Target/X86/X86GOTPLT.h
@@ -23,6 +23,14 @@
 
 const unsigned int X86GOTPLT0Num = 3;
 
+class X86GOTPLTEntry : public GOT::Entry<4>
+{
+public:
+  X86GOTPLTEntry(uint64_t pContent, SectionData* pParent)
+   : GOT::Entry<4>(pContent, pParent)
+  {}
+};
+
 /** \class X86GOTPLT
  *  \brief X86 .got.plt section.
  */
@@ -33,12 +41,19 @@
 
   ~X86GOTPLT();
 
+  void reserve(size_t pNum = 1);
+
+  X86GOTPLTEntry* consume();
+
   // hasGOT1 - return if this section has any GOT1 entry
   bool hasGOT1() const;
 
   void applyGOT0(uint64_t pAddress);
 
   void applyAllGOTPLT(const X86PLT& pPLT);
+
+private:
+  X86GOTPLTEntry* m_pLast; ///< the last consumed entry
 };
 
 } // namespace of mcld
diff --git a/lib/Target/X86/X86LDBackend.cpp b/lib/Target/X86/X86LDBackend.cpp
index 987daec..a18fedb 100644
--- a/lib/Target/X86/X86LDBackend.cpp
+++ b/lib/Target/X86/X86LDBackend.cpp
@@ -9,7 +9,8 @@
 #include "X86.h"
 #include "X86ELFDynamic.h"
 #include "X86LDBackend.h"
-#include "X86RelocationFactory.h"
+#include "X86Relocator.h"
+#include "X86GNUInfo.h"
 
 #include <llvm/ADT/Triple.h>
 #include <llvm/Support/Casting.h>
@@ -31,9 +32,9 @@
 //===----------------------------------------------------------------------===//
 // X86GNULDBackend
 //===----------------------------------------------------------------------===//
-X86GNULDBackend::X86GNULDBackend(const LinkerConfig& pConfig)
-  : GNULDBackend(pConfig),
-    m_pRelocFactory(NULL),
+X86GNULDBackend::X86GNULDBackend(const LinkerConfig& pConfig, X86GNUInfo* pInfo)
+  : GNULDBackend(pConfig, pInfo),
+    m_pRelocator(NULL),
     m_pGOT(NULL),
     m_pPLT(NULL),
     m_pGOTPLT(NULL),
@@ -45,7 +46,7 @@
 
 X86GNULDBackend::~X86GNULDBackend()
 {
-  delete m_pRelocFactory;
+  delete m_pRelocator;
   delete m_pGOT;
   delete m_pPLT;
   delete m_pGOTPLT;
@@ -54,21 +55,21 @@
   delete m_pDynamic;
 }
 
-RelocationFactory* X86GNULDBackend::getRelocFactory()
+bool X86GNULDBackend::initRelocator(const FragmentLinker& pLinker)
 {
-  assert(NULL != m_pRelocFactory);
-  return m_pRelocFactory;
-}
-
-bool X86GNULDBackend::initRelocFactory(const FragmentLinker& pLinker)
-{
-  if (NULL == m_pRelocFactory) {
-    m_pRelocFactory = new X86RelocationFactory(1024, *this);
-    m_pRelocFactory->setFragmentLinker(pLinker);
+  if (NULL == m_pRelocator) {
+    m_pRelocator = new X86Relocator(*this);
+    m_pRelocator->setFragmentLinker(pLinker);
   }
   return true;
 }
 
+Relocator* X86GNULDBackend::getRelocator()
+{
+  assert(NULL != m_pRelocator);
+  return m_pRelocator;
+}
+
 void X86GNULDBackend::doPreLayout(FragmentLinker& pLinker)
 {
   // set .got.plt size
@@ -89,13 +90,16 @@
     if (m_pPLT->hasPLT1())
       m_pPLT->finalizeSectionSize();
 
+    ELFFileFormat* file_format = getOutputFormat();
     // set .rel.dyn size
     if (!m_pRelDyn->empty())
-      m_pRelDyn->finalizeSectionSize();
+      file_format->getRelDyn().setSize(
+                                  m_pRelDyn->numOfRelocs() * getRelEntrySize());
 
     // set .rel.plt size
     if (!m_pRelPLT->empty())
-      m_pRelPLT->finalizeSectionSize();
+      file_format->getRelPlt().setSize(
+                                  m_pRelPLT->numOfRelocs() * getRelEntrySize());
   }
 }
 
@@ -109,7 +113,7 @@
 X86ELFDynamic& X86GNULDBackend::dynamic()
 {
   if (NULL == m_pDynamic)
-    m_pDynamic = new X86ELFDynamic(*this);
+    m_pDynamic = new X86ELFDynamic(*this, config());
 
   return *m_pDynamic;
 }
@@ -186,7 +190,7 @@
 
   // Determine the alignment by the symbol value
   // FIXME: here we use the largest alignment
-  uint32_t addralign = bitclass() / 8;
+  uint32_t addralign = config().targets().bitclass() / 8;
 
   // allocate space in BSS for the copy symbol
   Fragment* frag = new FillFragment(0x0, 1, pSym.size());
@@ -233,7 +237,7 @@
       // a dynamic relocations with RELATIVE type to this location is needed.
       // Reserve an entry in .rel.dyn
       if (pLinker.isOutputPIC()) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         // set Rel bit
         rsym->setReserved(rsym->reserved() | ReserveRel);
       }
@@ -256,7 +260,7 @@
       // entry in .rel.dyn
       if (LinkerConfig::DynObj ==
                    config().codeGenType() || rsym->isUndef() || rsym->isDyn()) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         // set GOTRel bit
         rsym->setReserved(rsym->reserved() | GOTRel);
         return;
@@ -276,7 +280,7 @@
         return;
       m_pGOT->reserve(2);
       // reserve an rel entry
-      m_pRelDyn->reserveEntry(*m_pRelocFactory);
+      m_pRelDyn->reserveEntry();
       // set GOTRel bit
       rsym->setReserved(rsym->reserved() | GOTRel);
       // define the section symbol for .tdata or .tbss
@@ -310,14 +314,14 @@
       setHasStaticTLS();
       // if buildint shared object, a RELATIVE dynamic relocation is needed
       if (LinkerConfig::DynObj == config().codeGenType()) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         rsym->setReserved(rsym->reserved() | ReserveRel);
       }
       if (rsym->reserved() & GOTRel)
         return;
       // reserve got and dyn relocation entries for tp-relative offset
       m_pGOT->reserve();
-      m_pRelDyn->reserveEntry(*m_pRelocFactory);
+      m_pRelDyn->reserveEntry();
       // set GOTRel bit
       rsym->setReserved(rsym->reserved() | GOTRel);
       m_pRelDyn->addSymbolToDynSym(*rsym->outSymbol());
@@ -329,7 +333,7 @@
         return;
       // reserve got and dyn relocation entries for tp-relative offset
       m_pGOT->reserve();
-      m_pRelDyn->reserveEntry(*m_pRelocFactory);
+      m_pRelDyn->reserveEntry();
       // set GOTRel bit
       rsym->setReserved(rsym->reserved() | GOTRel);
       m_pRelDyn->addSymbolToDynSym(*rsym->outSymbol());
@@ -340,7 +344,7 @@
       setHasStaticTLS();
       // if buildint shared object, a dynamic relocation is needed
       if (LinkerConfig::DynObj == config().codeGenType()) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         rsym->setReserved(rsym->reserved() | ReserveRel);
         // the target symbol of the dynamic relocation is rsym, so we need to
         // emit it into .dynsym
@@ -379,7 +383,7 @@
           // when calling X86PLT->reserveEntry())
           m_pPLT->reserveEntry();
           m_pGOTPLT->reserve();
-          m_pRelPLT->reserveEntry(*m_pRelocFactory);
+          m_pRelPLT->reserveEntry();
           // set PLT bit
           rsym->setReserved(rsym->reserved() | ReservePLT);
         }
@@ -388,7 +392,7 @@
       if (symbolNeedsDynRel(pLinker, *rsym, (rsym->reserved() & ReservePLT),
                                                                        true)) {
         // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         if (symbolNeedsCopyReloc(pLinker, pReloc, *rsym)) {
           LDSymbol& cpy_sym = defineSymbolforCopyReloc(pLinker, *rsym);
           addCopyReloc(*cpy_sym.resolveInfo());
@@ -430,7 +434,7 @@
       // when calling X86PLT->reserveEntry())
       m_pPLT->reserveEntry();
       m_pGOTPLT->reserve();
-      m_pRelPLT->reserveEntry(*m_pRelocFactory);
+      m_pRelPLT->reserveEntry();
       // set PLT bit
       rsym->setReserved(rsym->reserved() | ReservePLT);
       return;
@@ -446,7 +450,7 @@
       // entry in .rel.dyn
       if (LinkerConfig::DynObj ==
                    config().codeGenType() || rsym->isUndef() || rsym->isDyn()) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         // set GOTRel bit
         rsym->setReserved(rsym->reserved() | GOTRel);
         return;
@@ -469,7 +473,7 @@
           // when calling X86PLT->reserveEntry())
           m_pPLT->reserveEntry();
           m_pGOTPLT->reserve();
-          m_pRelPLT->reserveEntry(*m_pRelocFactory);
+          m_pRelPLT->reserveEntry();
           // set PLT bit
           rsym->setReserved(rsym->reserved() | ReservePLT);
         }
@@ -478,7 +482,7 @@
       if (symbolNeedsDynRel(pLinker, *rsym, (rsym->reserved() & ReservePLT),
                                                                       false)) {
         // symbol needs dynamic relocation entry, reserve an entry in .rel.dyn
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         if (symbolNeedsCopyReloc(pLinker, pReloc, *rsym)) {
           LDSymbol& cpy_sym = defineSymbolforCopyReloc(pLinker, *rsym);
           addCopyReloc(*cpy_sym.resolveInfo());
@@ -496,7 +500,7 @@
         return;
       // reserve two pairs of got entry and dynamic relocation
       m_pGOT->reserve(2);
-      m_pRelDyn->reserveEntry(*m_pRelocFactory, 2);
+      m_pRelDyn->reserveEntry(2);
       // set GOTRel bit
       rsym->setReserved(rsym->reserved() | GOTRel);
       return;
@@ -513,14 +517,14 @@
       setHasStaticTLS();
       // if buildint shared object, a RELATIVE dynamic relocation is needed
       if (LinkerConfig::DynObj == config().codeGenType()) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         rsym->setReserved(rsym->reserved() | ReserveRel);
       }
       if (rsym->reserved() & GOTRel)
         return;
       // reserve got and dyn relocation entries for tp-relative offset
       m_pGOT->reserve();
-      m_pRelDyn->reserveEntry(*m_pRelocFactory);
+      m_pRelDyn->reserveEntry();
       // set GOTRel bit
       rsym->setReserved(rsym->reserved() | GOTRel);
       return;
@@ -531,7 +535,7 @@
         return;
       // reserve got and dyn relocation entries for tp-relative offset
       m_pGOT->reserve();
-      m_pRelDyn->reserveEntry(*m_pRelocFactory);
+      m_pRelDyn->reserveEntry();
       // set GOTRel bit
       rsym->setReserved(rsym->reserved() | GOTRel);
       return;
@@ -541,7 +545,7 @@
       setHasStaticTLS();
       // if buildint shared object, a dynamic relocation is needed
       if (LinkerConfig::DynObj == config().codeGenType()) {
-        m_pRelDyn->reserveEntry(*m_pRelocFactory);
+        m_pRelDyn->reserveEntry();
         rsym->setReserved(rsym->reserved() | ReserveRel);
       }
       return;
@@ -579,7 +583,7 @@
 
   // check if we shoule issue undefined reference for the relocation target
   // symbol
-  if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak())
+  if (rsym->isUndef() && !rsym->isDyn() && !rsym->isWeak() && !rsym->isNull())
     fatal(diag::undefined_reference) << rsym->name();
 
   if ((rsym->reserved() & ReserveRel) != 0x0) {
@@ -608,18 +612,18 @@
     m_pPLT->applyPLT0();
     m_pPLT->applyPLT1();
     X86PLT::iterator it = m_pPLT->begin();
-    unsigned int plt0_size = llvm::cast<X86PLT0>((*it)).getEntrySize();
+    unsigned int plt0_size = llvm::cast<PLTEntryBase>((*it)).size();
 
-    memcpy(buffer, llvm::cast<X86PLT0>((*it)).getContent(), plt0_size);
+    memcpy(buffer, llvm::cast<PLTEntryBase>((*it)).getValue(), plt0_size);
     RegionSize += plt0_size;
     ++it;
 
-    X86PLT1* plt1 = 0;
+    PLTEntryBase* plt1 = 0;
     X86PLT::iterator ie = m_pPLT->end();
     while (it != ie) {
-      plt1 = &(llvm::cast<X86PLT1>(*it));
-      EntrySize = plt1->getEntrySize();
-      memcpy(buffer + RegionSize, plt1->getContent(), EntrySize);
+      plt1 = &(llvm::cast<PLTEntryBase>(*it));
+      EntrySize = plt1->size();
+      memcpy(buffer + RegionSize, plt1->getValue(), EntrySize);
       RegionSize += EntrySize;
       ++it;
     }
@@ -630,13 +634,13 @@
 
     uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
 
-    GOT::Entry* got = 0;
-    EntrySize = m_pGOT->getEntrySize();
+    X86GOTEntry* got = 0;
+    EntrySize = X86GOTEntry::EntrySize;
 
     for (X86GOT::iterator it = m_pGOT->begin(),
          ie = m_pGOT->end(); it != ie; ++it, ++buffer) {
-      got = &(llvm::cast<GOT::Entry>((*it)));
-      *buffer = static_cast<uint32_t>(got->getContent());
+      got = &(llvm::cast<X86GOTEntry>((*it)));
+      *buffer = static_cast<uint32_t>(got->getValue());
       RegionSize += EntrySize;
     }
   }
@@ -648,13 +652,13 @@
 
     uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.getBuffer());
 
-    GOT::Entry* got = 0;
-    EntrySize = m_pGOTPLT->getEntrySize();
+    X86GOTEntry* got = 0;
+    EntrySize = X86GOTPLTEntry::EntrySize;
 
     for (X86GOTPLT::iterator it = m_pGOTPLT->begin(),
          ie = m_pGOTPLT->end(); it != ie; ++it, ++buffer) {
-      got = &(llvm::cast<GOT::Entry>((*it)));
-      *buffer = static_cast<uint32_t>(got->getContent());
+      got = &(llvm::cast<X86GOTEntry>((*it)));
+      *buffer = static_cast<uint32_t>(got->getValue());
       RegionSize += EntrySize;
     }
   }
@@ -667,11 +671,6 @@
   return RegionSize;
 }
 
-uint32_t X86GNULDBackend::machine() const
-{
-  return llvm::ELF::EM_386;
-}
-
 X86GOT& X86GNULDBackend::getGOT()
 {
   assert(NULL != m_pGOT);
@@ -721,18 +720,18 @@
 }
 
 // Create a GOT entry for the TLS module index
-GOT::Entry& X86GNULDBackend::getTLSModuleID()
+X86GOTEntry& X86GNULDBackend::getTLSModuleID()
 {
-  static GOT::Entry* got_entry = NULL;
+  static X86GOTEntry* got_entry = NULL;
   if (NULL != got_entry)
     return *got_entry;
 
   // Allocate 2 got entries and 1 dynamic reloc for R_386_TLS_LDM
   m_pGOT->reserve(2);
   got_entry = m_pGOT->consume();
-  m_pGOT->consume()->setContent(0x0);
+  m_pGOT->consume()->setValue(0x0);
 
-  m_pRelDyn->reserveEntry(*m_pRelocFactory);
+  m_pRelDyn->reserveEntry();
   Relocation* rel_entry = m_pRelDyn->consumeEntry();
   rel_entry->setType(llvm::ELF::R_386_TLS_DTPMOD32);
   rel_entry->targetRef().assign(*got_entry, 0x0);
@@ -776,11 +775,6 @@
   return SHO_UNDEFINED;
 }
 
-unsigned int X86GNULDBackend::bitclass() const
-{
-  return 32;
-}
-
 void X86GNULDBackend::initTargetSections(Module& pModule, ObjectBuilder& pBuilder)
 {
   if (LinkerConfig::Object != config().codeGenType()) {
@@ -802,14 +796,12 @@
     // initialize .rel.plt
     LDSection& relplt = file_format->getRelPlt();
     relplt.setLink(&plt);
-    m_pRelPLT = new OutputRelocSection(pModule,
-                                       relplt,
-                                       getRelEntrySize());
+    m_pRelPLT = new OutputRelocSection(pModule, relplt);
+
     // initialize .rel.dyn
     LDSection& reldyn = file_format->getRelDyn();
-    m_pRelDyn = new OutputRelocSection(pModule,
-                                       reldyn,
-                                       getRelEntrySize());
+    m_pRelDyn = new OutputRelocSection(pModule, reldyn);
+
   }
 }
 
@@ -854,7 +846,7 @@
 TargetLDBackend* createX86LDBackend(const llvm::Target& pTarget,
                                     const LinkerConfig& pConfig)
 {
-  if (pConfig.triple().isOSDarwin()) {
+  if (pConfig.targets().triple().isOSDarwin()) {
     assert(0 && "MachO linker is not supported yet");
     /**
     return new X86MachOLDBackend(createX86MachOArchiveReader,
@@ -862,7 +854,7 @@
                                createX86MachOObjectWriter);
     **/
   }
-  if (pConfig.triple().isOSWindows()) {
+  if (pConfig.targets().triple().isOSWindows()) {
     assert(0 && "COFF linker is not supported yet");
     /**
     return new X86COFFLDBackend(createX86COFFArchiveReader,
@@ -870,7 +862,7 @@
                                createX86COFFObjectWriter);
     **/
   }
-  return new X86GNULDBackend(pConfig);
+  return new X86GNULDBackend(pConfig, new X86GNUInfo(pConfig.targets().triple()));
 }
 
 } // namespace of mcld
diff --git a/lib/Target/X86/X86LDBackend.h b/lib/Target/X86/X86LDBackend.h
index fb3aa6b..3f8a626 100644
--- a/lib/Target/X86/X86LDBackend.h
+++ b/lib/Target/X86/X86LDBackend.h
@@ -20,6 +20,7 @@
 namespace mcld {
 
 class LinkerConfig;
+class X86GNUInfo;
 
 //===----------------------------------------------------------------------===//
 /// X86GNULDBackend - linker backend of X86 target of GNU ELF format
@@ -71,17 +72,12 @@
   };
 
 public:
-  X86GNULDBackend(const LinkerConfig& pConfig);
+  X86GNULDBackend(const LinkerConfig& pConfig, X86GNUInfo* pInfo);
 
   ~X86GNULDBackend();
 
-  RelocationFactory* getRelocFactory();
-
   uint32_t machine() const;
 
-  bool isLittleEndian() const
-  { return true; }
-
   X86GOT& getGOT();
 
   const X86GOT& getGOT() const;
@@ -94,9 +90,7 @@
 
   const X86PLT& getPLT() const;
 
-  GOT::Entry& getTLSModuleID();
-
-  unsigned int bitclass() const;
+  X86GOTEntry& getTLSModuleID();
 
   /// preLayout - Backend can do any needed modification before layout
   void doPreLayout(FragmentLinker& pLinker);
@@ -130,16 +124,6 @@
   uint64_t emitSectionData(const LDSection& pSection,
                            MemoryRegion& pRegion) const;
 
-  /// OSABI - the value of e_ident[EI_OSABI]
-  /// FIXME
-  uint8_t OSABI() const
-  { return llvm::ELF::ELFOSABI_NONE; }
-
-  /// ABIVersion - the value of e_ident[EI_ABIVRESION]
-  /// FIXME
-  uint8_t ABIVersion() const
-  { return 0x0; }
-
   /// flags - the value of ElfXX_Ehdr::e_flags
   /// FIXME
   uint64_t flags() const
@@ -148,8 +132,11 @@
   uint64_t defaultTextSegmentAddr() const
   { return 0x08048000; }
 
-  // initRelocFactory - create and initialize RelocationFactory
-  bool initRelocFactory(const FragmentLinker& pLinker);
+  /// initRelocator - create and initialize Relocator.
+  bool initRelocator(const FragmentLinker& pLinker);
+
+  /// getRelocator - return relocator.
+  Relocator* getRelocator();
 
   void initTargetSections(Module& pModule, ObjectBuilder& pBuilder);
 
@@ -217,7 +204,7 @@
                                    const FragmentLinker& pLinker);
 
 private:
-  RelocationFactory* m_pRelocFactory;
+  Relocator* m_pRelocator;
   X86GOT* m_pGOT;
   X86PLT* m_pPLT;
   X86GOTPLT* m_pGOTPLT;
diff --git a/lib/Target/X86/X86PLT.cpp b/lib/Target/X86/X86PLT.cpp
index 5b5ac58..25eaab9 100644
--- a/lib/Target/X86/X86PLT.cpp
+++ b/lib/Target/X86/X86PLT.cpp
@@ -16,44 +16,30 @@
 #include <mcld/LinkerConfig.h>
 #include <mcld/Support/MsgHandling.h>
 
+using namespace mcld;
+
 //===----------------------------------------------------------------------===//
 // PLT entry data
 //===----------------------------------------------------------------------===//
-namespace {
-
-const uint8_t x86_dyn_plt0[] = {
-  0xff, 0xb3, 0x04, 0, 0, 0, // pushl  0x4(%ebx)
-  0xff, 0xa3, 0x08, 0, 0, 0, // jmp    *0x8(%ebx)
-  0x0f, 0x1f, 0x4,  0        // nopl   0(%eax)
-};
-
-const uint8_t x86_dyn_plt1[] = {
-  0xff, 0xa3, 0, 0, 0, 0,    // jmp    *sym@GOT(%ebx)
-  0x68, 0, 0, 0, 0,          // pushl  $offset
-  0xe9, 0, 0, 0, 0           // jmp    plt0
-};
-
-const uint8_t x86_exec_plt0[] = {
-  0xff, 0x35, 0, 0, 0, 0,    // pushl  .got + 4
-  0xff, 0x25, 0, 0, 0, 0,    // jmp    *(.got + 8)
-  0x0f, 0x1f, 0x4, 0         // nopl   0(%eax)
-};
-
-const uint8_t x86_exec_plt1[] = {
-  0xff, 0x25, 0, 0, 0, 0,    // jmp    *(sym in .got)
-  0x68, 0, 0, 0, 0,          // pushl  $offset
-  0xe9, 0, 0, 0, 0           // jmp    plt0
-};
-
+X86DynPLT0::X86DynPLT0(SectionData& pParent)
+  : PLT::Entry<sizeof(x86_dyn_plt0)>(pParent)
+{
 }
 
-namespace mcld {
+X86DynPLT1::X86DynPLT1(SectionData& pParent)
+  : PLT::Entry<sizeof(x86_dyn_plt1)>(pParent)
+{
+}
 
-X86PLT0::X86PLT0(SectionData& pParent, unsigned int pSize)
-  : PLT::Entry(pSize, pParent) { }
+X86ExecPLT0::X86ExecPLT0(SectionData& pParent)
+  : PLT::Entry<sizeof(x86_exec_plt0)>(pParent)
+{
+}
 
-X86PLT1::X86PLT1(SectionData& pParent, unsigned int pSize)
-  : PLT::Entry(pSize, pParent) { }
+X86ExecPLT1::X86ExecPLT1(SectionData& pParent)
+  : PLT::Entry<sizeof(x86_exec_plt1)>(pParent)
+{
+}
 
 //===----------------------------------------------------------------------===//
 // X86PLT
@@ -66,22 +52,25 @@
     m_Config(pConfig)
 {
   assert(LinkerConfig::DynObj == m_Config.codeGenType() ||
-         LinkerConfig::Exec == m_Config.codeGenType());
+         LinkerConfig::Exec   == m_Config.codeGenType() ||
+         LinkerConfig::Binary == m_Config.codeGenType());
 
   if (LinkerConfig::DynObj == m_Config.codeGenType()) {
-      m_PLT0 = x86_dyn_plt0;
-      m_PLT1 = x86_dyn_plt1;
-      m_PLT0Size = sizeof (x86_dyn_plt0);
-      m_PLT1Size = sizeof (x86_dyn_plt1);
+    m_PLT0 = x86_dyn_plt0;
+    m_PLT1 = x86_dyn_plt1;
+    m_PLT0Size = sizeof (x86_dyn_plt0);
+    m_PLT1Size = sizeof (x86_dyn_plt1);
+    // create PLT0
+    new X86DynPLT0(*m_SectionData);
   }
   else {
-      m_PLT0 = x86_exec_plt0;
-      m_PLT1 = x86_exec_plt1;
-      m_PLT0Size = sizeof (x86_exec_plt0);
-      m_PLT1Size = sizeof (x86_exec_plt1);
+    m_PLT0 = x86_exec_plt0;
+    m_PLT1 = x86_exec_plt1;
+    m_PLT0Size = sizeof (x86_exec_plt0);
+    m_PLT1Size = sizeof (x86_exec_plt1);
+    // create PLT0
+    new X86ExecPLT0(*m_SectionData);
   }
-  new X86PLT0(*m_SectionData, m_PLT0Size);
-
   m_Last = m_SectionData->begin();
 }
 
@@ -93,15 +82,15 @@
 {
   uint64_t size = 0;
   // plt0 size
-  size = getPLT0()->getEntrySize();
+  size = getPLT0()->size();
 
   // get first plt1 entry
   X86PLT::iterator it = begin();
   ++it;
   if (end() != it) {
     // plt1 size
-    X86PLT1* plt1 = &(llvm::cast<X86PLT1>(*it));
-    size += (m_SectionData->size() - 1) * plt1->getEntrySize();
+    PLTEntryBase* plt1 = &(llvm::cast<PLTEntryBase>(*it));
+    size += (m_SectionData->size() - 1) * plt1->size();
   }
   m_Section.setSize(size);
 
@@ -120,34 +109,37 @@
 
 void X86PLT::reserveEntry(size_t pNum)
 {
-  X86PLT1* plt1_entry = 0;
+  PLTEntryBase* plt1_entry = NULL;
 
   for (size_t i = 0; i < pNum; ++i) {
-    plt1_entry = new (std::nothrow) X86PLT1(*m_SectionData, m_PLT1Size);
 
-    if (!plt1_entry)
+    if (LinkerConfig::DynObj == m_Config.codeGenType())
+      plt1_entry = new X86DynPLT1(*m_SectionData);
+    else
+      plt1_entry = new X86ExecPLT1(*m_SectionData);
+
+    if (NULL == plt1_entry)
       fatal(diag::fail_allocate_memory_plt);
   }
 }
 
-PLT::Entry* X86PLT::consume()
+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<X86PLT1>(&(*m_Last));
+  return llvm::cast<PLTEntryBase>(&(*m_Last));
 }
 
-X86PLT0* X86PLT::getPLT0() const
+PLTEntryBase* X86PLT::getPLT0() const
 {
-
   iterator first = m_SectionData->getFragmentList().begin();
 
   assert(first != m_SectionData->getFragmentList().end() &&
          "FragmentList is empty, getPLT0 failed!");
 
-  X86PLT0* plt0 = &(llvm::cast<X86PLT0>(*first));
+  PLTEntryBase* plt0 = &(llvm::cast<PLTEntryBase>(*first));
 
   return plt0;
 }
@@ -155,15 +147,15 @@
 // FIXME: It only works on little endian machine.
 void X86PLT::applyPLT0()
 {
-  X86PLT0* plt0 = getPLT0();
+  PLTEntryBase* plt0 = getPLT0();
 
   unsigned char* data = 0;
-  data = static_cast<unsigned char*>(malloc(plt0->getEntrySize()));
+  data = static_cast<unsigned char*>(malloc(plt0->size()));
 
   if (!data)
     fatal(diag::fail_allocate_memory_plt);
 
-  memcpy(data, m_PLT0, plt0->getEntrySize());
+  memcpy(data, m_PLT0, plt0->size());
 
   if (m_PLT0 == x86_exec_plt0) {
     uint32_t *offset = reinterpret_cast<uint32_t*>(data + 2);
@@ -172,7 +164,7 @@
     *offset = m_GOTPLT.addr() + 8;
   }
 
-  plt0->setContent(data);
+  plt0->setValue(data);
 }
 
 // FIXME: It only works on little endian machine.
@@ -184,7 +176,7 @@
   X86PLT::iterator ie = m_SectionData->end();
   assert(it != ie && "FragmentList is empty, applyPLT1 failed!");
 
-  uint64_t GOTEntrySize = m_GOTPLT.getEntrySize();
+  uint64_t GOTEntrySize = X86GOTPLTEntry::EntrySize;
 
   // Skip GOT0
   uint64_t GOTEntryOffset = GOTEntrySize * X86GOTPLT0Num;
@@ -195,19 +187,19 @@
   uint64_t PLTEntryOffset = m_PLT0Size;
   ++it;
 
-  X86PLT1* plt1 = 0;
+  PLTEntryBase* plt1 = 0;
 
   uint64_t PLTRelOffset = 0;
 
   while (it != ie) {
-    plt1 = &(llvm::cast<X86PLT1>(*it));
+    plt1 = &(llvm::cast<PLTEntryBase>(*it));
     unsigned char *data;
-    data = static_cast<unsigned char*>(malloc(plt1->getEntrySize()));
+    data = static_cast<unsigned char*>(malloc(plt1->size()));
 
     if (!data)
       fatal(diag::fail_allocate_memory_plt);
 
-    memcpy(data, m_PLT1, plt1->getEntrySize());
+    memcpy(data, m_PLT1, plt1->size());
 
     uint32_t* offset;
 
@@ -223,10 +215,8 @@
     *offset = -(PLTEntryOffset + 12 + 4);
     PLTEntryOffset += m_PLT1Size;
 
-    plt1->setContent(data);
+    plt1->setValue(data);
     ++it;
   }
 }
 
-} // end namespace mcld
-
diff --git a/lib/Target/X86/X86PLT.h b/lib/Target/X86/X86PLT.h
index 5e8b45f..75a72e6 100644
--- a/lib/Target/X86/X86PLT.h
+++ b/lib/Target/X86/X86PLT.h
@@ -11,24 +11,70 @@
 
 #include <mcld/Target/PLT.h>
 
+namespace {
+
+const uint8_t x86_dyn_plt0[] = {
+  0xff, 0xb3, 0x04, 0, 0, 0, // pushl  0x4(%ebx)
+  0xff, 0xa3, 0x08, 0, 0, 0, // jmp    *0x8(%ebx)
+  0x0f, 0x1f, 0x4,  0        // nopl   0(%eax)
+};
+
+const uint8_t x86_dyn_plt1[] = {
+  0xff, 0xa3, 0, 0, 0, 0,    // jmp    *sym@GOT(%ebx)
+  0x68, 0, 0, 0, 0,          // pushl  $offset
+  0xe9, 0, 0, 0, 0           // jmp    plt0
+};
+
+const uint8_t x86_exec_plt0[] = {
+  0xff, 0x35, 0, 0, 0, 0,    // pushl  .got + 4
+  0xff, 0x25, 0, 0, 0, 0,    // jmp    *(.got + 8)
+  0x0f, 0x1f, 0x4, 0         // nopl   0(%eax)
+};
+
+const uint8_t x86_exec_plt1[] = {
+  0xff, 0x25, 0, 0, 0, 0,    // jmp    *(sym in .got)
+  0x68, 0, 0, 0, 0,          // pushl  $offset
+  0xe9, 0, 0, 0, 0           // jmp    plt0
+};
+
+} // anonymous namespace
+
 namespace mcld {
 
 class X86GOTPLT;
 class GOTEntry;
 class LinkerConfig;
 
-class X86PLT0 : public PLT::Entry
+//===----------------------------------------------------------------------===//
+// X86PLT Entry
+//===----------------------------------------------------------------------===//
+class X86DynPLT0 : public PLT::Entry<sizeof(x86_dyn_plt0)>
 {
 public:
-  X86PLT0(SectionData& pParent, unsigned int pSize);
+  X86DynPLT0(SectionData& pParent);
 };
 
-class X86PLT1 : public PLT::Entry
+class X86DynPLT1 : public PLT::Entry<sizeof(x86_dyn_plt1)>
 {
 public:
-  X86PLT1(SectionData& pParent, unsigned int pSize);
+  X86DynPLT1(SectionData& pParent);
 };
 
+class X86ExecPLT0 : public PLT::Entry<sizeof(x86_exec_plt0)>
+{
+public:
+  X86ExecPLT0(SectionData& pParent);
+};
+
+class X86ExecPLT1 : public PLT::Entry<sizeof(x86_exec_plt1)>
+{
+public:
+  X86ExecPLT1(SectionData& pParent);
+};
+
+//===----------------------------------------------------------------------===//
+// X86PLT
+//===----------------------------------------------------------------------===//
 /** \class X86PLT
  *  \brief X86 Procedure Linkage Table
  */
@@ -48,7 +94,7 @@
 
   void reserveEntry(size_t pNum = 1) ;
 
-  PLT::Entry* consume();
+  PLTEntryBase* consume();
 
   void applyPLT0();
 
@@ -58,7 +104,7 @@
   unsigned int getPLT1Size() const { return m_PLT1Size; }
 
 private:
-  X86PLT0* getPLT0() const;
+  PLTEntryBase* getPLT0() const;
 
 private:
   X86GOTPLT& m_GOTPLT;
@@ -77,3 +123,4 @@
 } // namespace of mcld
 
 #endif
+
diff --git a/lib/Target/X86/X86RelocationFunctions.h b/lib/Target/X86/X86RelocationFunctions.h
index 9b82739..df2e70c 100644
--- a/lib/Target/X86/X86RelocationFunctions.h
+++ b/lib/Target/X86/X86RelocationFunctions.h
@@ -8,8 +8,8 @@
 //===----------------------------------------------------------------------===//
 
 #define DECL_X86_APPLY_RELOC_FUNC(Name) \
-static X86RelocationFactory::Result Name    (Relocation& pEntry, \
-					     X86RelocationFactory& pParent);
+static X86Relocator::Result Name    (Relocation& pEntry, \
+					                          X86Relocator& pParent);
 
 #define DECL_X86_APPLY_RELOC_FUNCS \
 DECL_X86_APPLY_RELOC_FUNC(none)             \
diff --git a/lib/Target/X86/X86RelocationFactory.cpp b/lib/Target/X86/X86Relocator.cpp
similarity index 67%
rename from lib/Target/X86/X86RelocationFactory.cpp
rename to lib/Target/X86/X86Relocator.cpp
index d7cfe09..3b4d389 100644
--- a/lib/Target/X86/X86RelocationFactory.cpp
+++ b/lib/Target/X86/X86Relocator.cpp
@@ -1,4 +1,4 @@
-//===- X86RelocationFactory.cpp -------------------------------------------===//
+//===- X86Relocator.cpp -------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -11,10 +11,9 @@
 #include <llvm/Support/DataTypes.h>
 #include <llvm/Support/ELF.h>
 #include <mcld/Fragment/FragmentLinker.h>
-#include <mcld/LinkerConfig.h>
 #include <mcld/Support/MsgHandling.h>
 
-#include "X86RelocationFactory.h"
+#include "X86Relocator.h"
 #include "X86RelocationFunctions.h"
 
 using namespace mcld;
@@ -25,9 +24,8 @@
 DECL_X86_APPLY_RELOC_FUNCS
 
 /// the prototype of applying function
-typedef RelocationFactory::Result
-                          (*ApplyFunctionType)(Relocation& pReloc,
-                                               X86RelocationFactory& pParent);
+typedef Relocator::Result (*ApplyFunctionType)(Relocation& pReloc,
+                                               X86Relocator& pParent);
 
 // the table entry of applying functions
 struct ApplyFunctionTriple
@@ -43,20 +41,19 @@
 };
 
 //===--------------------------------------------------------------------===//
-// X86RelocationFactory
+// X86Relocator
 //===--------------------------------------------------------------------===//
-X86RelocationFactory::X86RelocationFactory(size_t pNum,
-                                           X86GNULDBackend& pParent)
-  : RelocationFactory(pNum),
+X86Relocator::X86Relocator(X86GNULDBackend& pParent)
+  : Relocator(),
     m_Target(pParent) {
 }
 
-X86RelocationFactory::~X86RelocationFactory()
+X86Relocator::~X86Relocator()
 {
 }
 
-RelocationFactory::Result
-X86RelocationFactory::applyRelocation(Relocation& pRelocation)
+Relocator::Result
+X86Relocator::applyRelocation(Relocation& pRelocation)
 {
   Relocation::Type type = pRelocation.type();
 
@@ -68,7 +65,7 @@
   return ApplyFunctions[type].func(pRelocation, *this);
 }
 
-const char* X86RelocationFactory::getName(Relocation::Type pType) const
+const char* X86Relocator::getName(Relocation::Type pType) const
 {
   return ApplyFunctions[pType].name;
 }
@@ -82,8 +79,8 @@
 Relocation& helper_DynRel(ResolveInfo* pSym,
                           Fragment& pFrag,
                           uint64_t pOffset,
-                          X86RelocationFactory::Type pType,
-                          X86RelocationFactory& pParent)
+                          X86Relocator::Type pType,
+                          X86Relocator& pParent)
 {
   X86GNULDBackend& ld_backend = pParent.getTarget();
   Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
@@ -102,7 +99,7 @@
 /// R_386_RELATIVE
 static bool
 helper_use_relative_reloc(const ResolveInfo& pSym,
-                          const X86RelocationFactory& pFactory)
+                          const X86Relocator& pFactory)
 
 {
   // if symbol is dynamic or undefine or preemptible
@@ -114,14 +111,14 @@
 }
 
 static
-GOT::Entry& helper_get_GOT_and_init(Relocation& pReloc,
-                                    X86RelocationFactory& pParent)
+X86GOTEntry& helper_get_GOT_and_init(Relocation& pReloc,
+                                     X86Relocator& pParent)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
   X86GNULDBackend& ld_backend = pParent.getTarget();
 
-  GOT::Entry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
+  X86GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
   if (NULL != got_entry)
     return *got_entry;
 
@@ -132,17 +129,17 @@
   // If we first get this GOT entry, we should initialize it.
   if (rsym->reserved() & X86GNULDBackend::ReserveGOT) {
     // No corresponding dynamic relocation, initialize to the symbol value.
-    got_entry->setContent(pReloc.symValue());
+    got_entry->setValue(pReloc.symValue());
   }
   else if (rsym->reserved() & X86GNULDBackend::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->setContent(pReloc.symValue());
+      got_entry->setValue(pReloc.symValue());
     }
     else {
       helper_DynRel(rsym, *got_entry, 0x0, llvm::ELF::R_386_GLOB_DAT, pParent);
-      got_entry->setContent(0);
+      got_entry->setValue(0);
     }
   }
   else {
@@ -153,31 +150,29 @@
 
 
 static
-X86RelocationFactory::Address helper_GOT_ORG(X86RelocationFactory& pParent)
+X86Relocator::Address helper_GOT_ORG(X86Relocator& pParent)
 {
   return pParent.getTarget().getGOTPLT().addr();
 }
 
 
 static
-X86RelocationFactory::Address helper_GOT(Relocation& pReloc,
-                                         X86RelocationFactory& pParent)
+X86Relocator::Address helper_GOT(Relocation& pReloc, X86Relocator& pParent)
 {
-  GOT::Entry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
-  X86RelocationFactory::Address got_addr = pParent.getTarget().getGOT().addr();
+  X86GOTEntry& got_entry = helper_get_GOT_and_init(pReloc, pParent);
+  X86Relocator::Address got_addr = pParent.getTarget().getGOT().addr();
   return got_addr + got_entry.getOffset();
 }
 
 
 static
-PLT::Entry& helper_get_PLT_and_init(Relocation& pReloc,
-                                    X86RelocationFactory& pParent)
+PLTEntryBase& helper_get_PLT_and_init(Relocation& pReloc, X86Relocator& pParent)
 {
   // rsym - The relocation target symbol
   ResolveInfo* rsym = pReloc.symInfo();
   X86GNULDBackend& ld_backend = pParent.getTarget();
 
-  PLT::Entry* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
+  PLTEntryBase* plt_entry = pParent.getSymPLTMap().lookUp(*rsym);
   if (NULL != plt_entry)
     return *plt_entry;
 
@@ -186,7 +181,7 @@
   pParent.getSymPLTMap().record(*rsym, *plt_entry);
   // If we first get this PLT entry, we should initialize it.
   if (rsym->reserved() & X86GNULDBackend::ReservePLT) {
-    GOT::Entry* gotplt_entry = pParent.getSymGOTPLTMap().lookUp(*rsym);
+    X86GOTPLTEntry* 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);
@@ -205,17 +200,16 @@
 
 
 static
-X86RelocationFactory::Address helper_PLT_ORG(X86RelocationFactory& pParent)
+X86Relocator::Address helper_PLT_ORG(X86Relocator& pParent)
 {
   return pParent.getTarget().getPLT().addr();
 }
 
 
 static
-X86RelocationFactory::Address helper_PLT(Relocation& pReloc,
-                                         X86RelocationFactory& pParent)
+X86Relocator::Address helper_PLT(Relocation& pReloc, X86Relocator& pParent)
 {
-  PLT::Entry& plt_entry = helper_get_PLT_and_init(pReloc, pParent);
+  PLTEntryBase& plt_entry = helper_get_PLT_and_init(pReloc, pParent);
   return helper_PLT_ORG(pParent) + plt_entry.getOffset();
 }
 
@@ -225,21 +219,19 @@
 //=========================================//
 
 // R_386_NONE
-X86RelocationFactory::Result none(Relocation& pReloc,
-                                  X86RelocationFactory& pParent)
+X86Relocator::Result none(Relocation& pReloc, X86Relocator& pParent)
 {
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_32: S + A
 // R_386_16
 // R_386_8
-X86RelocationFactory::Result abs(Relocation& pReloc,
-                                 X86RelocationFactory& pParent)
+X86Relocator::Result abs(Relocation& pReloc, X86Relocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
-  RelocationFactory::DWord S = pReloc.symValue();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
+  Relocator::DWord S = pReloc.symValue();
   bool has_dyn_rel = pParent.getTarget().symbolNeedsDynRel(
                               pParent.getFragmentLinker(),
                               *rsym,
@@ -251,7 +243,7 @@
   // but perform static relocation. (e.g., applying .debug section)
   if (0x0 == (llvm::ELF::SHF_ALLOC & target_sect.flag())) {
     pReloc.target() = S + A;
-    return X86RelocationFactory::OK;
+    return X86Relocator::OK;
   }
 
   // A local symbol may need REL Type dynamic relocation
@@ -267,7 +259,7 @@
                     pReloc.targetRef().offset(), pReloc.type(), pParent);
     }
     pReloc.target() = S + A;
-    return X86RelocationFactory::OK;
+    return X86Relocator::OK;
   }
 
   // An external symbol may need PLT and dynamic relocation
@@ -287,33 +279,32 @@
       else {
         helper_DynRel(rsym, *pReloc.targetRef().frag(),
                           pReloc.targetRef().offset(), pReloc.type(), pParent);
-        return X86RelocationFactory::OK;
+        return X86Relocator::OK;
       }
     }
   }
 
   // perform static relocation
   pReloc.target() = S + A;
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_PC32: S + A - P
 // R_386_PC16
 // R_386_PC8
-X86RelocationFactory::Result rel(Relocation& pReloc,
-                                 X86RelocationFactory& pParent)
+X86Relocator::Result rel(Relocation& pReloc, X86Relocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
-  RelocationFactory::DWord S = pReloc.symValue();
-  RelocationFactory::DWord P = pReloc.place();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
+  Relocator::DWord S = pReloc.symValue();
+  Relocator::DWord P = pReloc.place();
 
   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())) {
     pReloc.target() = S + A - P;
-    return X86RelocationFactory::OK;
+    return X86Relocator::OK;
   }
 
   // An external symbol may need PLT and dynamic relocation
@@ -334,80 +325,75 @@
       else {
         helper_DynRel(rsym, *pReloc.targetRef().frag(),
                           pReloc.targetRef().offset(), pReloc.type(), pParent);
-          return X86RelocationFactory::OK;
+          return X86Relocator::OK;
       }
     }
   }
 
    // perform static relocation
   pReloc.target() = S + A - P;
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_GOTOFF: S + A - GOT_ORG
-X86RelocationFactory::Result gotoff32(Relocation& pReloc,
-                                      X86RelocationFactory& pParent)
+X86Relocator::Result gotoff32(Relocation& pReloc, X86Relocator& pParent)
 {
-  RelocationFactory::DWord      A = pReloc.target() + pReloc.addend();
-  X86RelocationFactory::Address GOT_ORG = helper_GOT_ORG(pParent);
-  X86RelocationFactory::Address S = pReloc.symValue();
+  Relocator::DWord      A = pReloc.target() + pReloc.addend();
+  X86Relocator::Address GOT_ORG = helper_GOT_ORG(pParent);
+  X86Relocator::Address S = pReloc.symValue();
 
   pReloc.target() = S + A - GOT_ORG;
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_GOTPC: GOT_ORG + A - P
-X86RelocationFactory::Result gotpc32(Relocation& pReloc,
-                                     X86RelocationFactory& pParent)
+X86Relocator::Result gotpc32(Relocation& pReloc, X86Relocator& pParent)
 {
-  RelocationFactory::DWord      A       = pReloc.target() + pReloc.addend();
-  X86RelocationFactory::Address GOT_ORG = helper_GOT_ORG(pParent);
+  Relocator::DWord      A       = pReloc.target() + pReloc.addend();
+  X86Relocator::Address GOT_ORG = helper_GOT_ORG(pParent);
   // Apply relocation.
   pReloc.target() = GOT_ORG + A - pReloc.place();
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_GOT32: GOT(S) + A - GOT_ORG
-X86RelocationFactory::Result got32(Relocation& pReloc,
-                                   X86RelocationFactory& pParent)
+X86Relocator::Result got32(Relocation& pReloc, X86Relocator& pParent)
 {
   if (!(pReloc.symInfo()->reserved()
        & (X86GNULDBackend::ReserveGOT |X86GNULDBackend::GOTRel))) {
-    return X86RelocationFactory::BadReloc;
+    return X86Relocator::BadReloc;
   }
-  X86RelocationFactory::Address GOT_S   = helper_GOT(pReloc, pParent);
-  RelocationFactory::DWord      A       = pReloc.target() + pReloc.addend();
-  X86RelocationFactory::Address GOT_ORG = helper_GOT_ORG(pParent);
+  X86Relocator::Address GOT_S   = helper_GOT(pReloc, pParent);
+  Relocator::DWord      A       = pReloc.target() + pReloc.addend();
+  X86Relocator::Address GOT_ORG = helper_GOT_ORG(pParent);
   // Apply relocation.
   pReloc.target() = GOT_S + A - GOT_ORG;
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_PLT32: PLT(S) + A - P
-X86RelocationFactory::Result plt32(Relocation& pReloc,
-                                   X86RelocationFactory& pParent)
+X86Relocator::Result plt32(Relocation& pReloc, X86Relocator& pParent)
 {
   // PLT_S depends on if there is a PLT entry.
-  X86RelocationFactory::Address PLT_S;
+  X86Relocator::Address PLT_S;
   if ((pReloc.symInfo()->reserved() & X86GNULDBackend::ReservePLT))
     PLT_S = helper_PLT(pReloc, pParent);
   else
     PLT_S = pReloc.symValue();
-  RelocationFactory::DWord      A = pReloc.target() + pReloc.addend();
-  X86RelocationFactory::Address P = pReloc.place();
+  Relocator::DWord      A = pReloc.target() + pReloc.addend();
+  X86Relocator::Address P = pReloc.place();
   pReloc.target() = PLT_S + A - P;
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_TLS_GD:
-X86RelocationFactory::Result tls_gd(Relocation& pReloc,
-                                    X86RelocationFactory& pParent)
+X86Relocator::Result tls_gd(Relocation& pReloc, X86Relocator& pParent)
 {
   // global-dynamic
   ResolveInfo* rsym = pReloc.symInfo();
   // must reserve two pairs of got and dynamic relocation
   if (!(rsym->reserved() & X86GNULDBackend::GOTRel)) {
-     return X86RelocationFactory::BadReloc;
+     return X86Relocator::BadReloc;
   }
 
   X86GNULDBackend& ld_backend = pParent.getTarget();
@@ -416,21 +402,21 @@
   // 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
-  GOT::Entry* got_entry1 = pParent.getSymGOTMap().lookUp(*rsym);
+  X86GOTEntry* got_entry1 = pParent.getSymGOTMap().lookUp(*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);
-    GOT::Entry* got_entry2 = ld_backend.getGOT().consume();
-    got_entry1->setContent(0x0);
-    got_entry2->setContent(0x0);
+    X86GOTEntry* 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->setContent(pReloc.symValue());
+      got_entry2->setValue(pReloc.symValue());
 
       // for local tls symbol, add rel entry against the section symbol this
       // symbol belong to (.tdata or .tbss)
@@ -452,52 +438,49 @@
   }
 
   // perform relocation to the first got entry
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
   // GOT_OFF - the offset between the got_entry1 and _GLOBAL_OFFSET_TABLE (the
   // .got.plt section)
-  X86RelocationFactory::Address GOT_OFF =
+  X86Relocator::Address GOT_OFF =
      file_format->getGOT().addr() +
      got_entry1->getOffset() -
      file_format->getGOTPLT().addr();
   pReloc.target() = GOT_OFF + A;
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_TLS_LDM
-X86RelocationFactory::Result tls_ldm(Relocation& pReloc,
-                                     X86RelocationFactory& pParent)
+X86Relocator::Result tls_ldm(Relocation& pReloc, X86Relocator& pParent)
 {
   // FIXME: no linker optimization for TLS relocation
-  const GOT::Entry& got_entry = pParent.getTarget().getTLSModuleID();
+  const X86GOTEntry& got_entry = pParent.getTarget().getTLSModuleID();
 
   // All GOT offsets are relative to the end of the GOT.
-  X86RelocationFactory::SWord GOT_S = got_entry.getOffset() -
+  X86Relocator::SWord GOT_S = got_entry.getOffset() -
                                       (pParent.getTarget().getGOTPLT().addr() -
                                        pParent.getTarget().getGOT().addr());
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
   pReloc.target() = GOT_S + A;
 
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_TLS_LDO_32
-X86RelocationFactory::Result tls_ldo_32(Relocation& pReloc,
-                                        X86RelocationFactory& pParent)
+X86Relocator::Result tls_ldo_32(Relocation& pReloc, X86Relocator& pParent)
 {
   // FIXME: no linker optimization for TLS relocation
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
-  X86RelocationFactory::Address S = pReloc.symValue();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
+  X86Relocator::Address S = pReloc.symValue();
   pReloc.target() = S + A;
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_X86_TLS_IE
-X86RelocationFactory::Result tls_ie(Relocation& pReloc,
-                                    X86RelocationFactory& pParent)
+X86Relocator::Result tls_ie(Relocation& pReloc, X86Relocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
   if (!(rsym->reserved() & X86GNULDBackend::GOTRel)) {
-     return X86RelocationFactory::BadReloc;
+     return X86Relocator::BadReloc;
   }
 
   if (rsym->reserved() & X86GNULDBackend::ReserveRel) {
@@ -507,13 +490,13 @@
   }
 
   // set up the got and dynamic relocation entries if not exist
-  GOT::Entry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
+  X86GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
   if (NULL == got_entry) {
     // set got entry
     X86GNULDBackend& ld_backend = pParent.getTarget();
     got_entry = ld_backend.getGOT().consume();
     pParent.getSymGOTMap().record(*rsym, *got_entry);
-    got_entry->setContent(0x0);
+    got_entry->setValue(0x0);
     // set relocation entry
     Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
     rel_entry.setType(llvm::ELF::R_386_TLS_TPOFF);
@@ -522,32 +505,31 @@
   }
 
   // perform relocation to the absolute address of got_entry
-  X86RelocationFactory::Address GOT_S =
+  X86Relocator::Address GOT_S =
                  pParent.getTarget().getGOT().addr() + got_entry->getOffset();
 
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
   pReloc.target() = GOT_S + A;
 
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_386_TLS_GOTIE
-X86RelocationFactory::Result tls_gotie(Relocation& pReloc,
-                                       X86RelocationFactory& pParent)
+X86Relocator::Result tls_gotie(Relocation& pReloc, X86Relocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
   if (!(rsym->reserved() & X86GNULDBackend::GOTRel)) {
-     return X86RelocationFactory::BadReloc;
+     return X86Relocator::BadReloc;
   }
 
   // set up the got and dynamic relocation entries if not exist
-  GOT::Entry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
+  X86GOTEntry* got_entry = pParent.getSymGOTMap().lookUp(*rsym);
   if (NULL == got_entry) {
     // set got entry
     X86GNULDBackend& ld_backend = pParent.getTarget();
     got_entry = ld_backend.getGOT().consume();
     pParent.getSymGOTMap().record(*rsym, *got_entry);
-    got_entry->setContent(0x0);
+    got_entry->setValue(0x0);
     // set relocation entry
     Relocation& rel_entry = *ld_backend.getRelDyn().consumeEntry();
     rel_entry.setType(llvm::ELF::R_386_TLS_TPOFF);
@@ -556,17 +538,16 @@
   }
 
   // All GOT offsets are relative to the end of the GOT.
-  X86RelocationFactory::SWord GOT_S = got_entry->getOffset() -
+  X86Relocator::SWord GOT_S = got_entry->getOffset() -
     (pParent.getTarget().getGOTPLT().addr() - pParent.getTarget().getGOT().addr());
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
   pReloc.target() = GOT_S + A;
 
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
 // R_X86_TLS_LE
-X86RelocationFactory::Result tls_le(Relocation& pReloc,
-                                    X86RelocationFactory& pParent)
+X86Relocator::Result tls_le(Relocation& pReloc, X86Relocator& pParent)
 {
   ResolveInfo* rsym = pReloc.symInfo();
   if (pReloc.symInfo()->reserved() & X86GNULDBackend::ReserveRel) {
@@ -575,22 +556,21 @@
                   pReloc.targetRef().offset(),
                   llvm::ELF::R_386_TLS_TPOFF,
                   pParent);
-    return X86RelocationFactory::OK;
+    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);
-  RelocationFactory::DWord A = pReloc.target() + pReloc.addend();
-  X86RelocationFactory::Address S = pReloc.symValue();
+  Relocator::DWord A = pReloc.target() + pReloc.addend();
+  X86Relocator::Address S = pReloc.symValue();
   pReloc.target() = S + A - tls_seg->memsz();
-  return X86RelocationFactory::OK;
+  return X86Relocator::OK;
 }
 
-X86RelocationFactory::Result unsupport(Relocation& pReloc,
-                                       X86RelocationFactory& pParent)
+X86Relocator::Result unsupport(Relocation& pReloc, X86Relocator& pParent)
 {
-  return X86RelocationFactory::Unsupport;
+  return X86Relocator::Unsupport;
 }
 
diff --git a/lib/Target/X86/X86RelocationFactory.h b/lib/Target/X86/X86Relocator.h
similarity index 64%
rename from lib/Target/X86/X86RelocationFactory.h
rename to lib/Target/X86/X86Relocator.h
index 92119f1..7d3c289 100644
--- a/lib/Target/X86/X86RelocationFactory.h
+++ b/lib/Target/X86/X86Relocator.h
@@ -1,4 +1,4 @@
-//===-  X86RelocationFactory.h --------------------------------------------===//
+//===-  X86Relocator.h --------------------------------------------===//
 //
 //                     The MCLinker Project
 //
@@ -12,7 +12,7 @@
 #include <gtest.h>
 #endif
 
-#include <mcld/LD/RelocationFactory.h>
+#include <mcld/LD/Relocator.h>
 #include <mcld/Target/GOT.h>
 #include <mcld/Target/PLT.h>
 #include <mcld/Target/SymbolEntryMap.h>
@@ -22,19 +22,20 @@
 
 class ResolveInfo;
 
-/** \class X86RelocationFactory
- *  \brief X86RelocationFactory creates and destroys the X86 relocations.
+/** \class X86Relocator
+ *  \brief X86Relocator creates and destroys the X86 relocations.
  *
  */
-class X86RelocationFactory : public RelocationFactory
+class X86Relocator : public Relocator
 {
 public:
-  typedef SymbolEntryMap<PLT::Entry> SymPLTMap;
-  typedef SymbolEntryMap<GOT::Entry> SymGOTMap;
+  typedef SymbolEntryMap<PLTEntryBase> SymPLTMap;
+  typedef SymbolEntryMap<X86GOTEntry> SymGOTMap;
+  typedef SymbolEntryMap<X86GOTPLTEntry> SymGOTPLTMap;
 
 public:
-  X86RelocationFactory(size_t pNum, X86GNULDBackend& pParent);
-  ~X86RelocationFactory();
+  X86Relocator(X86GNULDBackend& pParent);
+  ~X86Relocator();
 
   Result applyRelocation(Relocation& pRelocation);
 
@@ -52,14 +53,14 @@
   const SymGOTMap& getSymGOTMap() const { return m_SymGOTMap; }
   SymGOTMap&       getSymGOTMap()       { return m_SymGOTMap; }
 
-  const SymGOTMap& getSymGOTPLTMap() const { return m_SymGOTPLTMap; }
-  SymGOTMap&       getSymGOTPLTMap()       { return m_SymGOTPLTMap; }
+  const SymGOTPLTMap& getSymGOTPLTMap() const { return m_SymGOTPLTMap; }
+  SymGOTPLTMap&       getSymGOTPLTMap()       { return m_SymGOTPLTMap; }
 
 private:
   X86GNULDBackend& m_Target;
   SymPLTMap m_SymPLTMap;
   SymGOTMap m_SymGOTMap;
-  SymGOTMap m_SymGOTPLTMap;
+  SymGOTPLTMap m_SymGOTPLTMap;
 };
 
 } // namespace of mcld
diff --git a/tools/llvm-mcld/llvm-mcld.cpp b/tools/llvm-mcld/llvm-mcld.cpp
index 28a18c6..e7a48d0 100644
--- a/tools/llvm-mcld/llvm-mcld.cpp
+++ b/tools/llvm-mcld/llvm-mcld.cpp
@@ -283,7 +283,7 @@
            cl::value_desc("directory"),
            cl::ValueRequired);
 
-static cl::list<std::string>
+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."),
@@ -597,6 +597,26 @@
                        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>
+ArgNoStdLib("nostdlib",
+            cl::desc("Only search lib dirs explicitly specified on cmdline"),
+            cl::init(false));
+
+static cl::opt<bool>
+ArgWarnCommon("warn-common",
+              cl::desc("warn common symbol"),
+              cl::init(false));
+
+static cl::opt<bool>
+ArgFatalWarnings("fatal-warnings",
+              cl::desc("turn all warnings into errors"),
+              cl::init(false));
+
 /// @{
 /// @name FIXME: end of unsupported options
 /// @}
@@ -606,6 +626,54 @@
                      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::desc("alias for -d"),
+                      cl::aliasopt(ArgDefineCommon));
+
+static cl::alias
+ArgDefineCommonAlias2("dp",
+                      cl::desc("alias for -d"),
+                      cl::aliasopt(ArgDefineCommon));
+
 //===----------------------------------------------------------------------===//
 // Scripting Options
 //===----------------------------------------------------------------------===//
@@ -743,6 +811,7 @@
     break;
   case mcld::CGFT_DSOFile:
   case mcld::CGFT_EXEFile:
+  case mcld::CGFT_BINARY:
   case mcld::CGFT_NULLFile:
     permission = 0755;
     break;
@@ -759,6 +828,44 @@
   return result_output;
 }
 
+/// 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 void 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;
+  }
+
+  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 (!llvm::TargetRegistry::lookupTarget(Prefix, IgnoredError))
+      continue;
+    TargetTriple = Prefix.str();
+    return;
+  }
+}
+
 static bool ShouldColorize()
 {
    const char* term = getenv("TERM");
@@ -788,6 +895,9 @@
   // set up soname
   pConfig.options().setSOName(ArgSOName);
 
+  // --fatal-warnings
+  pConfig.options().setFatalWarnings(ArgFatalWarnings);
+
   // -shared or -pie
   if (true == ArgShared || true == ArgPIE) {
     ArgFileType = mcld::CGFT_DSOFile;
@@ -795,6 +905,13 @@
   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) {
@@ -838,6 +955,7 @@
   pConfig.options().setStripDebug(ArgStripDebug);
   pConfig.options().setExportDynamic(ArgExportDynamic);
   pConfig.options().setWarnSharedTextrel(ArgWarnSharedTextrel);
+  pConfig.options().setDefineCommon(ArgDefineCommon);
 
   // set up rename map, for --wrap
   cl::list<std::string>::iterator wname;
@@ -968,13 +1086,6 @@
 {
   LLVMContext &Context = getGlobalContext();
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
-  cl::ParseCommandLineOptions(argc, argv, "MCLinker\n");
-
-#ifdef ENABLE_UNITTEST
-  if (UnitTest) {
-    return unit_test( argc, argv );
-  }
-#endif
 
   // Initialize targets first, so that --version shows registered targets.
   InitializeAllTargets();
@@ -986,6 +1097,15 @@
   mcld::InitializeAllEmulations();
   mcld::InitializeAllDiagnostics();
 
+  ParseProgName(argv[0]);
+  cl::ParseCommandLineOptions(argc, argv, "MCLinker\n");
+
+#ifdef ENABLE_UNITTEST
+  if (UnitTest) {
+    return unit_test( argc, argv );
+  }
+#endif
+
   // Load the module to be compiled...
   std::auto_ptr<llvm::Module> M;
 
@@ -1003,7 +1123,8 @@
   if (ArgBitcodeFilename.empty() &&
       (mcld::CGFT_DSOFile != ArgFileType &&
        mcld::CGFT_EXEFile != ArgFileType &&
-       mcld::CGFT_PARTIAL != 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"
@@ -1087,7 +1208,7 @@
     }
   }
   // Set up mcld::LinkerConfig
-  LDConfig.setTriple(TheTriple);
+  LDConfig.targets().setTriple(TheTriple);
 
   // Package up features to be passed to target/subtarget
   std::string FeaturesStr;
@@ -1199,6 +1320,9 @@
     PM.run(mod);
   }
 
+  if (mcld::getDiagnosticEngine().getPrinter()->getNumErrors())
+    return 1;
+
   // Declare success.
   Out->keep();
   return 0;
diff --git a/tools/mcld/include/alone/Linker.h b/tools/mcld/include/alone/Linker.h
index b0bdc5e..987b36a 100644
--- a/tools/mcld/include/alone/Linker.h
+++ b/tools/mcld/include/alone/Linker.h
@@ -15,16 +15,11 @@
 namespace mcld {
 
 class Module;
-class TargetLDBackend;
-class ObjectLinker;
-class ContextFactory;
+class IRBuilder;
 class LinkerConfig;
-class TreeIteratorBase;
+class Linker;
 class Input;
-class InputFactory;
-class InputBuilder;
 class MemoryArea;
-class MemoryAreaFactory;
 
 namespace sys { namespace fs {
 
@@ -43,11 +38,10 @@
   enum ErrorCode {
     kSuccess,
     kDoubleConfig,
-    kCreateBackend,
     kDelegateLDInfo,
     kFindNameSpec,
-    kOpenNameSpec,
     kOpenObjectFile,
+    kOpenMemory,
     kNotConfig,
     kNotSetUpOutput,
     kOpenOutput,
@@ -62,15 +56,11 @@
 private:
   const mcld::LinkerConfig *mLDConfig;
   mcld::Module *mModule;
-  mcld::TargetLDBackend *mBackend;
-  mcld::ObjectLinker *mObjLinker;
-  mcld::InputFactory *mInputFactory;
-  mcld::MemoryAreaFactory *mMemAreaFactory;
-  mcld::ContextFactory *mContextFactory;
-  mcld::InputBuilder *mBuilder;
-  mcld::TreeIteratorBase *mRoot;
+  mcld::Linker *mLinker;
+  mcld::IRBuilder *mBuilder;
   std::string mSOName;
-  mcld::MemoryArea* mOutput;
+  std::string mOutputPath;
+  int mOutputHandler;
 
 public:
   Linker();
@@ -97,12 +87,6 @@
 
 private:
   enum ErrorCode extractFiles(const LinkerConfig& pConfig);
-
-  enum ErrorCode openFile(const mcld::sys::fs::Path& pPath,
-                          enum ErrorCode pCode,
-                          mcld::Input& pInput);
-
-  void advanceRoot();
 };
 
 } // end namespace alone
diff --git a/tools/mcld/include/alone/Support/LinkerConfig.h b/tools/mcld/include/alone/Support/LinkerConfig.h
index 0aa3277..6eecdd5 100644
--- a/tools/mcld/include/alone/Support/LinkerConfig.h
+++ b/tools/mcld/include/alone/Support/LinkerConfig.h
@@ -86,6 +86,8 @@
 
   void setBsymbolic(bool pEnable = true);
 
+  void setDefineCommon(bool pEnable = true);
+
   void setSOName(const std::string &pSOName);
 
   void setDyld(const std::string &pDyld);
diff --git a/tools/mcld/include/alone/Support/Log.h b/tools/mcld/include/alone/Support/Log.h
index bc91d44..e3c80d1 100644
--- a/tools/mcld/include/alone/Support/Log.h
+++ b/tools/mcld/include/alone/Support/Log.h
@@ -13,6 +13,6 @@
 #include <cstdio>
 
 #define ALOGE(fmt, args...) \
-printf("%s:%s:%d: "fmt, __FILE__, __FUNCTION__, __LINE__, args)
+printf("%s:%s:%d: " fmt, __FILE__, __FUNCTION__, __LINE__, args)
 
 #endif // ALONE_SUPPORT_LOG_H
diff --git a/tools/mcld/lib/Core/Linker.cpp b/tools/mcld/lib/Core/Linker.cpp
index d3f1450..83de5a8 100644
--- a/tools/mcld/lib/Core/Linker.cpp
+++ b/tools/mcld/lib/Core/Linker.cpp
@@ -15,20 +15,11 @@
 
 #include <mcld/Module.h>
 #include <mcld/IRBuilder.h>
-#include <mcld/InputTree.h>
-#include <mcld/Object/ObjectLinker.h>
-#include <mcld/Fragment/FragmentLinker.h>
-#include <mcld/MC/InputFactory.h>
-#include <mcld/MC/ContextFactory.h>
-#include <mcld/MC/InputBuilder.h>
+#include <mcld/MC/MCLDInput.h>
+#include <mcld/Linker.h>
 #include <mcld/LD/LDSection.h>
 #include <mcld/LD/LDContext.h>
-#include <mcld/Target/TargetLDBackend.h>
 #include <mcld/Support/Path.h>
-#include <mcld/Support/MemoryArea.h>
-#include <mcld/Support/FileHandle.h>
-#include <mcld/Support/MemoryAreaFactory.h>
-#include <mcld/Support/TargetRegistry.h>
 
 using namespace alone;
 
@@ -38,14 +29,10 @@
     "Successfully compiled.",
     /* kDoubleConfig */
     "Configure Linker twice.",
-    /* kCreateBackend */
-    "Cannot create backend.",
     /* kDelegateLDInfo */
     "Cannot get linker information",
     /* kFindNameSpec */
     "Cannot find -lnamespec",
-    /* kOpenNameSpec */
-    "Cannot open -lnamespec",
     /* kOpenObjectFile */
     "Cannot open object file",
     /* kNotConfig */
@@ -75,15 +62,13 @@
 // Linker
 //===----------------------------------------------------------------------===//
 Linker::Linker()
-  : mLDConfig(NULL), mModule(NULL), mBackend(NULL), mObjLinker(NULL),
-    mInputFactory(NULL), mMemAreaFactory(NULL), mContextFactory(NULL),
-    mBuilder(NULL), mRoot(NULL), mOutput(NULL) {
+  : mLDConfig(NULL), mModule(NULL), mLinker(NULL), mBuilder(NULL),
+    mOutputHandler(-1) {
 }
 
 Linker::Linker(const LinkerConfig& pConfig)
-  : mLDConfig(NULL), mModule(NULL), mBackend(NULL), mObjLinker(NULL),
-    mInputFactory(NULL), mMemAreaFactory(NULL), mContextFactory(NULL),
-    mBuilder(NULL), mRoot(NULL), mOutput(NULL) {
+  : mLDConfig(NULL), mModule(NULL), mLinker(NULL), mBuilder(NULL),
+    mOutputHandler(-1) {
 
   const std::string &triple = pConfig.getTriple();
 
@@ -98,14 +83,8 @@
 
 Linker::~Linker() {
   delete mModule;
-  delete mObjLinker;
-  // FIXME: current implementation can not change the order of deleting
-  // ObjectLinker and TargetLDBackend. Because the deletion of relocation list
-  // in FragmentLinker (FragmentLinker is deleted by ObjectLinker) depends on
-  // RelocationFactory in TargetLDBackend
-  delete mBackend;
+  delete mLinker;
   delete mBuilder;
-  delete mRoot;
 }
 
 enum Linker::ErrorCode Linker::extractFiles(const LinkerConfig& pConfig) {
@@ -123,229 +102,73 @@
 
   extractFiles(pConfig);
 
-  mBackend = pConfig.getTarget()->createLDBackend(*mLDConfig);
-  if (mBackend == NULL) {
-    return kCreateBackend;
-  }
-
-  mInputFactory = new mcld::InputFactory(32, *mLDConfig);
-
-  mContextFactory = new mcld::ContextFactory(32);
-    /* 32 is a magic number, the estimated number of input files **/
-
-  mMemAreaFactory = new mcld::MemoryAreaFactory(32);
-
-  mBuilder = new mcld::InputBuilder(*mLDConfig,
-                                    *mInputFactory,
-                                    *mContextFactory,
-                                    *mMemAreaFactory,
-                                    true); // delegated
-
   mModule = new mcld::Module(mLDConfig->options().soname());
 
-  mRoot = new mcld::InputTree::iterator(mModule->getInputTree().root());
+  mBuilder = new mcld::IRBuilder(*mModule, *mLDConfig);
 
-  mObjLinker = new mcld::ObjectLinker(*mLDConfig, *mModule, *mBuilder, *mBackend);
+  mLinker = new mcld::Linker();
 
-  mObjLinker->initFragmentLinker();
+  mLinker->config(const_cast<mcld::LinkerConfig&>(*mLDConfig));
 
   return kSuccess;
 }
 
-void Linker::advanceRoot() {
-  if (mRoot->isRoot()) {
-    mRoot->move<mcld::TreeIteratorBase::Leftward>();
-  } else {
-    mRoot->move<mcld::TreeIteratorBase::Rightward>();
-  }
-  return;
-}
-
-enum Linker::ErrorCode Linker::openFile(const mcld::sys::fs::Path& pPath,
-                                        enum Linker::ErrorCode pCode,
-                                        mcld::Input& pInput) {
-  mcld::MemoryArea *input_memory = mMemAreaFactory->produce(pPath,
-                                                    mcld::FileHandle::ReadOnly);
-
-  if (input_memory->handler()->isGood()) {
-    pInput.setMemArea(input_memory);
-  } else {
-    return pCode;
-  }
-
-  mBuilder->setContext(pInput);
-  return kSuccess;
-}
-
 enum Linker::ErrorCode Linker::addNameSpec(const std::string &pNameSpec) {
-  const mcld::sys::fs::Path* path = NULL;
-  // find out the real path of the namespec.
-  if (mLDConfig->attribute().constraint().isSharedSystem()) {
-    // In the system with shared object support, we can find both archive
-    // and shared object.
-
-    if (mInputFactory->attr().isStatic()) {
-      // with --static, we must search an archive.
-      path = mLDConfig->options().directories().find(pNameSpec,
-                                                     mcld::Input::Archive);
-    }
-    else {
-      // otherwise, with --Bdynamic, we can find either an archive or a
-      // shared object.
-      path = mLDConfig->options().directories().find(pNameSpec,
-                                                     mcld::Input::DynObj);
-    }
-  }
-  else {
-    // In the system without shared object support, we only look for an
-    // archive.
-    path = mLDConfig->options().directories().find(pNameSpec,
-                                                 mcld::Input::Archive);
-  }
-
-  if (NULL == path)
+  mcld::Input* input = mBuilder->ReadInput(pNameSpec);
+  if (NULL == input)
     return kFindNameSpec;
-
-  mcld::Input* input = mInputFactory->produce(pNameSpec, *path,
-                                              mcld::Input::Unknown);
-  mModule->getInputTree().insert<mcld::InputTree::Positional>(*mRoot, *input);
-
-  advanceRoot();
-
-  return openFile(*path, kOpenNameSpec, *input);
+  return kSuccess;
 }
 
 /// addObject - Add a object file by the filename.
 enum Linker::ErrorCode Linker::addObject(const std::string &pObjectPath) {
-  mcld::Input* input = mInputFactory->produce(pObjectPath,
-                                              pObjectPath,
-                                              mcld::Input::Unknown);
-
-  mModule->getInputTree().insert<mcld::InputTree::Positional>(*mRoot, *input);
-
-  advanceRoot();
-
-  return openFile(pObjectPath, kOpenObjectFile, *input);
+  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 = mInputFactory->produce("memory object", "NAN",
-                                              mcld::Input::Unknown);
-
-  mModule->getInputTree().insert<mcld::InputTree::Positional>(*mRoot, *input);
-
-  advanceRoot();
-
-  mcld::MemoryArea *input_memory = mMemAreaFactory->produce(pMemory, pSize);
-  input->setMemArea(input_memory);
-
-  mcld::LDContext *input_context = mContextFactory->produce();
-  input->setContext(input_context);
-
+  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 = mInputFactory->produce("code object", "NAN",
-                                              mcld::Input::External);
-
-  mModule->getInputTree().insert<mcld::InputTree::Positional>(*mRoot, *input);
-
-  advanceRoot();
-
-  mcld::MemoryArea *input_memory = mMemAreaFactory->produce(pMemory, pSize);
-  input->setMemArea(input_memory);
-
-  mcld::LDContext *input_context = mContextFactory->produce();
-  input->setContext(input_context);
-
-  // FIXME: So far, FragmentLinker must set up output before add input files.
-  // set up LDContext
-  if (mObjLinker->hasInitLinker()) {
-    return kNotConfig;
-  }
-
-  // create NULL section
-  mcld::LDSection* null = mcld::IRBuilder::CreateELFHeader(*input, "",
-                              llvm::ELF::SHT_NULL, 0, 0);
-  null->setSize(0);
-  null->setOffset(0);
-  null->setInfo(0);
-
-  // create .text section
-  mcld::LDSection* text = mcld::IRBuilder::CreateELFHeader(*input, ".text",
-                              llvm::ELF::SHT_PROGBITS,
-                              llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR,
-                              1);
-
-  text->setSize(pSize);
-  text->setOffset(0x0);
-  text->setInfo(0);
-
+  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) {
-  // -----  initialize output file  ----- //
-  mcld::FileHandle::Permission perm = 0755;
-
-  mOutput = mMemAreaFactory->produce(
-                      pPath,
-                      mcld::FileHandle::ReadWrite |
-                        mcld::FileHandle::Truncate |
-                        mcld::FileHandle::Create,
-                      perm);
-
-  if (!mOutput->handler()->isGood()) {
-    return kOpenOutput;
-  }
-
+  mOutputPath = pPath;
   return kSuccess;
 }
 
 enum Linker::ErrorCode Linker::setOutput(int pFileHandler) {
-  mOutput = mMemAreaFactory->produce(pFileHandler, mcld::FileHandle::ReadWrite);
-
-  if (!mOutput->handler()->isGood()) {
-    return kOpenOutput;
-  }
-
+  mOutputHandler = pFileHandler;
   return kSuccess;
 }
 
 enum Linker::ErrorCode Linker::link() {
-  if (NULL == mOutput)
-    return kNotSetUpOutput;
-
-  if (!mObjLinker->hasInitLinker()) {
-    return kNotConfig;
+  mLinker->link(*mModule, *mBuilder);
+  if (!mOutputPath.empty()) {
+    mLinker->emit(mOutputPath);
+    return kSuccess;
   }
 
-  mObjLinker->initStdSections();
-
-  mObjLinker->normalize();
-
-  if (!mObjLinker->readRelocations())
-    return kReadSections;
-
-  if (!mObjLinker->mergeSections())
-    return kReadSections;
-
-  if (!mObjLinker->addStandardSymbols() || !mObjLinker->addTargetSymbols()) {
-    return kAddAdditionalSymbols;
+  if (-1 != mOutputHandler) {
+    mLinker->emit(mOutputHandler);
+    return kSuccess;
   }
-
-  mObjLinker->scanRelocations();
-  mObjLinker->prelayout();
-  mObjLinker->layout();
-  mObjLinker->postlayout();
-  mObjLinker->finalizeSymbolValue();
-  mObjLinker->relocation();
-  mObjLinker->emitOutput(*mOutput);
-  mObjLinker->postProcessing(*mOutput);
-
-  return kSuccess;
+  return kNotSetUpOutput;
 }
 
diff --git a/tools/mcld/lib/Support/LinkerConfig.cpp b/tools/mcld/lib/Support/LinkerConfig.cpp
index 3a53ae1..3715bf8 100644
--- a/tools/mcld/lib/Support/LinkerConfig.cpp
+++ b/tools/mcld/lib/Support/LinkerConfig.cpp
@@ -157,6 +157,11 @@
   return;
 }
 
+void LinkerConfig::setDefineCommon(bool pEnable) {
+  mLDConfig->options().setDefineCommon(pEnable);
+  return;
+}
+
 void LinkerConfig::setSOName(const std::string &pSOName) {
   mLDConfig->options().setSOName(pSOName);
   return;
diff --git a/tools/mcld/lib/Support/TargetLinkerConfigs.cpp b/tools/mcld/lib/Support/TargetLinkerConfigs.cpp
index 0382c2a..1ce0237 100644
--- a/tools/mcld/lib/Support/TargetLinkerConfigs.cpp
+++ b/tools/mcld/lib/Support/TargetLinkerConfigs.cpp
@@ -10,7 +10,9 @@
 #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;
 
@@ -28,6 +30,10 @@
 #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();
@@ -53,6 +59,9 @@
     getLDConfig()->scripts().sectionMap().append(".ARM.extab", ".ARM.extab", exist);
     getLDConfig()->scripts().sectionMap().append(".ARM.attributes", ".ARM.attributes", exist);
   }
+
+  // set up relocation factory
+  mcld::Relocation::SetUp(*getLDConfig());
 }
 #endif // defined(PROVIDE_ARM_CODEGEN)
 
@@ -63,6 +72,10 @@
 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();
@@ -80,6 +93,9 @@
   if (!getLDConfig()->options().hasDyld()) {
     getLDConfig()->options().setDyld(gDefaultDyld);
   }
+
+  // set up relocation factory
+  mcld::Relocation::SetUp(*getLDConfig());
 }
 #endif // defined(PROVIDE_MIPS_CODEGEN)
 
@@ -89,6 +105,10 @@
 #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();
@@ -106,6 +126,9 @@
   if (!getLDConfig()->options().hasDyld()) {
     getLDConfig()->options().setDyld(gDefaultDyld);
   }
+
+  // set up relocation factory
+  mcld::Relocation::SetUp(*getLDConfig());
 }
 
 X86_32LinkerConfig::X86_32LinkerConfig()
@@ -123,6 +146,11 @@
 //===----------------------------------------------------------------------===//
 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();
@@ -133,12 +161,15 @@
   getLDConfig()->attribute().predefined().setDynamic();
 
   // set up section map
-  if (llvm::Triple::arm == getLDConfig()->triple().getArch() &&
+  if (llvm::Triple::arm == getLDConfig()->targets().triple().getArch() &&
       getLDConfig()->codeGenType() != mcld::LinkerConfig::Object) {
     bool exist = false;
     getLDConfig()->scripts().sectionMap().append(".ARM.exidx", ".ARM.exidx", exist);
     getLDConfig()->scripts().sectionMap().append(".ARM.extab", ".ARM.extab", exist);
     getLDConfig()->scripts().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 a66fb7c..58a9bb0 100644
--- a/tools/mcld/main.cpp
+++ b/tools/mcld/main.cpp
@@ -97,6 +97,33 @@
         llvm::cl::desc("Set the name of the dynamic linker."),
         llvm::cl::value_desc("Program"));
 
+static llvm::cl::opt<bool>
+OptRelocatable("relocatable",
+               llvm::cl::desc("Generate relocatable output"),
+               llvm::cl::init(false));
+
+static llvm::cl::alias
+OptRelocatableAlias("r",
+                    llvm::cl::desc("alias for --relocatable"),
+                    llvm::cl::aliasopt(OptRelocatable));
+
+static llvm::cl::opt<bool>
+OptDefineCommon("d",
+                llvm::cl::ZeroOrMore,
+                llvm::cl::desc("Define common symbol"),
+                llvm::cl::init(false));
+
+static llvm::cl::alias
+OptDefineCommonAlias1("dc",
+                      llvm::cl::desc("alias for -d"),
+                      llvm::cl::aliasopt(OptDefineCommon));
+
+static llvm::cl::alias
+OptDefineCommonAlias2("dp",
+                      llvm::cl::desc("alias for -d"),
+                      llvm::cl::aliasopt(OptDefineCommon));
+
+
 //===----------------------------------------------------------------------===//
 // Inputs
 //===----------------------------------------------------------------------===//
@@ -135,7 +162,7 @@
 static void MCLDVersionPrinter() {
   llvm::raw_ostream &os = llvm::outs();
   os << "mcld (The MCLinker Project, http://mclinker.googlecode.com/):\n"
-     << "  version: "MCLD_VERSION"\n"
+     << "  version: " MCLD_VERSION "\n"
      << "  Default target: " << DEFAULT_TARGET_TRIPLE_STRING << "\n";
 
   os << "\n";
@@ -236,6 +263,9 @@
   // 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: "
diff --git a/unittests/FragmentTest.cpp b/unittests/FragmentTest.cpp
index 9713f48..43f51b6 100644
--- a/unittests/FragmentTest.cpp
+++ b/unittests/FragmentTest.cpp
@@ -47,9 +47,8 @@
   new Fragment(Fragment::Alignment, s);
   new Fragment(Fragment::Region, s);
   new Fragment(Fragment::Fillment, s);
-  new Fragment(Fragment::Relocation, s);
   new Fragment(Fragment::Target, s);
-  EXPECT_TRUE(6 == s->size());
+  EXPECT_TRUE(5 == s->size());
 
   LDSection::Destroy(test);
 //  SectionData::Destroy(s);
diff --git a/unittests/Linker/TestLinker.cpp b/unittests/Linker/TestLinker.cpp
deleted file mode 100644
index d1ead28..0000000
--- a/unittests/Linker/TestLinker.cpp
+++ /dev/null
@@ -1,290 +0,0 @@
-//===- TestLinker.cpp -----------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include "TestLinker.h"
-
-#include <llvm/Support/TargetSelect.h>
-
-#include <mcld/Environment.h>
-#include <mcld/InputTree.h>
-#include <mcld/LD/TextDiagnosticPrinter.h>
-#include <mcld/MC/InputBuilder.h>
-#include <mcld/MC/InputFactory.h>
-#include <mcld/MC/MCLDDirectory.h>
-#include <mcld/Target/TargetLDBackend.h>
-#include <mcld/Support/Space.h>
-#include <mcld/Support/TargetSelect.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Support/raw_ostream.h>
-#include <mcld/Support/SystemUtils.h>
-#include <mcld/Support/MemoryAreaFactory.h>
-#include <mcld/MC/ContextFactory.h>
-
-using namespace mcld;
-using namespace mcld::sys::fs;
-using namespace mcld::test;
-
-//===----------------------------------------------------------------------===//
-// TestLinker
-//===----------------------------------------------------------------------===//
-TestLinker::TestLinker()
-  : m_pTarget(NULL), m_pObjLinker(NULL), m_pConfig(NULL), m_pDiagLineInfo(NULL),
-    m_pDiagPrinter(NULL), m_pBackend(NULL), m_pBuilder(NULL), m_pOutput(NULL) {
-}
-
-TestLinker::~TestLinker()
-{
-  std::list<mcld::FileHandle*>::iterator file, fEnd = m_FileHandleList.end();
-  for (file = m_FileHandleList.begin(); file != fEnd; ++file)
-    delete (*file);
-
-  std::list<mcld::MemoryArea*>::iterator mem, mEnd = m_MemAreaList.end() ;
-  for (mem = m_MemAreaList.begin(); mem != mEnd; ++mem)
-    delete (*mem);
-
-  delete m_pObjLinker;
-  delete m_pConfig;
-  delete m_pDiagLineInfo;
-  delete m_pDiagPrinter;
-  delete m_pBackend;
-  delete m_pBuilder;
-  delete m_pOutput;
-}
-
-bool TestLinker::initialize(const std::string &pTriple)
-{
-  // initilaize all llvm::Target and mcld::Target
-  llvm::InitializeAllTargets();
-  llvm::InitializeAllAsmPrinters();
-  llvm::InitializeAllAsmParsers();
-  llvm::InitializeAllTargetMCs();
-  mcld::Initialize();
-
-  // create mcld::LinkerConfig
-  m_pConfig = new LinkerConfig(pTriple);
-
-  m_Root = m_Module.getInputTree().root();
-
-  // specify mcld::Target
-  std::string error;
-  m_pTarget = mcld::TargetRegistry::lookupTarget(pTriple, error);
-  if (NULL == m_pTarget) {
-    fatal(diag::fatal_cannot_init_target) << pTriple << error;
-    return false;
-  }
-
-  // create mcld::DiagnosticLineInfo
-  m_pDiagLineInfo = m_pTarget->createDiagnosticLineInfo(*m_pTarget, pTriple);
-  if (NULL == m_pDiagLineInfo) {
-    fatal(diag::fatal_cannot_init_lineinfo) << pTriple;
-    return false;
-  }
-  mcld::getDiagnosticEngine().setLineInfo(*m_pDiagLineInfo);
-
-  // create mcld::TargetLDBackend
-  m_pBackend = m_pTarget->createLDBackend(*m_pConfig);
-  if (NULL == m_pBackend) {
-    fatal(diag::fatal_cannot_init_backend) << pTriple;
-    return false;
-  }
-
-  m_pInputFactory = new mcld::InputFactory(10, *m_pConfig);
-  m_pContextFactory = new mcld::ContextFactory(10);
-  m_pMemAreaFactory = new mcld::MemoryAreaFactory(10);
-  m_pBuilder = new mcld::InputBuilder(*m_pConfig,
-                                      *m_pInputFactory,
-                                      *m_pContextFactory,
-                                      *m_pMemAreaFactory,
-                                      true);
-
-  m_pObjLinker = new mcld::ObjectLinker(*m_pConfig, m_Module, *m_pBuilder, *m_pBackend);
-  m_pObjLinker->initFragmentLinker();
-
-  return true;
-}
-
-void TestLinker::addSearchDir(const std::string &pDirPath)
-{
-  assert(NULL != m_pConfig && "initialize() must be called before addSearchDir");
-  assert(!m_pConfig->options().sysroot().empty() &&
-         "must setSysRoot before addSearchDir");
-
-  if (!m_pConfig->options().directories().insert(pDirPath)) {
-    mcld::warning(mcld::diag::warn_cannot_open_search_dir) << pDirPath;
-  }
-}
-
-void TestLinker::setSysRoot(const mcld::sys::fs::Path &pPath)
-{
-  assert(NULL != m_pConfig && "initialize() must be called before setSysRoot");
-  m_pConfig->options().setSysroot(pPath);
-}
-
-void TestLinker::addObject(const std::string &pPath)
-{
-  mcld::Input* input = m_pInputFactory->produce(pPath, pPath,
-                                                mcld::Input::Unknown);
-
-  m_Module.getInputTree().insert<mcld::InputTree::Positional>(m_Root, *input);
-
-  advanceRoot();
-
-  mcld::FileHandle* handler = new mcld::FileHandle();
-  m_FileHandleList.push_back(handler);
-  if (!handler->open(pPath, mcld::FileHandle::ReadOnly)) {
-    mcld::error(mcld::diag::err_cannot_open_file)
-                                      << pPath
-                                      << mcld::sys::strerror(handler->error());
-  }
-
-  mcld::MemoryArea* input_memory = new MemoryArea(*handler);
-  input->setMemArea(input_memory);
-  m_MemAreaList.push_back(input_memory);
-
-  m_pBuilder->setContext(*input);
-}
-
-void TestLinker::addObject(void* pMemBuffer, size_t pSize)
-{
-  mcld::Input* input = m_pInputFactory->produce("memory object", "NAN",
-                                                mcld::Input::Unknown);
-
-  m_Module.getInputTree().insert<mcld::InputTree::Positional>(m_Root, *input);
-
-  advanceRoot();
-
-  mcld::Space* space = Space::Create(pMemBuffer, pSize);
-  mcld::MemoryArea* input_memory = new MemoryArea(*space);
-  input->setMemArea(input_memory);
-  m_MemAreaList.push_back(input_memory);
-
-  mcld::LDContext* context = m_pContextFactory->produce();
-  input->setContext(context);
-}
-
-void TestLinker::addObject(int pFileHandler)
-{
-  mcld::Input* input = m_pInputFactory->produce("handler object", "NAN",
-                                                mcld::Input::Unknown);
-
-  m_Module.getInputTree().insert<mcld::InputTree::Positional>(m_Root, *input);
-
-  advanceRoot();
-
-  mcld::FileHandle* handler = new mcld::FileHandle();
-  m_FileHandleList.push_back(handler);
-  handler->delegate(pFileHandler);
-
-  mcld::MemoryArea* input_memory = new MemoryArea(*handler);
-  input->setMemArea(input_memory);
-  m_MemAreaList.push_back(input_memory);
-
-  mcld::LDContext* context = m_pContextFactory->produce();
-  input->setContext(context);
-}
-
-void TestLinker::addNameSpec(const std::string &pNameSpec)
-{
-  mcld::sys::fs::Path* path = NULL;
-  // find out the real path of the namespec.
-  if (m_pConfig->attribute().constraint().isSharedSystem()) {
-    // In the system with shared object support, we can find both archive
-    // and shared object.
-
-    if (m_pInputFactory->attr().isStatic()) {
-      // with --static, we must search an archive.
-      path = m_pConfig->options().directories().find(pNameSpec,
-                                                     mcld::Input::Archive);
-    }
-    else {
-      // otherwise, with --Bdynamic, we can find either an archive or a
-      // shared object.
-      path = m_pConfig->options().directories().find(pNameSpec,
-                                                   mcld::Input::DynObj);
-    }
-  }
-  else {
-    // In the system without shared object support, we only look for an
-    // archive.
-    path = m_pConfig->options().directories().find(pNameSpec,
-                                                 mcld::Input::Archive);
-  }
-
-  if (NULL == path) {
-    mcld::fatal(diag::err_cannot_find_namespec) << pNameSpec;
-    return;
-  }
-
-  mcld::Input* input = m_pInputFactory->produce(pNameSpec, *path,
-                                                mcld::Input::Unknown);
-
-  m_Module.getInputTree().insert<mcld::InputTree::Positional>(m_Root, *input);
-
-  advanceRoot();
-
-  mcld::FileHandle* handler = new mcld::FileHandle();
-  m_FileHandleList.push_back(handler);
-  if (!handler->open(*path, mcld::FileHandle::ReadOnly)) {
-    mcld::error(mcld::diag::err_cannot_open_file)
-                                      << *path
-                                      << mcld::sys::strerror(handler->error());
-  }
-
-  mcld::MemoryArea* input_memory = new MemoryArea(*handler);
-  input->setMemArea(input_memory);
-  m_MemAreaList.push_back(input_memory);
-
-  m_pBuilder->setContext(*input);
-}
-
-bool TestLinker::setOutput(const std::string &pPath)
-{
-  mcld::FileHandle* handler = new mcld::FileHandle();
-  m_FileHandleList.push_back(handler);
-  bool open_res = handler->open(pPath, mcld::FileHandle::ReadWrite |
-                                       mcld::FileHandle::Truncate |
-                                       mcld::FileHandle::Create,
-                                mcld::FileHandle::Permission(0755));
-  if (!open_res) {
-    mcld::error(mcld::diag::err_cannot_open_file)
-                                      << pPath
-                                      << mcld::sys::strerror(handler->error());
-  }
-
-  m_pOutput = new MemoryArea(*handler);
-
-  // FIXME: remove the initStdSections().
-  m_pObjLinker->initStdSections();
-  return true;
-}
-
-bool TestLinker::setOutput(const sys::fs::Path &pPath)
-{
-  return setOutput(pPath.native());
-}
-
-bool TestLinker::setOutput(int pFileHandler)
-{
-  mcld::FileHandle* handler = new mcld::FileHandle();
-  handler->delegate(pFileHandler);
-  m_FileHandleList.push_back(handler);
-
-  m_pOutput = new MemoryArea(*handler);
-
-  // FIXME: remove the initStdSections().
-  m_pObjLinker->initStdSections();
-  return true;
-}
-
-void TestLinker::advanceRoot()
-{
-    if (m_Root.isRoot())
-      --m_Root;
-    else
-      ++m_Root;
-}
diff --git a/unittests/Linker/TestLinker.h b/unittests/Linker/TestLinker.h
deleted file mode 100644
index 701a405..0000000
--- a/unittests/Linker/TestLinker.h
+++ /dev/null
@@ -1,139 +0,0 @@
-//===- TestLinker.h -------------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_TEST_LINKER_H
-#define MCLD_TEST_LINKER_H
-
-#include <gtest.h>
-
-#include <string>
-#include <list>
-
-#include <mcld/Module.h>
-#include <mcld/Object/ObjectLinker.h>
-#include <mcld/Fragment/FragmentLinker.h>
-#include <mcld/LD/DiagnosticPrinter.h>
-#include <mcld/LD/DiagnosticLineInfo.h>
-#include <mcld/Support/TargetRegistry.h>
-#include <mcld/Support/Path.h>
-
-namespace mcld {
-
-class FileHandle;
-class LinkerConfig;
-class TargetLDBackend;
-class RegionFactory;
-class InputFactory;
-class MemoryAreaFactory;
-class ContextFactory;
-class InputBuilder;
-
-namespace test {
-
-class TestLinker
-{
-public:
-  TestLinker();
-
-  ~TestLinker();
-
-  bool initialize(const std::string &pTriple);
-
-  LinkerConfig* config() {
-    assert(NULL != m_pConfig);
-    return m_pConfig;
-  }
-
-  const LinkerConfig* config() const {
-    assert(NULL != m_pConfig);
-    return m_pConfig;
-  }
-
-  const Module* module() const { return &m_Module; }
-  Module*       module()       { return &m_Module; }
-
-  // -----  search directories  ----- //
-  void addSearchDir(const std::string &pPath);
-
-  void setSysRoot(const mcld::sys::fs::Path &pPath);
-
-  // -----  input operators  ----- //
-  void addObject(const std::string &pPath);
-
-  void addObject(const mcld::sys::fs::Path &pPath)
-  { addObject(pPath.native()); }
-
-  void addObject(void* pMemBuffer, size_t pSize);
-
-  void addObject(int pFileHandler);
-
-  void addNameSpec(const std::string &pNameSpec);
-
-  bool setOutput(const std::string &pPath);
-
-  bool setOutput(int pFileHandler);
-
-  bool setOutput(const sys::fs::Path &pPath);
-
-  const MemoryArea* getOutput() const { return m_pOutput; }
-
-  MemoryArea*       getOutput()       { return m_pOutput; }
-
-  /// getObjLinker
-  ObjectLinker* getObjLinker() {
-    assert(NULL != m_pObjLinker);
-    return m_pObjLinker;
-  }
-
-  /// getObjLinker
-  const ObjectLinker* getObjLinker() const {
-    assert(NULL != m_pObjLinker);
-    return m_pObjLinker;
-  }
-
-  /// getLinker
-  FragmentLinker* getLinker() {
-    assert(NULL != m_pObjLinker);
-    return m_pObjLinker->getLinker();
-  }
-
-  /// getLinker
-  const FragmentLinker* getLinker() const {
-    assert(NULL != m_pObjLinker);
-    return m_pObjLinker->getLinker();
-  }
-
-private:
-  void advanceRoot();
-
-private:
-  const mcld::Target* m_pTarget;
-  mcld::ObjectLinker *m_pObjLinker;
-  mcld::LinkerConfig* m_pConfig;
-  mcld::Module m_Module;
-  mcld::DiagnosticLineInfo* m_pDiagLineInfo;
-  mcld::DiagnosticPrinter* m_pDiagPrinter;
-  mcld::TargetLDBackend* m_pBackend;
-  mcld::InputTree::iterator m_Root;
-  mcld::InputFactory* m_pInputFactory;
-  mcld::MemoryAreaFactory* m_pMemAreaFactory;
-  mcld::ContextFactory* m_pContextFactory;
-
-  mcld::InputBuilder* m_pBuilder;
-
-  std::list<mcld::FileHandle*> m_FileHandleList;
-  std::list<mcld::MemoryArea*> m_MemAreaList;
-
-  mcld::MemoryArea* m_pOutput;
-};
-
-} // namespace of test
-} // namespace of mcld
-
-#endif
-
diff --git a/unittests/LinkerTest.cpp b/unittests/LinkerTest.cpp
index 64da08d..00ba23b 100644
--- a/unittests/LinkerTest.cpp
+++ b/unittests/LinkerTest.cpp
@@ -352,6 +352,7 @@
   gotplt_o.append("test/PLT/gotplt.o");
   Input* input = builder.CreateInput("gotplt.o", gotplt_o, Input::Object);
 
+  /// Sections
   /// [ 0]                   NULL            00000000 000000 000000 00      0   0  0
   builder.CreateELFHeader(*input,
                           "",
@@ -374,25 +375,35 @@
   Fragment* text_frag = builder.CreateRegion(text_content, 0x10);
   builder.AppendFragment(*text_frag, *text_data);
 
-  // [ 3] .data             PROGBITS        00000000 000044 000000 00  WA  0   0  4
-  builder.CreateELFHeader(*input,
+  /// [ 2] .rel.text         REL             00000000 0002ac 000008 08      7   1  4
+  LDSection* rel_text = builder.CreateELFHeader(*input,
+                          ".rel.text",
+                          llvm::ELF::SHT_REL,
+                          0x0, 4);
+  rel_text->setLink(text);
+  builder.CreateRelocData(*rel_text);
+
+  /// [ 3] .data             PROGBITS        00000000 000044 000000 00  WA  0   0  4
+  LDSection* data = builder.CreateELFHeader(*input,
                           ".data",
                           llvm::ELF::SHT_PROGBITS,
                           llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
                           4);
 
-  // [ 4] .bss              NOBITS          00000000 000044 000000 00  WA  0   0  4
-  builder.CreateELFHeader(*input,
+  /// [ 4] .bss              NOBITS          00000000 000044 000000 00  WA  0   0  4
+  LDSection* bss = builder.CreateELFHeader(*input,
                           ".bss",
-                          llvm::ELF::SHT_PROGBITS,
+                          llvm::ELF::SHT_NOBITS,
                           llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
                           4);
-  // [ 5] .ARM.attributes   ARM_ATTRIBUTES  00000000 000044 000020 00      0   0  1
+  builder.CreateBSS(*bss);
+
+  /// [ 5] .ARM.attributes   ARM_ATTRIBUTES  00000000 000044 000020 00      0   0  1
   LDSection* attr = builder.CreateELFHeader(*input,
                               ".ARM.attributes",
                               llvm::ELF::SHT_ARM_ATTRIBUTES,
                               0x0,
-                              4);
+                              1);
 
   SectionData* attr_data = builder.CreateSectionData(*attr);
   static uint8_t attr_content[] = {
@@ -407,6 +418,48 @@
   Fragment* attr_frag = builder.CreateRegion(attr_content, 0x20);
   builder.AppendFragment(*attr_frag, *attr_data);
 
+  /// Symbols
+  /// 1: 00000000     0 FILE    LOCAL  DEFAULT  ABS Output/gotplt.bc
+  builder.AddSymbol(*input,
+                    "Output/gotplt.bc", ResolveInfo::File,
+                    ResolveInfo::Define, ResolveInfo::Local, 0);
+  /// 2: 00000000     0 SECTION LOCAL  DEFAULT    1 
+  builder.AddSymbol(*input,
+                    ".text", ResolveInfo::Section,
+                    ResolveInfo::Define, ResolveInfo::Local, 0, 0x0, text);
+  /// 3: 00000000     0 SECTION LOCAL  DEFAULT    3
+  builder.AddSymbol(*input,
+                    ".data", ResolveInfo::Section,
+                    ResolveInfo::Define, ResolveInfo::Local, 0, 0x0, data);
+  /// 4: 00000000     0 SECTION LOCAL  DEFAULT    4 
+  builder.AddSymbol(*input,
+                    ".bss", ResolveInfo::Section,
+                    ResolveInfo::Define, ResolveInfo::Local, 0, 0x0, bss);
+  /// 5: 00000000     0 SECTION LOCAL  DEFAULT    5 
+  builder.AddSymbol(*input,
+                    ".ARM.attributes", ResolveInfo::Section,
+                    ResolveInfo::Define, ResolveInfo::Local, 0, 0x0, attr);
+  /// 6: 00000000    16 FUNC    GLOBAL DEFAULT    1 _Z1fv
+  builder.AddSymbol(*input,
+                    "_Z1fv", ResolveInfo::Function,
+                    ResolveInfo::Define, ResolveInfo::Global,
+                    16,
+                    0x0,
+                    text);
+
+  /// 7: 00000000     0 NOTYPE  GLOBAL DEFAULT  UND _Z1gv
+  LDSymbol* z1gv = builder.AddSymbol(*input,
+                                     "_Z1gv",
+                                     ResolveInfo::NoType,
+                                     ResolveInfo::Undefined,
+                                     ResolveInfo::Global,
+                                     0);
+
+ /// Relocations
+ /// Offset     Info    Type            Sym.Value  Sym. Name
+ /// 00000004  0000071b R_ARM_PLT32       00000000   _Z1gv
+ builder.AddRelocation(*rel_text, llvm::ELF::R_ARM_PLT32, *z1gv, 0x4);
+
   if (linker.link(module, builder)) {
     linker.emit("libgotplt.so"); ///< -o libgotplt.so
   }
diff --git a/unittests/ReadStageTest.cpp b/unittests/ReadStageTest.cpp
deleted file mode 100644
index b2aaf8d..0000000
--- a/unittests/ReadStageTest.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-//===- ReadStageTest.cpp --------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include "ReadStageTest.h"
-
-#include <mcld/Module.h>
-#include <mcld/LD/LDContext.h>
-#include <mcld/LD/LDSection.h>
-#include <mcld/LD/SectionData.h>
-#include <mcld/Fragment/Fragment.h>
-#include <mcld/Fragment/FragmentRef.h>
-#include <mcld/LD/LDSymbol.h>
-#include <mcld/LD/ResolveInfo.h>
-#include <mcld/MC/InputFactory.h>
-#include <mcld/Support/FileHandle.h>
-
-#include <sstream>
-#include <iostream>
-
-using namespace std;
-
-using namespace mcld;
-using namespace mcld::test;
-
-
-// Constructor can do set-up work for all test here.
-ReadStageTest::ReadStageTest()
-  : m_pLinker(NULL) {
-}
-
-// Destructor can do clean-up work that doesn't throw exceptions here.
-ReadStageTest::~ReadStageTest()
-{
-}
-
-// SetUp() will be called immediately before each test.
-void ReadStageTest::SetUp()
-{
-  m_pLinker = new mcld::test::TestLinker();
-  m_pLinker->initialize("arm-none-linux-gnueabi");
-
-  // set up target-dependent constraints of attributes
-  m_pLinker->config()->attribute().constraint().enableWholeArchive();
-  m_pLinker->config()->attribute().constraint().disableAsNeeded();
-  m_pLinker->config()->attribute().constraint().setSharedSystem();
-
-  // set up the predefined attributes
-  m_pLinker->config()->attribute().predefined().setWholeArchive();
-  m_pLinker->config()->attribute().predefined().setDynamic();
-
-  // set up target dependent options
-  mcld::sys::fs::Path path = TOPDIR;
-  path.append("test/libs/ARM/Android/android-14");
-  m_pLinker->setSysRoot(path);
-  m_pLinker->addSearchDir("=/");
-
-  m_pLinker->config()->options().setDyld("/usr/lib/ld.so.1");
-  m_pLinker->config()->options().setBsymbolic(true);
-}
-
-// TearDown() will be called immediately after each test.
-void ReadStageTest::TearDown()
-{
-  delete m_pLinker;
-}
-
-void ReadStageTest::dumpInput(const mcld::Input &pInput, mcld::FileHandle &pFile, size_t pIdent)
-{
-  stringstream sstream;
-  for (size_t i=0; i < pIdent; ++i)
-    sstream << " ";
-  sstream << "<input name=\"" << pInput.name() << "\">\n";
-
-  LDContext::const_sect_iterator sect, sectEnd = pInput.context()->sectEnd();
-  for (sect = pInput.context()->sectBegin(); sect != sectEnd; ++sect) {
-    for (size_t i=0; i < (pIdent+1); ++i)
-      sstream << " ";
-    sstream << "<section name=\"" << (*sect)->name() << "\"/>\n";
-  }
-  for (size_t i=0; i < pIdent; ++i)
-    sstream << " ";
-  sstream << "</input>\n";
-
-  size_t org_size = pFile.size();
-  pFile.truncate(sstream.str().size() + org_size);
-  pFile.write(sstream.str().data(), org_size, sstream.str().size());
-}
-
-void ReadStageTest::dumpOutput(const mcld::Module& pModule, mcld::FileHandle &pFile, size_t pIdent)
-{
-  stringstream sstream;
-  for (size_t i=0; i < pIdent; ++i)
-    sstream << " ";
-  sstream << "<output name=\"" << m_pLinker->module()->name() << "\">\n";
-
-  Module::const_iterator sect, sectEnd = pModule.end();
-  for (sect = pModule.begin(); sect != sectEnd; ++sect) {
-    for (size_t i=0; i < (pIdent+1); ++i)
-      sstream << " ";
-    sstream << "<section name=\"" << (*sect)->name() << "\"/>\n";
-  }
-  for (size_t i=0; i < pIdent; ++i)
-    sstream << " ";
-  sstream << "</output>\n";
-
-  size_t org_size = pFile.size();
-  pFile.truncate(sstream.str().size() + org_size);
-  pFile.write(sstream.str().data(), org_size, sstream.str().size());
-}
-//===----------------------------------------------------------------------===//
-// Testcases
-//===----------------------------------------------------------------------===//
-TEST_F(ReadStageTest, quake) {
-  mcld::sys::fs::Path top_level = TOPDIR;
-
-  // set up output
-  m_pLinker->config()->setCodeGenType(mcld::LinkerConfig::DynObj);
-  m_pLinker->setOutput(top_level + "unittests/plasma.so");
-
-
-  // set up input
-  m_pLinker->addObject(top_level + "test/libs/ARM/Android/android-14/crtbegin_so.o");
-  m_pLinker->addObject(top_level + "test/Android/Plasma/ARM/plasma.o");
-  m_pLinker->addNameSpec("m");
-  m_pLinker->addNameSpec("log");
-  m_pLinker->addNameSpec("jnigraphics");
-  m_pLinker->addNameSpec("c");
-  m_pLinker->addObject(top_level + "test/libs/ARM/Android/android-14/crtend_so.o");
-
-  // dump status
-  m_pLinker->getObjLinker()->normalize();
-
-  FileHandle file;
-  file.open(top_level + "unittests/read_stage.xml",
-     FileHandle::ReadWrite | FileHandle::Create | FileHandle::Truncate, 0644);
-
-  Module::input_iterator input, inEnd = m_pLinker->module()->input_end();
-  for (input = m_pLinker->module()->input_begin(); input != inEnd; ++input) {
-    dumpInput(**input, file, 1);
-  }
-
-  dumpOutput(*m_pLinker->module(), file, 1);
-  // dump status
-  ASSERT_TRUE(m_pLinker->getObjLinker()->mergeSections());
-}
-
diff --git a/unittests/ReadStageTest.h b/unittests/ReadStageTest.h
deleted file mode 100644
index e799664..0000000
--- a/unittests/ReadStageTest.h
+++ /dev/null
@@ -1,44 +0,0 @@
-//===- ReadStageTest.h ----------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_UNITTEST_READSTAGE_TEST_H
-#define MCLD_UNITTEST_READSTAGE_TEST_H
-
-#include <gtest.h>
-#include "Linker/TestLinker.h"
-
-namespace mcld {
-namespace test {
-
-class ReadStageTest : public ::testing::Test
-{
-public:
-  // Constructor can do set-up work for all test here.
-  ReadStageTest();
-
-  // Destructor can do clean-up work that doesn't throw exceptions here.
-  virtual ~ReadStageTest();
-
-  // SetUp() will be called immediately before each test.
-  virtual void SetUp();
-
-  // TearDown() will be called immediately after each test.
-  virtual void TearDown();
-
-  void dumpInput(const mcld::Input &pInput, mcld::FileHandle &pFile, size_t pIdent);
-
-  void dumpOutput(const mcld::Module &pModule, mcld::FileHandle &pFile, size_t pIdent);
-protected:
-  TestLinker* m_pLinker;
-};
-
-} // end of namespace test
-} // end of namespace mcld
-
-#endif
-
diff --git a/unittests/SectionDataTest.cpp b/unittests/SectionDataTest.cpp
index 5113068..dfabc15 100644
--- a/unittests/SectionDataTest.cpp
+++ b/unittests/SectionDataTest.cpp
@@ -60,9 +60,8 @@
   new Fragment(Fragment::Alignment, s);
   new Fragment(Fragment::Region, s);
   new Fragment(Fragment::Fillment, s);
-  new Fragment(Fragment::Relocation, s);
   new Fragment(Fragment::Target, s);
-  EXPECT_TRUE(6 == s->size());
+  EXPECT_TRUE(5 == s->size());
 
   //iterator
   llvm::iplist<Fragment>::iterator iter=s->begin();
@@ -74,8 +73,6 @@
   ++iter;
   EXPECT_TRUE(Fragment::Fillment == iter->getKind());
   ++iter;
-  EXPECT_TRUE(Fragment::Relocation == iter->getKind());
-  ++iter;
   EXPECT_TRUE(Fragment::Target == iter->getKind());
   ++iter;
   EXPECT_TRUE(iter == s->end());
diff --git a/unittests/StaticResolverTest.cpp b/unittests/StaticResolverTest.cpp
index cb4c668..bd40cd5 100644
--- a/unittests/StaticResolverTest.cpp
+++ b/unittests/StaticResolverTest.cpp
@@ -26,8 +26,6 @@
   // create testee. modify it if need
   m_pResolver = new StaticResolver();
 
-  mcld::InitializeAllDiagnostics();
-
   m_pConfig = new LinkerConfig("arm-none-linux-gnueabi");
 }
 
diff --git a/unittests/TestLinkerTest.cpp b/unittests/TestLinkerTest.cpp
deleted file mode 100644
index 0b1a141..0000000
--- a/unittests/TestLinkerTest.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//===- TestLinkerTest.cpp -------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include "Linker/TestLinker.h"
-#include "TestLinkerTest.h"
-
-#include <mcld/Support/Path.h>
-#include <mcld/MC/MCLDDirectory.h>
-#include <mcld/MC/InputFactory.h>
-
-using namespace mcld;
-using namespace mcld::test;
-using namespace mcld::sys::fs;
-using namespace mcldtest;
-
-
-// Constructor can do set-up work for all test here.
-TestLinkerTest::TestLinkerTest()
-  : m_pLinker(NULL) {
-}
-
-// Destructor can do clean-up work that doesn't throw exceptions here.
-TestLinkerTest::~TestLinkerTest()
-{
-}
-
-// SetUp() will be called immediately before each test.
-void TestLinkerTest::SetUp()
-{
-  m_pLinker = new mcld::test::TestLinker();
-  m_pLinker->initialize("arm-none-linux-gnueabi");
-
-  // set up target-dependent constraints of attributes
-  m_pLinker->config()->attribute().constraint().enableWholeArchive();
-  m_pLinker->config()->attribute().constraint().disableAsNeeded();
-  m_pLinker->config()->attribute().constraint().setSharedSystem();
-
-  // set up the predefined attributes
-  m_pLinker->config()->attribute().predefined().setWholeArchive();
-  m_pLinker->config()->attribute().predefined().setDynamic();
-
-  // set up target dependent options
-  mcld::sys::fs::Path path = TOPDIR;
-  path.append("test/libs/ARM/Android/android-14");
-  m_pLinker->setSysRoot(path);
-  m_pLinker->addSearchDir("=/");
-
-  m_pLinker->config()->options().setDyld("/usr/lib/ld.so.1");
-  m_pLinker->config()->options().setBsymbolic(true);
-}
-
-// TearDown() will be called immediately after each test.
-void TestLinkerTest::TearDown()
-{
-  delete m_pLinker;
-}
-
-//===----------------------------------------------------------------------===//
-// Testcases
-//===----------------------------------------------------------------------===//
-TEST_F( TestLinkerTest, test) {
-  m_pLinker->config()->options().setVerbose(3);
-  mcld::sys::fs::Path top_level = TOPDIR;
-  m_pLinker->addObject(top_level + "test/libs/ARM/Android/android-14/crtbegin_so.o");
-  m_pLinker->addObject(top_level + "test/Android/Plasma/ARM/plasma.o");
-  m_pLinker->addNameSpec("m");
-  m_pLinker->addNameSpec("log");
-  m_pLinker->addNameSpec("jnigraphics");
-  m_pLinker->addNameSpec("c");
-  m_pLinker->addObject(top_level + "test/libs/ARM/Android/android-14/crtend_so.o");
-}
-
diff --git a/unittests/TestLinkerTest.h b/unittests/TestLinkerTest.h
deleted file mode 100644
index ba6efcf..0000000
--- a/unittests/TestLinkerTest.h
+++ /dev/null
@@ -1,40 +0,0 @@
-//===- TestLinkerTest.h ---------------------------------------------------===//
-//
-//                     The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_TEST_LINKER_TEST_H
-#define MCLD_TEST_LINKER_TEST_H
-#include <gtest.h>
-
-#include "Linker/TestLinker.h"
-
-namespace mcldtest
-{
-
-class TestLinkerTest : public ::testing::Test
-{
-public:
-  // Constructor can do set-up work for all test here.
-  TestLinkerTest();
-
-  // Destructor can do clean-up work that doesn't throw exceptions here.
-  virtual ~TestLinkerTest();
-
-  // SetUp() will be called immediately before each test.
-  virtual void SetUp();
-
-  // TearDown() will be called immediately after each test.
-  virtual void TearDown();
-
-protected:
-  mcld::test::TestLinker* m_pLinker;
-};
-
-} // namespace of mcldtest
-
-#endif
-
diff --git a/unittests/UniqueGCFactoryBaseTest.cpp b/unittests/UniqueGCFactoryBaseTest.cpp
index f8e098a..45a2aca 100644
--- a/unittests/UniqueGCFactoryBaseTest.cpp
+++ b/unittests/UniqueGCFactoryBaseTest.cpp
@@ -19,8 +19,6 @@
 // Constructor can do set-up work for all test here.
 UniqueGCFactoryBaseTest::UniqueGCFactoryBaseTest()
 {
-  InitializeAllDiagnostics();
-
   m_pConfig = new LinkerConfig("arm-none-linux-gnueabi");
 }