--- libmalloc/libmalloc-521.100.59/tests/malloc_realloc_large.c
+++ libmalloc/libmalloc-792.80.2/tests/malloc_realloc_large.c
@@ -39,7 +39,7 @@
 }
 
 T_DECL(realloc_large_huge, "call realloc on LARGE and HUGE allocations",
-		T_META_TAG_XZONE_ONLY)
+		T_META_TAG_XZONE_ONLY, T_META_TAG_VM_PREFERRED)
 {
 	// Large allocation shrink in place
 	size_t size1 = LARGE_BLOCK_SIZE_MAX;
@@ -49,7 +49,14 @@
 	void *ptr2 = realloc(ptr1, size2);
 	T_ASSERT_TRUE(memchk(ptr2, 'A', size2), "contents unchanged after realloc");
 	T_ASSERT_LE(size2, malloc_size(ptr2), "realloc LARGE smaller");
-	T_ASSERT_EQ(ptr1, ptr2, "realloc LARGE smaller in-place");
+
+	bool has_sanitizer = false;
+#if CONFIG_SANITIZER
+	has_sanitizer = malloc_sanitizer_is_enabled();
+#endif
+	if (!has_sanitizer) {
+		T_ASSERT_EQ(ptr1, ptr2, "realloc LARGE smaller in-place");
+	}
 	free(ptr2);
 
 	// Large allocation grow in place
@@ -73,7 +80,12 @@
 	T_ASSERT_TRUE(memchk(ptr2, 'C', size2), "contents unchanged after realloc");
 	T_ASSERT_LE(size2, malloc_size(ptr2),
 			"realloc HUGE smaller");
+
+#if MALLOC_TARGET_EXCLAVES
+	T_LOG("exclaves don't support resizing mappings, skipping realloc in-place");
+#else
 	T_ASSERT_EQ(ptr1, ptr2, "realloc HUGE smaller in-place");
+#endif // !MALLOC_TARGET_EXCLAVES
 	free(ptr2);
 
 	// Huge allocation grow in place
@@ -111,7 +123,6 @@
 	T_ASSERT_TRUE(memchk(ptr2, 'E', size2), "contents unchanged after realloc");
 	T_ASSERT_LE(size2, malloc_size(ptr2),
 			"realloc LARGE aligned");
-	T_ASSERT_NE(ptr1, ptr2, "realloc aligned allocation not in-place");
 	free(ptr2);
 
 	// Large allocation to huge reallocation
@@ -150,9 +161,37 @@
 	free(ptr2);
 }
 
+#if CONFIG_MTE
+// TODO: support for tagging large allocations
+#if 0
+T_DECL(realloc_grow_in_place_with_mte,
+		"Ensure tags are extended when growing in-place",
+		T_META_TAG_XZONE_ONLY,
+		T_META_ENVVAR("MallocTagAllInternal=1"))
+{
+	// Large allocation grow in place
+	size_t size1 = LARGE_BLOCK_SIZE_MAX / 4;
+	size_t size2 = LARGE_BLOCK_SIZE_MAX / 2;
+	void *ptr1 = malloc(size1);
+	memset(ptr1, 'B', size1);
+	void *ptr2 = realloc(ptr1, size2);
+
+	// realloc() should be in-place, but we can't guarantee it, so we cannot do
+	// `T_ASSERT_EQ(ptr1, ptr2)` here
+	T_ASSERT_TRUE(memchk(ptr2, 'B', size1),
+			"contents unchanged after realloc, before: %p, after: %p", ptr1, ptr2);
+	T_ASSERT_LE(size2, malloc_size(ptr2), "realloc LARGE larger");
+	// MTE tags for extended space have been updated
+	memset(ptr2, 'C', size2);
+	T_ASSERT_TRUE(memchk(ptr2, 'C', size2), "extra space is properly tagged");
+	free(ptr2);
+}
+#endif
+#endif
+
 T_DECL(realloc_overlap_mmap,
 		"Make sure that realloc in place doesn't overwrite existing mmap",
-		T_META_TAG_XZONE_ONLY)
+		T_META_TAG_XZONE_ONLY, T_META_TAG_VM_PREFERRED)
 {
 	// Allocate a huge buffer
 	void *ptr = malloc(LARGE_BLOCK_SIZE_MAX * 2);
@@ -160,6 +199,17 @@
 
 	// mmap some anonymous memory just past the end of that allocation
 	void *map_addr = (void*)((uintptr_t)ptr + LARGE_BLOCK_SIZE_MAX * 3);
+#if MALLOC_TARGET_EXCLAVES
+	plat_map_t plat_map = { 0 };
+	_liblibc_map_type_t type = LIBLIBC_MAP_TYPE_PRIVATE |
+			LIBLIBC_MAP_TYPE_FIXED | LIBLIBC_MAP_TYPE_NORAND;
+	// liblibc errors if you try to mmap with PROT_NONE
+	void *map = mmap_plat(&plat_map, (uintptr_t)map_addr, LARGE_BLOCK_SIZE_MAX,
+			PROT_READ, type, 0, 0);
+	if (map == NULL) {
+		T_SKIP("VM isn't setup to mmap after the huge allocation");
+	}
+#else // MALLOC_TARGET_EXCLAVES
 	void *map = mmap(map_addr, LARGE_BLOCK_SIZE_MAX, PROT_NONE, MAP_ANON | MAP_PRIVATE, 0, 0);
 	if (map == MAP_FAILED || map != map_addr) {
 		// Couldn't map memory just past the end of the huge allocation, due to
@@ -171,6 +221,7 @@
 		// test if we get really unlucky here.
 		T_SKIP("VM isn't setup to mmap after the huge allocation");
 	}
+#endif // MALLOC_TARGET_EXCLAVES
 
 	T_ASSERT_EQ(map_addr, map, "mmap'd at expected address");
 
@@ -180,5 +231,10 @@
 	T_ASSERT_NE(ptr2, ptr, "realloc overwrote existing mmap");
 	memset(ptr2, 0xaa, LARGE_BLOCK_SIZE_MAX * 4);
 	free(ptr2);
+
+#if MALLOC_TARGET_EXCLAVES
+	munmap_plat(&plat_map, map, LARGE_BLOCK_SIZE_MAX);
+#else
 	munmap(map, LARGE_BLOCK_SIZE_MAX);
-}
+#endif // MALLOC_TARGET_EXCLAVES
+}