diff --git a/linker/dlfcn.c b/linker/dlfcn.c
new file mode 100644
index 0000000..cd73d11
--- /dev/null
+++ b/linker/dlfcn.c
@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2007 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 <dlfcn.h>
+#include <pthread.h>
+#include "linker.h"
+
+/* This file hijacks the symbols stubbed out in libdl.so. */
+
+#define DL_SUCCESS                    0
+#define DL_ERR_CANNOT_FIND_LIBRARY    1
+#define DL_ERR_INVALID_LIBRARY_HANDLE 2
+#define DL_ERR_BAD_SYMBOL_NAME        3
+#define DL_ERR_SYMBOL_NOT_FOUND       4
+#define DL_ERR_SYMBOL_NOT_GLOBAL      5
+
+static const char *dl_errors[] = {
+    [DL_SUCCESS] = NULL,
+    [DL_ERR_CANNOT_FIND_LIBRARY] = "Cannot find library",
+    [DL_ERR_INVALID_LIBRARY_HANDLE] = "Invalid library handle",
+    [DL_ERR_BAD_SYMBOL_NAME] = "Invalid symbol name",
+    [DL_ERR_SYMBOL_NOT_FOUND] = "Symbol not found",
+    [DL_ERR_SYMBOL_NOT_GLOBAL] = "Symbol is not global",
+};
+
+static int dl_last_err = DL_SUCCESS;
+
+#define likely(expr)   __builtin_expect (expr, 1)
+#define unlikely(expr) __builtin_expect (expr, 0)
+
+static pthread_mutex_t dl_lock = PTHREAD_MUTEX_INITIALIZER;
+
+void *dlopen(const char *filename, int flag) 
+{
+    soinfo *ret;
+
+    pthread_mutex_lock(&dl_lock);
+    ret = find_library(filename);
+    if (unlikely(ret == NULL)) {
+        dl_last_err = DL_ERR_CANNOT_FIND_LIBRARY;
+    } else {
+        ret->refcount++;
+    }
+    pthread_mutex_unlock(&dl_lock);
+    return ret;
+}
+
+const char *dlerror(void)
+{
+    const char *err = dl_errors[dl_last_err];
+    dl_last_err = DL_SUCCESS;
+    return err;
+}
+
+void *dlsym(void *handle, const char *symbol)
+{
+    unsigned base;
+    Elf32_Sym *sym;
+    unsigned bind;
+
+    pthread_mutex_lock(&dl_lock);
+    
+    if(unlikely(handle == 0)) { 
+        dl_last_err = DL_ERR_INVALID_LIBRARY_HANDLE;
+        goto err;
+    }
+    if(unlikely(symbol == 0)) {
+        dl_last_err = DL_ERR_BAD_SYMBOL_NAME;
+        goto err;
+    }
+    
+    if(handle == RTLD_DEFAULT) {
+        sym = lookup(symbol, &base);
+    } else if(handle == RTLD_NEXT) {
+        sym = lookup(symbol, &base);
+    } else {
+        sym = lookup_in_library((soinfo*) handle, symbol);
+        base = ((soinfo*) handle)->base;
+    }
+
+    if(likely(sym != 0)) {
+        bind = ELF32_ST_BIND(sym->st_info);
+    
+        if(likely((bind == STB_GLOBAL) && (sym->st_shndx != 0))) {
+            unsigned ret = sym->st_value + base;
+            pthread_mutex_unlock(&dl_lock);
+            return (void*)ret;
+        }
+
+        dl_last_err = DL_ERR_SYMBOL_NOT_GLOBAL;
+    }
+    else dl_last_err = DL_ERR_SYMBOL_NOT_FOUND;
+
+err:
+    pthread_mutex_unlock(&dl_lock);
+    return 0;
+}
+
+int dlclose(void *handle)
+{
+    pthread_mutex_lock(&dl_lock);
+    (void)unload_library((soinfo*)handle);
+    pthread_mutex_unlock(&dl_lock);
+    return 0;
+}
+
+#if defined(ANDROID_ARM_LINKER)
+//                     0000000 00011111 111112 22222222 233333333334444444444
+//                     0123456 78901234 567890 12345678 901234567890123456789
+#define ANDROID_LIBDL_STRTAB \
+                      "dlopen\0dlclose\0dlsym\0dlerror\0dl_unwind_find_exidx\0"
+
+#elif defined(ANDROID_X86_LINKER)
+//                     0000000 00011111 111112 22222222 2333333333344444
+//                     0123456 78901234 567890 12345678 9012345678901234
+#define ANDROID_LIBDL_STRTAB \
+                      "dlopen\0dlclose\0dlsym\0dlerror\0dl_iterate_phdr\0"
+
+#else /* !defined(ANDROID_ARM_LINKER) && !defined(ANDROID_X86_LINKER) */
+#error Unsupported architecture. Only ARM and x86 are presently supported.
+#endif
+
+
+static Elf32_Sym libdl_symtab[] = {
+      // total length of libdl_info.strtab, including trailing 0
+      // This is actually the the STH_UNDEF entry. Technically, it's
+      // supposed to have st_name == 0, but instead, it points to an index
+      // in the strtab with a \0 to make iterating through the symtab easier.
+    { st_name: sizeof(ANDROID_LIBDL_STRTAB) - 1,
+    },
+    { st_name: 0,   // starting index of the name in libdl_info.strtab
+      st_value: (Elf32_Addr) &dlopen,
+      st_info: STB_GLOBAL << 4,
+      st_shndx: 1,
+    },
+    { st_name: 7,
+      st_value: (Elf32_Addr) &dlclose,
+      st_info: STB_GLOBAL << 4,
+      st_shndx: 1,
+    },
+    { st_name: 15,
+      st_value: (Elf32_Addr) &dlsym,
+      st_info: STB_GLOBAL << 4,
+      st_shndx: 1,
+    },
+    { st_name: 21,
+      st_value: (Elf32_Addr) &dlerror,
+      st_info: STB_GLOBAL << 4,
+      st_shndx: 1,
+    },
+#ifdef ANDROID_ARM_LINKER
+    { st_name: 29,
+      st_value: (Elf32_Addr) &dl_unwind_find_exidx,
+      st_info: STB_GLOBAL << 4,
+      st_shndx: 1,
+    },
+#elif defined(ANDROID_X86_LINKER)
+    { st_name: 29,
+      st_value: (Elf32_Addr) &dl_iterate_phdr,
+      st_info: STB_GLOBAL << 4,
+      st_shndx: 1,
+    },
+#endif
+};
+
+/* Fake out a hash table with a single bucket.
+ * A search of the hash table will look through
+ * libdl_symtab starting with index [1], then
+ * use libdl_chains to find the next index to
+ * look at.  libdl_chains should be set up to
+ * walk through every element in libdl_symtab,
+ * and then end with 0 (sentinel value).
+ *
+ * I.e., libdl_chains should look like
+ * { 0, 2, 3, ... N, 0 } where N is the number
+ * of actual symbols, or nelems(libdl_symtab)-1
+ * (since the first element of libdl_symtab is not
+ * a real symbol).
+ *
+ * (see _elf_lookup())
+ *
+ * Note that adding any new symbols here requires
+ * stubbing them out in libdl.
+ */
+static unsigned libdl_buckets[1] = { 1 };
+static unsigned libdl_chains[6] = { 0, 2, 3, 4, 5, 0 };
+
+soinfo libdl_info = {
+    name: "libdl.so",
+    flags: FLAG_LINKED,
+
+    strtab: ANDROID_LIBDL_STRTAB,
+    symtab: libdl_symtab,
+
+    nbucket: 1,
+    nchain: 6,
+    bucket: libdl_buckets,
+    chain: libdl_chains,
+};
+