newlinker/dlfcn.c - native_client/nacl-bionic - Git at Google

 /*
  * 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 <stdio.h>
 #include "linker.h"
 #include "linker_format.h"

 #include "irt_syscalls.h"

 #define DL_SUCCESS                    0
 #define DL_ERR_CANNOT_LOAD_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 char dl_err_buf[1024];
 static const char *dl_err_str;

 static const char *dl_errors[] = {
     [DL_ERR_CANNOT_LOAD_LIBRARY] = "Cannot load 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",
 };

 #define likely(expr)   __builtin_expect (expr, 1)
 #define unlikely(expr) __builtin_expect (expr, 0)

 pthread_mutex_t dl_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;

 static void set_dlerror(int err)
 {
     format_buffer(dl_err_buf, sizeof(dl_err_buf), "%s: %s", dl_errors[err],
              linker_get_error());
     dl_err_str = (const char *)&dl_err_buf[0];
 };

 void *dlopen(const char *filename, int flag)
 {
     soinfo *ret;

     pthread_mutex_lock(&dl_lock);
     ret = find_loaded_library(filename);

     if (!ret) {
       ret = load_library(filename, 1);
       if (ret) {
         soinfo_link_image(ret);
         soinfo_call_constructors(ret);
       }
     } else {
       ret->refcount++;
     }

     if (ret == NULL) {
         set_dlerror(DL_ERR_CANNOT_LOAD_LIBRARY);
     }
     pthread_mutex_unlock(&dl_lock);
     return ret;
 }

 const char *dlerror(void)
 {
     const char *tmp = dl_err_str;
     dl_err_str = NULL;
     return (const char *)tmp;
 }

 void *dlsym(void *handle, const char *symbol)
 {
     soinfo *found;
     Elf32_Sym *sym;
     unsigned bind;

     pthread_mutex_lock(&dl_lock);

     if(unlikely(handle == 0)) {
         set_dlerror(DL_ERR_INVALID_LIBRARY_HANDLE);
         goto err;
     }
     if(unlikely(symbol == 0)) {
         set_dlerror(DL_ERR_BAD_SYMBOL_NAME);
         goto err;
     }

     if(handle == RTLD_DEFAULT) {
         sym = lookup(symbol, &found, NULL);
     } else if(handle == RTLD_NEXT) {
         void *ret_addr = __builtin_return_address(0);
         soinfo *si = find_containing_library(ret_addr);

         sym = NULL;
         if(si && si->next) {
             sym = lookup(symbol, &found, si->next);
         }
     } else {
         found = (soinfo*)handle;
         sym = soinfo_lookup(found, symbol);
     }

     if(likely(sym != 0)) {
         bind = ELF32_ST_BIND(sym->st_info);

         // NACL MOD BEGIN UPSTREAM
         // Allow weak symbols as return values of dlsym. Without this,
         // dlsym("isalpha") may fail if 1. you are building your program
         // with g++ (not gcc), 2. you have -DNDEBUG, and 3. your
         // program calls isalpha directly. This issue happens even on
         // a real android device.
         if(likely((bind == STB_GLOBAL || bind == STB_WEAK) &&
                   (sym->st_shndx != 0))) {
         // NACL MOD END UPSTREAM
             // NACL MOD BEGIN
             // Use found->load_bias instead of found->base. Without
             // this, the calculation will be wrong for the main
             // executable. Upstream bionic already has this fix.
             unsigned ret = sym->st_value + found->load_bias;
             // NACL MOD END
             pthread_mutex_unlock(&dl_lock);
             return (void*)ret;
         }

         set_dlerror(DL_ERR_SYMBOL_NOT_GLOBAL);
     }
     else
         set_dlerror(DL_ERR_SYMBOL_NOT_FOUND);

 err:
     pthread_mutex_unlock(&dl_lock);
     return 0;
 }

 int dladdr(const void *addr, Dl_info *info)
 {
     int ret = 0;

     pthread_mutex_lock(&dl_lock);

     /* Determine if this address can be found in any library currently mapped */
     soinfo *si = find_containing_library(addr);

     if(si) {
         memset(info, 0, sizeof(Dl_info));

         info->dli_fname = si->name;
         info->dli_fbase = (void*)si->base;

         /* Determine if any symbol in the library contains the specified address */
         Elf32_Sym *sym = soinfo_find_symbol(si, addr);

         if(sym != NULL) {
             info->dli_sname = si->strtab + sym->st_name;
             info->dli_saddr = (void*)(si->base + sym->st_value);
         }

         ret = 1;
     }

     pthread_mutex_unlock(&dl_lock);

     return ret;
 }

 int dlclose(void* handle) {
     pthread_mutex_lock(&dl_lock);
     int result = soinfo_unload((soinfo*)handle);
     pthread_mutex_unlock(&dl_lock);
     return result;
 }

 _irt_syscalls_t** dl_irt_ptr() {
 	return &g_nacl_irt_syscalls_ptr;
 }

 // NACL MOD BEGIN
 // Added dl_iterate_phdr for arm.
 #if defined(ANDROID_ARM_LINKER)
 //                     0000000 00011111 111112 22222222 2333333 333344444444445555555 5556666666666777 77777778888
 //                     0123456 78901234 567890 12345678 9012345 678901234567890123456 7890123456789012 34567890123
 #define ANDROID_LIBDL_STRTAB \
                       "dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0dl_unwind_find_exidx\0dl_iterate_phdr\0dl_irt_ptr\0"

 // Add x86-64 support.
 #elif defined(ANDROID_X86_LINKER) || defined(ANDROID_MIPS_LINKER) \
     || defined(ANDROID_X86_64_LINKER)
 // NACL MOD END
 //                     0000000 00011111 111112 22222222 2333333 3333444444444455
 //                     0123456 78901234 567890 12345678 9012345 6789012345678901
 #define ANDROID_LIBDL_STRTAB \
                       "dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0dl_iterate_phdr\0"
 #else
 #error Unsupported architecture. Only ARM, MIPS, and x86 are presently supported.
 #endif

 // NACL MOD BEGIN
 // 64bit NaCl uses ELF64 but its pointer type is 32bit. This means we
 // cannot initialize a 64bit integer in Elf64_Sym (st_value) by a
 // pointer. Specifically, on x86-64b NaCl, we cannot compile code like
 //
 // Elf64_Sym sym = { st_value: (Elf64_Addr)&sym };
 //
 // So, we define another struct Elf64_Sym_NaCl. This is very similar
 // to Elf64_Sym, but its st_value is divided into two 32bit integers
 // (i.e., st_value and st_value_padding). This is only used to define
 // |libdl_symtab| below. |libdl_symtab| will be passed to
 // libdl_info.symtab in this file. Other code will not use this and
 // use normal Elf64_Sym instead.
 #if defined(ANDROID_X86_64_LINKER) && defined(__native_client__)
 typedef struct {
   Elf64_Word st_name;
   unsigned char st_info;
   unsigned char st_other;
   Elf64_Half st_shndx;
   // Put lower bits first because we are little endian.
   unsigned st_value;
   // We will not fill this field, so this will be initialized to zero.
   unsigned st_value_padding;
   Elf64_Xword st_size;
 } Elf64_Sym_NaCl;

 // Static assertions for the layout of Elf64_Sym_NaCl.
 #define STATIC_ASSERT(cond, name) \
   struct StaticAssert_ ## name { char name[(cond) ? 1 : -1]; }
 STATIC_ASSERT(sizeof(Elf64_Sym_NaCl) == sizeof(Elf64_Sym),
               SizeOf_Elf64_Sym_NaCl);
 STATIC_ASSERT(offsetof(Elf64_Sym_NaCl, st_value) ==
               offsetof(Elf64_Sym, st_value),
               OffsetOf_st_value);
 STATIC_ASSERT(offsetof(Elf64_Sym_NaCl, st_size) ==
               offsetof(Elf64_Sym, st_size),
               OffsetOf_st_size);

 // Remove map from Elf32_Addr to Elf64_Addr defined in linker.h.
 #undef Elf32_Addr

 static Elf64_Sym_NaCl libdl_symtab[] =
 #else
 static Elf32_Sym libdl_symtab[] =
 #endif
 {
 // NACL MOD END
       // 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,
     },
     { st_name: 29,
       st_value: (Elf32_Addr) &dladdr,
       st_info: STB_GLOBAL << 4,
       st_shndx: 1,
     },
 #ifdef ANDROID_ARM_LINKER
     { st_name: 36,
       st_value: (Elf32_Addr) &dl_unwind_find_exidx,
       st_info: STB_GLOBAL << 4,
       st_shndx: 1,
     },
     // NACL MOD BEGIN
     // Added dl_iterate_phdr for arm.
     { st_name: 57,
       st_value: (Elf32_Addr) &dl_iterate_phdr,
       st_info: STB_GLOBAL << 4,
       st_shndx: 1,
     },
     { st_name: 73,
       st_value: (Elf32_Addr) &dl_irt_ptr,
       st_info: STB_GLOBAL << 4,
       st_shndx: 1,
     },
     // Add x86-64 support.
 #elif defined(ANDROID_X86_LINKER) || defined(ANDROID_MIPS_LINKER) \
     || defined(ANDROID_X86_64_LINKER)
     // NACL MOD END
     { st_name: 36,
       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 };
 // NACL MOD BEGIN
 // Size now varies because dl_iterate_phdr has been added for arm.
 #ifdef ANDROID_ARM_LINKER
 static unsigned libdl_chains[9] = { 0, 2, 3, 4, 5, 6, 7, 8, 0 };
 #else
 static unsigned libdl_chains[7] = { 0, 2, 3, 4, 5, 6, 7, 0 };
 #endif
 // NACL MOD END

 soinfo libdl_info = {
     name: "libdl.so",
     flags: FLAG_LINKED,

     strtab: ANDROID_LIBDL_STRTAB,
     // NACL MOD BEGIN
     // Add a cast to convert Elf64_Sym_NaCl* to Elf32_Sym* (note that
     // Elf32_Sym is mapped to Elf64_Sym on x86-64).
     symtab: (Elf32_Sym *)libdl_symtab,
     // NACL MOD END

     nbucket: 1,
 // NACL MOD BEGIN
 // Allow size to vary because dl_iterate_phdr has been added for arm.
     nchain: sizeof(libdl_chains) / sizeof(*libdl_chains) - 1,
 // NACL MOD END
     bucket: libdl_buckets,
     chain: libdl_chains,
 };
	/*
	* 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 <stdio.h>
	#include "linker.h"
	#include "linker_format.h"

	#include "irt_syscalls.h"

	#define DL_SUCCESS 0
	#define DL_ERR_CANNOT_LOAD_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 char dl_err_buf[1024];
	static const char *dl_err_str;

	static const char *dl_errors[] = {
	[DL_ERR_CANNOT_LOAD_LIBRARY] = "Cannot load 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",
	};

	#define likely(expr) __builtin_expect (expr, 1)
	#define unlikely(expr) __builtin_expect (expr, 0)

	pthread_mutex_t dl_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;

	static void set_dlerror(int err)
	{
	format_buffer(dl_err_buf, sizeof(dl_err_buf), "%s: %s", dl_errors[err],
	linker_get_error());
	dl_err_str = (const char *)&dl_err_buf[0];
	};

	void dlopen(const char filename, int flag)
	{
	soinfo *ret;

	pthread_mutex_lock(&dl_lock);
	ret = find_loaded_library(filename);

	if (!ret) {
	ret = load_library(filename, 1);
	if (ret) {
	soinfo_link_image(ret);
	soinfo_call_constructors(ret);
	}
	} else {
	ret->refcount++;
	}

	if (ret == NULL) {
	set_dlerror(DL_ERR_CANNOT_LOAD_LIBRARY);
	}
	pthread_mutex_unlock(&dl_lock);
	return ret;
	}

	const char *dlerror(void)
	{
	const char *tmp = dl_err_str;
	dl_err_str = NULL;
	return (const char *)tmp;
	}

	void dlsym(void handle, const char *symbol)
	{
	soinfo *found;
	Elf32_Sym *sym;
	unsigned bind;

	pthread_mutex_lock(&dl_lock);

	if(unlikely(handle == 0)) {
	set_dlerror(DL_ERR_INVALID_LIBRARY_HANDLE);
	goto err;
	}
	if(unlikely(symbol == 0)) {
	set_dlerror(DL_ERR_BAD_SYMBOL_NAME);
	goto err;
	}

	if(handle == RTLD_DEFAULT) {
	sym = lookup(symbol, &found, NULL);
	} else if(handle == RTLD_NEXT) {
	void *ret_addr = __builtin_return_address(0);
	soinfo *si = find_containing_library(ret_addr);

	sym = NULL;
	if(si && si->next) {
	sym = lookup(symbol, &found, si->next);
	}
	} else {
	found = (soinfo*)handle;
	sym = soinfo_lookup(found, symbol);
	}

	if(likely(sym != 0)) {
	bind = ELF32_ST_BIND(sym->st_info);

	// NACL MOD BEGIN UPSTREAM
	// Allow weak symbols as return values of dlsym. Without this,
	// dlsym("isalpha") may fail if 1. you are building your program
	// with g++ (not gcc), 2. you have -DNDEBUG, and 3. your
	// program calls isalpha directly. This issue happens even on
	// a real android device.
	if(likely((bind == STB_GLOBAL \|\| bind == STB_WEAK) &&
	(sym->st_shndx != 0))) {
	// NACL MOD END UPSTREAM
	// NACL MOD BEGIN
	// Use found->load_bias instead of found->base. Without
	// this, the calculation will be wrong for the main
	// executable. Upstream bionic already has this fix.
	unsigned ret = sym->st_value + found->load_bias;
	// NACL MOD END
	pthread_mutex_unlock(&dl_lock);
	return (void*)ret;
	}

	set_dlerror(DL_ERR_SYMBOL_NOT_GLOBAL);
	}
	else
	set_dlerror(DL_ERR_SYMBOL_NOT_FOUND);

	err:
	pthread_mutex_unlock(&dl_lock);
	return 0;
	}

	int dladdr(const void addr, Dl_info info)
	{
	int ret = 0;

	pthread_mutex_lock(&dl_lock);

	/* Determine if this address can be found in any library currently mapped */
	soinfo *si = find_containing_library(addr);

	if(si) {
	memset(info, 0, sizeof(Dl_info));

	info->dli_fname = si->name;
	info->dli_fbase = (void*)si->base;

	/* Determine if any symbol in the library contains the specified address */
	Elf32_Sym *sym = soinfo_find_symbol(si, addr);

	if(sym != NULL) {
	info->dli_sname = si->strtab + sym->st_name;
	info->dli_saddr = (void*)(si->base + sym->st_value);
	}

	ret = 1;
	}

	pthread_mutex_unlock(&dl_lock);

	return ret;
	}

	int dlclose(void* handle) {
	pthread_mutex_lock(&dl_lock);
	int result = soinfo_unload((soinfo*)handle);
	pthread_mutex_unlock(&dl_lock);
	return result;
	}

	_irt_syscalls_t** dl_irt_ptr() {
	return &g_nacl_irt_syscalls_ptr;
	}

	// NACL MOD BEGIN
	// Added dl_iterate_phdr for arm.
	#if defined(ANDROID_ARM_LINKER)
	// 0000000 00011111 111112 22222222 2333333 333344444444445555555 5556666666666777 77777778888
	// 0123456 78901234 567890 12345678 9012345 678901234567890123456 7890123456789012 34567890123
	#define ANDROID_LIBDL_STRTAB \
	"dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0dl_unwind_find_exidx\0dl_iterate_phdr\0dl_irt_ptr\0"

	// Add x86-64 support.
	#elif defined(ANDROID_X86_LINKER) \|\| defined(ANDROID_MIPS_LINKER) \
	\|\| defined(ANDROID_X86_64_LINKER)
	// NACL MOD END
	// 0000000 00011111 111112 22222222 2333333 3333444444444455
	// 0123456 78901234 567890 12345678 9012345 6789012345678901
	#define ANDROID_LIBDL_STRTAB \
	"dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0dl_iterate_phdr\0"
	#else
	#error Unsupported architecture. Only ARM, MIPS, and x86 are presently supported.
	#endif

	// NACL MOD BEGIN
	// 64bit NaCl uses ELF64 but its pointer type is 32bit. This means we
	// cannot initialize a 64bit integer in Elf64_Sym (st_value) by a
	// pointer. Specifically, on x86-64b NaCl, we cannot compile code like
	//
	// Elf64_Sym sym = { st_value: (Elf64_Addr)&sym };
	//
	// So, we define another struct Elf64_Sym_NaCl. This is very similar
	// to Elf64_Sym, but its st_value is divided into two 32bit integers
	// (i.e., st_value and st_value_padding). This is only used to define
	// \|libdl_symtab\| below. \|libdl_symtab\| will be passed to
	// libdl_info.symtab in this file. Other code will not use this and
	// use normal Elf64_Sym instead.
	#if defined(ANDROID_X86_64_LINKER) && defined(__native_client__)
	typedef struct {
	Elf64_Word st_name;
	unsigned char st_info;
	unsigned char st_other;
	Elf64_Half st_shndx;
	// Put lower bits first because we are little endian.
	unsigned st_value;
	// We will not fill this field, so this will be initialized to zero.
	unsigned st_value_padding;
	Elf64_Xword st_size;
	} Elf64_Sym_NaCl;

	// Static assertions for the layout of Elf64_Sym_NaCl.
	#define STATIC_ASSERT(cond, name) \
	struct StaticAssert_ ## name { char name[(cond) ? 1 : -1]; }
	STATIC_ASSERT(sizeof(Elf64_Sym_NaCl) == sizeof(Elf64_Sym),
	SizeOf_Elf64_Sym_NaCl);
	STATIC_ASSERT(offsetof(Elf64_Sym_NaCl, st_value) ==
	offsetof(Elf64_Sym, st_value),
	OffsetOf_st_value);
	STATIC_ASSERT(offsetof(Elf64_Sym_NaCl, st_size) ==
	offsetof(Elf64_Sym, st_size),
	OffsetOf_st_size);

	// Remove map from Elf32_Addr to Elf64_Addr defined in linker.h.
	#undef Elf32_Addr

	static Elf64_Sym_NaCl libdl_symtab[] =
	#else
	static Elf32_Sym libdl_symtab[] =
	#endif
	{
	// NACL MOD END
	// 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,
	},
	{ st_name: 29,
	st_value: (Elf32_Addr) &dladdr,
	st_info: STB_GLOBAL << 4,
	st_shndx: 1,
	},
	#ifdef ANDROID_ARM_LINKER
	{ st_name: 36,
	st_value: (Elf32_Addr) &dl_unwind_find_exidx,
	st_info: STB_GLOBAL << 4,
	st_shndx: 1,
	},
	// NACL MOD BEGIN
	// Added dl_iterate_phdr for arm.
	{ st_name: 57,
	st_value: (Elf32_Addr) &dl_iterate_phdr,
	st_info: STB_GLOBAL << 4,
	st_shndx: 1,
	},
	{ st_name: 73,
	st_value: (Elf32_Addr) &dl_irt_ptr,
	st_info: STB_GLOBAL << 4,
	st_shndx: 1,
	},
	// Add x86-64 support.
	#elif defined(ANDROID_X86_LINKER) \|\| defined(ANDROID_MIPS_LINKER) \
	\|\| defined(ANDROID_X86_64_LINKER)
	// NACL MOD END
	{ st_name: 36,
	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 };
	// NACL MOD BEGIN
	// Size now varies because dl_iterate_phdr has been added for arm.
	#ifdef ANDROID_ARM_LINKER
	static unsigned libdl_chains[9] = { 0, 2, 3, 4, 5, 6, 7, 8, 0 };
	#else
	static unsigned libdl_chains[7] = { 0, 2, 3, 4, 5, 6, 7, 0 };
	#endif
	// NACL MOD END

	soinfo libdl_info = {
	name: "libdl.so",
	flags: FLAG_LINKED,

	strtab: ANDROID_LIBDL_STRTAB,
	// NACL MOD BEGIN
	// Add a cast to convert Elf64_Sym_NaCl* to Elf32_Sym* (note that
	// Elf32_Sym is mapped to Elf64_Sym on x86-64).
	symtab: (Elf32_Sym *)libdl_symtab,
	// NACL MOD END

	nbucket: 1,
	// NACL MOD BEGIN
	// Allow size to vary because dl_iterate_phdr has been added for arm.
	nchain: sizeof(libdl_chains) / sizeof(*libdl_chains) - 1,
	// NACL MOD END
	bucket: libdl_buckets,
	chain: libdl_chains,
	};