diff --git a/Android.mk b/Android.mk
index 5d5dccb..1c71962 100644
--- a/Android.mk
+++ b/Android.mk
@@ -245,5 +245,207 @@
 
 include $(BUILD_HOST_STATIC_LIBRARY)
 
+
+LLVM_ROOT_PATH := external/llvm
+
+#=============================================================================
+# android librsloader for libbcc (Device)
+#-----------------------------------------------------------------------------
+
+rsloader_SRC_FILES := \
+  driver/linkloader/android/librsloader.cpp \
+  driver/linkloader/lib/ELFHeader.cpp \
+  driver/linkloader/lib/ELFSymbol.cpp \
+  driver/linkloader/lib/ELFSectionHeader.cpp \
+  driver/linkloader/lib/ELFTypes.cpp \
+  driver/linkloader/lib/GOT.cpp \
+  driver/linkloader/lib/MemChunk.cpp \
+  driver/linkloader/lib/StubLayout.cpp \
+  driver/linkloader/utils/helper.cpp \
+  driver/linkloader/utils/raw_ostream.cpp \
+  driver/linkloader/utils/rsl_assert.cpp
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := librsloader
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := $(rsloader_SRC_FILES)
+
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
+
+LOCAL_CFLAGS += $(rs_base_CFLAGS)
+
+LOCAL_C_INCLUDES := \
+  $(LOCAL_PATH)/driver/linkloader \
+  $(LOCAL_PATH)/driver/linkloader/include \
+  $(LOCAL_C_INCLUDES)
+
+include $(LLVM_ROOT_PATH)/llvm-device-build.mk
+include $(BUILD_STATIC_LIBRARY)
+
+
+#=============================================================================
+# android librsloader for libbcc (Host)
+#-----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := librsloader
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := $(rsloader_SRC_FILES)
+
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
+
+LOCAL_CFLAGS += $(rs_base_CFLAGS)
+LOCAL_CFLAGS += -D__HOST__
+
+LOCAL_C_INCLUDES := \
+  $(LOCAL_PATH)/driver/linkloader \
+  $(LOCAL_PATH)/driver/linkloader/include \
+  $(LOCAL_C_INCLUDES)
+
+include $(LLVM_ROOT_PATH)/llvm-host-build.mk
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+
+#=============================================================================
+# librsloader-test (Device)
+#-----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := test-librsloader
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SHARED_LIBRARIES := \
+  libstlport
+
+LOCAL_STATIC_LIBRARIES := \
+  librsloader \
+  libcutils \
+  libLLVMSupport
+
+LOCAL_SRC_FILES := \
+  driver/linkloader/android/test-librsloader.c
+
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
+
+LOCAL_CFLAGS += $(rs_base_CFLAGS)
+
+LOCAL_C_INCLUDES := \
+  $(LOCAL_PATH)/driver/linkloader \
+  $(LOCAL_PATH)/driver/linkloader/include
+
+include $(LLVM_ROOT_PATH)/llvm-device-build.mk
+include $(BUILD_EXECUTABLE)
+
+
+#=============================================================================
+# librsloader-test (Host)
+#-----------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := test-librsloader
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_LDLIBS := \
+  -lpthread \
+  -ldl
+
+LOCAL_STATIC_LIBRARIES := \
+  librsloader \
+  libcutils \
+  libLLVMSupport
+
+LOCAL_SRC_FILES := \
+  driver/linkloader/android/test-librsloader.c
+
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
+
+LOCAL_CFLAGS += $(rs_base_CFLAGS)
+
+LOCAL_C_INCLUDES := \
+  $(LOCAL_PATH)/driver/linkloader \
+  $(LOCAL_PATH)/driver/linkloader/include
+
+include $(LLVM_ROOT_PATH)/llvm-host-build.mk
+include $(BUILD_HOST_EXECUTABLE)
+
+
+#=============================================================================
+# rsloader
+#-----------------------------------------------------------------------------
+
+ifdef BUILD_RSLOADER_TOOL
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := rsloader
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SHARED_LIBRARIES := \
+  libstlport
+
+LOCAL_STATIC_LIBRARIES := \
+  libLLVMSupport
+
+LOCAL_SRC_FILES := \
+  driver/linkloader/lib/ELFHeader.cpp \
+  driver/linkloader/lib/ELFSymbol.cpp \
+  driver/linkloader/lib/ELFSectionHeader.cpp \
+  driver/linkloader/lib/ELFTypes.cpp \
+  driver/linkloader/lib/StubLayout.cpp \
+  driver/linkloader/utils/raw_ostream.cpp \
+  driver/linkloader/utils/rsl_assert.cpp \
+  driver/linkloader/utils/helper.cpp \
+  driver/linkloader/main.cpp
+
+LOCAL_C_INCLUDES := \
+  $(LOCAL_PATH)/driver/linkloader \
+  $(LOCAL_PATH)/driver/linkloader/include \
+  $(LOCAL_C_INCLUDES)
+
+include $(LLVM_ROOT_PATH)/llvm-device-build.mk
+include $(BUILD_EXECUTABLE)
+endif
+
+
+#=============================================================================
+# stub-layout-unit-test
+#-----------------------------------------------------------------------------
+
+ifdef BUILD_STUB_LAYOUT_TEST
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := stub-layout-unit-test
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SHARED_LIBRARIES := \
+  libstlport
+
+LOCAL_SRC_FILES := \
+  driver/linkloader/lib/StubLayout.cpp \
+  driver/linkloader/utils/raw_ostream.cpp \
+  driver/linkloader/utils/helper.cpp \
+  driver/linkloader/tests/stub-test.cpp
+
+LOCAL_C_INCLUDES := \
+  $(LOCAL_PATH)/driver/linkloader \
+  $(LOCAL_PATH)/driver/linkloader/include \
+  $(LOCAL_C_INCLUDES)
+
+include $(LLVM_ROOT_PATH)/llvm-device-build.mk
+include $(BUILD_EXECUTABLE)
+endif
+
+
 include $(call all-makefiles-under,$(LOCAL_PATH))
 
