diff --git a/libc/include/dlfcn.h b/libc/include/dlfcn.h
index afa7687..c2e8980 100644
--- a/libc/include/dlfcn.h
+++ b/libc/include/dlfcn.h
@@ -43,11 +43,12 @@
                                in dli_sname */
 } Dl_info;
 
-extern void*        dlopen(const char*  filename, int flag);
-extern int          dlclose(void*  handle);
-extern const char*  dlerror(void);
-extern void*        dlsym(void*  handle, const char*  symbol);
-extern int          dladdr(const void* addr, Dl_info *info);
+extern void* dlopen(const char*  filename, int flag);
+extern int dlclose(void*  handle);
+extern const char* dlerror(void);
+extern void* dlsym(void* handle, const char* symbol) __nonnull((2));
+extern void* dlvsym(void* handle, const char* symbol, const char* version) __nonnull((2, 3));
+extern int dladdr(const void* addr, Dl_info *info);
 
 enum {
 #if defined(__LP64__)
diff --git a/libc/private/bionic_macros.h b/libc/private/bionic_macros.h
index 4f3cf89..4969bd9 100644
--- a/libc/private/bionic_macros.h
+++ b/libc/private/bionic_macros.h
@@ -42,8 +42,8 @@
   (((value) + (alignment) - 1) & ~((alignment) - 1))
 
 #define BIONIC_ROUND_UP_POWER_OF_2(value) \
-  (sizeof(value) == 8) \
+  ((sizeof(value) == 8) \
     ? (1UL << (64 - __builtin_clzl(static_cast<unsigned long>(value)))) \
-    : (1UL << (32 - __builtin_clz(static_cast<unsigned int>(value))))
+    : (1UL << (32 - __builtin_clz(static_cast<unsigned int>(value)))))
 
 #endif // _BIONIC_MACROS_H_
diff --git a/libc/upstream-dlmalloc/malloc.c b/libc/upstream-dlmalloc/malloc.c
index 3c9d36b..a61c0da 100644
--- a/libc/upstream-dlmalloc/malloc.c
+++ b/libc/upstream-dlmalloc/malloc.c
@@ -4822,8 +4822,13 @@
       req = MAX_SIZE_T; /* force downstream failure on overflow */
   }
   mem = dlmalloc(req);
-  if (mem != 0 && calloc_must_clear(mem2chunk(mem)))
-    memset(mem, 0, req);
+  if (mem != 0) {
+    mchunkptr p = mem2chunk(mem);
+    if (calloc_must_clear(p)) {
+      /* Make sure to clear all of the buffer, not just the requested size. */
+      memset(mem, 0, chunksize(p) - overhead_for(p));
+    }
+  }
   return mem;
 }
 
diff --git a/libdl/libdl.arm.map b/libdl/libdl.arm.map
index 5ad9f9d..b9e494a 100644
--- a/libdl/libdl.arm.map
+++ b/libdl/libdl.arm.map
@@ -18,6 +18,7 @@
   global:
     android_init_namespaces;
     android_create_namespace;
+    dlvsym;
 } LIBC;
 
 LIBC_PRIVATE {
diff --git a/libdl/libdl.arm64.map b/libdl/libdl.arm64.map
index 3535774..a8c98da 100644
--- a/libdl/libdl.arm64.map
+++ b/libdl/libdl.arm64.map
@@ -17,6 +17,7 @@
   global:
     android_init_namespaces;
     android_create_namespace;
+    dlvsym;
 } LIBC;
 
 LIBC_PRIVATE {
diff --git a/libdl/libdl.c b/libdl/libdl.c
index af2f83e..0604d3e 100644
--- a/libdl/libdl.c
+++ b/libdl/libdl.c
@@ -24,9 +24,17 @@
 // in the dynamic linker and hijacked at runtime.
 
 void* dlopen(const char* filename __unused, int flag __unused) { return 0; }
+
 const char* dlerror(void) { return 0; }
+
 void* dlsym(void* handle __unused, const char* symbol __unused) { return 0; }
+
+void* dlvsym(void* handle __unused, const char* symbol __unused, const char* version __unused) {
+  return 0;
+}
+
 int dladdr(const void* addr __unused, Dl_info* info __unused) { return 0; }
+
 int dlclose(void* handle __unused) { return 0; }
 
 #if defined(__arm__)
diff --git a/libdl/libdl.map.txt b/libdl/libdl.map.txt
index 8d123fe..55a03cb 100644
--- a/libdl/libdl.map.txt
+++ b/libdl/libdl.map.txt
@@ -32,6 +32,7 @@
   global:
     android_init_namespaces;
     android_create_namespace;
+    dlvsym;
 } LIBC;
 
 LIBC_PRIVATE {
diff --git a/libdl/libdl.mips.map b/libdl/libdl.mips.map
index 3535774..a8c98da 100644
--- a/libdl/libdl.mips.map
+++ b/libdl/libdl.mips.map
@@ -17,6 +17,7 @@
   global:
     android_init_namespaces;
     android_create_namespace;
+    dlvsym;
 } LIBC;
 
 LIBC_PRIVATE {
diff --git a/libdl/libdl.mips64.map b/libdl/libdl.mips64.map
index 3535774..a8c98da 100644
--- a/libdl/libdl.mips64.map
+++ b/libdl/libdl.mips64.map
@@ -17,6 +17,7 @@
   global:
     android_init_namespaces;
     android_create_namespace;
+    dlvsym;
 } LIBC;
 
 LIBC_PRIVATE {
diff --git a/libdl/libdl.x86.map b/libdl/libdl.x86.map
index 3535774..a8c98da 100644
--- a/libdl/libdl.x86.map
+++ b/libdl/libdl.x86.map
@@ -17,6 +17,7 @@
   global:
     android_init_namespaces;
     android_create_namespace;
+    dlvsym;
 } LIBC;
 
 LIBC_PRIVATE {
diff --git a/libdl/libdl.x86_64.map b/libdl/libdl.x86_64.map
index 3535774..a8c98da 100644
--- a/libdl/libdl.x86_64.map
+++ b/libdl/libdl.x86_64.map
@@ -17,6 +17,7 @@
   global:
     android_init_namespaces;
     android_create_namespace;
+    dlvsym;
 } LIBC;
 
 LIBC_PRIVATE {
diff --git a/linker/dlfcn.cpp b/linker/dlfcn.cpp
index 788a7a0..ba54d39 100644
--- a/linker/dlfcn.cpp
+++ b/linker/dlfcn.cpp
@@ -88,11 +88,10 @@
 
 extern android_namespace_t* g_anonymous_namespace;
 
-void* dlsym(void* handle, const char* symbol) {
-  void* caller_addr = __builtin_return_address(0);
+void* dlsym_impl(void* handle, const char* symbol, const char* version, void* caller_addr) {
   ScopedPthreadMutexLocker locker(&g_dl_mutex);
   void* result;
-  if (!do_dlsym(handle, symbol, nullptr, caller_addr, &result)) {
+  if (!do_dlsym(handle, symbol, version, caller_addr, &result)) {
     __bionic_format_dlerror(linker_get_error_buffer(), nullptr);
     return nullptr;
   }
@@ -100,6 +99,16 @@
   return result;
 }
 
+void* dlsym(void* handle, const char* symbol) {
+  void* caller_addr = __builtin_return_address(0);
+  return dlsym_impl(handle, symbol, nullptr, caller_addr);
+}
+
+void* dlvsym(void* handle, const char* symbol, const char* version) {
+  void* caller_addr = __builtin_return_address(0);
+  return dlsym_impl(handle, symbol, version, caller_addr);
+}
+
 int dladdr(const void* addr, Dl_info* info) {
   ScopedPthreadMutexLocker locker(&g_dl_mutex);
   return do_dladdr(addr, info);
@@ -179,11 +188,11 @@
   // 00000000001 1111111112222222222 3333333333444444444455555555556666666666777 777777788888888889999999999
   // 01234567890 1234567890123456789 0123456789012345678901234567890123456789012 345678901234567890123456789
     "erate_phdr\0android_dlopen_ext\0android_set_application_target_sdk_version\0android_get_application_tar"
-  // 0000000000111111 111122222222223333333333 4444444444555555555566666
-  // 0123456789012345 678901234567890123456789 0123456789012345678901234
-    "get_sdk_version\0android_init_namespaces\0android_create_namespace\0"
+  // 0000000000111111 111122222222223333333333 4444444444555555555566666 6666677
+  // 0123456789012345 678901234567890123456789 0123456789012345678901234 5678901
+    "get_sdk_version\0android_init_namespaces\0android_create_namespace\0dlvsym\0"
 #if defined(__arm__)
-  // 265
+  // 272
     "dl_unwind_find_exidx\0"
 #endif
     ;
@@ -207,8 +216,9 @@
   ELFW(SYM_INITIALIZER)(173, &android_get_application_target_sdk_version, 1),
   ELFW(SYM_INITIALIZER)(216, &android_init_namespaces, 1),
   ELFW(SYM_INITIALIZER)(240, &android_create_namespace, 1),
+  ELFW(SYM_INITIALIZER)(265, &dlvsym, 1),
 #if defined(__arm__)
-  ELFW(SYM_INITIALIZER)(265, &dl_unwind_find_exidx, 1),
+  ELFW(SYM_INITIALIZER)(272, &dl_unwind_find_exidx, 1),
 #endif
 };
 
@@ -225,9 +235,9 @@
 // Note that adding any new symbols here requires stubbing them out in libdl.
 static unsigned g_libdl_buckets[1] = { 1 };
 #if defined(__arm__)
-static unsigned g_libdl_chains[] = { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0 };
+static unsigned g_libdl_chains[] = { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0 };
 #else
-static unsigned g_libdl_chains[] = { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0 };
+static unsigned g_libdl_chains[] = { 0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0 };
 #endif
 
 static uint8_t __libdl_info_buf[sizeof(soinfo)] __attribute__((aligned(8)));
diff --git a/linker/linker.cpp b/linker/linker.cpp
index 99152ed..e38e252 100644
--- a/linker/linker.cpp
+++ b/linker/linker.cpp
@@ -2187,7 +2187,7 @@
     return sym_name;
   }
 
-  return std::string(sym_name) + "@" + sym_ver;
+  return std::string(sym_name) + ", version " + sym_ver;
 }
 
 void do_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) {
@@ -2312,8 +2312,8 @@
   version_info* vi = nullptr;
 
   if (sym_ver != nullptr) {
-    vi_instance.name = sym_name;
-    vi_instance.elf_hash = calculate_elf_hash(sym_name);
+    vi_instance.name = sym_ver;
+    vi_instance.elf_hash = calculate_elf_hash(sym_ver);
     vi = &vi_instance;
   }
 
diff --git a/tests/dlfcn_test.cpp b/tests/dlfcn_test.cpp
index 30eea4a..81479d5 100644
--- a/tests/dlfcn_test.cpp
+++ b/tests/dlfcn_test.cpp
@@ -624,8 +624,10 @@
   handle = dlopen("libtest_with_dependency_loop.so", RTLD_NOW | RTLD_NOLOAD);
   ASSERT_TRUE(handle == nullptr);
 #ifdef __BIONIC__
-  // TODO: glibc returns nullptr on dlerror() here. Is it bug?
   ASSERT_STREQ("dlopen failed: library \"libtest_with_dependency_loop.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror());
+#else
+  // TODO: glibc returns nullptr on dlerror() here. Is it bug?
+  ASSERT_TRUE(dlerror() == nullptr);
 #endif
 
   handle = dlopen("libtest_with_dependency_a.so", RTLD_NOW | RTLD_NOLOAD);
@@ -763,14 +765,6 @@
   ASSERT_STREQ("dlsym failed: library handle is null", dlerror());
 #endif
 
-  // NULL symbol name.
-#if defined(__BIONIC__)
-  // glibc marks this parameter non-null and SEGVs if you cheat.
-  sym = dlsym(self, nullptr);
-  ASSERT_TRUE(sym == nullptr);
-  ASSERT_STREQ("dlsym failed: symbol name is null", dlerror());
-#endif
-
   // Symbol that doesn't exist.
   sym = dlsym(self, "ThisSymbolDoesNotExist");
   ASSERT_TRUE(sym == nullptr);
@@ -1054,6 +1048,26 @@
   dlclose(handle);
 }
 
+TEST(dlfcn, dlvsym_smoke) {
+  void* handle = dlopen("libtest_versioned_lib.so", RTLD_NOW);
+  ASSERT_TRUE(handle != nullptr) << dlerror();
+  typedef int (*fn_t)();
+
+  {
+    fn_t fn = reinterpret_cast<fn_t>(dlvsym(handle, "versioned_function", "nonversion"));
+    ASSERT_TRUE(fn == nullptr);
+    ASSERT_SUBSTR("undefined symbol: versioned_function, version nonversion", dlerror());
+  }
+
+  {
+    fn_t fn = reinterpret_cast<fn_t>(dlvsym(handle, "versioned_function", "TESTLIB_V2"));
+    ASSERT_TRUE(fn != nullptr) << dlerror();
+    ASSERT_EQ(2, fn());
+  }
+
+  dlclose(handle);
+}
+
 // This preempts the implementation from libtest_versioned_lib.so
 extern "C" int version_zero_function() {
   return 0;
diff --git a/tests/malloc_test.cpp b/tests/malloc_test.cpp
index b76625a..5af5a6f 100644
--- a/tests/malloc_test.cpp
+++ b/tests/malloc_test.cpp
@@ -372,3 +372,22 @@
   }
 #endif
 }
+
+TEST(malloc, calloc_usable_size) {
+  for (size_t size = 1; size <= 2048; size++) {
+    void* pointer = malloc(size);
+    ASSERT_TRUE(pointer != nullptr);
+    memset(pointer, 0xeb, malloc_usable_size(pointer));
+    free(pointer);
+
+    // We should get a previous pointer that has been set to non-zero.
+    // If calloc does not zero out all of the data, this will fail.
+    uint8_t* zero_mem = reinterpret_cast<uint8_t*>(calloc(1, size));
+    ASSERT_TRUE(pointer != nullptr);
+    size_t usable_size = malloc_usable_size(zero_mem);
+    for (size_t i = 0; i < usable_size; i++) {
+      ASSERT_EQ(0, zero_mem[i]) << "Failed at allocation size " << size << " at byte " << i;
+    }
+    free(zero_mem);
+  }
+}