diff --git a/driver/linkloader/android/librsloader.cpp b/driver/linkloader/android/librsloader.cpp
new file mode 100644
index 0000000..200006f
--- /dev/null
+++ b/driver/linkloader/android/librsloader.cpp
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2011-2012, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "librsloader.h"
+
+#include "ELFObject.h"
+#include "ELFSectionSymTab.h"
+#include "ELFSymbol.h"
+
+#include "utils/serialize.h"
+
+#define LOG_TAG "bcc"
+#include "cutils/log.h"
+
+#include <llvm/ADT/OwningPtr.h>
+#include <llvm/Support/ELF.h>
+
+static inline RSExecRef wrap(ELFObject<32> *object) {
+  return reinterpret_cast<RSExecRef>(object);
+}
+
+static inline ELFObject<32> *unwrap(RSExecRef object) {
+  return reinterpret_cast<ELFObject<32> *>(object);
+}
+
+extern "C" RSExecRef rsloaderCreateExec(unsigned char const *buf,
+                                        size_t buf_size,
+                                        RSFindSymbolFn find_symbol,
+                                        void *find_symbol_context) {
+  RSExecRef object = rsloaderLoadExecutable(buf, buf_size);
+  if (!object) {
+    return NULL;
+  }
+
+  if (!rsloaderRelocateExecutable(object, find_symbol, find_symbol_context)) {
+    rsloaderDisposeExec(object);
+    return NULL;
+  }
+
+  return object;
+}
+
+extern "C" RSExecRef rsloaderLoadExecutable(unsigned char const *buf,
+                                            size_t buf_size) {
+  ArchiveReaderLE AR(buf, buf_size);
+
+  llvm::OwningPtr<ELFObject<32> > object(ELFObject<32>::read(AR));
+  if (!object) {
+    ALOGE("Unable to load the ELF object.");
+    return NULL;
+  }
+
+  return wrap(object.take());
+}
+
+extern "C" int rsloaderRelocateExecutable(RSExecRef object_,
+                                          RSFindSymbolFn find_symbol,
+                                          void *find_symbol_context) {
+  ELFObject<32>* object = unwrap(object_);
+
+  object->relocate(find_symbol, find_symbol_context);
+  return (object->getMissingSymbols() == 0);
+}
+
+extern "C" void rsloaderUpdateSectionHeaders(RSExecRef object_,
+                                             unsigned char *buf) {
+  ELFObject<32> *object = unwrap(object_);
+
+  // Remap the section header addresses to match the loaded code
+  llvm::ELF::Elf32_Ehdr* header = reinterpret_cast<llvm::ELF::Elf32_Ehdr*>(buf);
+
+  llvm::ELF::Elf32_Shdr* shtab =
+      reinterpret_cast<llvm::ELF::Elf32_Shdr*>(buf + header->e_shoff);
+
+  for (int i = 0; i < header->e_shnum; i++) {
+    if (shtab[i].sh_flags & SHF_ALLOC) {
+      ELFSectionBits<32>* bits =
+          static_cast<ELFSectionBits<32>*>(object->getSectionByIndex(i));
+      if (bits) {
+        const unsigned char* addr = bits->getBuffer();
+        shtab[i].sh_addr = reinterpret_cast<llvm::ELF::Elf32_Addr>(addr);
+      }
+    }
+  }
+}
+
+extern "C" void rsloaderDisposeExec(RSExecRef object) {
+  delete unwrap(object);
+}
+
+extern "C" void *rsloaderGetSymbolAddress(RSExecRef object_,
+                                          char const *name) {
+  ELFObject<32> *object = unwrap(object_);
+
+  ELFSectionSymTab<32> *symtab =
+    static_cast<ELFSectionSymTab<32> *>(object->getSectionByName(".symtab"));
+
+  if (!symtab) {
+    return NULL;
+  }
+
+  ELFSymbol<32> *symbol = symtab->getByName(name);
+
+  if (!symbol) {
+    ALOGV("Symbol not found: %s\n", name);
+    return NULL;
+  }
+
+  int machine = object->getHeader()->getMachine();
+
+  return symbol->getAddress(machine, false);
+}
+
+extern "C" size_t rsloaderGetSymbolSize(RSExecRef object_, char const *name) {
+  ELFObject<32> *object = unwrap(object_);
+
+  ELFSectionSymTab<32> *symtab =
+    static_cast<ELFSectionSymTab<32> *>(object->getSectionByName(".symtab"));
+
+  if (!symtab) {
+    return 0;
+  }
+
+  ELFSymbol<32> *symbol = symtab->getByName(name);
+
+  if (!symbol) {
+    ALOGV("Symbol not found: %s\n", name);
+    return 0;
+  }
+
+  return (size_t)symbol->getSize();
+}
+
+extern "C" size_t rsloaderGetFuncCount(RSExecRef object) {
+  ELFSectionSymTab<32> *symtab = static_cast<ELFSectionSymTab<32> *>(
+    unwrap(object)->getSectionByName(".symtab"));
+
+  if (!symtab) {
+    return 0;
+  }
+
+  return symtab->getFuncCount();
+}
+
+extern "C" void rsloaderGetFuncNameList(RSExecRef object,
+                                        size_t size,
+                                        char const **list) {
+  ELFSectionSymTab<32> *symtab = static_cast<ELFSectionSymTab<32> *>(
+    unwrap(object)->getSectionByName(".symtab"));
+
+  if (symtab) {
+    symtab->getFuncNameList(size, list);
+  }
+}
diff --git a/driver/linkloader/android/librsloader.h b/driver/linkloader/android/librsloader.h
new file mode 100644
index 0000000..ab8361a
--- /dev/null
+++ b/driver/linkloader/android/librsloader.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2011-2012, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIBRSLOADER_H
+#define LIBRSLOADER_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct RSExecOpaque;
+typedef struct RSExecOpaque *RSExecRef;
+typedef void *(*RSFindSymbolFn)(void *, char const *);
+
+RSExecRef rsloaderCreateExec(unsigned char const *buf,
+                             size_t buf_size,
+                             RSFindSymbolFn find_symbol,
+                             void *find_symbol_context);
+
+RSExecRef rsloaderLoadExecutable(unsigned char const *buf,
+                                 size_t buf_size);
+
+int rsloaderRelocateExecutable(RSExecRef object,
+                               RSFindSymbolFn find_symbol,
+                               void *find_symbol_context);
+
+void rsloaderUpdateSectionHeaders(RSExecRef object, unsigned char *buf);
+
+void rsloaderDisposeExec(RSExecRef object);
+
+void *rsloaderGetSymbolAddress(RSExecRef object, char const *name);
+
+size_t rsloaderGetSymbolSize(RSExecRef object, char const *name);
+
+size_t rsloaderGetFuncCount(RSExecRef object);
+
+void rsloaderGetFuncNameList(RSExecRef object, size_t size, char const **list);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* LIBRSLOADER_H */
diff --git a/driver/linkloader/android/test-librsloader.c b/driver/linkloader/android/test-librsloader.c
new file mode 100644
index 0000000..3c9ac2d
--- /dev/null
+++ b/driver/linkloader/android/test-librsloader.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "librsloader.h"
+#include "utils/rsl_assert.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+struct func_entry_t {
+  char const *name;
+  size_t name_len;
+  void *addr;
+};
+
+void *find_sym(void *context, char const *name) {
+  static struct func_entry_t const tab[] = {
+#define DEF(NAME, ADDR) \
+    { NAME, sizeof(NAME) - 1, (void *)(&(ADDR)) },
+
+    DEF("printf", printf)
+    DEF("scanf", scanf)
+    DEF("__isoc99_scanf", scanf)
+    DEF("rand", rand)
+    DEF("time", time)
+    DEF("srand", srand)
+#undef DEF
+  };
+
+  static size_t const tab_size = sizeof(tab) / sizeof(struct func_entry_t);
+
+  // Note: Since our table is small, we are using trivial O(n) searching
+  // function.  For bigger table, it will be better to use binary
+  // search or hash function.
+  size_t i;
+  size_t name_len = strlen(name);
+  for (i = 0; i < tab_size; ++i) {
+    if (name_len == tab[i].name_len && strcmp(name, tab[i].name) == 0) {
+      return tab[i].addr;
+    }
+  }
+
+  rsl_assert(0 && "Can't find symbol.");
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  if (argc < 2) {
+    fprintf(stderr, "USAGE: %s [ELF] [ARGS]\n", argv[0]);
+    exit(EXIT_FAILURE);
+  }
+
+  int fd = open(argv[1], O_RDONLY);
+  if (fd < 0) {
+    fprintf(stderr, "ERROR: Unable to open the file: %s\n", argv[1]);
+    exit(EXIT_FAILURE);
+  }
+
+  struct stat sb;
+  if (fstat(fd, &sb) != 0) {
+    fprintf(stderr, "ERROR: Unable to stat the file: %s\n", argv[1]);
+    close(fd);
+    exit(EXIT_FAILURE);
+  }
+
+  unsigned char const *image = (unsigned char const *)
+    mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+
+  if (image == MAP_FAILED) {
+    fprintf(stderr, "ERROR: Unable to mmap the file: %s\n", argv[1]);
+    close(fd);
+    exit(EXIT_FAILURE);
+  }
+
+  RSExecRef object = rsloaderCreateExec(image, sb.st_size, find_sym, 0);
+  if (!object) {
+    fprintf(stderr, "ERROR: Unable to load elf object.\n");
+    close(fd);
+    exit(EXIT_FAILURE);
+  }
+
+  int (*main_stub)(int, char **) =
+    (int (*)(int, char **))rsloaderGetSymbolAddress(object, "main");
+
+  int ret = main_stub(argc - 1, argv + 1);
+  printf("============================================================\n");
+  printf("ELF object finished with code: %d\n", ret);
+  fflush(stdout);
+
+  rsloaderDisposeExec(object);
+
+  close(fd);
+
+  return EXIT_SUCCESS;
+}
diff --git a/driver/linkloader/include/ELF.h b/driver/linkloader/include/ELF.h
new file mode 100644
index 0000000..6205b98
--- /dev/null
+++ b/driver/linkloader/include/ELF.h
@@ -0,0 +1,19 @@
+#ifndef ELF_H
+#define ELF_H
+
+#include <llvm/Support/ELF.h>
+// FIXME: Can't using namespace in header file!
+using namespace llvm::ELF;
+
+// These definitions are not defined in include/llvm/Support/ELF.h.
+// So we define them here.
+
+#ifndef ET_LOOS
+#define ET_LOOS 0xfe00
+#endif
+
+#ifndef ET_HIOS
+#define ET_HIOS 0xfeff
+#endif
+
+#endif // ELF_H
diff --git a/driver/linkloader/include/ELFHeader.h b/driver/linkloader/include/ELFHeader.h
new file mode 100644
index 0000000..98fa920
--- /dev/null
+++ b/driver/linkloader/include/ELFHeader.h
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_HEADER_H
+#define ELF_HEADER_H
+
+#include "ELFTypes.h"
+#include "ELF.h"
+
+#include <llvm/ADT/OwningPtr.h>
+
+#include <string.h>
+
+class ELFHeaderHelperMixin {
+protected:
+  static char const *getClassStr(int clazz);
+  static char const *getEndiannessStr(int endianness);
+  static char const *getOSABIStr(int abi);
+  static char const *getObjectTypeStr(uint16_t type);
+  static char const *getMachineStr(uint16_t machine);
+  static char const *getVersionStr(uint32_t version);
+};
+
+template <unsigned Bitwidth>
+class ELFHeader : private ELFHeaderHelperMixin {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+protected:
+  byte_t   e_ident[EI_NIDENT];
+  half_t   e_type;
+  half_t   e_machine;
+  word_t   e_version;
+  addr_t   e_entry;
+  offset_t e_phoff;
+  offset_t e_shoff;
+  word_t   e_flags;
+  half_t   e_ehsize;
+  half_t   e_phentsize;
+  half_t   e_phnum;
+  half_t   e_shentsize;
+  half_t   e_shnum;
+  half_t   e_shstrndx;
+
+protected:
+  ELFHeader() { }
+
+public:
+  byte_t getClass() const {
+    return e_ident[EI_CLASS];
+  }
+
+  byte_t getEndianness() const {
+    return e_ident[EI_DATA];
+  }
+
+  byte_t getVersionFromIdent() const {
+    return e_ident[EI_VERSION];
+  }
+
+  byte_t getOSABI() const {
+    return e_ident[EI_OSABI];
+  }
+
+  byte_t getABIVersion() const {
+    return e_ident[EI_ABIVERSION];
+  }
+
+  bool is32bit() const {
+    return e_ident[EI_CLASS] == ELFCLASS32;
+  }
+
+  bool is64bit() const {
+    return e_ident[EI_CLASS] == ELFCLASS64;
+  }
+
+  bool isBigEndian() const {
+    return e_ident[EI_DATA] == ELFDATA2MSB;
+  }
+
+  bool isLittleEndian() const {
+    return e_ident[EI_DATA] == ELFDATA2LSB;
+  }
+
+  half_t getObjectType() const {
+    return e_type;
+  }
+
+  half_t getMachine() const {
+    return e_machine;
+  }
+
+  word_t getVersion() const {
+    return e_version;
+  }
+
+  addr_t getEntryAddress() const {
+    return e_entry;
+  }
+
+  offset_t getProgramHeaderTableOffset() const {
+    return e_phoff;
+  }
+
+  offset_t getSectionHeaderTableOffset() const {
+    return e_shoff;
+  }
+
+  word_t getFlags() const {
+    return e_flags;
+  }
+
+  half_t getELFHeaderSize() const {
+    return e_ehsize;
+  }
+
+  half_t getProgramHeaderEntrySize() const {
+    return e_phentsize;
+  }
+
+  half_t getProgramHeaderNum() const {
+    return e_phnum;
+  }
+
+  half_t getSectionHeaderEntrySize() const {
+    return e_shentsize;
+  }
+
+  half_t getSectionHeaderNum() const {
+    return e_shnum;
+  }
+
+  half_t getStringSectionIndex() const {
+    return e_shstrndx;
+  }
+
+  template <typename Archiver>
+  static ELFHeader *read(Archiver &AR) {
+    if (!AR) {
+      // Archiver is in bad state before calling read function.
+      // Return NULL and do nothing.
+      return 0;
+    }
+
+    llvm::OwningPtr<ELFHeader> header(new ELFHeader());
+    if (!header->serialize(AR)) {
+      // Unable to read the structure.  Return NULL.
+      return 0;
+    }
+
+    if (!header->isValid()) {
+      // Header read from archiver is not valid.  Return NULL.
+      return 0;
+    }
+
+    return header.take();
+  }
+
+  void print();
+
+  bool isValid() const {
+    return (isValidELFIdent() && isCompatibleHeaderSize());
+  }
+
+private:
+  template <typename Archiver>
+  bool serialize(Archiver &AR) {
+    AR.prologue(TypeTraits<ELFHeaderTy>::size);
+
+    AR & e_ident;
+    AR & e_type;
+    AR & e_machine;
+    AR & e_version;
+    AR & e_entry;
+    AR & e_phoff;
+    AR & e_shoff;
+    AR & e_flags;
+    AR & e_ehsize;
+    AR & e_phentsize;
+    AR & e_phnum;
+    AR & e_shentsize;
+    AR & e_shnum;
+    AR & e_shstrndx;
+
+    AR.epilogue(TypeTraits<ELFHeaderTy>::size);
+    return AR;
+  }
+
+  bool isValidMagicWord() const {
+    return (memcmp(e_ident, "\x7f" "ELF", 4) == 0);
+  }
+
+  bool isValidClass() const {
+    return ((Bitwidth == 32 && is32bit()) ||
+            (Bitwidth == 64 && is64bit()));
+  }
+
+  bool isValidEndianness() const {
+    return (isBigEndian() || isLittleEndian());
+  }
+
+  bool isValidHeaderVersion() const {
+    return (getVersion() == EV_CURRENT);
+  }
+
+  bool isUnusedZeroedPadding() const {
+    for (size_t i = EI_PAD; i < EI_NIDENT; ++i) {
+      if (e_ident[i] != 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool isValidELFIdent() const {
+    return (isValidMagicWord() &&
+            isValidClass() &&
+            isValidEndianness() &&
+            isValidHeaderVersion() &&
+            isUnusedZeroedPadding());
+  }
+
+  bool isCompatibleHeaderSize() const {
+    return (
+      (e_ehsize == TypeTraits<ELFHeaderTy>::size) &&
+      (e_phnum == 0 || e_phentsize == TypeTraits<ELFProgramHeaderTy>::size) &&
+      (e_shnum == 0 || e_shentsize == TypeTraits<ELFSectionHeaderTy>::size));
+  }
+};
+
+#include "impl/ELFHeader.hxx"
+
+#endif // ELF_HEADER_H
diff --git a/driver/linkloader/include/ELFObject.h b/driver/linkloader/include/ELFObject.h
new file mode 100644
index 0000000..d715d51
--- /dev/null
+++ b/driver/linkloader/include/ELFObject.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_OBJECT_H
+#define ELF_OBJECT_H
+
+#include "ELFTypes.h"
+#include "MemChunk.h"
+
+#include "utils/rsl_assert.h"
+
+#include <llvm/ADT/OwningPtr.h>
+
+#include <string>
+#include <vector>
+
+template <unsigned Bitwidth>
+class ELFObject {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+private:
+  llvm::OwningPtr<ELFHeaderTy> header;
+  llvm::OwningPtr<ELFSectionHeaderTableTy> shtab;
+  std::vector<ELFSectionTy *> stab;
+
+  MemChunk SHNCommonData;
+  unsigned char *SHNCommonDataPtr;
+  size_t SHNCommonDataFreeSize;
+
+  bool missingSymbols;
+
+  // TODO: Need refactor!
+  bool initSHNCommonDataSize(size_t SHNCommonDataSize) {
+    rsl_assert(!SHNCommonDataPtr && "Can't init twice.");
+    if (!SHNCommonData.allocate(SHNCommonDataSize)) {
+      return false;
+    }
+
+    SHNCommonDataPtr = SHNCommonData.getBuffer();
+    SHNCommonDataFreeSize = SHNCommonDataSize;
+    return true;
+  }
+
+private:
+  ELFObject() : SHNCommonDataPtr(NULL), missingSymbols(false) { }
+
+public:
+  template <typename Archiver>
+  static ELFObject *read(Archiver &AR);
+
+  ELFHeaderTy const *getHeader() const {
+    return header.get();
+  }
+
+  ELFSectionHeaderTableTy const *getSectionHeaderTable() const {
+    return shtab.get();
+  }
+
+  char const *getSectionName(size_t i) const;
+  ELFSectionTy const *getSectionByIndex(size_t i) const;
+  ELFSectionTy *getSectionByIndex(size_t i);
+  ELFSectionTy const *getSectionByName(std::string const &str) const;
+  ELFSectionTy *getSectionByName(std::string const &str);
+
+  inline bool getMissingSymbols() const {
+    return missingSymbols;
+  }
+
+  void *allocateSHNCommonData(size_t size, size_t align = 1) {
+    rsl_assert(size > 0 && align != 0);
+
+    rsl_assert(SHNCommonDataPtr && "Must init common data size before use!");
+
+    // Ensure alignment
+    size_t rem = ((uintptr_t)SHNCommonDataPtr) % align;
+    if (rem != 0) {
+      SHNCommonDataPtr += align - rem;
+      SHNCommonDataFreeSize -= align - rem;
+    }
+
+    // Ensure the free size is sufficient
+    if (SHNCommonDataFreeSize < size) {
+      return NULL;
+    }
+
+    // Allcoate
+    void *result = SHNCommonDataPtr;
+    SHNCommonDataPtr += size;
+    SHNCommonDataFreeSize -= size;
+
+    return result;
+  }
+
+  void relocate(void *(*find_sym)(void *context, char const *name),
+                void *context);
+
+  void print() const;
+
+  ~ELFObject() {
+    for (size_t i = 0; i < stab.size(); ++i) {
+      // Delete will check the pointer is nullptr or not by himself.
+      delete stab[i];
+    }
+  }
+
+private:
+  void relocateARM(void *(*find_sym)(void *context, char const *name),
+                   void *context,
+                   ELFSectionRelTableTy *reltab,
+                   ELFSectionProgBitsTy *text);
+
+  void relocateX86_32(void *(*find_sym)(void *context, char const *name),
+                      void *context,
+                      ELFSectionRelTableTy *reltab,
+                      ELFSectionProgBitsTy *text);
+
+  void relocateX86_64(void *(*find_sym)(void *context, char const *name),
+                      void *context,
+                      ELFSectionRelTableTy *reltab,
+                      ELFSectionProgBitsTy *text);
+
+  void relocateMIPS(void *(*find_sym)(void *context, char const *name),
+                    void *context,
+                    ELFSectionRelTableTy *reltab,
+                    ELFSectionProgBitsTy *text);
+};
+
+#include "impl/ELFObject.hxx"
+
+#endif // ELF_OBJECT_H
diff --git a/driver/linkloader/include/ELFReloc.h b/driver/linkloader/include/ELFReloc.h
new file mode 100644
index 0000000..c6bf759
--- /dev/null
+++ b/driver/linkloader/include/ELFReloc.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_RELOC_H
+#define ELF_RELOC_H
+
+#include "ELFTypes.h"
+#include "utils/rsl_assert.h"
+
+#include <llvm/ADT/OwningPtr.h>
+#include <string>
+#include <stdint.h>
+
+template <unsigned Bitwidth>
+class ELFReloc_CRTP {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+protected:
+  size_t index;
+
+  addr_t    r_offset;
+  relinfo_t r_info;
+  addend_t  r_addend;
+
+protected:
+  ELFReloc_CRTP() : index(0), r_offset(0), r_addend(0) { }
+  ~ELFReloc_CRTP() { }
+
+public:
+  size_t getIndex() const {
+    return index;
+  }
+
+  addr_t getOffset() const {
+    return r_offset;
+  }
+
+  addend_t getAddend() const {
+    return r_addend;
+  }
+
+  bool isValid() const {
+    // FIXME: Should check the correctness of the relocation entite.
+    return true;
+  }
+
+  template <typename Archiver>
+  static ELFRelocTy *readRel(Archiver &AR, size_t index);
+
+  template <typename Archiver>
+  static ELFRelocTy *readRela(Archiver &AR, size_t index);
+
+  void print(bool shouldPrintHeader = false) const;
+
+private:
+  ELFRelocTy *concrete() {
+    return static_cast<ELFRelocTy *>(this);
+  }
+
+  ELFRelocTy const *concrete() const {
+    return static_cast<ELFRelocTy const *>(this);
+  }
+
+  template <typename Archiver>
+  bool serializeRel(Archiver &AR) {
+    rsl_assert(r_addend == 0 && "r_addend should be zero before serialization.");
+
+    AR.prologue(TypeTraits<ELFRelocRelTy>::size);
+
+    AR & r_offset;
+    AR & r_info;
+
+    AR.epilogue(TypeTraits<ELFRelocRelTy>::size);
+    return AR;
+  }
+
+  template <typename Archiver>
+  bool serializeRela(Archiver &AR) {
+    AR.prologue(TypeTraits<ELFRelocRelaTy>::size);
+
+    AR & r_offset;
+    AR & r_info;
+    AR & r_addend;
+
+    AR.epilogue(TypeTraits<ELFRelocRelaTy>::size);
+    return AR;
+  }
+
+};
+
+template <>
+class ELFReloc<32> : public ELFReloc_CRTP<32> {
+  friend class ELFReloc_CRTP<32>;
+
+private:
+  ELFReloc() {
+  }
+
+public:
+  word_t getSymTabIndex() const {
+#define ELF32_R_SYM(i)  ((i)>>8)
+    return ELF32_R_SYM(this->r_info);
+#undef ELF32_R_SYM
+  }
+
+  word_t getType() const {
+#define ELF32_R_TYPE(i)   ((unsigned char)(i))
+    return ELF32_R_TYPE(this->r_info);
+#undef ELF32_R_TYPE
+  }
+
+};
+
+template <>
+class ELFReloc<64> : public ELFReloc_CRTP<64> {
+  friend class ELFReloc_CRTP<64>;
+
+private:
+  ELFReloc() {
+  }
+
+public:
+  xword_t getSymTabIndex() const {
+#define ELF64_R_SYM(i)    ((i)>>32)
+    return ELF64_R_SYM(this->r_info);
+#undef ELF64_R_SYM
+  }
+
+  xword_t getType() const {
+#define ELF64_R_TYPE(i)   ((i)&0xffffffffL)
+    return ELF64_R_TYPE(this->r_info);
+#undef ELF64_R_TYPE
+  }
+};
+
+#include "impl/ELFReloc.hxx"
+
+#endif // ELF_RELOC_H
diff --git a/driver/linkloader/include/ELFSection.h b/driver/linkloader/include/ELFSection.h
new file mode 100644
index 0000000..74c4c13
--- /dev/null
+++ b/driver/linkloader/include/ELFSection.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_H
+#define ELF_SECTION_H
+
+#include "ELFTypes.h"
+#include <llvm/ADT/OwningPtr.h>
+
+template <unsigned Bitwidth>
+class ELFSection {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+protected:
+  ELFSection() { }
+
+public:
+  virtual ~ELFSection() { }
+
+  virtual void print() const = 0;
+
+  template <typename Archiver>
+  static ELFSection *read(Archiver &AR, ELFObjectTy *,
+                          ELFSectionHeaderTy const *);
+};
+
+#include "impl/ELFSection.hxx"
+
+#endif // ELF_SECTION_H
diff --git a/driver/linkloader/include/ELFSectionBits.h b/driver/linkloader/include/ELFSectionBits.h
new file mode 100644
index 0000000..2d80c1a
--- /dev/null
+++ b/driver/linkloader/include/ELFSectionBits.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_BITS_H
+#define ELF_SECTION_BITS_H
+
+#include "ELFTypes.h"
+#include "ELFSection.h"
+#include "MemChunk.h"
+
+#include <llvm/ADT/OwningPtr.h>
+
+template <unsigned Bitwidth>
+class ELFSectionBits : public ELFSection<Bitwidth> {
+protected:
+  ELFSectionHeader<Bitwidth> const *sh;
+  MemChunk chunk;
+
+protected:
+  ELFSectionBits() : sh(NULL) { }
+
+public:
+  virtual void print() const;
+
+  bool protect();
+
+  unsigned char const *getBuffer() const {
+    return chunk.getBuffer();
+  }
+
+  unsigned char *getBuffer() {
+    return chunk.getBuffer();
+  }
+
+  unsigned char &operator[](size_t index) {
+    return chunk[index];
+  }
+
+  unsigned char const &operator[](size_t index) const {
+    return chunk[index];
+  }
+
+  size_t size() const {
+    return chunk.size();
+  }
+
+};
+
+#include "impl/ELFSectionBits.hxx"
+
+#endif // ELF_SECTION_BITS_H
diff --git a/driver/linkloader/include/ELFSectionHeader.h b/driver/linkloader/include/ELFSectionHeader.h
new file mode 100644
index 0000000..7871315
--- /dev/null
+++ b/driver/linkloader/include/ELFSectionHeader.h
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_HEADER_H
+#define ELF_SECTION_HEADER_H
+
+#include "ELFTypes.h"
+
+#include <llvm/ADT/OwningPtr.h>
+#include <stdint.h>
+
+class ELFSectionHeaderHelperMixin {
+protected:
+  static char const *getSectionTypeStr(uint32_t type);
+};
+
+template <unsigned Bitwidth>
+class ELFSectionHeader_CRTP : private ELFSectionHeaderHelperMixin {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+protected:
+  ELFObjectTy const *owner;
+
+  size_t index;
+
+  word_t sh_name;
+  word_t sh_type;
+  addr_t sh_addr;
+  offset_t sh_offset;
+  word_t sh_link;
+  word_t sh_info;
+
+protected:
+  ELFSectionHeader_CRTP() { }
+  ~ELFSectionHeader_CRTP() { }
+
+public:
+  size_t getIndex() const {
+    return index;
+  }
+
+  word_t getNameIndex() const {
+    return sh_name;
+  }
+
+  char const *getName() const;
+
+  word_t getType() const {
+    return sh_type;
+  }
+
+  addr_t getAddress() const {
+    return sh_addr;
+  }
+
+  offset_t getOffset() const {
+    return sh_offset;
+  }
+
+  word_t getLink() const {
+    return sh_link;
+  }
+
+  word_t getExtraInfo() const {
+    return sh_info;
+  }
+
+  bool isValid() const {
+    // FIXME: Should check the correctness of the section header.
+    return true;
+  }
+
+  template <typename Archiver>
+  static ELFSectionHeaderTy *
+  read(Archiver &AR, ELFObjectTy const *owner, size_t index = 0);
+
+  void print(bool shouldPrintHeader = false) const;
+
+private:
+  ELFSectionHeaderTy *concrete() {
+    return static_cast<ELFSectionHeaderTy *>(this);
+  }
+
+  ELFSectionHeaderTy const *concrete() const {
+    return static_cast<ELFSectionHeaderTy const *>(this);
+  }
+};
+
+
+#include "impl/ELFSectionHeader.hxx"
+
+template <>
+class ELFSectionHeader<32> : public ELFSectionHeader_CRTP<32> {
+  friend class ELFSectionHeader_CRTP<32>;
+
+private:
+  word_t sh_flags;
+  word_t sh_size;
+  word_t sh_addralign;
+  word_t sh_entsize;
+
+private:
+  ELFSectionHeader() {
+  }
+
+  template <typename Archiver>
+  bool serialize(Archiver &AR) {
+    AR.prologue(TypeTraits<ELFSectionHeader>::size);
+
+    AR & sh_name;
+    AR & sh_type;
+    AR & sh_flags;
+    AR & sh_addr;
+    AR & sh_offset;
+    AR & sh_size;
+    AR & sh_link;
+    AR & sh_info;
+    AR & sh_addralign;
+    AR & sh_entsize;
+
+    AR.epilogue(TypeTraits<ELFSectionHeader>::size);
+    return AR;
+  }
+
+public:
+  word_t getFlags() const {
+    return sh_flags;
+  }
+
+  word_t getSize() const {
+    return sh_size;
+  }
+
+  word_t getAddressAlign() const {
+    return sh_addralign;
+  }
+
+  word_t getEntrySize() const {
+    return sh_entsize;
+  }
+};
+
+template <>
+class ELFSectionHeader<64> : public ELFSectionHeader_CRTP<64> {
+  friend class ELFSectionHeader_CRTP<64>;
+
+private:
+  xword_t sh_flags;
+  xword_t sh_size;
+  xword_t sh_addralign;
+  xword_t sh_entsize;
+
+private:
+  ELFSectionHeader() {
+  }
+
+  template <typename Archiver>
+  bool serialize(Archiver &AR) {
+    AR.prologue(TypeTraits<ELFSectionHeader>::size);
+
+    AR & sh_name;
+    AR & sh_type;
+    AR & sh_flags;
+    AR & sh_addr;
+    AR & sh_offset;
+    AR & sh_size;
+    AR & sh_link;
+    AR & sh_info;
+    AR & sh_addralign;
+    AR & sh_entsize;
+
+    AR.epilogue(TypeTraits<ELFSectionHeader>::size);
+    return AR;
+  }
+
+public:
+  xword_t getFlags() const {
+    return sh_flags;
+  }
+
+  xword_t getSize() const {
+    return sh_size;
+  }
+
+  xword_t getAddressAlign() const {
+    return sh_addralign;
+  }
+
+  xword_t getEntrySize() const {
+    return sh_entsize;
+  }
+};
+
+#endif // ELF_SECTION_HEADER_H
diff --git a/driver/linkloader/include/ELFSectionHeaderTable.h b/driver/linkloader/include/ELFSectionHeaderTable.h
new file mode 100644
index 0000000..fb7f9ed
--- /dev/null
+++ b/driver/linkloader/include/ELFSectionHeaderTable.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_HEADER_TABLE_H
+#define ELF_SECTION_HEADER_TABLE_H
+
+#include "ELFTypes.h"
+
+#include <llvm/ADT/OwningPtr.h>
+#include <llvm/ADT/StringMap.h>
+
+#include <vector>
+#include <string>
+
+template <unsigned Bitwidth>
+class ELFSectionHeaderTable {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+private:
+  std::vector<ELFSectionHeaderTy *> table;
+  llvm::StringMap<ELFSectionHeaderTy *> name_map;
+
+private:
+  ELFSectionHeaderTable() {
+  }
+
+public:
+  ~ELFSectionHeaderTable();
+
+  template <typename Archiver>
+  static ELFSectionHeaderTableTy *read(Archiver &AR, ELFObjectTy *owner);
+
+  ELFSectionHeaderTy const *operator[](size_t i) const {
+    return table[i];
+  }
+
+  ELFSectionHeaderTy *operator[](size_t i) {
+    return table[i];
+  }
+
+  void buildNameMap();
+
+  ELFSectionHeaderTy const *getByName(const std::string &name) const;
+  ELFSectionHeaderTy *getByName(const std::string &name);
+
+  void print() const;
+};
+
+#include "impl/ELFSectionHeaderTable.hxx"
+
+#endif // ELF_SECTION_HEADER_TABLE_H
diff --git a/driver/linkloader/include/ELFSectionNoBits.h b/driver/linkloader/include/ELFSectionNoBits.h
new file mode 100644
index 0000000..5c4b3f2
--- /dev/null
+++ b/driver/linkloader/include/ELFSectionNoBits.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_NOBITS_H
+#define ELF_SECTION_NOBITS_H
+
+#include "ELFTypes.h"
+#include "ELFSectionBits.h"
+#include "ELFSectionHeader.h"
+#include "MemChunk.h"
+
+template <unsigned Bitwidth>
+class ELFSectionNoBits : public ELFSectionBits<Bitwidth> {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+public:
+  template <typename Archiver>
+  static ELFSectionNoBits *read(Archiver &AR, ELFSectionHeaderTy const *sh);
+};
+
+#include "impl/ELFSectionNoBits.hxx"
+
+#endif // ELF_SECTION_NOBITS_H
diff --git a/driver/linkloader/include/ELFSectionProgBits.h b/driver/linkloader/include/ELFSectionProgBits.h
new file mode 100644
index 0000000..e0da71e
--- /dev/null
+++ b/driver/linkloader/include/ELFSectionProgBits.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_PROGBITS_H
+#define ELF_SECTION_PROGBITS_H
+
+#include "ELFTypes.h"
+#include "ELFSectionBits.h"
+#include "ELFSectionHeader.h"
+#include "MemChunk.h"
+#include "StubLayout.h"
+
+template <unsigned Bitwidth>
+class ELFSectionProgBits : public ELFSectionBits<Bitwidth> {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+private:
+  StubLayout *stubs;
+
+public:
+  template <typename Archiver>
+  static ELFSectionProgBits *read(Archiver &AR,
+                                  ELFObjectTy *owner,
+                                  ELFSectionHeaderTy const *sh);
+
+  StubLayout *getStubLayout() {
+    return stubs;
+  }
+
+  ELFSectionProgBits(int machine) {
+    switch(machine) {
+    case EM_ARM:
+        stubs = new StubLayoutARM();
+      break;
+
+    case EM_MIPS:
+        stubs = new StubLayoutMIPS();
+      break;
+
+    default:
+        stubs = NULL;
+    }
+  }
+
+  ~ELFSectionProgBits() {
+    if (stubs)
+      delete stubs;
+  }
+
+private:
+  template <typename Archiver>
+  bool serialize(Archiver &AR) {
+    ELFSectionHeaderTy const *sh = this->sh;
+    MemChunk &chunk = this->chunk;
+
+    AR.seek(sh->getOffset(), true);
+    AR.prologue(sh->getSize());
+    AR.readBytes(chunk.getBuffer(), sh->getSize());
+    AR.epilogue(sh->getSize());
+
+    return AR;
+  }
+};
+
+#include "impl/ELFSectionProgBits.hxx"
+
+#endif // ELF_SECTION_PROGBITS_H
diff --git a/driver/linkloader/include/ELFSectionRelTable.h b/driver/linkloader/include/ELFSectionRelTable.h
new file mode 100644
index 0000000..2799501
--- /dev/null
+++ b/driver/linkloader/include/ELFSectionRelTable.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_REL_TABLE_H
+#define ELF_SECTION_REL_TABLE_H
+
+#include "ELFTypes.h"
+#include "ELFSection.h"
+
+#include <string>
+#include <vector>
+
+template <unsigned Bitwidth>
+class ELFSectionRelTable : public ELFSection<Bitwidth> {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+private:
+  std::vector<ELFRelocTy *> table;
+
+private:
+  ELFSectionRelTable() { }
+
+public:
+  virtual ~ELFSectionRelTable();
+
+  virtual void print() const;
+
+  template <typename Archiver>
+  static ELFSectionRelTable *read(Archiver &AR, ELFSectionHeaderTy const *sh);
+
+  size_t size() const {
+    return table.size();
+  }
+
+  ELFRelocTy const *operator[](size_t index) const {
+    return table[index];
+  }
+
+  ELFRelocTy *operator[](size_t index) {
+    return table[index];
+  }
+
+  size_t getMaxNumStubs(ELFObjectTy const *) const;
+};
+
+#include "impl/ELFSectionRelTable.hxx"
+
+#endif // ELF_SECTION_REL_TABLE_H
diff --git a/driver/linkloader/include/ELFSectionStrTab.h b/driver/linkloader/include/ELFSectionStrTab.h
new file mode 100644
index 0000000..458dfa3
--- /dev/null
+++ b/driver/linkloader/include/ELFSectionStrTab.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_STRTAB_H
+#define ELF_SECTION_STRTAB_H
+
+#include "ELFTypes.h"
+#include "ELFSection.h"
+
+#include <vector>
+
+template <unsigned Bitwidth>
+class ELFSectionStrTab : public ELFSection<Bitwidth> {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+private:
+  ELFSectionHeaderTy const *section_header;
+  std::vector<char> buf;
+
+private:
+  ELFSectionStrTab() { }
+
+public:
+  template <typename Archiver>
+  static ELFSectionStrTab *read(Archiver &AR, ELFSectionHeaderTy const *sh);
+
+  virtual void print() const;
+
+  char const *operator[](size_t index) const {
+    return &*buf.begin() + index;
+  }
+};
+
+#include "impl/ELFSectionStrTab.hxx"
+
+#endif // ELF_SECTION_STRTAB_H
diff --git a/driver/linkloader/include/ELFSectionSymTab.h b/driver/linkloader/include/ELFSectionSymTab.h
new file mode 100644
index 0000000..821067f
--- /dev/null
+++ b/driver/linkloader/include/ELFSectionSymTab.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_SYMTAB_H
+#define ELF_SECTION_SYMTAB_H
+
+#include "ELFTypes.h"
+
+#include <llvm/ADT/StringMap.h>
+
+#include <vector>
+#include <string>
+
+template <unsigned Bitwidth>
+class ELFSectionSymTab : public ELFSection<Bitwidth> {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+private:
+  std::vector<ELFSymbolTy *> table;
+  llvm::StringMap<ELFSymbolTy *> name_map;
+
+private:
+  ELFSectionSymTab() { }
+
+public:
+  ~ELFSectionSymTab();
+
+  template <typename Archiver>
+  static ELFSectionSymTab *
+  read(Archiver &AR, ELFObjectTy *owner, ELFSectionHeaderTy const *sh);
+
+  virtual void print() const;
+
+  size_t size() const {
+    return table.size();
+  }
+
+  ELFSymbolTy const *operator[](size_t index) const {
+    return table[index];
+  }
+
+  ELFSymbolTy *operator[](size_t index) {
+    return table[index];
+  }
+
+  void buildNameMap();
+
+  ELFSymbolTy const *getByName(std::string const &name) const;
+
+  ELFSymbolTy *getByName(std::string const &name) {
+    return const_cast<ELFSymbolTy *>(
+           const_cast<ELFSectionSymTabTy const *>(this)->getByName(name));
+  }
+
+  size_t getFuncCount() const;
+
+  void getFuncNameList(size_t size, char const **list) const;
+
+  size_t getExternFuncCount() const;
+
+};
+
+#include "impl/ELFSectionSymTab.hxx"
+
+#endif // ELF_SECTION_SYMTAB_H
diff --git a/driver/linkloader/include/ELFSymbol.h b/driver/linkloader/include/ELFSymbol.h
new file mode 100644
index 0000000..d78ba5a
--- /dev/null
+++ b/driver/linkloader/include/ELFSymbol.h
@@ -0,0 +1,199 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SYMBOL_H
+#define ELF_SYMBOL_H
+
+#include "ELFTypes.h"
+#include "ELF.h"
+
+#include <llvm/ADT/OwningPtr.h>
+
+#include <string>
+#include <algorithm>
+
+#include <stdint.h>
+#include <stdlib.h>
+
+class ELFSymbolHelperMixin {
+protected:
+  static char const *getTypeStr(uint8_t);
+  static char const *getBindingAttributeStr(uint8_t);
+  static char const *getVisibilityStr(uint8_t);
+};
+
+template <unsigned Bitwidth>
+class ELFSymbol_CRTP : private ELFSymbolHelperMixin {
+public:
+  ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(Bitwidth);
+
+protected:
+  ELFObject<Bitwidth> const *owner;
+
+  size_t index;
+
+  word_t st_name;
+  byte_t st_info;
+  byte_t st_other;
+  half_t st_shndx;
+  addr_t st_value;
+  symsize_t st_size;
+
+  mutable void *my_addr;
+
+protected:
+  ELFSymbol_CRTP() { my_addr = 0; }
+
+  ~ELFSymbol_CRTP() {
+#if 0
+    if (my_addr != 0 &&
+        getType() == STT_OBJECT &&
+        getSectionIndex() == SHN_COMMON) {
+      std::free(my_addr);
+    }
+#endif
+  }
+
+public:
+  size_t getIndex() const {
+    return index;
+  }
+
+  word_t getNameIndex() const {
+    return st_name;
+  }
+
+  char const *getName() const;
+
+// I don't want to include elf.h in .h file, so define those macro by ourself.
+#define ELF_ST_BIND(i)   ((i)>>4)
+#define ELF_ST_TYPE(i)   ((i)&0xf)
+#define ELF_ST_INFO(b,t) (((b)<<4)+((t)&0xf))
+  byte_t getType() const {
+    return ELF_ST_TYPE(st_info);
+  }
+
+  byte_t getBindingAttribute() const {
+    return ELF_ST_BIND(st_info);
+  }
+#undef ELF_ST_BIND
+#undef ELF_ST_TYPE
+#undef ELF_ST_INFO
+
+#define ELF_ST_VISIBILITY(o) ((o)&0x3)
+  byte_t getVisibility() const {
+    return ELF_ST_VISIBILITY(st_other);
+  }
+#undef ELF_ST_VISIBILITY
+
+  half_t getSectionIndex() const {
+    return st_shndx;
+  }
+
+  addr_t getValue() const {
+    return st_value;
+  }
+
+  symsize_t getSize() const {
+    return st_size;
+  }
+
+  void *getAddress(int machine, bool autoAlloc = true) const;
+
+  void setAddress(void *addr) {
+    my_addr = addr;
+  }
+
+  bool isValid() const {
+    // FIXME: Should check the correctness of the section header.
+    return true;
+  }
+
+  bool isConcreteFunc() const {
+    return getType() == STT_FUNC;
+  }
+
+  bool isExternFunc() const {
+    return getType() == STT_NOTYPE;
+  }
+
+  template <typename Archiver>
+  static ELFSymbolTy *
+  read(Archiver &AR, ELFObject<Bitwidth> const *owner, size_t index = 0);
+
+  void print(bool shouldPrintHeader = false) const;
+
+private:
+  ELFSymbolTy *concrete() {
+    return static_cast<ELFSymbolTy *>(this);
+  }
+
+  ELFSymbolTy const *concrete() const {
+    return static_cast<ELFSymbolTy const *>(this);
+  }
+};
+
+template <>
+class ELFSymbol<32> : public ELFSymbol_CRTP<32> {
+  friend class ELFSymbol_CRTP<32>;
+
+private:
+  ELFSymbol() {
+  }
+
+  template <typename Archiver>
+  bool serialize(Archiver &AR) {
+    AR.prologue(TypeTraits<ELFSymbol>::size);
+
+    AR & st_name;
+    AR & st_value;
+    AR & st_size;
+    AR & st_info;
+    AR & st_other;
+    AR & st_shndx;
+
+    AR.epilogue(TypeTraits<ELFSymbol>::size);
+    return AR;
+  }
+};
+
+template <>
+class ELFSymbol<64> : public ELFSymbol_CRTP<64> {
+  friend class ELFSymbol_CRTP<64>;
+
+private:
+  ELFSymbol() {
+  }
+
+  template <typename Archiver>
+  bool serialize(Archiver &AR) {
+    AR.prologue(TypeTraits<ELFSymbol>::size);
+
+    AR & st_name;
+    AR & st_info;
+    AR & st_other;
+    AR & st_shndx;
+    AR & st_value;
+    AR & st_size;
+
+    AR.epilogue(TypeTraits<ELFSymbol>::size);
+    return AR;
+  }
+};
+
+#include "impl/ELFSymbol.hxx"
+
+#endif // ELF_SYMBOL_H
diff --git a/driver/linkloader/include/ELFTypes.h b/driver/linkloader/include/ELFTypes.h
new file mode 100644
index 0000000..3e99f78
--- /dev/null
+++ b/driver/linkloader/include/ELFTypes.h
@@ -0,0 +1,215 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_TYPES_H
+#define ELF_TYPES_H
+
+#include "utils/traits.h"
+
+#include <stdint.h>
+#include <llvm/Support/raw_ostream.h>
+
+
+// ELF structure forward declarations
+template <unsigned Bitwidth> class ELFHeader;
+template <unsigned Bitwidth> class ELFObject;
+template <unsigned Bitwidth> class ELFProgramHeader;
+template <unsigned Bitwidth> class ELFReloc;
+template <unsigned Bitwidth> class ELFRelocRel; // For TypeTraits
+template <unsigned Bitwidth> class ELFRelocRela; // For TypeTraits
+template <unsigned Bitwidth> class ELFSection;
+template <unsigned Bitwidth> class ELFSectionBits;
+template <unsigned Bitwidth> class ELFSectionHeader;
+template <unsigned Bitwidth> class ELFSectionHeaderTable;
+template <unsigned Bitwidth> class ELFSectionNoBits;
+template <unsigned Bitwidth> class ELFSectionProgBits;
+template <unsigned Bitwidth> class ELFSectionRelTable;
+template <unsigned Bitwidth> class ELFSectionStrTab;
+template <unsigned Bitwidth> class ELFSectionSymTab;
+template <unsigned Bitwidth> class ELFSymbol;
+
+// Note: Following TypeTraits specialization MUST be compliant to the
+// System V Application Binary Interface, Chap 4, Data Representation.
+
+TYPE_TRAITS_SPECIALIZE(ELFHeader<32>        , 52, 4)
+TYPE_TRAITS_SPECIALIZE(ELFHeader<64>        , 64, 8)
+
+TYPE_TRAITS_SPECIALIZE(ELFProgramHeader<32> , 32, 4)
+TYPE_TRAITS_SPECIALIZE(ELFProgramHeader<64> , 56, 8)
+
+TYPE_TRAITS_SPECIALIZE(ELFSectionHeader<32> , 40, 4)
+TYPE_TRAITS_SPECIALIZE(ELFSectionHeader<64> , 64, 8)
+
+TYPE_TRAITS_SPECIALIZE(ELFSymbol<32>        , 16, 4)
+TYPE_TRAITS_SPECIALIZE(ELFSymbol<64>        , 24, 8)
+
+TYPE_TRAITS_SPECIALIZE(ELFRelocRel<32>      , 8, 4)
+TYPE_TRAITS_SPECIALIZE(ELFRelocRel<64>      , 16, 8)
+
+TYPE_TRAITS_SPECIALIZE(ELFRelocRela<32>     , 12, 4)
+TYPE_TRAITS_SPECIALIZE(ELFRelocRela<64>     , 24, 8)
+
+
+// ELF primitive type wrappers
+namespace detail {
+#define ELF_TYPE_WRAPPER(TYPE, IMPL)                                        \
+  struct TYPE {                                                             \
+    IMPL value;                                                             \
+                                                                            \
+    TYPE() : value(0) { }                                                   \
+    TYPE(IMPL val) : value(val) { }                                         \
+                                                                            \
+    TYPE &operator=(TYPE const &with) { value = with.value; return *this; } \
+    TYPE &operator=(IMPL val) { value = val; return *this; }                \
+                                                                            \
+    operator IMPL() const { return value; }                                 \
+  };
+
+  ELF_TYPE_WRAPPER(ELFHalf      , uint16_t)
+  ELF_TYPE_WRAPPER(ELFWord      , uint32_t)
+  ELF_TYPE_WRAPPER(ELFSword     , int32_t)
+  ELF_TYPE_WRAPPER(ELFXword     , uint64_t)
+  ELF_TYPE_WRAPPER(ELFSxword    , int64_t)
+  ELF_TYPE_WRAPPER(ELF32Address , uint32_t)
+  ELF_TYPE_WRAPPER(ELF32Offset  , uint32_t)
+  ELF_TYPE_WRAPPER(ELF64Address , uint64_t)
+  ELF_TYPE_WRAPPER(ELF64Offset  , uint64_t)
+
+#undef ELF_TYPE_WRAPPER
+
+  extern llvm::raw_ostream &operator<<(llvm::raw_ostream &,
+                                       ELF32Address const &);
+  extern llvm::raw_ostream &operator<<(llvm::raw_ostream &,
+                                       ELF32Offset const &);
+  extern llvm::raw_ostream &operator<<(llvm::raw_ostream &,
+                                       ELF64Address const &);
+  extern llvm::raw_ostream &operator<<(llvm::raw_ostream &,
+                                       ELF64Offset const &);
+}
+
+// Note: Following TypeTraits specialization MUST be compliant to the
+// System V Application Binary Interface, Chap 4, Data Representation.
+
+TYPE_TRAITS_SPECIALIZE(detail::ELFHalf      , 2, 2)
+TYPE_TRAITS_SPECIALIZE(detail::ELFWord      , 4, 4)
+TYPE_TRAITS_SPECIALIZE(detail::ELFSword     , 4, 4)
+TYPE_TRAITS_SPECIALIZE(detail::ELFXword     , 8, 8)
+TYPE_TRAITS_SPECIALIZE(detail::ELFSxword    , 8, 8)
+TYPE_TRAITS_SPECIALIZE(detail::ELF32Address , 4, 4)
+TYPE_TRAITS_SPECIALIZE(detail::ELF32Offset  , 4, 4)
+TYPE_TRAITS_SPECIALIZE(detail::ELF64Address , 8, 8)
+TYPE_TRAITS_SPECIALIZE(detail::ELF64Offset  , 8, 8)
+
+template <unsigned Bitwidth>
+struct ELFPrimitiveTypes;
+
+template <>
+struct ELFPrimitiveTypes<32> {
+  typedef detail::ELF32Address  address;
+  typedef detail::ELF32Offset   offset;
+
+  typedef unsigned char         byte;
+  typedef detail::ELFHalf       half;
+  typedef detail::ELFWord       word;
+  typedef detail::ELFSword      sword;
+
+  typedef detail::ELFWord       relinfo;
+  typedef detail::ELFSword      addend;
+  typedef detail::ELFWord       symsize;
+
+  // Note: Don't use these types.  They are not in the specification of
+  // ELF 32.  However, we need these typedefs to define the type introduce
+  // macro.
+  typedef void xword;
+  typedef void sxword;
+};
+
+template <>
+struct ELFPrimitiveTypes<64> {
+  typedef detail::ELF64Address  address;
+  typedef detail::ELF64Offset   offset;
+
+  typedef unsigned char         byte;
+  typedef detail::ELFHalf       half;
+  typedef detail::ELFWord       word;
+  typedef detail::ELFSword      sword;
+  typedef detail::ELFXword      xword;
+  typedef detail::ELFSxword     sxword;
+
+  typedef detail::ELFXword      relinfo;
+  typedef detail::ELFSxword     addend;
+  typedef detail::ELFXword      symsize;
+};
+
+
+// Macros to introduce these ELF types to a specific scope
+
+#define ELF_STRUCT_TYPE_INTRO_TO_SCOPE(BITWIDTH)                            \
+  typedef ELFHeader<BITWIDTH>             ELFHeaderTy;                      \
+  typedef ELFObject<BITWIDTH>             ELFObjectTy;                      \
+  typedef ELFProgramHeader<BITWIDTH>      ELFProgramHeaderTy;               \
+  typedef ELFReloc<BITWIDTH>              ELFRelocTy;                       \
+  typedef ELFRelocRel<BITWIDTH>           ELFRelocRelTy;                    \
+  typedef ELFRelocRela<BITWIDTH>          ELFRelocRelaTy;                   \
+  typedef ELFSection<BITWIDTH>            ELFSectionTy;                     \
+  typedef ELFSectionBits<BITWIDTH>        ELFSectionBitsTy;                 \
+  typedef ELFSectionHeader<BITWIDTH>      ELFSectionHeaderTy;               \
+  typedef ELFSectionHeaderTable<BITWIDTH> ELFSectionHeaderTableTy;          \
+  typedef ELFSectionNoBits<BITWIDTH>      ELFSectionNoBitsTy;               \
+  typedef ELFSectionProgBits<BITWIDTH>    ELFSectionProgBitsTy;             \
+  typedef ELFSectionRelTable<BITWIDTH>    ELFSectionRelTableTy;             \
+  typedef ELFSectionStrTab<BITWIDTH>      ELFSectionStrTabTy;               \
+  typedef ELFSectionSymTab<BITWIDTH>      ELFSectionSymTabTy;               \
+  typedef ELFSymbol<BITWIDTH>             ELFSymbolTy;
+
+
+#define ELF_TYPE_INTRO_TO_TEMPLATE_SCOPE(BITWIDTH)                          \
+  /* ELF structures */                                                      \
+  ELF_STRUCT_TYPE_INTRO_TO_SCOPE(BITWIDTH)                                  \
+                                                                            \
+  /* ELF primitives */                                                      \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::address addr_t;             \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::offset  offset_t;           \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::byte    byte_t;             \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::half    half_t;             \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::word    word_t;             \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::sword   sword_t;            \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::xword   xword_t;            \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::sxword  sxword_t;           \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::relinfo relinfo_t;          \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::addend  addend_t;           \
+  typedef typename ELFPrimitiveTypes<BITWIDTH>::symsize symsize_t;
+
+
+#define ELF_TYPE_INTRO_TO_SCOPE(BITWIDTH)                                   \
+  /* ELF structures */                                                      \
+  ELF_STRUCT_TYPE_INTRO_TO_SCOPE(BITWIDTH)                                  \
+                                                                            \
+  /* ELF primitives */                                                      \
+  typedef ELFPrimitiveTypes<BITWIDTH>::address  addr_t;                     \
+  typedef ELFPrimitiveTypes<BITWIDTH>::offset   offset_t;                   \
+  typedef ELFPrimitiveTypes<BITWIDTH>::byte     byte_t;                     \
+  typedef ELFPrimitiveTypes<BITWIDTH>::half     half_t;                     \
+  typedef ELFPrimitiveTypes<BITWIDTH>::word     word_t;                     \
+  typedef ELFPrimitiveTypes<BITWIDTH>::sword    sword_t;                    \
+  typedef ELFPrimitiveTypes<BITWIDTH>::xword    xword_t;                    \
+  typedef ELFPrimitiveTypes<BITWIDTH>::sxword   sxword_t;                   \
+  typedef ELFPrimitiveTypes<BITWIDTH>::relinfo  relinfo_t;                  \
+  typedef ELFPrimitiveTypes<BITWIDTH>::addend   addend_t;                   \
+  typedef ELFPrimitiveTypes<BITWIDTH>::symsize  symsize_t;
+
+
+#endif // ELF_TYPES_H
diff --git a/driver/linkloader/include/GOT.h b/driver/linkloader/include/GOT.h
new file mode 100644
index 0000000..b72bf66
--- /dev/null
+++ b/driver/linkloader/include/GOT.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef GOT_H
+#define GOT_H
+
+#include "utils/rsl_assert.h"
+#include "ELF.h"
+
+#define GP_OFFSET	((int)0x8000)
+#define GOT_SIZE	(1 << 16)	// bytes
+#define GOT_ENTRY_SIZE	4	// bytes
+#define NUM_OF_GOT_ENTRY	(GOT_SIZE/GOT_ENTRY_SIZE)
+
+void *got_address();
+int search_got(int symbol_index, void *addr, uint8_t bind_type);
+
+#endif // GOT_H
diff --git a/driver/linkloader/include/MemChunk.h b/driver/linkloader/include/MemChunk.h
new file mode 100644
index 0000000..fb853e9
--- /dev/null
+++ b/driver/linkloader/include/MemChunk.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MEM_CHUNK_H
+#define MEM_CHUNK_H
+
+#include <stddef.h>
+#include <stdlib.h>
+
+class MemChunk {
+private:
+  unsigned char *buf;
+  size_t buf_size;
+
+public:
+  MemChunk();
+
+  ~MemChunk();
+
+  bool allocate(size_t size);
+
+  void print() const;
+
+  bool protect(int prot);
+
+  unsigned char const *getBuffer() const {
+    return buf;
+  }
+
+  unsigned char *getBuffer() {
+    return buf;
+  }
+
+  unsigned char &operator[](size_t index) {
+    return buf[index];
+  }
+
+  unsigned char const &operator[](size_t index) const {
+    return buf[index];
+  }
+
+  size_t size() const {
+    return buf_size;
+  }
+
+};
+
+#endif // MEM_CHUNK_H
diff --git a/driver/linkloader/include/StubLayout.h b/driver/linkloader/include/StubLayout.h
new file mode 100644
index 0000000..9705743
--- /dev/null
+++ b/driver/linkloader/include/StubLayout.h
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef STUB_LAYOUT_H
+#define STUB_LAYOUT_H
+
+#include <map>
+#include <stdlib.h>
+
+class StubLayout {
+private:
+  unsigned char *table;
+  size_t count;
+
+  std::map<void *, void *> stub_index;
+
+public:
+  StubLayout();
+  virtual ~StubLayout() { }
+
+  void initStubTable(unsigned char *table, size_t count);
+  void *allocateStub(void *addr = 0);
+
+  size_t calcStubTableSize(size_t count) const;
+  virtual size_t getUnitStubSize() const = 0;
+
+private:
+  virtual void setStubAddress(void *stub, void *addr) = 0;
+
+};
+
+class StubLayoutARM : public StubLayout {
+public:
+  StubLayoutARM() { }
+  size_t getUnitStubSize() const;
+
+private:
+  virtual void setStubAddress(void *stub, void *addr);
+};
+
+class StubLayoutMIPS : public StubLayout {
+public:
+  StubLayoutMIPS() { }
+  size_t getUnitStubSize() const;
+
+private:
+  virtual void setStubAddress(void *stub, void *addr);
+};
+
+
+#endif // STUB_LAYOUT_H
diff --git a/driver/linkloader/include/impl/ELFHeader.hxx b/driver/linkloader/include/impl/ELFHeader.hxx
new file mode 100644
index 0000000..993b0e2
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFHeader.hxx
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_HEADER_HXX
+#define ELF_HEADER_HXX
+
+#include "utils/raw_ostream.h"
+
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/Format.h>
+
+template <unsigned Bitwidth>
+void ELFHeader<Bitwidth>::print() {
+  using namespace llvm;
+
+  out() << fillformat('=', 79) << '\n';
+  out().changeColor(raw_ostream::WHITE, true);
+  out() << "ELF Header\n";
+  out().resetColor();
+  out() << fillformat('-', 79) << '\n';
+
+#define PRINT_LINT(title, value) \
+  out() << format("  %-32s : ", (char const *)(title)) << (value) << '\n'
+  PRINT_LINT("Class",                 getClassStr(getClass()));
+  PRINT_LINT("Endianness",            getEndiannessStr(getEndianness()));
+  PRINT_LINT("Header Version",        (unsigned)getVersion());
+  PRINT_LINT("OS ABI",                getOSABIStr(getOSABI()));
+  PRINT_LINT("ABI Version",           (unsigned)getABIVersion());
+  PRINT_LINT("Object Type",           getObjectTypeStr(getObjectType()));
+  PRINT_LINT("Machine",               getMachineStr(getMachine()));
+  PRINT_LINT("Version",               getVersionStr(getVersion()));
+  PRINT_LINT("Entry Address",         getEntryAddress());
+  PRINT_LINT("Program Header Offset", getProgramHeaderTableOffset());
+  PRINT_LINT("Section Header Offset", getSectionHeaderTableOffset());
+  PRINT_LINT("Flags",                 getFlags());
+  PRINT_LINT("ELF Header Size",       getELFHeaderSize());
+  PRINT_LINT("Program Header Size",   getProgramHeaderEntrySize());
+  PRINT_LINT("Program Header Num",    getProgramHeaderNum());
+  PRINT_LINT("Section Header Size",   getSectionHeaderEntrySize());
+  PRINT_LINT("Section Header Num",    getSectionHeaderNum());
+  PRINT_LINT("String Section Index",  getStringSectionIndex());
+#undef PRINT_LINT
+
+  out() << fillformat('=', 79) << "\n\n";
+}
+
+#endif // ELF_HEADER_HXX
diff --git a/driver/linkloader/include/impl/ELFObject.hxx b/driver/linkloader/include/impl/ELFObject.hxx
new file mode 100644
index 0000000..ca47820
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFObject.hxx
@@ -0,0 +1,740 @@
+/*
+ * Copyright 2011-2012, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_OBJECT_HXX
+#define ELF_OBJECT_HXX
+
+#include "ELFHeader.h"
+#include "ELFReloc.h"
+#include "ELFSection.h"
+#include "ELFSectionHeaderTable.h"
+#include "StubLayout.h"
+#include "GOT.h"
+#include "ELF.h"
+
+#include <llvm/ADT/SmallVector.h>
+
+#include "utils/rsl_assert.h"
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+inline ELFObject<Bitwidth> *
+ELFObject<Bitwidth>::read(Archiver &AR) {
+  llvm::OwningPtr<ELFObjectTy> object(new ELFObjectTy());
+
+  // Read header
+  object->header.reset(ELFHeaderTy::read(AR));
+  if (!object->header) {
+    return 0;
+  }
+
+  // Read section table
+  object->shtab.reset(ELFSectionHeaderTableTy::read(AR, object.get()));
+  if (!object->shtab) {
+    return 0;
+  }
+
+  // Read each section
+  llvm::SmallVector<size_t, 4> progbits_ndx;
+  for (size_t i = 0; i < object->header->getSectionHeaderNum(); ++i) {
+    if ((*object->shtab)[i]->getType() == SHT_PROGBITS) {
+      object->stab.push_back(NULL);
+      progbits_ndx.push_back(i);
+    } else {
+      llvm::OwningPtr<ELFSectionTy> sec(
+        ELFSectionTy::read(AR, object.get(), (*object->shtab)[i]));
+      object->stab.push_back(sec.take());
+    }
+  }
+
+  object->shtab->buildNameMap();
+  ELFSectionSymTabTy *symtab =
+    static_cast<ELFSectionSymTabTy *>(object->getSectionByName(".symtab"));
+  rsl_assert(symtab && "Symtab is required.");
+  symtab->buildNameMap();
+
+  for (size_t i = 0; i < progbits_ndx.size(); ++i) {
+    size_t index = progbits_ndx[i];
+
+    llvm::OwningPtr<ELFSectionTy> sec(
+      ELFSectionTy::read(AR, object.get(), (*object->shtab)[index]));
+    object->stab[index] = sec.take();
+  }
+
+  return object.take();
+}
+
+template <unsigned Bitwidth>
+inline char const *ELFObject<Bitwidth>::getSectionName(size_t i) const {
+  ELFSectionTy const *sec = stab[header->getStringSectionIndex()];
+
+  if (sec) {
+    ELFSectionStrTabTy const &st =
+      static_cast<ELFSectionStrTabTy const &>(*sec);
+    return st[i];
+  }
+
+  return NULL;
+}
+
+template <unsigned Bitwidth>
+inline ELFSection<Bitwidth> const *
+ELFObject<Bitwidth>::getSectionByIndex(size_t i) const {
+  return stab[i];
+}
+
+template <unsigned Bitwidth>
+inline ELFSection<Bitwidth> *
+ELFObject<Bitwidth>::getSectionByIndex(size_t i) {
+  return stab[i];
+}
+
+template <unsigned Bitwidth>
+inline ELFSection<Bitwidth> const *
+ELFObject<Bitwidth>::getSectionByName(std::string const &str) const {
+  size_t idx = getSectionHeaderTable()->getByName(str)->getIndex();
+  return stab[idx];
+}
+
+template <unsigned Bitwidth>
+inline ELFSection<Bitwidth> *
+ELFObject<Bitwidth>::getSectionByName(std::string const &str) {
+  ELFObjectTy const *const_this = this;
+  ELFSectionTy const *sptr = const_this->getSectionByName(str);
+  // Const cast for the same API's const and non-const versions.
+  return const_cast<ELFSectionTy *>(sptr);
+}
+
+
+template <unsigned Bitwidth>
+inline void ELFObject<Bitwidth>::
+relocateARM(void *(*find_sym)(void *context, char const *name),
+            void *context,
+            ELFSectionRelTableTy *reltab,
+            ELFSectionProgBitsTy *text) {
+  // FIXME: Should be implement in independent files.
+  rsl_assert(Bitwidth == 32 && "ARM only have 32 bits.");
+
+  ELFSectionSymTabTy *symtab =
+    static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
+  rsl_assert(symtab && "Symtab is required.");
+
+  for (size_t i = 0; i < reltab->size(); ++i) {
+    // FIXME: Can not implement here, use Fixup!
+    ELFRelocTy *rel = (*reltab)[i];
+    ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
+
+    // FIXME: May be not uint32_t *.
+    typedef int32_t Inst_t;
+    Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
+    Inst_t P = (Inst_t)(int64_t)inst;
+    Inst_t A = 0;
+    Inst_t S = (Inst_t)(int64_t)sym->getAddress(EM_ARM);
+    Inst_t T = 0;
+
+    if (sym->isConcreteFunc() && (sym->getValue() & 0x1)) {
+      T = 1;
+    }
+
+    word_t reltype = rel->getType();
+    switch (reltype) {
+    default:
+      rsl_assert(0 && "Not implemented relocation type.");
+      break;
+
+    case R_ARM_ABS32:
+      {
+        if (S == 0 && sym->getType() == STT_NOTYPE) {
+          void *ext_sym = find_sym(context, sym->getName());
+          if (!ext_sym) {
+            missingSymbols = true;
+          }
+          S = (Inst_t)(uintptr_t)ext_sym;
+          sym->setAddress(ext_sym);
+        }
+        A = *inst;
+        *inst = (S + A) | T;
+      }
+      break;
+
+      // FIXME: Predefine relocation codes.
+    case R_ARM_CALL:
+    case R_ARM_THM_CALL:
+    case R_ARM_JUMP24:
+    case R_ARM_THM_JUMP24:
+      {
+#define SIGN_EXTEND(x, l) (((x)^(1<<((l)-1)))-(1<<(l-1)))
+        if (reltype == R_ARM_CALL || reltype == R_ARM_JUMP24) {
+          A = (Inst_t)(int64_t)SIGN_EXTEND(*inst & 0xFFFFFF, 24);
+          A <<= 2;
+        } else {
+          // Hack for two 16bit.
+          *inst = ((*inst >> 16) & 0xFFFF) | (*inst << 16);
+          Inst_t s  = (*inst >> 26) & 0x1u,    // 26
+                 u  = (*inst >> 16) & 0x3FFu,  // 25-16
+                 l  =  *inst        & 0x7FFu, // 10-0
+                 j1 = (*inst >> 13) & 0x1u,    // 13
+                 j2 = (*inst >> 11) & 0x1u;    // 11
+          Inst_t i1 = (~(j1 ^ s)) & 0x1u,
+                 i2 = (~(j2 ^ s)) & 0x1u;
+          // [31-25][24][23][22][21-12][11-1][0]
+          //      0   s  i1  i2      u     l  0
+          A = SIGN_EXTEND((s << 23) | (i1 << 22) | (i2 << 21) | (u << 11) | l, 24);
+          A <<= 1;
+        }
+#undef SIGN_EXTEND
+
+        void *callee_addr = sym->getAddress(EM_ARM);
+
+        switch (sym->getType()) {
+        default:
+          rsl_assert(0 && "Wrong type for R_ARM_CALL relocation.");
+          abort();
+          break;
+
+        case STT_FUNC:
+          // NOTE: Callee function is in the object file, but it may be
+          // in different PROGBITS section (which may be far call).
+
+          if (callee_addr == 0) {
+            rsl_assert(0 && "We should get function address at previous "
+                   "sym->getAddress(EM_ARM) function call.");
+            abort();
+          }
+          break;
+
+        case STT_NOTYPE:
+          // NOTE: Callee function is an external function.  Call find_sym
+          // if it has not resolved yet.
+
+          if (callee_addr == 0) {
+            callee_addr = find_sym(context, sym->getName());
+            if (!callee_addr) {
+              missingSymbols = true;
+            }
+            sym->setAddress(callee_addr);
+          }
+          break;
+        }
+
+        // Get the stub for this function
+        StubLayout *stub_layout = text->getStubLayout();
+
+        if (!stub_layout) {
+          llvm::errs() << "unable to get stub layout." << "\n";
+          abort();
+        }
+
+        void *stub = stub_layout->allocateStub(callee_addr);
+
+        if (!stub) {
+          llvm::errs() << "unable to allocate stub." << "\n";
+          abort();
+        }
+
+        //LOGI("Function %s: using stub %p\n", sym->getName(), stub);
+        S = (uint32_t)(uintptr_t)stub;
+
+        if (reltype == R_ARM_CALL || reltype == R_ARM_JUMP24) {
+          // Relocate the R_ARM_CALL relocation type
+          uint32_t result = (S + A - P) >> 2;
+
+          if (result > 0x007FFFFF && result < 0xFF800000) {
+            rsl_assert(0 && "Stub is still too far");
+            abort();
+          }
+
+          *inst = ((result) & 0x00FFFFFF) | (*inst & 0xFF000000);
+        } else {
+          P &= ~0x3;  // Base address align to 4 bytes.  (For BLX.)
+
+          // Relocate the R_ARM_THM_CALL relocation type
+          uint32_t result = (S + A - P) >> 1;
+
+          if (result > 0x007FFFFF && result < 0xFF800000) {
+            rsl_assert(0 && "Stub is still too far");
+            abort();
+          }
+
+          //*inst &= 0xF800D000u;
+          // Rewrite instruction to BLX.  (Stub is always ARM.)
+          *inst &= 0xF800C000u;
+          // [31-25][24][23][22][21-12][11-1][0]
+          //      0   s  i1  i2      u     l  0
+          Inst_t s  = (result >> 23) & 0x1u,   // 26
+                 u  = (result >> 11) & 0x3FFu, // 25-16
+                 // For BLX, bit [0] is 0.
+                 l  =  result        & 0x7FEu, // 10-0
+                 i1 = (result >> 22) & 0x1u,
+                 i2 = (result >> 21) & 0x1u;
+          Inst_t j1 = ((~i1) ^ s) & 0x01u,       // 13
+                 j2 = ((~i2) ^ s) & 0x01u;       // 11
+          *inst |= s << 26;
+          *inst |= u << 16;
+          *inst |= l;
+          *inst |= j1 << 13;
+          *inst |= j2 << 11;
+          // Hack for two 16bit.
+          *inst = ((*inst >> 16) & 0xFFFF) | (*inst << 16);
+        }
+      }
+      break;
+    case R_ARM_MOVT_ABS:
+    case R_ARM_MOVW_ABS_NC:
+    case R_ARM_THM_MOVW_ABS_NC:
+    case R_ARM_THM_MOVT_ABS:
+      {
+        if (S == 0 && sym->getType() == STT_NOTYPE) {
+          void *ext_sym = find_sym(context, sym->getName());
+          if (!ext_sym) {
+            missingSymbols = true;
+          }
+          S = (Inst_t)(uintptr_t)ext_sym;
+          sym->setAddress(ext_sym);
+        }
+        if (reltype == R_ARM_MOVT_ABS
+            || reltype == R_ARM_THM_MOVT_ABS) {
+          S >>= 16;
+        }
+
+        if (reltype == R_ARM_MOVT_ABS
+            || reltype == R_ARM_MOVW_ABS_NC) {
+          // No need sign extend.
+          A = ((*inst & 0xF0000) >> 4) | (*inst & 0xFFF);
+          uint32_t result = (S + A);
+          *inst = (((result) & 0xF000) << 4) |
+            ((result) & 0xFFF) |
+            (*inst & 0xFFF0F000);
+        } else {
+          // Hack for two 16bit.
+          *inst = ((*inst >> 16) & 0xFFFF) | (*inst << 16);
+          // imm16: [19-16][26][14-12][7-0]
+          A = (((*inst >>  4) & 0xF000u) |
+               ((*inst >> 15) & 0x0800u) |
+               ((*inst >>  4) & 0x0700u) |
+               ( *inst        & 0x00FFu));
+          uint32_t result;
+          if (reltype == R_ARM_THM_MOVT_ABS) {
+            result = (S + A);
+          } else {
+            result = (S + A) | T;
+          }
+          // imm16: [19-16][26][14-12][7-0]
+          *inst &= 0xFBF08F00u;
+          *inst |= (result & 0xF000u) << 4;
+          *inst |= (result & 0x0800u) << 15;
+          *inst |= (result & 0x0700u) << 4;
+          *inst |= (result & 0x00FFu);
+          // Hack for two 16bit.
+          *inst = ((*inst >> 16) & 0xFFFF) | (*inst << 16);
+        }
+      }
+      break;
+    }
+    //llvm::errs() << "S:     " << (void *)S << '\n';
+    //llvm::errs() << "A:     " << (void *)A << '\n';
+    //llvm::errs() << "P:     " << (void *)P << '\n';
+    //llvm::errs() << "S+A:   " << (void *)(S+A) << '\n';
+    //llvm::errs() << "S+A-P: " << (void *)(S+A-P) << '\n';
+  }
+}
+
+template <unsigned Bitwidth>
+inline void ELFObject<Bitwidth>::
+relocateX86_64(void *(*find_sym)(void *context, char const *name),
+               void *context,
+               ELFSectionRelTableTy *reltab,
+               ELFSectionProgBitsTy *text) {
+  rsl_assert(Bitwidth == 64 && "Only support X86_64.");
+
+  ELFSectionSymTabTy *symtab =
+    static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
+  rsl_assert(symtab && "Symtab is required.");
+
+  for (size_t i = 0; i < reltab->size(); ++i) {
+    // FIXME: Can not implement here, use Fixup!
+    ELFRelocTy *rel = (*reltab)[i];
+    ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
+
+    //typedef uint64_t Inst_t;
+    typedef int32_t Inst_t;
+    Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
+    Inst_t P = (Inst_t)(int64_t)inst;
+    Inst_t A = (Inst_t)(int64_t)rel->getAddend();
+    Inst_t S = (Inst_t)(int64_t)sym->getAddress(EM_X86_64);
+
+    if (S == 0) {
+      S = (Inst_t)(int64_t)find_sym(context, sym->getName());
+      if (!S) {
+        missingSymbols = true;
+      }
+      sym->setAddress((void *)S);
+    }
+
+    switch (rel->getType()) {
+      default:
+        rsl_assert(0 && "Not implemented relocation type.");
+        break;
+
+      // FIXME: XXX: R_X86_64_64 is 64 bit, there is a big problem here.
+      case 1: // R_X86_64_64
+        *inst = (S+A);
+        break;
+
+      case 2: // R_X86_64_PC32
+        *inst = (S+A-P);
+        break;
+
+      case 10: // R_X86_64_32
+      case 11: // R_X86_64_32S
+        *inst = (S+A);
+        break;
+    }
+  }
+}
+
+template <unsigned Bitwidth>
+inline void ELFObject<Bitwidth>::
+relocateX86_32(void *(*find_sym)(void *context, char const *name),
+               void *context,
+               ELFSectionRelTableTy *reltab,
+               ELFSectionProgBitsTy *text) {
+  rsl_assert(Bitwidth == 32 && "Only support X86.");
+
+  ELFSectionSymTabTy *symtab =
+    static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
+  rsl_assert(symtab && "Symtab is required.");
+
+  for (size_t i = 0; i < reltab->size(); ++i) {
+    // FIXME: Can not implement here, use Fixup!
+    ELFRelocTy *rel = (*reltab)[i];
+    ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
+
+    //typedef uint64_t Inst_t;
+    typedef int32_t Inst_t;
+    Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
+    Inst_t P = (Inst_t)(uintptr_t)inst;
+    Inst_t A = (Inst_t)(uintptr_t)*inst;
+    Inst_t S = (Inst_t)(uintptr_t)sym->getAddress(EM_386);
+
+    if (S == 0) {
+      S = (Inst_t)(uintptr_t)find_sym(context, sym->getName());
+      if (!S) {
+        missingSymbols = true;
+      }
+      sym->setAddress((void *)S);
+    }
+
+    switch (rel->getType()) {
+    default:
+      rsl_assert(0 && "Not implemented relocation type.");
+      break;
+
+    case R_386_PC32:
+      *inst = (S+A-P);
+      break;
+
+    case R_386_32:
+      *inst = (S+A);
+      break;
+    }
+  }
+}
+
+template <unsigned Bitwidth>
+inline void ELFObject<Bitwidth>::
+relocateMIPS(void *(*find_sym)(void *context, char const *name),
+             void *context,
+             ELFSectionRelTableTy *reltab,
+             ELFSectionProgBitsTy *text) {
+  rsl_assert(Bitwidth == 32 && "Only support 32-bit MIPS.");
+
+  ELFSectionSymTabTy *symtab =
+    static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
+  rsl_assert(symtab && "Symtab is required.");
+
+  for (size_t i = 0; i < reltab->size(); ++i) {
+    // FIXME: Can not implement here, use Fixup!
+    ELFRelocTy *rel = (*reltab)[i];
+    ELFSymbolTy *sym = (*symtab)[rel->getSymTabIndex()];
+
+    typedef int32_t Inst_t;
+    Inst_t *inst = (Inst_t *)&(*text)[rel->getOffset()];
+    Inst_t P = (Inst_t)(uintptr_t)inst;
+    Inst_t A = (Inst_t)(uintptr_t)*inst;
+    Inst_t S = (Inst_t)(uintptr_t)sym->getAddress(EM_MIPS);
+
+    bool need_stub = false;
+
+    if (S == 0 && strcmp (sym->getName(), "_gp_disp") != 0) {
+      need_stub = true;
+      S = (Inst_t)(uintptr_t)find_sym(context, sym->getName());
+      if (!S) {
+        missingSymbols = true;
+      }
+      sym->setAddress((void *)S);
+    }
+
+    switch (rel->getType()) {
+    default:
+      rsl_assert(0 && "Not implemented relocation type.");
+      break;
+
+    case R_MIPS_NONE:
+    case R_MIPS_JALR: // ignore this
+      break;
+
+    case R_MIPS_16:
+      *inst &= 0xFFFF0000;
+      A = A & 0xFFFF;
+      A = S + (short)A;
+      rsl_assert(A >= -32768 && A <= 32767 && "R_MIPS_16 overflow.");
+      *inst |= (A & 0xFFFF);
+      break;
+
+    case R_MIPS_32:
+      *inst = S + A;
+      break;
+
+    case R_MIPS_26:
+      *inst &= 0xFC000000;
+      if (need_stub == false) {
+        A = (A & 0x3FFFFFF) << 2;
+        if (sym->getBindingAttribute() == STB_LOCAL) { // local binding
+          A |= ((P + 4) & 0xF0000000);
+          A += S;
+          *inst |= ((A >> 2) & 0x3FFFFFF);
+        } else { // external binding
+          if (A & 0x08000000) // Sign extend from bit 27
+            A |= 0xF0000000;
+          A += S;
+          *inst |= ((A >> 2) & 0x3FFFFFF);
+          if (((P + 4) >> 28) != (A >> 28)) { // far local call
+            void *stub = text->getStubLayout()->allocateStub((void *)A);
+            rsl_assert(stub && "cannot allocate stub.");
+            sym->setAddress(stub);
+            S = (int32_t)(intptr_t)stub;
+            *inst |= ((S >> 2) & 0x3FFFFFF);
+            rsl_assert(((P + 4) >> 28) == (S >> 28) && "stub is too far.");
+          }
+        }
+      } else { // shared-library call
+        A = (A & 0x3FFFFFF) << 2;
+        rsl_assert(A == 0 && "R_MIPS_26 addend is not zero.");
+        void *stub = text->getStubLayout()->allocateStub((void *)S);
+        rsl_assert(stub && "cannot allocate stub.");
+        sym->setAddress(stub);
+        S = (int32_t)(intptr_t)stub;
+        *inst |= ((S >> 2) & 0x3FFFFFF);
+        rsl_assert(((P + 4) >> 28) == (S >> 28) && "stub is too far.");
+      }
+      break;
+
+    case R_MIPS_HI16:
+      *inst &= 0xFFFF0000;
+      A = (A & 0xFFFF) << 16;
+      // Find the nearest LO16 relocation type after this entry
+      for (size_t j = i + 1; j < reltab->size(); j++) {
+        ELFRelocTy *this_rel = (*reltab)[j];
+        ELFSymbolTy *this_sym = (*symtab)[this_rel->getSymTabIndex()];
+        if (this_rel->getType() == R_MIPS_LO16 && this_sym == sym) {
+          Inst_t *this_inst = (Inst_t *)&(*text)[this_rel->getOffset()];
+          Inst_t this_A = (Inst_t)(uintptr_t)*this_inst;
+          this_A = this_A & 0xFFFF;
+          A += (short)this_A;
+          break;
+        }
+      }
+      if (strcmp (sym->getName(), "_gp_disp") == 0) {
+          S = (int)(intptr_t)got_address() + GP_OFFSET - (int)P;
+          sym->setAddress((void *)S);
+      }
+      *inst |= (((S + A + (int)0x8000) >> 16) & 0xFFFF);
+      break;
+
+    case R_MIPS_LO16:
+      *inst &= 0xFFFF0000;
+      A = A & 0xFFFF;
+      if (strcmp (sym->getName(), "_gp_disp") == 0) {
+          S = (Inst_t)(intptr_t)sym->getAddress(EM_MIPS);
+      }
+      *inst |= ((S + A) & 0xFFFF);
+      break;
+
+    case R_MIPS_GOT16:
+    case R_MIPS_CALL16:
+      {
+        *inst &= 0xFFFF0000;
+        A = A & 0xFFFF;
+        if (rel->getType() == R_MIPS_GOT16) {
+          if (sym->getBindingAttribute() == STB_LOCAL) {
+            A <<= 16;
+
+            // Find the nearest LO16 relocation type after this entry
+            for (size_t j = i + 1; j < reltab->size(); j++) {
+              ELFRelocTy *this_rel = (*reltab)[j];
+              ELFSymbolTy *this_sym = (*symtab)[this_rel->getSymTabIndex()];
+              if (this_rel->getType() == R_MIPS_LO16 && this_sym == sym) {
+                Inst_t *this_inst = (Inst_t *)&(*text)[this_rel->getOffset()];
+                Inst_t this_A = (Inst_t)(uintptr_t)*this_inst;
+                this_A = this_A & 0xFFFF;
+                A += (short)this_A;
+                break;
+              }
+            }
+          } else {
+            rsl_assert(A == 0 && "R_MIPS_GOT16 addend is not 0.");
+          }
+        } else { // R_MIPS_CALL16
+          rsl_assert(A == 0 && "R_MIPS_CALL16 addend is not 0.");
+        }
+        int got_index = search_got((int)rel->getSymTabIndex(), (void *)(S + A),
+                                   sym->getBindingAttribute());
+        int got_offset = (got_index << 2) - GP_OFFSET;
+        *inst |= (got_offset & 0xFFFF);
+      }
+      break;
+
+    case R_MIPS_GPREL32:
+      *inst = A + S - ((int)(intptr_t)got_address() + GP_OFFSET);
+      break;
+    }
+  }
+}
+
+
+// TODO: Refactor all relocations.
+template <unsigned Bitwidth>
+inline void ELFObject<Bitwidth>::
+relocate(void *(*find_sym)(void *context, char const *name), void *context) {
+  // Init SHNCommonDataSize.
+  // Need refactoring
+  size_t SHNCommonDataSize = 0;
+
+  ELFSectionSymTabTy *symtab =
+    static_cast<ELFSectionSymTabTy *>(getSectionByName(".symtab"));
+  rsl_assert(symtab && "Symtab is required.");
+
+  for (size_t i = 0; i < symtab->size(); ++i) {
+    ELFSymbolTy *sym = (*symtab)[i];
+
+    if (sym->getType() != STT_OBJECT) {
+      continue;
+    }
+
+    size_t idx = (size_t)sym->getSectionIndex();
+    switch (idx) {
+    default:
+      if ((*shtab)[idx]->getType() == SHT_NOBITS) {
+        // FIXME(logan): This is a workaround for .lcomm directives
+        // bug of LLVM ARM MC code generator.  Remove this when the
+        // LLVM bug is fixed.
+
+        size_t align = 16;
+        SHNCommonDataSize += (size_t)sym->getSize() + align;
+      }
+      break;
+
+    case SHN_COMMON:
+      {
+        size_t align = (size_t)sym->getValue();
+        SHNCommonDataSize += (size_t)sym->getSize() + align;
+      }
+      break;
+
+    case SHN_ABS:
+    case SHN_UNDEF:
+    case SHN_XINDEX:
+      break;
+    }
+  }
+  if (!initSHNCommonDataSize(SHNCommonDataSize)) {
+    rsl_assert("Allocate memory for common variable fail!");
+    // TODO: Refactor object loading to use proper status/error returns.
+    // We mark the object as having missing symbols and return early in this
+    // case to signal a loading error (usually due to running out of
+    // available memory to allocate).
+    missingSymbols = true;
+    return;
+  }
+
+  for (size_t i = 0; i < stab.size(); ++i) {
+    ELFSectionHeaderTy *sh = (*shtab)[i];
+    if (sh->getType() != SHT_REL && sh->getType() != SHT_RELA) {
+      continue;
+    }
+    ELFSectionRelTableTy *reltab =
+      static_cast<ELFSectionRelTableTy *>(stab[i]);
+    rsl_assert(reltab && "Relocation section can't be NULL.");
+
+    const char *reltab_name = sh->getName();
+    const char *need_rel_name;
+    if (sh->getType() == SHT_REL) {
+      need_rel_name = reltab_name + 4;
+      // ".rel.xxxx"
+      //      ^ start from here.
+    } else {
+      need_rel_name = reltab_name + 5;
+    }
+
+    ELFSectionProgBitsTy *need_rel =
+      static_cast<ELFSectionProgBitsTy *>(getSectionByName(need_rel_name));
+    rsl_assert(need_rel && "Need be relocated section can't be NULL.");
+
+    switch (getHeader()->getMachine()) {
+      case EM_ARM:
+        relocateARM(find_sym, context, reltab, need_rel);
+        break;
+      case EM_386:
+        relocateX86_32(find_sym, context, reltab, need_rel);
+        break;
+      case EM_X86_64:
+        relocateX86_64(find_sym, context, reltab, need_rel);
+        break;
+      case EM_MIPS:
+        relocateMIPS(find_sym, context, reltab, need_rel);
+        break;
+
+      default:
+        rsl_assert(0 && "Only support ARM, MIPS, X86, and X86_64 relocation.");
+        break;
+    }
+  }
+
+  for (size_t i = 0; i < stab.size(); ++i) {
+    ELFSectionHeaderTy *sh = (*shtab)[i];
+    if (sh->getType() == SHT_PROGBITS || sh->getType() == SHT_NOBITS) {
+      if (stab[i]) {
+        static_cast<ELFSectionBitsTy *>(stab[i])->protect();
+      }
+    }
+  }
+}
+
+template <unsigned Bitwidth>
+inline void ELFObject<Bitwidth>::print() const {
+  header->print();
+  shtab->print();
+
+  for (size_t i = 0; i < stab.size(); ++i) {
+    ELFSectionTy *sec = stab[i];
+    if (sec) {
+      sec->print();
+    }
+  }
+}
+
+#endif // ELF_OBJECT_HXX
diff --git a/driver/linkloader/include/impl/ELFReloc.hxx b/driver/linkloader/include/impl/ELFReloc.hxx
new file mode 100644
index 0000000..6b55e02
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFReloc.hxx
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_RELOC_HXX
+#define ELF_RELOC_HXX
+
+#include "utils/raw_ostream.h"
+
+#include <llvm/Support/Format.h>
+#include <llvm/Support/raw_ostream.h>
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+inline ELFReloc<Bitwidth> *
+ELFReloc_CRTP<Bitwidth>::readRela(Archiver &AR, size_t index) {
+  if (!AR) {
+    // Archiver is in bad state before calling read function.
+    // Return NULL and do nothing.
+    return 0;
+  }
+
+  llvm::OwningPtr<ELFRelocTy> sh(new ELFRelocTy());
+
+  if (!sh->serializeRela(AR)) {
+    // Unable to read the structure.  Return NULL.
+    return 0;
+  }
+
+  if (!sh->isValid()) {
+    // Rel read from archiver is not valid.  Return NULL.
+    return 0;
+  }
+
+  // Set the section header index
+  sh->index = index;
+
+  return sh.take();
+}
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+inline ELFReloc<Bitwidth> *
+ELFReloc_CRTP<Bitwidth>::readRel(Archiver &AR, size_t index) {
+  if (!AR) {
+    // Archiver is in bad state before calling read function.
+    // Return NULL and do nothing.
+    return 0;
+  }
+
+  llvm::OwningPtr<ELFRelocTy> sh(new ELFRelocTy());
+
+  sh->r_addend = 0;
+  if (!sh->serializeRel(AR)) {
+    return 0;
+  }
+
+  if (!sh->isValid()) {
+    // Rel read from archiver is not valid.  Return NULL.
+    return 0;
+  }
+
+  // Set the section header index
+  sh->index = index;
+
+  return sh.take();
+}
+
+template <unsigned Bitwidth>
+inline void ELFReloc_CRTP<Bitwidth>::print(bool shouldPrintHeader) const {
+  using namespace llvm;
+  if (shouldPrintHeader) {
+    out() << '\n' << fillformat('=', 79) << '\n';
+    out().changeColor(raw_ostream::WHITE, true);
+    out() << "ELF Relaocation Table Entry "
+          << this->getIndex() << '\n';
+    out().resetColor();
+    out() << fillformat('-', 79) << '\n';
+  } else {
+    out() << fillformat('-', 79) << '\n';
+    out().changeColor(raw_ostream::YELLOW, true);
+    out() << "ELF Relaocation Table Entry "
+          << this->getIndex() << " : " << '\n';
+    out().resetColor();
+  }
+
+#define PRINT_LINT(title, value) \
+  out() << format("  %-13s : ", (char const *)(title)) << (value) << '\n'
+  PRINT_LINT("Offset",       concrete()->getOffset()       );
+  PRINT_LINT("SymTab Index", concrete()->getSymTabIndex()  );
+  PRINT_LINT("Type",         concrete()->getType()         );
+  PRINT_LINT("Addend",       concrete()->getAddend()       );
+#undef PRINT_LINT
+}
+
+#endif // ELF_RELOC_HXX
diff --git a/driver/linkloader/include/impl/ELFSection.hxx b/driver/linkloader/include/impl/ELFSection.hxx
new file mode 100644
index 0000000..fb0e6f6
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSection.hxx
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_HXX
+#define ELF_SECTION_HXX
+
+#include "utils/raw_ostream.h"
+
+#include <llvm/Support/raw_ostream.h>
+
+#include "ELFSectionHeader.h"
+#include "ELFSectionStrTab.h"
+#include "ELFSectionSymTab.h"
+#include "ELFSectionProgBits.h"
+#include "ELFSectionNoBits.h"
+#include "ELFSectionRelTable.h"
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+inline ELFSection<Bitwidth> *
+ELFSection<Bitwidth>::read(Archiver &AR,
+                           ELFObjectTy *owner,
+                           ELFSectionHeaderTy const *sh) {
+  using namespace std;
+
+  switch (sh->getType()) {
+    default:
+      // Uknown type of ELF section.  Return NULL.
+      //llvm::errs() << "WARNING: Unknown section type.\n";
+      return 0;
+
+    case SHT_STRTAB:
+      return ELFSectionStrTabTy::read(AR, sh);
+
+    case SHT_SYMTAB:
+      return ELFSectionSymTabTy::read(AR, owner, sh);
+
+    case SHT_PROGBITS:
+      return ELFSectionProgBitsTy::read(AR, owner, sh);
+
+    case SHT_NOBITS:
+      return ELFSectionNoBitsTy::read(AR, sh);
+
+    case SHT_REL:
+    case SHT_RELA:
+      return ELFSectionRelTableTy::read(AR, sh);
+
+    case SHT_NULL:
+      // TODO: Not Yet Implemented
+      return 0;
+  };
+}
+
+#endif // ELF_SECTION_HXX
diff --git a/driver/linkloader/include/impl/ELFSectionBits.hxx b/driver/linkloader/include/impl/ELFSectionBits.hxx
new file mode 100644
index 0000000..bd585d4
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSectionBits.hxx
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_BITS_HXX
+#define ELF_SECTION_BITS_HXX
+
+#include "utils/flush_cpu_cache.h"
+#include "utils/helper.h"
+
+#include <llvm/Support/raw_ostream.h>
+
+#include <sys/mman.h>
+
+template <unsigned Bitwidth>
+inline void ELFSectionBits<Bitwidth>::print() const {
+  using namespace llvm;
+
+  char const *section_type_str =
+    (sh->getType() == SHT_NOBITS) ? "NOBITS" : "PROGBITS";
+
+  out() << '\n' << fillformat('=', 79) << '\n';
+  out().changeColor(raw_ostream::WHITE, true);
+  out() << "ELF " << section_type_str << ": " << sh->getName() << '\n';
+  out().resetColor();
+  out() << fillformat('-', 79) << '\n';
+
+  out() << "  Size         : " << sh->getSize() << '\n';
+  out() << "  Start Address: " << (void *)chunk.getBuffer() << '\n';
+  out() << fillformat('-', 79) << '\n';
+
+  chunk.print();
+
+  out() << fillformat('=', 79) << '\n';
+}
+
+template <unsigned Bitwidth>
+inline bool ELFSectionBits<Bitwidth>::protect() {
+  int prot = PROT_READ;
+
+  if (sh->getFlags() & SHF_WRITE) {
+    prot |= PROT_WRITE;
+  }
+
+  if (sh->getFlags() & SHF_EXECINSTR) {
+    prot |= PROT_EXEC;
+  }
+
+  return chunk.protect(prot);
+}
+
+#endif // ELF_SECTION_BITS_HXX
diff --git a/driver/linkloader/include/impl/ELFSectionHeader.hxx b/driver/linkloader/include/impl/ELFSectionHeader.hxx
new file mode 100644
index 0000000..78a5495
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSectionHeader.hxx
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_HEADER_HXX
+#define ELF_SECTION_HEADER_HXX
+
+#include "utils/raw_ostream.h"
+#include <llvm/Support/Format.h>
+#include <llvm/Support/raw_ostream.h>
+
+#include "ELFObject.h"
+
+template <unsigned Bitwidth>
+char const *ELFSectionHeader_CRTP<Bitwidth>::getName() const {
+  return owner->getSectionName(getNameIndex());
+}
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+typename ELFSectionHeader_CRTP<Bitwidth>::ELFSectionHeaderTy *
+ELFSectionHeader_CRTP<Bitwidth>::read(Archiver &AR,
+                                      ELFObjectTy const *owner,
+                                      size_t index) {
+
+  if (!AR) {
+    // Archiver is in bad state before calling read function.
+    // Return NULL and do nothing.
+    return 0;
+  }
+
+  llvm::OwningPtr<ELFSectionHeaderTy> sh(new ELFSectionHeaderTy());
+
+  if (!sh->serialize(AR)) {
+    // Unable to read the structure.  Return NULL.
+    return 0;
+  }
+
+  if (!sh->isValid()) {
+    // Header read from archiver is not valid.  Return NULL.
+    return 0;
+  }
+
+  // Set the section header index
+  sh->index = index;
+
+  // Set the owner elf object
+  sh->owner = owner;
+
+  return sh.take();
+}
+
+template <unsigned Bitwidth>
+void ELFSectionHeader_CRTP<Bitwidth>::print(bool shouldPrintHeader) const {
+  using namespace llvm;
+
+  if (shouldPrintHeader) {
+    out() << '\n' << fillformat('=', 79) << '\n';
+    out().changeColor(raw_ostream::WHITE, true);
+    out() << "ELF Section Header "
+      << this->getIndex() << '\n';
+    out().resetColor();
+    out() << fillformat('-', 79) << '\n';
+  } else {
+    out() << fillformat('-', 79) << '\n';
+    out().changeColor(raw_ostream::YELLOW, true);
+    out() << "ELF Section Header "
+      << this->getIndex() << " : " << '\n';
+    out().resetColor();
+  }
+
+#define PRINT_LINT(title, value) \
+  out() << format("  %-13s : ", (char const *)(title)) << (value) << '\n'
+  PRINT_LINT("Name",          getName() );
+  PRINT_LINT("Type",          getSectionTypeStr(getType()));
+  PRINT_LINT("Flags",         concrete()->getFlags());
+  PRINT_LINT("Address",       getAddress());
+  PRINT_LINT("Offset",        getOffset());
+  PRINT_LINT("Size",          concrete()->getSize());
+  PRINT_LINT("Link",          getLink());
+  PRINT_LINT("Extra Info",    getExtraInfo());
+  PRINT_LINT("Address Align", concrete()->getAddressAlign());
+  PRINT_LINT("Entry Size",    concrete()->getEntrySize());
+#undef PRINT_LINT
+
+  if (shouldPrintHeader) {
+    out() << fillformat('=', 79) << '\n';
+  }
+}
+
+#endif // ELF_SECTION_HEADER_HXX
diff --git a/driver/linkloader/include/impl/ELFSectionHeaderTable.hxx b/driver/linkloader/include/impl/ELFSectionHeaderTable.hxx
new file mode 100644
index 0000000..1f693a4
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSectionHeaderTable.hxx
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_HEADER_TABLE_HXX
+#define ELF_SECTION_HEADER_TABLE_HXX
+
+#include "ELFHeader.h"
+#include "ELFObject.h"
+#include "ELFSectionHeader.h"
+
+#include "utils/rsl_assert.h"
+
+template <unsigned Bitwidth>
+ELFSectionHeaderTable<Bitwidth>::~ELFSectionHeaderTable() {
+  for (size_t i = 0; i < table.size(); ++i) {
+    delete table[i];
+  }
+}
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+inline ELFSectionHeaderTable<Bitwidth> *
+ELFSectionHeaderTable<Bitwidth>::read(Archiver &AR, ELFObjectTy *owner) {
+  if (!AR) {
+    // Archiver is in bad state before calling read function.
+    // Return NULL and do nothing.
+    return 0;
+  }
+
+  // Allocate a new section header table and assign the owner.
+  llvm::OwningPtr<ELFSectionHeaderTable> tab(new ELFSectionHeaderTable());
+
+  // Get ELF header
+  ELFHeaderTy const *header = owner->getHeader();
+
+  rsl_assert(header->getSectionHeaderEntrySize() ==
+         TypeTraits<ELFSectionHeaderTy>::size);
+
+  // Seek to the address of section header
+  AR.seek(header->getSectionHeaderTableOffset(), true);
+
+  for (size_t i = 0; i < header->getSectionHeaderNum(); ++i) {
+    llvm::OwningPtr<ELFSectionHeaderTy> sh(
+      ELFSectionHeaderTy::read(AR, owner, i));
+
+    if (!sh) {
+      // Something wrong while reading the section header.
+      return 0;
+    }
+
+    tab->table.push_back(sh.take());
+  }
+
+  return tab.take();
+}
+
+template <unsigned Bitwidth>
+inline void ELFSectionHeaderTable<Bitwidth>::print() const {
+  using namespace llvm;
+
+  out() << '\n' << fillformat('=', 79) << '\n';
+  out().changeColor(raw_ostream::WHITE, true);
+  out() << "ELF Section Header Table" << '\n';
+  out().resetColor();
+
+  for (size_t i = 0; i < table.size(); ++i) {
+    (*this)[i]->print();
+  }
+
+  out() << fillformat('=', 79) << '\n';
+}
+
+template <unsigned Bitwidth>
+inline void ELFSectionHeaderTable<Bitwidth>::buildNameMap() {
+  for (size_t i = 0; i < table.size(); ++i) {
+    ELFSectionHeaderTy *sh = table[i];
+    if ( sh ) {
+      name_map[sh->getName()] = sh;
+    }
+  }
+}
+
+template <unsigned Bitwidth>
+inline ELFSectionHeader<Bitwidth> const *
+ELFSectionHeaderTable<Bitwidth>::getByName(const std::string &name) const {
+  typename llvm::StringMap<ELFSectionHeaderTy *>::const_iterator sh =
+    name_map.find(name);
+  if (sh == name_map.end()) {
+    // Return SHN_UNDEF section header;
+    return table[0];
+  }
+  return sh->getValue();
+}
+
+template <unsigned Bitwidth>
+inline ELFSectionHeader<Bitwidth> *
+ELFSectionHeaderTable<Bitwidth>::getByName(const std::string &name) {
+  ELFSectionHeaderTableTy const *const_this = this;
+  ELFSectionHeaderTy const *shptr = const_this->getByName(name);
+  // Const cast for the same API's const and non-const versions.
+  return const_cast<ELFSectionHeaderTy *>(shptr);
+}
+
+#endif // ELF_SECTION_HEADER_TABLE_HXX
diff --git a/driver/linkloader/include/impl/ELFSectionNoBits.hxx b/driver/linkloader/include/impl/ELFSectionNoBits.hxx
new file mode 100644
index 0000000..d1a6436
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSectionNoBits.hxx
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_NOBITS_HXX
+#define ELF_SECTION_NOBITS_HXX
+
+#include "ELFTypes.h"
+
+#include "utils/raw_ostream.h"
+
+#include <llvm/Support/Format.h>
+#include <llvm/Support/raw_ostream.h>
+
+#include <sys/mman.h>
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+inline ELFSectionNoBits<Bitwidth> *
+ELFSectionNoBits<Bitwidth>::read(Archiver &AR, ELFSectionHeaderTy const *sh) {
+  llvm::OwningPtr<ELFSectionNoBits> result(new ELFSectionNoBits());
+
+  if (!result->chunk.allocate(sh->getSize())) {
+    return NULL;
+  }
+
+  result->sh = sh;
+
+  return result.take();
+}
+
+#endif // ELF_SECTION_NOBITS_HXX
diff --git a/driver/linkloader/include/impl/ELFSectionProgBits.hxx b/driver/linkloader/include/impl/ELFSectionProgBits.hxx
new file mode 100644
index 0000000..434e5b5
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSectionProgBits.hxx
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_PROGBITS_HXX
+#define ELF_SECTION_PROGBITS_HXX
+
+#include "ELFTypes.h"
+#include "StubLayout.h"
+
+#include <llvm/Support/Format.h>
+#include <llvm/Support/raw_ostream.h>
+
+#include "utils/raw_ostream.h"
+
+#include <string.h>
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+ELFSectionProgBits<Bitwidth> *
+ELFSectionProgBits<Bitwidth>::read(Archiver &AR,
+                                   ELFObjectTy *owner,
+                                   ELFSectionHeaderTy const *sh) {
+  int machine = owner->getHeader()->getMachine();
+  ELFSectionProgBits *secp = new ELFSectionProgBits(machine);
+  llvm::OwningPtr<ELFSectionProgBits> result(secp);
+  size_t max_num_stubs = 0;
+  // Align section boundary to 4 bytes.
+  size_t section_size = (sh->getSize() + 3) / 4 * 4;
+  size_t alloc_size = section_size;
+  StubLayout *stubs = result->getStubLayout();
+  if (stubs) {
+    // Compute the maximal possible numbers of stubs
+    std::string reltab_name(".rel" + std::string(sh->getName()));
+
+    ELFSectionRelTableTy const *reltab =
+      static_cast<ELFSectionRelTableTy *>(
+        owner->getSectionByName(reltab_name.c_str()));
+
+    if (reltab) {
+      // If we have relocation table, then get the approximation of
+      // maximum numbers of stubs.
+      max_num_stubs = reltab->getMaxNumStubs(owner);
+    }
+
+    // Compute the stub table size
+    size_t stub_table_size = stubs->calcStubTableSize(max_num_stubs);
+
+    // Allocate PROGBITS section with stubs table
+    alloc_size += stub_table_size;
+  }
+
+  // Allocate text section
+  if (!result->chunk.allocate(alloc_size)) {
+    return NULL;
+  }
+
+  if (stubs) {
+    stubs->initStubTable(result->chunk.getBuffer() + section_size,
+                         max_num_stubs);
+  }
+
+  result->sh = sh;
+
+  if (!result->serialize(AR)) {
+    // Unable to read the progbits section.
+    return NULL;
+  }
+
+  return result.take();
+}
+
+#endif // ELF_SECTION_PROGBITS_HXX
diff --git a/driver/linkloader/include/impl/ELFSectionRelTable.hxx b/driver/linkloader/include/impl/ELFSectionRelTable.hxx
new file mode 100644
index 0000000..c6c4dde
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSectionRelTable.hxx
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_REL_TABLE_HXX
+#define ELF_SECTION_REL_TABLE_HXX
+
+#include "ELF.h"
+#include "ELFHeader.h"
+#include "ELFObject.h"
+#include "ELFReloc.h"
+#include "ELFTypes.h"
+
+#include <set>
+
+template <unsigned Bitwidth>
+ELFSectionRelTable<Bitwidth>::~ELFSectionRelTable() {
+  using namespace std;
+  for (size_t i = 0; i < table.size(); ++i) {
+    delete table[i];
+  }
+}
+
+template <unsigned Bitwidth>
+void ELFSectionRelTable<Bitwidth>::print() const {
+  using namespace llvm;
+
+  out() << '\n' << fillformat('=', 79) << '\n';
+  out().changeColor(raw_ostream::WHITE, true);
+  out() << "Relocation Table" << '\n';
+  out().resetColor();
+
+  for (size_t i = 0; i < this->size(); ++i) {
+    (*this)[i]->print();
+  }
+
+  out() << fillformat('=', 79) << '\n';
+}
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+ELFSectionRelTable<Bitwidth> *
+ELFSectionRelTable<Bitwidth>::read(Archiver &AR,
+                                   ELFSectionHeaderTy const *sh) {
+
+  rsl_assert(sh->getType() == SHT_REL || sh->getType() == SHT_RELA);
+
+  llvm::OwningPtr<ELFSectionRelTable> rt(new ELFSectionRelTable());
+
+  // Seek to the start of the table
+  AR.seek(sh->getOffset(), true);
+
+  // Count the relocation entries
+  size_t size = sh->getSize() / sh->getEntrySize();
+
+  // Read every relocation entries
+  if (sh->getType() == SHT_REL) {
+    rsl_assert(sh->getEntrySize() == TypeTraits<ELFRelocRelTy>::size);
+    for (size_t i = 0; i < size; ++i) {
+      rt->table.push_back(ELFRelocTy::readRel(AR, i));
+    }
+
+  } else {
+    rsl_assert(sh->getEntrySize() == TypeTraits<ELFRelocRelaTy>::size);
+    for (size_t i = 0; i < size; ++i) {
+      rt->table.push_back(ELFRelocTy::readRela(AR, i));
+    }
+  }
+
+  if (!AR) {
+    // Unable to read the table.
+    return 0;
+  }
+
+  return rt.take();
+}
+
+template <unsigned Bitwidth>
+size_t ELFSectionRelTable<Bitwidth>::
+getMaxNumStubs(ELFObjectTy const *obj) const {
+  switch (obj->getHeader()->getMachine()) {
+  case EM_ARM:
+    {
+      std::set<uint32_t> sym_index_set;
+
+      for (size_t i = 0; i < size(); ++i) {
+        ELFRelocTy *rel = table[i];
+
+        switch (rel->getType()) {
+        case R_ARM_CALL:
+        case R_ARM_THM_CALL:
+        case R_ARM_JUMP24:
+        case R_ARM_THM_JUMP24:
+          sym_index_set.insert(rel->getSymTabIndex());
+          break;
+        }
+      }
+
+      return sym_index_set.size();
+    }
+
+  case EM_MIPS:
+    {
+      std::set<uint32_t> sym_index_set;
+
+      for (size_t i = 0; i < size(); ++i) {
+        ELFRelocTy *rel = table[i];
+
+        if (rel->getType() == R_MIPS_26) {
+          sym_index_set.insert(rel->getSymTabIndex());
+        }
+      }
+
+      return sym_index_set.size();
+    }
+
+  case EM_386:
+  case EM_X86_64:
+    return 0;
+
+  default:
+    rsl_assert(0 && "Only support ARM, MIPS, X86, and X86_64 relocation.");
+    return 0;
+  }
+}
+
+#endif // ELF_SECTION_REL_TABLE_HXX
diff --git a/driver/linkloader/include/impl/ELFSectionStrTab.hxx b/driver/linkloader/include/impl/ELFSectionStrTab.hxx
new file mode 100644
index 0000000..4e9eb4e
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSectionStrTab.hxx
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_STR_TAB_HXX
+#define ELF_SECTION_STR_TAB_HXX
+
+#include "utils/helper.h"
+#include "utils/raw_ostream.h"
+
+#include <llvm/ADT/OwningPtr.h>
+#include <llvm/Support/Format.h>
+#include <llvm/Support/raw_ostream.h>
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+ELFSectionStrTab<Bitwidth> *
+ELFSectionStrTab<Bitwidth>::read(Archiver &AR,
+                                 ELFSectionHeaderTy const *sh) {
+
+  llvm::OwningPtr<ELFSectionStrTab> st(new ELFSectionStrTab());
+  st->buf.resize(sh->getSize());
+
+  // Save section_header
+  st->section_header = sh;
+
+  AR.seek(sh->getOffset(), true);
+  AR.prologue(sh->getSize());
+  AR.readBytes(&*st->buf.begin(), sh->getSize());
+  AR.epilogue(sh->getSize());
+
+  if (!AR) {
+    // Unable to read the string table.
+    return 0;
+  }
+
+  return st.take();
+}
+
+template <unsigned Bitwidth>
+void ELFSectionStrTab<Bitwidth>::print() const {
+  using namespace llvm;
+
+  out() << '\n' << fillformat('=', 79) << '\n';
+  out().changeColor(raw_ostream::WHITE, true);
+  out() << "ELF String Table: " << this->section_header->getName() << '\n';
+  out().resetColor();
+  out() << fillformat('-', 79) << '\n';
+
+  dump_hex((unsigned char const *)&*buf.begin(), buf.size(), 0, buf.size());
+
+  out() << fillformat('=', 79) << '\n';
+}
+
+#endif // ELF_SECTION_STR_TAB_HXX
diff --git a/driver/linkloader/include/impl/ELFSectionSymTab.hxx b/driver/linkloader/include/impl/ELFSectionSymTab.hxx
new file mode 100644
index 0000000..b179383
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSectionSymTab.hxx
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SECTION_SYM_TAB_HXX
+#define ELF_SECTION_SYM_TAB_HXX
+
+#include "ELFSectionHeader.h"
+#include "ELFSymbol.h"
+#include "utils/rsl_assert.h"
+
+template <unsigned Bitwidth>
+ELFSectionSymTab<Bitwidth>::~ELFSectionSymTab() {
+  for (size_t i = 0; i < table.size(); ++i) {
+    delete table[i];
+  }
+}
+
+template <unsigned Bitwidth>
+size_t ELFSectionSymTab<Bitwidth>::getFuncCount() const {
+  size_t result = 0;
+  for (size_t i = 0; i < table.size(); ++i) {
+    if (table[i] && table[i]->isConcreteFunc()) {
+      result++;
+    }
+  }
+  return result;
+}
+
+template <unsigned Bitwidth>
+inline size_t ELFSectionSymTab<Bitwidth>::getExternFuncCount() const {
+  size_t result = 0;
+  for (size_t i = 0; i < table.size(); ++i) {
+    if (table[i] && table[i]->isExternFunc()) {
+      result++;
+    }
+  }
+  return result;
+}
+
+template <unsigned Bitwidth>
+inline void ELFSectionSymTab<Bitwidth>::buildNameMap() {
+  for (size_t i = 0; i < table.size(); ++i) {
+    ELFSymbolTy *symbol = table[i];
+    if ( symbol ) {
+      name_map[symbol->getName()] = symbol;
+    }
+  }
+}
+
+template <unsigned Bitwidth>
+inline ELFSymbol<Bitwidth> const *
+ELFSectionSymTab<Bitwidth>::getByName(std::string const &name) const {
+  typename llvm::StringMap<ELFSymbolTy *>::const_iterator symbol =
+    name_map.find(name);
+  if (symbol == name_map.end()) {
+    return NULL;
+  }
+  return symbol->getValue();
+}
+
+template <unsigned Bitwidth>
+inline void
+ELFSectionSymTab<Bitwidth>::getFuncNameList(size_t size,
+                                            char const **list) const {
+  for (size_t i = 0, j = 0; i < table.size() && j < size; ++i) {
+    if (table[i] && table[i]->isConcreteFunc()) {
+      list[j++] = table[i]->getName();
+    }
+  }
+}
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+ELFSectionSymTab<Bitwidth> *
+ELFSectionSymTab<Bitwidth>::read(Archiver &AR,
+                                 ELFObjectTy *owner,
+                                 ELFSectionHeaderTy const *sh) {
+
+  llvm::OwningPtr<ELFSectionSymTabTy> st(new ELFSectionSymTabTy());
+
+  // Assert that entry size will be the same as standard.
+  rsl_assert(sh->getEntrySize() == TypeTraits<ELFSymbolTy>::size);
+
+  // Seek to the start of symbol table
+  AR.seek(sh->getOffset(), true);
+
+  // Read all symbol table entry
+  size_t size = sh->getSize() / sh->getEntrySize();
+  for (size_t i = 0; i < size; ++i) {
+    st->table.push_back(ELFSymbolTy::read(AR, owner, i));
+  }
+
+  if (!AR) {
+    // Unable to read the table.
+    return 0;
+  }
+
+  return st.take();
+}
+
+template <unsigned Bitwidth>
+void ELFSectionSymTab<Bitwidth>::print() const {
+  using namespace llvm;
+
+  out() << '\n' << fillformat('=', 79) << '\n';
+  out().changeColor(raw_ostream::WHITE, true);
+  out() << "Symbol Table" << '\n';
+  out().resetColor();
+
+  for (size_t i = 0; i < table.size(); ++i) {
+    table[i]->print();
+  }
+
+  out() << fillformat('=', 79) << '\n';
+}
+
+#endif // ELF_SECTION_SYM_TAB_HXX
diff --git a/driver/linkloader/include/impl/ELFSymbol.hxx b/driver/linkloader/include/impl/ELFSymbol.hxx
new file mode 100644
index 0000000..b3c6087
--- /dev/null
+++ b/driver/linkloader/include/impl/ELFSymbol.hxx
@@ -0,0 +1,316 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ELF_SYMBOL_HXX
+#define ELF_SYMBOL_HXX
+
+#include "ELFSectionHeaderTable.h"
+#include "ELFSection.h"
+#include "ELFSectionStrTab.h"
+
+#include "ELFObject.h"
+#include "ELFSectionHeaderTable.h"
+#include "ELFSectionProgBits.h"
+#include "ELFSectionNoBits.h"
+
+#include "utils/rsl_assert.h"
+#include "ELF.h"
+
+template <unsigned Bitwidth>
+inline char const *ELFSymbol_CRTP<Bitwidth>::getName() const {
+  ELFSectionHeaderTableTy const &shtab = *owner->getSectionHeaderTable();
+  size_t const index = shtab.getByName(std::string(".strtab"))->getIndex();
+  ELFSectionTy const *section = owner->getSectionByIndex(index);
+  ELFSectionStrTabTy const &strtab =
+    *static_cast<ELFSectionStrTabTy const *>(section);
+  return strtab[getNameIndex()];
+}
+
+template <unsigned Bitwidth>
+template <typename Archiver>
+inline ELFSymbol<Bitwidth> *
+ELFSymbol_CRTP<Bitwidth>::read(Archiver &AR,
+                               ELFObjectTy const *owner,
+                               size_t index) {
+  if (!AR) {
+    // Archiver is in bad state before calling read function.
+    // Return NULL and do nothing.
+    return 0;
+  }
+
+  llvm::OwningPtr<ELFSymbolTy> sh(new ELFSymbolTy());
+
+  if (!sh->serialize(AR)) {
+    // Unable to read the structure.  Return NULL.
+    return 0;
+  }
+
+  if (!sh->isValid()) {
+    // SymTabEntry read from archiver is not valid.  Return NULL.
+    return 0;
+  }
+
+  // Set the section header index
+  sh->index = index;
+
+  // Set the owner elf object
+  sh->owner = owner;
+
+  return sh.take();
+}
+
+template <unsigned Bitwidth>
+inline void ELFSymbol_CRTP<Bitwidth>::print(bool shouldPrintHeader) const {
+  using namespace llvm;
+
+  if (shouldPrintHeader) {
+    out() << '\n' << fillformat('=', 79) << '\n';
+    out().changeColor(raw_ostream::WHITE, true);
+    out() << "ELF Symbol Table Entry "
+          << this->getIndex() << '\n';
+    out().resetColor();
+    out() << fillformat('-', 79) << '\n';
+  } else {
+    out() << fillformat('-', 79) << '\n';
+    out().changeColor(raw_ostream::YELLOW, true);
+    out() << "ELF Symbol Table Entry "
+          << this->getIndex() << " : " << '\n';
+    out().resetColor();
+  }
+
+#define PRINT_LINT(title, value) \
+  out() << format("  %-11s : ", (char const *)(title)) << (value) << '\n'
+  PRINT_LINT("Name",        getName()                                    );
+  PRINT_LINT("Type",        getTypeStr(getType())                        );
+  PRINT_LINT("Bind",        getBindingAttributeStr(getBindingAttribute()));
+  PRINT_LINT("Visibility",  getVisibilityStr(getVisibility())            );
+  PRINT_LINT("Shtab Index", getSectionIndex()                            );
+  PRINT_LINT("Value",       getValue()                                   );
+  PRINT_LINT("Size",        getSize()                                    );
+#undef PRINT_LINT
+
+// TODO: Horizontal type or vertical type can use option to decide.
+#if 0
+  using namespace term::color;
+  using namespace std;
+
+  cout << setw(20) << getName() <<
+          setw(10) << getTypeStr(getType()) <<
+          setw(10) << getBindingAttributeStr(getBindingAttribute()) <<
+          setw(15) << getVisibilityStr(getVisibility()) <<
+          setw(10) << getSectionIndex() <<
+          setw(7) << getValue() <<
+          setw(7) << getSize() <<
+          endl;
+#endif
+}
+
+template <unsigned Bitwidth>
+void *ELFSymbol_CRTP<Bitwidth>::getAddress(int machine, bool autoAlloc) const {
+  if (my_addr != 0) {
+    return my_addr;
+  }
+  size_t idx = (size_t)getSectionIndex();
+  switch (getType()) {
+    default:
+      break;
+
+    case STT_OBJECT:
+      switch (idx) {
+        default:
+          {
+            ELFSectionHeaderTableTy const *header =
+              owner->getSectionHeaderTable();
+
+            unsigned section_type = (*header)[idx]->getType();
+
+            rsl_assert((section_type == SHT_PROGBITS ||
+                        section_type == SHT_NOBITS) &&
+                       "STT_OBJECT with not BITS section.");
+
+            if (section_type == SHT_NOBITS) {
+              // FIXME(logan): This is a workaround for .lcomm directives
+              // bug of LLVM ARM MC code generator.  Remove this when the
+              // LLVM bug is fixed.
+
+              size_t align = 16;
+
+              my_addr = const_cast<ELFObjectTy *>(owner)->
+                allocateSHNCommonData((size_t)getSize(), align);
+
+              if (!my_addr) {
+                rsl_assert(0 && "Unable to allocate memory for SHN_COMMON.");
+                abort();
+              }
+            } else {
+              ELFSectionTy const *sec = owner->getSectionByIndex(idx);
+              rsl_assert(sec != 0 && "STT_OBJECT with null section.");
+
+              ELFSectionBitsTy const &st =
+                static_cast<ELFSectionBitsTy const &>(*sec);
+              my_addr =const_cast<unsigned char *>(&st[0] + (off_t)getValue());
+            }
+          }
+          break;
+
+        case SHN_COMMON:
+          {
+            if (!autoAlloc) {
+              return NULL;
+            }
+#if 0
+#if _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
+            if (posix_memalign(&my_addr,
+                               std::max((size_t)getValue(), sizeof(void*)),
+                               (size_t)getSize()) != 0) {
+              rsl_assert(0 && "posix_memalign failed.");
+            }
+#else
+            my_addr = memalign(std::max((size_t)getValue(), sizeof(void *)),
+                               (size_t)getSize());
+
+            rsl_assert(my_addr != NULL && "memalign failed.");
+#endif
+            if (my_addr) {
+              memset(my_addr, '\0', getSize());
+            }
+#else
+            size_t align = (size_t)getValue();
+            my_addr = const_cast<ELFObjectTy *>(owner)->
+                          allocateSHNCommonData((size_t)getSize(), align);
+            if (!my_addr) {
+              rsl_assert(0 && "Unable to allocate memory for SHN_COMMON.");
+              abort();
+            }
+#endif
+          }
+          break;
+
+        case SHN_UNDEF:
+          if (machine == EM_MIPS && strcmp(getName(), "_gp_disp") == 0) // OK for MIPS
+            break;
+
+        case SHN_ABS:
+        case SHN_XINDEX:
+          rsl_assert(0 && "STT_OBJECT with special st_shndx.");
+          break;
+      }
+      break;
+
+
+    case STT_FUNC:
+      switch (idx) {
+        default:
+          {
+#ifndef NDEBUG
+            ELFSectionHeaderTableTy const *header =
+              owner->getSectionHeaderTable();
+            rsl_assert((*header)[idx]->getType() == SHT_PROGBITS &&
+                   "STT_FUNC with not PROGBITS section.");
+#endif
+            ELFSectionTy const *sec = owner->getSectionByIndex(idx);
+            rsl_assert(sec != 0 && "STT_FUNC with null section.");
+
+            ELFSectionProgBitsTy const &st =
+              static_cast<ELFSectionProgBitsTy const &>(*sec);
+            my_addr = const_cast<unsigned char *>(&st[0] + (off_t)getValue());
+          }
+          break;
+
+        case SHN_ABS:
+        case SHN_COMMON:
+        case SHN_UNDEF:
+        case SHN_XINDEX:
+          rsl_assert(0 && "STT_FUNC with special st_shndx.");
+          break;
+      }
+      break;
+
+
+    case STT_SECTION:
+      switch (idx) {
+        default:
+          {
+#ifndef NDEBUG
+            ELFSectionHeaderTableTy const *header =
+              owner->getSectionHeaderTable();
+            rsl_assert(((*header)[idx]->getType() == SHT_PROGBITS ||
+                    (*header)[idx]->getType() == SHT_NOBITS) &&
+                   "STT_SECTION with not BITS section.");
+#endif
+            ELFSectionTy const *sec = owner->getSectionByIndex(idx);
+            rsl_assert(sec != 0 && "STT_SECTION with null section.");
+
+            ELFSectionBitsTy const &st =
+              static_cast<ELFSectionBitsTy const &>(*sec);
+            my_addr = const_cast<unsigned char *>(&st[0] + (off_t)getValue());
+          }
+          break;
+
+        case SHN_ABS:
+        case SHN_COMMON:
+        case SHN_UNDEF:
+        case SHN_XINDEX:
+          rsl_assert(0 && "STT_SECTION with special st_shndx.");
+          break;
+      }
+      break;
+
+    case STT_NOTYPE:
+      switch (idx) {
+        default:
+          {
+#ifndef NDEBUG
+            ELFSectionHeaderTableTy const *header =
+              owner->getSectionHeaderTable();
+            rsl_assert(((*header)[idx]->getType() == SHT_PROGBITS ||
+                    (*header)[idx]->getType() == SHT_NOBITS) &&
+                   "STT_SECTION with not BITS section.");
+#endif
+            ELFSectionTy const *sec = owner->getSectionByIndex(idx);
+            rsl_assert(sec != 0 && "STT_SECTION with null section.");
+
+            ELFSectionBitsTy const &st =
+              static_cast<ELFSectionBitsTy const &>(*sec);
+            my_addr = const_cast<unsigned char *>(&st[0] + (off_t)getValue());
+          }
+          break;
+
+        case SHN_ABS:
+        case SHN_COMMON:
+        case SHN_XINDEX:
+          rsl_assert(0 && "STT_SECTION with special st_shndx.");
+          break;
+        case SHN_UNDEF:
+          return 0;
+      }
+      break;
+      return 0;
+
+    case STT_COMMON:
+    case STT_FILE:
+    case STT_TLS:
+    case STT_LOOS:
+    case STT_HIOS:
+    case STT_LOPROC:
+    case STT_HIPROC:
+      rsl_assert(0 && "Not implement.");
+      return 0;
+  }
+  return my_addr;
+}
+
+#endif // ELF_SYMBOL_HXX
diff --git a/driver/linkloader/lib/ELFHeader.cpp b/driver/linkloader/lib/ELFHeader.cpp
new file mode 100644
index 0000000..5e21d3e
--- /dev/null
+++ b/driver/linkloader/lib/ELFHeader.cpp
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ELFHeader.h"
+#include "ELF.h"
+
+char const *ELFHeaderHelperMixin::getClassStr(int clazz) {
+  switch (clazz) {
+  default:
+#define CASE_PAIR(A, B) case A: return B;
+  CASE_PAIR(ELFCLASSNONE, "Invalid class")
+  CASE_PAIR(ELFCLASS32, "32bit")
+  CASE_PAIR(ELFCLASS64, "64bit")
+#undef CASE_PAIR
+  }
+}
+
+char const *ELFHeaderHelperMixin::getEndiannessStr(int endianness) {
+  switch (endianness) {
+  default:
+#define CASE_PAIR(A, B) case A: return B;
+  CASE_PAIR(ELFDATANONE, "Invalid endianness")
+  CASE_PAIR(ELFDATA2LSB, "Little endian")
+  CASE_PAIR(ELFDATA2MSB, "Big endian")
+#undef CASE_PAIR
+  }
+}
+
+char const *ELFHeaderHelperMixin::getOSABIStr(int abi) {
+  if (abi >= 64 && abi <= 255) {
+    return "Architecture specific";
+  }
+
+  switch (abi) {
+  default: return "Unknown OS ABI";
+#define CASE_PAIR(A, B) case A: return B;
+  CASE_PAIR(ELFOSABI_NONE, "No extensions or not specified")
+  CASE_PAIR(ELFOSABI_HPUX, "HP-UX")
+  CASE_PAIR(ELFOSABI_NETBSD, "NetBSD")
+  CASE_PAIR(ELFOSABI_LINUX, "Linux")
+  CASE_PAIR(ELFOSABI_SOLARIS, "Solaris")
+  CASE_PAIR(ELFOSABI_AIX, "AIX")
+  CASE_PAIR(ELFOSABI_FREEBSD, "FreeBSD")
+  CASE_PAIR(ELFOSABI_TRU64, "Tru64")
+  CASE_PAIR(ELFOSABI_MODESTO, "Modesto")
+  CASE_PAIR(ELFOSABI_OPENBSD, "OpenBSD")
+#undef CASE_PAIR
+  }
+}
+
+char const *ELFHeaderHelperMixin::getObjectTypeStr(uint16_t type) {
+  switch (type) {
+  default: return "No file type";
+
+  case ET_REL:  return "Relocatable file";
+  case ET_EXEC: return "Executable file";
+  case ET_DYN:  return "Shared object file";
+  case ET_CORE: return "Core file";
+
+  case ET_LOOS: case ET_HIOS:
+    return "Operating system-specific";
+
+  case ET_LOPROC: case ET_HIPROC:
+    return "Processor-specific";
+  }
+}
+
+char const *ELFHeaderHelperMixin::getMachineStr(uint16_t machine) {
+  switch (machine) {
+    default: return "No machine or unknown";
+    case EM_386: return "Intel 80386 (X86)";
+    case EM_X86_64: return "AMD x86-64 architecture";
+    case EM_ARM: return "Advanced RISC Machine (ARM)";
+    case EM_MIPS: return "MIPS";
+  }
+}
+
+char const *ELFHeaderHelperMixin::getVersionStr(uint32_t version) {
+  switch (version) {
+    default: return "Invalid version";
+    case EV_CURRENT: return "Current version";
+  }
+}
diff --git a/driver/linkloader/lib/ELFSectionHeader.cpp b/driver/linkloader/lib/ELFSectionHeader.cpp
new file mode 100644
index 0000000..03930d6
--- /dev/null
+++ b/driver/linkloader/lib/ELFSectionHeader.cpp
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ELFSectionHeader.h"
+#include "ELF.h"
+
+// ARM Section Header Type Definitions
+
+// TODO: These definitions are not defined in external/elfutils/libelf/
+// elf.h.  So we to this by ourself.  Maybe we should update elf.h
+// instead.
+
+#ifndef SHT_ARM_EXIDX
+#define SHT_ARM_EXIDX (SHT_LOPROC + 1)
+#endif
+
+#ifndef SHT_ARM_PREEMPTMAP
+#define SHT_ARM_PREEMPTMAP (SHT_LOPROC + 2)
+#endif
+
+#ifndef SHT_ARM_ATTRIBUTES
+#define SHT_ARM_ATTRIBUTES (SHT_LOPROC + 3)
+#endif
+
+char const *ELFSectionHeaderHelperMixin::getSectionTypeStr(uint32_t type) {
+  switch (type) {
+    default: return "(UNKNOWN)";
+
+#define CASE(TYPE) \
+    case SHT_##TYPE: return #TYPE;
+
+    // General section header type
+    CASE(NULL) CASE(PROGBITS) CASE(SYMTAB) CASE(STRTAB) CASE(RELA) CASE(HASH)
+    CASE(DYNAMIC) CASE(NOTE) CASE(NOBITS) CASE(REL) CASE(SHLIB)
+    CASE(DYNSYM) CASE(INIT_ARRAY) CASE(FINI_ARRAY) CASE(PREINIT_ARRAY)
+    CASE(GROUP) CASE(SYMTAB_SHNDX) CASE(LOOS) CASE(HIOS) CASE(LOPROC)
+    CASE(HIPROC) CASE(LOUSER) CASE(HIUSER)
+
+    // ARM-specific section header type
+    CASE(ARM_EXIDX) CASE(ARM_PREEMPTMAP) CASE(ARM_ATTRIBUTES)
+
+#undef CASE
+  }
+}
diff --git a/driver/linkloader/lib/ELFSymbol.cpp b/driver/linkloader/lib/ELFSymbol.cpp
new file mode 100644
index 0000000..cfdab1c
--- /dev/null
+++ b/driver/linkloader/lib/ELFSymbol.cpp
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ELFSymbol.h"
+#include "ELF.h"
+
+char const *
+ELFSymbolHelperMixin::getTypeStr(uint8_t type) {
+  switch (type) {
+    default: return "(UNKNOWN)";
+
+#define CASE(TYPE) \
+    case STT_##TYPE: return #TYPE;
+
+    CASE(NOTYPE)
+    CASE(OBJECT)
+    CASE(FUNC)
+    CASE(SECTION)
+    CASE(FILE)
+    CASE(COMMON)
+    CASE(TLS)
+    CASE(LOOS)
+    CASE(HIOS)
+    CASE(LOPROC)
+    CASE(HIPROC)
+
+#undef CASE
+  }
+}
+
+char const *
+ELFSymbolHelperMixin::getBindingAttributeStr(uint8_t type) {
+  switch (type) {
+    default: return "(UNKNOWN)";
+
+#define CASE(TYPE) \
+    case STB_##TYPE: return #TYPE;
+
+    CASE(LOCAL)
+    CASE(GLOBAL)
+    CASE(WEAK)
+    CASE(LOOS)
+    CASE(HIOS)
+    CASE(LOPROC)
+    CASE(HIPROC)
+
+#undef CASE
+  }
+}
+char const *
+ELFSymbolHelperMixin::getVisibilityStr(uint8_t type) {
+  switch (type) {
+    default: return "(UNKNOWN)";
+
+#define CASE(TYPE) \
+    case STV_##TYPE: return #TYPE;
+
+    CASE(DEFAULT)
+    CASE(INTERNAL)
+    CASE(HIDDEN)
+    CASE(PROTECTED)
+
+#undef CASE
+  }
+}
diff --git a/driver/linkloader/lib/ELFTypes.cpp b/driver/linkloader/lib/ELFTypes.cpp
new file mode 100644
index 0000000..7c82eab
--- /dev/null
+++ b/driver/linkloader/lib/ELFTypes.cpp
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ELFTypes.h"
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/Format.h>
+
+namespace detail {
+
+#define ELF_TYPE_PRINT_OPERATOR(TYPE, FORMAT_WIDTH)                         \
+  llvm::raw_ostream &operator<<(llvm::raw_ostream &os, TYPE const &val) {   \
+    os << llvm::format("%0*x", FORMAT_WIDTH, val.value);                    \
+    return os;                                                              \
+  }
+
+  ELF_TYPE_PRINT_OPERATOR(ELF32Address, 8)
+  ELF_TYPE_PRINT_OPERATOR(ELF32Offset,  8)
+  ELF_TYPE_PRINT_OPERATOR(ELF64Address, 16)
+  ELF_TYPE_PRINT_OPERATOR(ELF64Offset,  16)
+
+#undef ELF_TYPE_PRINT_OPERATOR
+
+} // end namespace detail
diff --git a/driver/linkloader/lib/GOT.cpp b/driver/linkloader/lib/GOT.cpp
new file mode 100644
index 0000000..3f523c5
--- /dev/null
+++ b/driver/linkloader/lib/GOT.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include "GOT.h"
+
+void *got_symbol_addresses[NUM_OF_GOT_ENTRY];
+int got_symbol_indexes[NUM_OF_GOT_ENTRY];
+size_t got_symbol_count = 0;
+
+void *got_address()
+{
+  return &got_symbol_addresses[0];
+}
+
+int search_got(int symbol_index, void *addr, uint8_t bind_type)
+{
+  size_t i;
+
+  // For local symbols (R_MIPS_GOT16), we only store the high 16-bit value
+  // after adding 0x8000.
+  if (bind_type == STB_LOCAL)
+    addr = (void *)(((intptr_t)addr + 0x8000) & 0xFFFF0000);
+
+  for (i = 0; i < got_symbol_count; i++) {
+    if (got_symbol_indexes[i] == symbol_index) {
+      if (bind_type == STB_LOCAL) {
+        // Check if the value is the same for local symbols.
+        // If yes, we can reuse this entry.
+        // If not, we continue searching.
+        if (got_symbol_addresses[i] == addr) {
+          return i;
+        }
+      }
+      else {
+        // The value must be the same for global symbols .
+        rsl_assert (got_symbol_addresses[i] == addr
+                    && "MIPS GOT address error.");
+        return i;
+      }
+    }
+  }
+
+  // Cannot find this symbol with correct value, so we need to create one
+  rsl_assert (got_symbol_count < NUM_OF_GOT_ENTRY && "MIPS GOT is full.");
+  got_symbol_indexes[got_symbol_count] = symbol_index;
+  got_symbol_addresses[got_symbol_count] = addr;
+  got_symbol_count++;
+  return (got_symbol_count - 1);
+}
diff --git a/driver/linkloader/lib/MemChunk.cpp b/driver/linkloader/lib/MemChunk.cpp
new file mode 100644
index 0000000..24dcf8e
--- /dev/null
+++ b/driver/linkloader/lib/MemChunk.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MemChunk.h"
+
+#include "utils/flush_cpu_cache.h"
+#include "utils/helper.h"
+
+#include <llvm/Support/raw_ostream.h>
+
+#include <sys/mman.h>
+
+#include <stdlib.h>
+
+#ifndef MAP_32BIT
+#define MAP_32BIT 0
+// Note: If the <sys/mman.h> does not come with MAP_32BIT, then we
+// define it as zero, so that it won't manipulate the flags.
+#endif
+
+//#define USE_FIXED_ADDR_MEM_CHUNK 1
+
+#if USE_FIXED_ADDR_MEM_CHUNK
+static uintptr_t StartAddr = 0x7e000000UL;
+#endif
+
+MemChunk::MemChunk() : buf((unsigned char *)MAP_FAILED), buf_size(0) {
+}
+
+MemChunk::~MemChunk() {
+  if (buf != MAP_FAILED) {
+    munmap(buf, buf_size);
+  }
+}
+
+bool MemChunk::allocate(size_t size) {
+  if (size == 0) {
+    return true;
+  }
+#if USE_FIXED_ADDR_MEM_CHUNK
+  buf = (unsigned char *)mmap((void *)StartAddr, size,
+                              PROT_READ | PROT_WRITE,
+                              MAP_PRIVATE | MAP_ANON | MAP_32BIT,
+                              -1, 0);
+#else
+  buf = (unsigned char *)mmap(0, size,
+                              PROT_READ | PROT_WRITE,
+                              MAP_PRIVATE | MAP_ANON | MAP_32BIT,
+                              -1, 0);
+#endif
+
+  if (buf == MAP_FAILED) {
+    return false;
+  }
+
+#if USE_FIXED_ADDR_MEM_CHUNK
+  StartAddr += (size + 4095) / 4096 * 4096;
+#endif
+
+  buf_size = size;
+  return true;
+}
+
+void MemChunk::print() const {
+  if (buf != MAP_FAILED) {
+    dump_hex(buf, buf_size, 0, buf_size);
+  }
+}
+
+bool MemChunk::protect(int prot) {
+  if (buf_size > 0) {
+    int ret = mprotect((void *)buf, buf_size, prot);
+    if (ret == -1) {
+      llvm::errs() << "Error: Can't mprotect.\n";
+      return false;
+    }
+
+    if (prot & PROT_EXEC) {
+      FLUSH_CPU_CACHE(buf, buf + buf_size);
+    }
+  }
+
+  return true;
+}
diff --git a/driver/linkloader/lib/StubLayout.cpp b/driver/linkloader/lib/StubLayout.cpp
new file mode 100644
index 0000000..00555ad
--- /dev/null
+++ b/driver/linkloader/lib/StubLayout.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "StubLayout.h"
+
+#include "utils/flush_cpu_cache.h"
+#include "utils/raw_ostream.h"
+#include "utils/rsl_assert.h"
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+
+StubLayout::StubLayout() : table(NULL), count(0) {
+}
+
+void StubLayout::initStubTable(unsigned char *table_, size_t count_) {
+  table = table_;
+  count = count_;
+}
+
+void *StubLayout::allocateStub(void *addr) {
+  // Check if we have created this stub or not.
+  std::map<void *, void *>::iterator index_iter = stub_index.find(addr);
+
+  if (index_iter != stub_index.end()) {
+    return index_iter->second;
+  }
+
+  // We have to create a new stub
+  if (count == 0) {
+    // No free stub slot is available
+    return NULL;
+  }
+
+  // Initialize the stub
+  unsigned char *stub = table;
+  setStubAddress(stub, addr);
+  stub_index.insert(std::make_pair(addr, stub));
+
+  // Increase the free stub slot pointer
+  table += getUnitStubSize();
+  count--;
+
+  return stub;
+}
+
+size_t StubLayout::calcStubTableSize(size_t count) const {
+  return count * getUnitStubSize();
+}
+
+size_t StubLayoutARM::getUnitStubSize() const {
+  return 8;
+}
+
+void StubLayoutARM::setStubAddress(void *stub_, void *addr) {
+  uint8_t *stub = (uint8_t *)stub_;
+  stub[0] = 0x04; // ldr pc, [pc, #-4]
+  stub[1] = 0xf0; // ldr pc, [pc, #-4]
+  stub[2] = 0x1f; // ldr pc, [pc, #-4]
+  stub[3] = 0xe5; // ldr pc, [pc, #-4]
+
+  void **target = (void **)(stub + 4);
+  *target = addr;
+}
+
+size_t StubLayoutMIPS::getUnitStubSize() const {
+  return 16;
+}
+
+void StubLayoutMIPS::setStubAddress(void *stub_, void *addr) {
+  uint32_t addr32 = (uint32_t)(uintptr_t)addr;
+  uint16_t addr_hi16 = (addr32 >> 16) &  0xffff;
+  uint16_t addr_lo16 = addr32 & 0xffff;
+
+  uint32_t *stub = (uint32_t *)stub_;
+  stub[0] = 0x3c190000ul | addr_hi16; // lui
+  stub[1] = 0x37390000ul | addr_lo16; // ori
+  stub[2] = 0x03200008ul; // jr (jump register)
+  stub[3] = 0x00000000ul; // nop
+}
diff --git a/driver/linkloader/main.cpp b/driver/linkloader/main.cpp
new file mode 100644
index 0000000..2ead7ec
--- /dev/null
+++ b/driver/linkloader/main.cpp
@@ -0,0 +1,259 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ELFObject.h"
+
+#include "utils/serialize.h"
+#include "ELF.h"
+
+#include <llvm/ADT/OwningPtr.h>
+
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <map>
+#include <stdio.h>
+#include <stdarg.h>
+
+using namespace std;
+
+bool open_mmap_file(char const *filename,
+                    int &fd,
+                    unsigned char const *&image,
+                    size_t &size);
+
+void close_mmap_file(int fd,
+                     unsigned char const *image,
+                     size_t size);
+
+void dump_and_run_file(unsigned char const *image, size_t size,
+                       int argc, char **argv);
+
+int main(int argc, char **argv) {
+  // Check arguments
+  if (argc < 2) {
+    llvm::errs() << "USAGE: " << argv[0] << " [ELFObjectFile] [ARGS]\n";
+    exit(EXIT_FAILURE);
+  }
+
+  // Filename from argument
+  char const *filename = argv[1];
+
+  // Open the file
+  int fd = -1;
+  unsigned char const *image = NULL;
+  size_t image_size = 0;
+
+  if (!open_mmap_file(filename, fd, image, image_size)) {
+    exit(EXIT_FAILURE);
+  }
+
+  // Dump and run the file
+  dump_and_run_file(image, image_size, argc - 1, argv + 1);
+
+  // Close the file
+  close_mmap_file(fd, image, image_size);
+
+  return EXIT_SUCCESS;
+}
+
+// FIXME: I don't like these stub as well.  However, before we implement
+// x86 64bit far jump stub, we have to ensure find_sym only returns
+// near address.
+
+int stub_printf(char const *fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+  int result = vprintf(fmt, ap);
+  va_end(ap);
+  return result;
+}
+
+int stub_scanf(char const *fmt, ...) {
+  va_list ap;
+  va_start(ap, fmt);
+  int result = vscanf(fmt, ap);
+  va_end(ap);
+  return result;
+}
+
+void stub_srand(unsigned int seed) {
+  srand(seed);
+}
+
+int stub_rand() {
+  return rand();
+}
+
+time_t stub_time(time_t *output) {
+  return time(output);
+}
+
+void *find_sym(void *context, char const *name) {
+  struct func_entry_t {
+    char const *name;
+    size_t name_len;
+    void *addr;
+  };
+
+  static func_entry_t const tab[] = {
+#define DEF(NAME, ADDR) \
+    { NAME, sizeof(NAME) - 1, (void *)(ADDR) },
+
+    DEF("printf", stub_printf)
+    DEF("scanf", stub_scanf)
+    DEF("__isoc99_scanf", stub_scanf)
+    DEF("rand", stub_rand)
+    DEF("time", stub_time)
+    DEF("srand", stub_srand)
+#undef DEF
+  };
+
+  static size_t const tab_size = sizeof(tab) / sizeof(func_entry_t);
+
+  // Note: Since our table is small, we are using trivial O(n) searching
+  // function.  For bigger table, it will be better to use binary
+  // search or hash function.
+  size_t name_len = strlen(name);
+  for (size_t i = 0; i < tab_size; ++i) {
+    if (name_len == tab[i].name_len && strcmp(name, tab[i].name) == 0) {
+      return tab[i].addr;
+    }
+  }
+
+  assert(0 && "Can't find symbol.");
+  return 0;
+}
+
+template <unsigned Bitwidth, typename Archiver>
+void dump_and_run_object(Archiver &AR, int argc, char **argv) {
+  llvm::OwningPtr<ELFObject<Bitwidth> > object(ELFObject<Bitwidth>::read(AR));
+
+  if (!object) {
+    llvm::errs() << "ERROR: Unable to load object\n";
+  }
+
+  object->print();
+  out().flush();
+
+  ELFSectionSymTab<Bitwidth> *symtab =
+    static_cast<ELFSectionSymTab<Bitwidth> *>(
+        object->getSectionByName(".symtab"));
+
+  object->relocate(find_sym, 0);
+  out() << "relocate finished!\n";
+  out().flush();
+
+  int machine = object->getHeader()->getMachine();
+
+  void *main_addr = symtab->getByName("main")->getAddress(machine);
+  out() << "main address: " << main_addr << "\n";
+  out().flush();
+
+  ((int (*)(int, char **))main_addr)(argc, argv);
+  fflush(stdout);
+}
+
+template <typename Archiver>
+void dump_and_run_file_from_archive(bool is32bit, Archiver &AR,
+                                    int argc, char **argv) {
+  if (is32bit) {
+    dump_and_run_object<32>(AR, argc, argv);
+  } else {
+    dump_and_run_object<64>(AR, argc, argv);
+  }
+}
+
+void dump_and_run_file(unsigned char const *image, size_t size,
+                       int argc, char **argv) {
+  if (size < EI_NIDENT) {
+    llvm::errs() << "ERROR: ELF identification corrupted.\n";
+    return;
+  }
+
+  if (image[EI_DATA] != ELFDATA2LSB && image[EI_DATA] != ELFDATA2MSB) {
+    llvm::errs() << "ERROR: Unknown endianness.\n";
+    return;
+  }
+
+  if (image[EI_CLASS] != ELFCLASS32 && image[EI_CLASS] != ELFCLASS64) {
+    llvm::errs() << "ERROR: Unknown machine class.\n";
+    return;
+  }
+
+  bool isLittleEndian = (image[EI_DATA] == ELFDATA2LSB);
+  bool is32bit = (image[EI_CLASS] == ELFCLASS32);
+
+  if (isLittleEndian) {
+    ArchiveReaderLE AR(image, size);
+    dump_and_run_file_from_archive(is32bit, AR, argc, argv);
+  } else {
+    ArchiveReaderBE AR(image, size);
+    dump_and_run_file_from_archive(is32bit, AR, argc, argv);
+  }
+}
+
+bool open_mmap_file(char const *filename,
+                    int &fd,
+                    unsigned char const *&image,
+                    size_t &size) {
+  // Query the file status
+  struct stat sb;
+  if (stat(filename, &sb) != 0) {
+    llvm::errs() << "ERROR: " << filename << " not found.\n";
+    return false;
+  }
+
+  if (!S_ISREG(sb.st_mode)) {
+    llvm::errs() << "ERROR: " << filename << " is not a regular file.\n";
+    return false;
+  }
+
+  size = (size_t)sb.st_size;
+
+  // Open the file in readonly mode
+  fd = open(filename, O_RDONLY);
+  if (fd < 0) {
+    llvm::errs() << "ERROR: Unable to open " << filename << "\n";
+    return false;
+  }
+
+  // Map the file image
+  image = static_cast<unsigned char const *>(
+    mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0));
+
+  if (image == MAP_FAILED) {
+    llvm::errs() << "ERROR: Unable to map " << filename << " to memory.\n";
+    close(fd);
+    return false;
+  }
+
+  return true;
+}
+
+void close_mmap_file(int fd,
+                     unsigned char const *image,
+                     size_t size) {
+  if (image) {
+    munmap((void *)image, size);
+  }
+
+  if (fd >= 0) {
+    close(fd);
+  }
+}
diff --git a/driver/linkloader/tests/images/clean-testcases.sh b/driver/linkloader/tests/images/clean-testcases.sh
new file mode 100755
index 0000000..1c2d0be
--- /dev/null
+++ b/driver/linkloader/tests/images/clean-testcases.sh
@@ -0,0 +1,18 @@
+#!/bin/bash -e
+
+
+# Copyright (C) 2011 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+rm -rf *.o *.bc
diff --git a/driver/linkloader/tests/images/gen-testcases.sh b/driver/linkloader/tests/images/gen-testcases.sh
new file mode 100755
index 0000000..26c7cdf
--- /dev/null
+++ b/driver/linkloader/tests/images/gen-testcases.sh
@@ -0,0 +1,41 @@
+#!/bin/bash -e
+
+
+# Copyright (C) 2011-2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+CYAN='\033[1;36m'
+RESET='\033[m'
+
+echo -e "${CYAN}Generating bitcode ...${RESET}"
+clang -emit-llvm -std=c89 -Wall -c test.c -o test.bc
+clang -emit-llvm -std=c89 -Wall -c simple-test.c -o simple-test.bc
+clang -emit-llvm -std=c89 -Wall -c rodata-test.c -o rodata-test.bc
+
+function gen_test_cases {
+  echo -e "${CYAN}Generating for $1 ...${RESET}"
+  llc -filetype=obj -relocation-model=static -mtriple $2 $3 test.bc -o test-$1.o
+  llc -filetype=obj -relocation-model=static -mtriple $2 $3 simple-test.bc -o simple-test-$1.o
+  llc -filetype=obj -relocation-model=static -mtriple $2 $3 rodata-test.bc -o rodata-test-$1.o
+}
+
+gen_test_cases arm    armv7-none-linux-gnueabi
+gen_test_cases tegra2 armv7-none-linux-gnueabi '-mcpu=cortex-a9 -mattr=+vfp3'
+gen_test_cases thumb2 thumb-none-linux-gnueabi '-march=thumb -mattr=+thumb2'
+gen_test_cases thumb2lc thumb-none-linux-gnueabi '-mattr=+thumb2,+neonfp,+vfp3 -arm-long-calls'
+gen_test_cases thumb2lc-xoom thumb-none-linux-gnueabi '-mattr=+thumb2 -arm-long-calls'
+gen_test_cases x86_32 i686-none-linux
+gen_test_cases x86_64 x86_64-none-linux
+gen_test_cases mipsel mipsel-none-linux-gnueabi
diff --git a/driver/linkloader/tests/images/rodata-test.c b/driver/linkloader/tests/images/rodata-test.c
new file mode 100644
index 0000000..d695d01
--- /dev/null
+++ b/driver/linkloader/tests/images/rodata-test.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include<stdio.h>
+
+static char const *const test_str[] = {
+  "string 1",
+  "string 2",
+  "string 3",
+  "long long long long long long string"
+};
+
+static size_t test_str_count = sizeof(test_str) / sizeof(char const *const);
+
+int main(){
+  int i;
+  printf("test_str: %p\n", &test_str);
+  for (i = 0; i < test_str_count; ++i) {
+    printf("%p\n", test_str[i]);
+    printf("%s\n", test_str[i]);
+  }
+
+  return 0;
+}
diff --git a/driver/linkloader/tests/images/simple-test.c b/driver/linkloader/tests/images/simple-test.c
new file mode 100644
index 0000000..c59201d
--- /dev/null
+++ b/driver/linkloader/tests/images/simple-test.c
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+int main() {
+  srand(time(NULL));
+
+  unsigned int ans = rand() % 100;
+  unsigned int user = 100;
+  unsigned int left = 0;
+  unsigned int right = 99;
+
+  printf("Hello, droid!  Let's play a number guessing game!\n");
+
+  while (user != ans) {
+    printf("Please input a number [%d-%d]:\n", left, right);
+
+    if (scanf("%u", &user) != 1) {
+      break;
+    }
+
+    if (user < left || user > right) {
+      /* Out of range, ignore this answer. */
+      continue;
+    } else if (user == ans) {
+      printf("You got it!\n");
+      break;
+    } else if (user < ans) {
+      left = user;
+    } else {
+      right = user;
+    }
+  }
+
+  return 0;
+}
diff --git a/driver/linkloader/tests/images/test.c b/driver/linkloader/tests/images/test.c
new file mode 100644
index 0000000..01b69a1
--- /dev/null
+++ b/driver/linkloader/tests/images/test.c
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include<stdio.h>
+static void hello_function(const char *ptr){
+        printf("%s", ptr);
+}
+int my_add(int para_x, int para_y){
+        return para_x + para_y;
+}
+int global_z_i;
+double global_z_d;
+int global_big_z_i[1000];
+double global_big_z_d[1000];
+static int global_static_z_i;
+static double global_static_z_d;
+static int global_static_big_z_i[1000];
+static double global_static_big_z_d[1000];
+int global_z_i_init = 1;
+double global_z_d_init = 1.1;
+/*extern int extern_z_i;   */
+/*extern double extern_z_d;*/
+int main(){
+        static int local_static_z_i;
+        static double local_static_z_d;
+        static int local_static_z_i_init = 2;
+        static double local_static_z_d_init = 2.2;
+        local_static_z_i = local_static_z_i_init;
+        local_static_z_d = local_static_z_d_init;
+        printf("%d %f\n", local_static_z_i, local_static_z_d);
+        printf("%d %f\n", local_static_z_i_init, local_static_z_d_init);
+        hello_function("Hello world!1\n");
+        hello_function("Hello world!2\n");
+        hello_function("Hello world!3\n");
+        global_z_i = my_add(1,2);
+        global_z_d = 3.3;
+        printf("%d %f\n", global_z_i, global_z_d);
+        global_big_z_i[100] = 4;
+        global_big_z_d[100] = 4.4;
+        printf("%d %f\n", global_big_z_i[100], global_big_z_d[100]);
+        global_static_z_i = my_add(2,1);
+        global_static_z_d = 3.3;
+        printf("%d %f\n", global_static_z_i, global_static_z_d);
+        int local_z_i = global_static_z_i = global_z_i;
+        double local_z_d = global_static_z_d = global_z_d;
+        printf("%d %f\n", local_z_i, local_z_d);
+        global_static_big_z_i[500] = 5;
+        global_static_big_z_d[500] = 5.5;
+        printf("%d %f\n", global_static_big_z_i[500], global_static_big_z_d[500]);
+        global_z_i_init = 6;
+        global_z_d_init = 6.6;
+        printf("%d %f\n", global_z_i_init, global_z_d_init);
+        /*printf("%d %f\n", extern_z_i, extern_z_d);*/
+        return 0;
+}
diff --git a/driver/linkloader/tests/stubs/arm-stub.c b/driver/linkloader/tests/stubs/arm-stub.c
new file mode 100644
index 0000000..2138f9a
--- /dev/null
+++ b/driver/linkloader/tests/stubs/arm-stub.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+
+// Note: The first instruction stands for ldr, which loads the data from
+// memory to the specified register.  Notice that due to the pipeline design,
+// when ldr is executed, the program will be advanced by 8.  So, to get our
+// address we should substract it by 4.
+
+uint32_t stub[] = {
+  0xe51ff004ul, // ldr pc, [pc, #-4]
+  0x00000000ul  // address
+};
+
+int test() {
+  printf("hello world!\n");
+  return 5;
+}
+
+int main() {
+  int (*f)() = (int (*)())stub;
+  stub[1] = (uint32_t)(uintptr_t)test;
+
+  printf("return = %d\n", f());
+  return EXIT_SUCCESS;
+}
diff --git a/driver/linkloader/tests/stubs/mips-stub.c b/driver/linkloader/tests/stubs/mips-stub.c
new file mode 100644
index 0000000..ff34d03
--- /dev/null
+++ b/driver/linkloader/tests/stubs/mips-stub.c
@@ -0,0 +1,48 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+// --------------
+// Register Usage
+// --------------
+// $0       zero
+// $1       at
+// $2-$3    function return value registers
+// $4-$7    function argument registers
+// $8-$15   temporary
+// $16-$23  saved register
+// $24-$25  temporary
+// $26-$27  os kernel
+// $28      global pointer
+// $29      stack pointer
+// $30      saved register
+// $31      return addres reigster
+
+// --------------------
+// Instruction Encoding
+// --------------------
+// lui: 0011 1100 000t tttt iiii iiii iiii iiii
+// ori: 0011 01ss ssst tttt iiii iiii iiii iiii
+// jr:  0000 00ss sss0 0000 0000 0000 0000 1000
+// nop:  0000 0000 0000 0000 0000 0000 0000 0000
+
+uint32_t stub[] = {
+  0x3c190000ul,
+  0x37390000ul,
+  0x03200008ul,
+  0x00000000ul
+};
+
+int test() {
+  printf("hello world!\n");
+  return 5;
+}
+
+int main() {
+  int (*f)() = (int (*)())stub;
+  stub[0] |= (((uint32_t)(uintptr_t)test) >> 16) & 0xffff;
+  stub[1] |= (((uint32_t)(uintptr_t)test)) & 0xffff;
+
+  printf("return = %d\n", f());
+  return EXIT_SUCCESS;
+}
diff --git a/driver/linkloader/tests/stubs/stub-layout-test.cpp b/driver/linkloader/tests/stubs/stub-layout-test.cpp
new file mode 100644
index 0000000..ba07cd2
--- /dev/null
+++ b/driver/linkloader/tests/stubs/stub-layout-test.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "StubLayout.h"
+
+void function1() {
+  printf("hello ");
+}
+
+void function2() {
+  printf("world!\n");
+}
+
+int main() {
+  StubLayout stubs;
+
+  void (*func1)() = (void (*)())stubs.allocateStub((void *)&function1);
+  void (*func2)() = (void (*)())stubs.allocateStub((void *)&function2);
+
+  if (!func1) {
+    fprintf(stderr, "ERROR: Unable to allocate stub for function1\n");
+    exit(EXIT_FAILURE);
+  }
+
+  if (!func2) {
+    fprintf(stderr, "ERROR: Unable to allocate stub for function2\n");
+    exit(EXIT_FAILURE);
+  }
+
+  function1();
+  function2();
+
+  func1();
+  func2();
+
+  return EXIT_SUCCESS;
+}
diff --git a/driver/linkloader/utils/flush_cpu_cache.h b/driver/linkloader/utils/flush_cpu_cache.h
new file mode 100644
index 0000000..7a269ed
--- /dev/null
+++ b/driver/linkloader/utils/flush_cpu_cache.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLUSH_CPU_CACHE_H
+#define FLUSH_CPU_CACHE_H
+
+#if defined(__arm__) || defined(__mips__)
+
+// Note: Though we wish to use the gcc builtin function __clear_cache to
+// invalidate the instruction cache; however, the toolchain of Android
+// has not supported it properly.  We are going to use cacheflush system
+// call to invalidate the instruction cache.
+//
+// As a side note, Dalvik VM use the same system call to invalidate the
+// instruction as well.
+
+#include <unistd.h>
+
+#define FLUSH_CPU_CACHE(BEGIN, END) \
+  cacheflush(((long)(BEGIN)), ((long)(END)), 0)
+
+#if 0 && defined(__mips__)
+
+// Note: Following code does not work with Android Toolchain, though they
+// works while using standalone mips-linux-gnu-gcc.
+
+#include <sys/cachectl.h>
+#define FLUSH_CPU_CACHE(BEGIN, END) \
+  _flush_cache(reinterpret_cast<char*>(BEGIN), END-BEGIN+1, BCACHE);
+
+#endif
+
+#else
+
+#define FLUSH_CPU_CACHE(BEGIN, END) do { } while (0)
+
+#endif
+
+#endif // FLUSH_CPU_CACHE_H
diff --git a/driver/linkloader/utils/helper.cpp b/driver/linkloader/utils/helper.cpp
new file mode 100644
index 0000000..2dce54f
--- /dev/null
+++ b/driver/linkloader/utils/helper.cpp
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "helper.h"
+#include "raw_ostream.h"
+
+#include <stdlib.h>
+#include <ctype.h>
+
+using namespace llvm;
+
+void dump_hex(unsigned char const *data,
+              size_t size, size_t begin, size_t end) {
+  if (end <= begin) {
+    // Nothing to print now.  Return directly.
+    return;
+  }
+
+  size_t lower = begin & (~0xfUL);
+  size_t upper = (end & (~0xfUL)) ? end : ((end + 16UL) & (~0xfUL));
+
+  for (size_t i = lower; i < upper; i += 16) {
+    out() << format("%08x", i) << ':';
+
+    if (i < begin) {
+      out().changeColor(raw_ostream::MAGENTA);
+    }
+
+    for (size_t j = i, k = i + 16; j < k; ++j) {
+      if (j == begin) {
+        out().resetColor();
+      }
+
+      if (j == end) {
+        out().changeColor(raw_ostream::MAGENTA);
+      }
+
+      if (j < size) {
+        out() << ' ' << format("%02x", (unsigned)data[j]);
+      }
+    }
+
+    out().resetColor();
+    out() << "  ";
+
+    for (size_t j = i, k = i + 16; j < k; ++j) {
+      if (data[j] > 0x20 && data[j] < 0x7f) {
+        out() << (char)data[j];
+      } else {
+        out() << '.';
+      }
+    }
+
+    out() << '\n';
+  }
+}
diff --git a/driver/linkloader/utils/helper.h b/driver/linkloader/utils/helper.h
new file mode 100644
index 0000000..000666a
--- /dev/null
+++ b/driver/linkloader/utils/helper.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HELPER_H
+#define HELPER_H
+
+#include <stdlib.h>
+
+extern void dump_hex(unsigned char const *data,
+                     size_t size, size_t begin, size_t end);
+
+#endif // HELPER_H
diff --git a/driver/linkloader/utils/raw_ostream.cpp b/driver/linkloader/utils/raw_ostream.cpp
new file mode 100644
index 0000000..7efd10e
--- /dev/null
+++ b/driver/linkloader/utils/raw_ostream.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "raw_ostream.h"
+
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/Format.h>
+#include <cstdarg>
+#include <cstring>
+
+llvm::raw_ostream &out() {
+  static llvm::raw_ostream &singleton = llvm::outs();
+  return singleton;
+}
+
+MyFormat const fillformat(char const fill_char, // Fill character.
+                          int const length,     // Fill Width.
+                          char const *format_s, // Format string.
+                          ...) {                // Format variable.
+  using namespace std;
+  struct MyFormat t_format;
+  va_list valist;
+  va_start(valist, format_s);
+  t_format.ptr = new char[length+1];
+  t_format.ptr[length] = '\0';
+  vsnprintf(t_format.ptr, length, format_s, valist);
+  int real_len = strlen(t_format.ptr);
+  int fill_len = length;
+  memmove(t_format.ptr + fill_len, t_format.ptr, real_len);
+  memset(t_format.ptr, fill_char, fill_len);
+  return t_format;
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &os, MyFormat const &mf) {
+  os << mf.ptr;
+  delete mf.ptr;
+  return os;
+}
diff --git a/driver/linkloader/utils/raw_ostream.h b/driver/linkloader/utils/raw_ostream.h
new file mode 100644
index 0000000..0f7a5be
--- /dev/null
+++ b/driver/linkloader/utils/raw_ostream.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RAW_OSTREAM_H
+#define RAW_OSTREAM_H
+
+#include <llvm/Support/raw_ostream.h>
+#include <llvm/Support/Format.h>
+
+extern llvm::raw_ostream &out();
+struct MyFormat {
+  char *ptr;
+};
+extern MyFormat const fillformat(char const,        // Fill character.
+                                 int const,         // Fill Width.
+                                 char const * = "", // Format string.
+                                 ...);              // Format variable.
+extern llvm::raw_ostream &operator<<(llvm::raw_ostream &, MyFormat const &);
+
+#endif // RAW_OSTREAM_H
diff --git a/driver/linkloader/utils/rsl_assert.cpp b/driver/linkloader/utils/rsl_assert.cpp
new file mode 100644
index 0000000..cdd3207
--- /dev/null
+++ b/driver/linkloader/utils/rsl_assert.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rsl_assert.h"
+
+#include <llvm/Support/raw_ostream.h>
+
+#include <stdlib.h>
+
+#if !defined(__HOST__)
+#define LOG_TAG "bcc"
+#include <cutils/log.h>
+#endif
+
+extern "C" void ASSERT_FAILED(char const *file,
+                              unsigned line,
+                              char const *expr) {
+#if defined(__HOST__)
+  llvm::errs() << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
+  llvm::errs() << "rslAssert [" << file << ":" << line << "] " << expr << "\n";
+  llvm::errs() << "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
+#else
+  ALOGE("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+  ALOGE("rslAssert [%s:%d] %s\n", file, line, expr);
+  ALOGE("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
+#endif
+
+  abort();
+}
diff --git a/driver/linkloader/utils/rsl_assert.h b/driver/linkloader/utils/rsl_assert.h
new file mode 100644
index 0000000..cd20b83
--- /dev/null
+++ b/driver/linkloader/utils/rsl_assert.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef RSL_ASSERT_H
+#define RSL_ASSERT_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+extern void ASSERT_FAILED(char const *file,
+                          unsigned line,
+                          char const *expr);
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+#ifdef RSL_NDEBUG
+
+#define rsl_assert(EXPR) \
+  do { } while (0)
+
+#else
+
+#define rsl_assert(EXPR)                                      \
+  do {                                                        \
+    if (!(EXPR)) {                                            \
+      ASSERT_FAILED(__FILE__, __LINE__, #EXPR);               \
+    }                                                         \
+  } while (0)
+
+#endif
+
+#endif // RSL_ASSERT_H
diff --git a/driver/linkloader/utils/serialize.h b/driver/linkloader/utils/serialize.h
new file mode 100644
index 0000000..3d15158
--- /dev/null
+++ b/driver/linkloader/utils/serialize.h
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(SERIALIZE_H)
+#define SERIALIZE_H
+
+#include "traits.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "utils/rsl_assert.h"
+#include <string.h>
+#include <stdint.h>
+#include <stddef.h>
+
+namespace detail {
+  inline bool is_host_little_endian() {
+    unsigned long one = 0x1UL;
+    return *reinterpret_cast<unsigned char *>(&one);
+  }
+
+  inline void swap_byte_order(unsigned char (&array)[1]) {
+    // Nothing to do
+  }
+
+  inline void swap_byte_order(unsigned char (&array)[2]) {
+    std::swap(array[0], array[1]);
+  }
+
+  inline void swap_byte_order(unsigned char (&array)[4]) {
+    std::swap(array[0], array[3]);
+    std::swap(array[1], array[2]);
+  }
+
+  inline void swap_byte_order(unsigned char (&array)[8]) {
+    std::swap(array[0], array[7]);
+    std::swap(array[1], array[6]);
+    std::swap(array[2], array[5]);
+    std::swap(array[3], array[4]);
+  }
+}
+
+
+template <bool isArchiveLittleEndian>
+class ArchiveReader {
+private:
+  unsigned char const *buf_begin;
+  unsigned char const *buf_end;
+  unsigned char const *cursor;
+  unsigned char const *cursor_base;
+
+  bool good;
+
+public:
+  ArchiveReader(unsigned char const *buf = NULL, size_t size = 0)
+  : buf_begin(buf), buf_end(buf + size),
+    cursor(buf), cursor_base(NULL), good(buf != NULL) {
+  }
+
+  void prologue(size_t size) {
+    rsl_assert(cursor_base == NULL);
+    cursor_base = cursor;
+  }
+
+  void epilogue(size_t size) {
+    rsl_assert(cursor_base != NULL);
+    rsl_assert(cursor_base + size >= cursor);
+    cursor = cursor_base + size;
+    cursor_base = NULL;
+  }
+
+  void seek(off_t off, bool from_begin = false) {
+    if (from_begin) {
+      cursor = buf_begin + off;
+    } else {
+      cursor += off;
+    }
+  }
+
+  void readBytes(void *array, size_t size) {
+    if (!good || cursor + size > buf_end) {
+      good = false;
+    } else {
+      memcpy(array, cursor, size);
+    }
+  }
+
+  template <size_t size>
+  void operator&(char (&array)[size]) {
+    readBytes(array, size);
+    seek(size);
+  }
+
+  template <size_t size>
+  void operator&(unsigned char (&array)[size]) {
+    readBytes(array, size);
+    seek(size);
+  }
+
+  template <typename T>
+  void operator&(T &v) {
+    seekAlignment<T>();
+    readBytes(&v, TypeTraits<T>::size);
+    seek(TypeTraits<T>::size);
+
+    if (isArchiveLittleEndian != detail::is_host_little_endian()) {
+      detail::swap_byte_order(
+        reinterpret_cast<unsigned char (&)[TypeTraits<T>::size]>(v));
+    }
+  }
+
+  operator void const *() const {
+    return good ? this : 0;
+  }
+
+  bool operator!() const {
+    return !good;
+  }
+
+private:
+  template <typename T>
+  void seekAlignment() {
+    size_t align = TypeTraits<T>::align;
+    size_t delta = static_cast<size_t>(cursor - buf_begin) % align;
+
+    if (delta > 0) {
+      seek(align - delta);
+    }
+  }
+
+};
+
+typedef ArchiveReader<true>  ArchiveReaderLE;
+typedef ArchiveReader<false> ArchiveReaderBE;
+
+#endif // SERIALIZE_H
diff --git a/driver/linkloader/utils/traits.h b/driver/linkloader/utils/traits.h
new file mode 100644
index 0000000..df7e7f7
--- /dev/null
+++ b/driver/linkloader/utils/traits.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2011, The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TRAITS_H
+#define TRAITS_H
+
+#include <stddef.h>
+
+template <typename Type>
+struct TypeTraits {
+private:
+  struct AlignmentTest {
+    char pending;
+    Type element;
+  };
+
+public:
+  enum { size = sizeof(Type) };
+  enum { align = offsetof(AlignmentTest, element) };
+};
+
+#define TYPE_TRAITS_SPECIALIZE(TYPE, SIZE, ALIGN) \
+template <> \
+struct TypeTraits<TYPE> { \
+  enum { size = SIZE }; \
+  enum { align = ALIGN }; \
+};
+
+#endif // TRAITS_H