Enable MSAN support again (#46348)

Keno · web-flow · commit beb3ab4e5260 · 2022-08-19T16:02:51.000-04:00
Analogous to (and dependent on) #46336, but for msan. The biggest change is a workaround for LLVM's lack for TLS relocation support (I had a fix for that about 7 years ago at https://reviews.llvm.org/D8815, but that was x86_64-linux-gnu only, while this workaround works everywhere - though we should consider resurrecting my patch for performance at some point). The rest is mostly build fixes and plumbing to get the sanitizer flags through to the dependencies.
diff --git a/cli/loader_exe.c b/cli/loader_exe.c
@@ -36,7 +36,7 @@ int main(int argc, char * argv[])
 {
 #endif
 
-#if defined(_COMPILER_ASAN_ENABLED_) || defined(_COMPILER_TSAN_ENABLED_)
+#if defined(_COMPILER_ASAN_ENABLED_) || defined(_COMPILER_TSAN_ENABLED_) || defined(_COMPILER_MSAN_ENABLED_)
     // ASAN/TSAN do not support RTLD_DEEPBIND
     // https://github.com/google/sanitizers/issues/611
     putenv("LBT_USE_RTLD_DEEPBIND=0");
diff --git a/deps/blastrampoline.mk b/deps/blastrampoline.mk
@@ -11,7 +11,7 @@ $(BUILDDIR)/$(BLASTRAMPOLINE_SRC_DIR)/build-configured: $(BUILDDIR)/$(BLASTRAMPO
 	echo 1 > $@
 
 $(BUILDDIR)/$(BLASTRAMPOLINE_SRC_DIR)/build-compiled: $(BUILDDIR)/$(BLASTRAMPOLINE_SRC_DIR)/build-configured
-	cd $(dir $@)/src && $(MAKE) $(MAKE_COMMON)
+	cd $(dir $@)/src && $(MAKE) $(MAKE_COMMON) CC="$(CC) $(SANITIZE_OPTS)"
 	echo 1 > $@
 
 define BLASTRAMPOLINE_INSTALL
diff --git a/deps/dsfmt.mk b/deps/dsfmt.mk
@@ -3,7 +3,7 @@ include $(SRCDIR)/dsfmt.version
 
 ifneq ($(USE_BINARYBUILDER_DSFMT),1)
 
-DSFMT_CFLAGS := $(CFLAGS) -DNDEBUG -DDSFMT_MEXP=19937 $(fPIC) -DDSFMT_DO_NOT_USE_OLD_NAMES -DDSFMT_SHLIB
+DSFMT_CFLAGS := $(CFLAGS) -DNDEBUG -DDSFMT_MEXP=19937 $(fPIC) -DDSFMT_DO_NOT_USE_OLD_NAMES -DDSFMT_SHLIB $(SANITIZE_OPTS)
 DSFMT_CFLAGS += -O3 -finline-functions -fomit-frame-pointer -fno-strict-aliasing \
 		--param max-inline-insns-single=1800 -Wall  -std=c99 -shared
 ifeq ($(ARCH), x86_64)
diff --git a/deps/libsuitesparse.mk b/deps/libsuitesparse.mk
@@ -22,11 +22,11 @@ SUITESPARSE_LIB := $(LDFLAGS) -L"$(abspath $(BUILDDIR))/SuiteSparse-$(LIBSUITESP
 ifeq ($(OS), Darwin)
 SUITESPARSE_LIB += $(RPATH_ESCAPED_ORIGIN)
 endif
-LIBSUITESPARSE_MFLAGS := CC="$(CC)" CXX="$(CXX)" F77="$(FC)" \
+LIBSUITESPARSE_MFLAGS := CC="$(CC) $(SANITIZE_OPTS)" CXX="$(CXX) $(SANITIZE_OPTS)" F77="$(FC)" \
 	  AR="$(AR)" RANLIB="$(RANLIB)" \
 	  BLAS="-L$(build_shlibdir) -lblastrampoline" \
 	  LAPACK="-L$(build_shlibdir) -lblastrampoline" \
-	  LDFLAGS="$(SUITESPARSE_LIB)" CFOPENMP="" CUDA=no CUDA_PATH="" \
+	  LDFLAGS="$(SUITESPARSE_LIB) $(SANITIZE_LDFLAGS) -Wl,--warn-unresolved-symbols" CFOPENMP="" CUDA=no CUDA_PATH="" \
 	  UMFPACK_CONFIG="$(UMFPACK_CONFIG)" \
 	  CHOLMOD_CONFIG="$(CHOLMOD_CONFIG)" \
 	  SPQR_CONFIG="$(SPQR_CONFIG)"
diff --git a/deps/llvm.mk b/deps/llvm.mk
@@ -147,7 +147,7 @@ endif
 ifeq ($(LLVM_SANITIZE),1)
 ifeq ($(SANITIZE_MEMORY),1)
 LLVM_CFLAGS += -fsanitize=memory -fsanitize-memory-track-origins
-LLVM_LDFLAGS += -fsanitize=memory -fsanitize-memory-track-origins
+LLVM_LDFLAGS += -fsanitize=memory -fsanitize-memory-track-origins -rpath $(build_shlibdir)
 LLVM_CXXFLAGS += -fsanitize=memory -fsanitize-memory-track-origins
 LLVM_CMAKE += -DLLVM_USE_SANITIZER="MemoryWithOrigins"
 endif
diff --git a/deps/openblas.mk b/deps/openblas.mk
@@ -5,7 +5,7 @@ OPENBLAS_GIT_URL := https://github.com/xianyi/OpenBLAS.git
 OPENBLAS_TAR_URL = https://api.github.com/repos/xianyi/OpenBLAS/tarball/$1
 $(eval $(call git-external,openblas,OPENBLAS,,,$(BUILDDIR)))
 
-OPENBLAS_BUILD_OPTS := CC="$(CC)" FC="$(FC)" LD="$(LD)" RANLIB="$(RANLIB)" TARGET=$(OPENBLAS_TARGET_ARCH) BINARY=$(BINARY)
+OPENBLAS_BUILD_OPTS := CC="$(CC) $(SANITIZE_OPTS)" FC="$(FC) $(SANITIZE_OPTS) -L/home/keno/julia-msan/usr/lib" LD="$(LD) $(SANITIZE_LDFLAGS)" RANLIB="$(RANLIB)" BINARY=$(BINARY)
 
 # Thread support
 ifeq ($(OPENBLAS_USE_THREAD), 1)
@@ -21,9 +21,14 @@ endif
 OPENBLAS_BUILD_OPTS += NO_AFFINITY=1
 
 # Build for all architectures - required for distribution
+ifeq ($(SANITIZE_MEMORY),1)
+OPENBLAS_BUILD_OPTS += TARGET=GENERIC
+else
+OPENBLAS_BUILD_OPTS += TARGET=$(OPENBLAS_TARGET_ARCH)
 ifeq ($(OPENBLAS_DYNAMIC_ARCH), 1)
 OPENBLAS_BUILD_OPTS += DYNAMIC_ARCH=1
 endif
+endif
 
 # 64-bit BLAS interface
 ifeq ($(USE_BLAS64), 1)
diff --git a/deps/tools/common.mk b/deps/tools/common.mk
@@ -11,9 +11,9 @@ endif
 ifeq ($(OS),WINNT)
 CONFIGURE_COMMON += LDFLAGS="$(LDFLAGS) -Wl,--stack,8388608"
 else
-CONFIGURE_COMMON += LDFLAGS="$(LDFLAGS) $(RPATH_ESCAPED_ORIGIN)"
+CONFIGURE_COMMON += LDFLAGS="$(LDFLAGS) $(RPATH_ESCAPED_ORIGIN) $(SANITIZE_LDFLAGS)"
 endif
-CONFIGURE_COMMON += F77="$(FC)" CC="$(CC)" CXX="$(CXX)" LD="$(LD)"
+CONFIGURE_COMMON += F77="$(FC)" CC="$(CC) $(SANITIZE_OPTS)" CXX="$(CXX) $(SANITIZE_OPTS)" LD="$(LD)"
 
 CMAKE_CC_ARG := $(CC_ARG)
 CMAKE_CXX_ARG := $(CXX_ARG)
@@ -30,11 +30,11 @@ endif
 # The call to which here is to work around https://cmake.org/Bug/view.php?id=14366
 CMAKE_COMMON += -DCMAKE_C_COMPILER="$$(which $(CC_BASE))"
 ifneq ($(strip $(CMAKE_CC_ARG)),)
-CMAKE_COMMON += -DCMAKE_C_COMPILER_ARG1="$(CMAKE_CC_ARG)"
+CMAKE_COMMON += -DCMAKE_C_COMPILER_ARG1="$(CMAKE_CC_ARG) $(SANITIZE_OPTS)"
 endif
 CMAKE_COMMON += -DCMAKE_CXX_COMPILER="$(CXX_BASE)"
 ifneq ($(strip $(CMAKE_CXX_ARG)),)
-CMAKE_COMMON += -DCMAKE_CXX_COMPILER_ARG1="$(CMAKE_CXX_ARG)"
+CMAKE_COMMON += -DCMAKE_CXX_COMPILER_ARG1="$(CMAKE_CXX_ARG) $(SANITIZE_OPTS)"
 endif
 CMAKE_COMMON += -DCMAKE_LINKER="$$(which $(LD))" -DCMAKE_AR="$$(which $(AR))" -DCMAKE_RANLIB="$$(which $(RANLIB))"
 
diff --git a/deps/unwind.mk b/deps/unwind.mk
@@ -3,7 +3,7 @@ include $(SRCDIR)/unwind.version
 include $(SRCDIR)/llvmunwind.version
 
 ifneq ($(USE_BINARYBUILDER_LIBUNWIND),1)
-LIBUNWIND_CFLAGS := -U_FORTIFY_SOURCE $(fPIC) -lz
+LIBUNWIND_CFLAGS := -U_FORTIFY_SOURCE $(fPIC) -lz $(SANITIZE_OPTS)
 LIBUNWIND_CPPFLAGS :=
 
 ifeq ($(USE_SYSTEM_ZLIB),0)
diff --git a/deps/utf8proc.mk b/deps/utf8proc.mk
@@ -5,7 +5,7 @@ $(eval $(call git-external,utf8proc,UTF8PROC,,,$(BUILDDIR)))
 
 UTF8PROC_OBJ_LIB    := $(build_libdir)/libutf8proc.a
 UTF8PROC_OBJ_HEADER := $(build_includedir)/utf8proc.h
-UTF8PROC_CFLAGS     := -O2
+UTF8PROC_CFLAGS     := -O2 $(SANITIZE_OPTS)
 UTF8PROC_MFLAGS     := CC="$(CC)" CFLAGS="$(CFLAGS) $(UTF8PROC_CFLAGS)" PICFLAG="$(fPIC)" AR="$(AR)"
 UTF8PROC_BUILDDIR   := $(BUILDDIR)/$(UTF8PROC_SRC_DIR)
 
diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
@@ -27,6 +27,7 @@
 #include <llvm/Transforms/Scalar.h>
 #include <llvm/Transforms/Vectorize.h>
 #include <llvm/Transforms/Instrumentation/AddressSanitizer.h>
+#include <llvm/Transforms/Instrumentation/MemorySanitizer.h>
 #include <llvm/Transforms/Instrumentation/ThreadSanitizer.h>
 #include <llvm/Transforms/Scalar/GVN.h>
 #include <llvm/Transforms/IPO/AlwaysInliner.h>
@@ -737,7 +738,7 @@ void addOptimizationPasses(legacy::PassManagerBase *PM, int opt_level,
         PM->add(createAddressSanitizerFunctionPass());
 #endif
 #if defined(_COMPILER_MSAN_ENABLED_)
-        PM->add(createMemorySanitizerPass(true));
+        PM->add(createMemorySanitizerLegacyPassPass());
 #endif
 #if defined(_COMPILER_TSAN_ENABLED_)
         PM->add(createThreadSanitizerLegacyPassPass());
@@ -892,7 +893,7 @@ void addOptimizationPasses(legacy::PassManagerBase *PM, int opt_level,
     PM->add(createAddressSanitizerFunctionPass());
 #endif
 #if defined(_COMPILER_MSAN_ENABLED_)
-    PM->add(createMemorySanitizerPass(true));
+    PM->add(createMemorySanitizerLegacyPassPass());
 #endif
 #if defined(_COMPILER_TSAN_ENABLED_)
     PM->add(createThreadSanitizerLegacyPassPass());
diff --git a/src/cgmemmgr.cpp b/src/cgmemmgr.cpp
@@ -856,8 +856,11 @@ uint8_t *RTDyldMemoryManagerJL::allocateCodeSection(uintptr_t Size,
                                                     StringRef SectionName)
 {
     // allocating more than one code section can confuse libunwind.
+#if defined(_COMPILER_MSAN_ENABLED_)
+    // TODO: Figure out why msan needs this.
     assert(!code_allocated);
     code_allocated = true;
+#endif
     total_allocated += Size;
     if (exe_alloc)
         return (uint8_t*)exe_alloc->alloc(Size, Alignment);
diff --git a/src/codegen.cpp b/src/codegen.cpp
@@ -6,7 +6,7 @@
 #if defined(_CPU_X86_)
 #define JL_NEED_FLOATTEMP_VAR 1
 #endif
-#if defined(_OS_WINDOWS_) || defined(_OS_FREEBSD_)
+#if defined(_OS_WINDOWS_) || defined(_OS_FREEBSD_) || defined(_COMPILER_MSAN_ENABLED_)
 #define JL_DISABLE_FPO
 #endif
 
@@ -2120,6 +2120,9 @@ static void jl_init_function(Function *F)
 #if defined(_COMPILER_ASAN_ENABLED_)
     attr.addAttribute(Attribute::SanitizeAddress);
 #endif
+#if defined(_COMPILER_MSAN_ENABLED_)
+    attr.addAttribute(Attribute::SanitizeMemory);
+#endif
 #if JL_LLVM_VERSION >= 140000
     F->addFnAttrs(attr);
 #else
diff --git a/src/debuginfo.cpp b/src/debuginfo.cpp
@@ -1067,6 +1067,15 @@ bool jl_dylib_DI_for_fptr(size_t pointer, object::SectionRef *Section, int64_t *
 #ifdef __GLIBC__
     struct link_map *extra_info;
     dladdr_success = dladdr1((void*)pointer, &dlinfo, (void**)&extra_info, RTLD_DL_LINKMAP) != 0;
+    if (dladdr_success) {
+        msan_unpoison(&dlinfo, sizeof(dlinfo));
+        if (dlinfo.dli_fname)
+            msan_unpoison_string(dlinfo.dli_fname);
+        if (dlinfo.dli_sname)
+            msan_unpoison_string(dlinfo.dli_sname);
+        msan_unpoison(&extra_info, sizeof(struct link_map*));
+        msan_unpoison(extra_info, sizeof(struct link_map));
+    }
 #else
 #ifdef _OS_DARWIN_
     // On macOS 12, dladdr(-1, …) succeeds and returns the main executable image,
diff --git a/src/dlload.c b/src/dlload.c
@@ -115,7 +115,7 @@ static inline uintptr_t RoundUpTo(uintptr_t size, uintptr_t boundary) {
 static inline uintptr_t RoundDownTo(uintptr_t x, uintptr_t boundary) {
   return x & ~(boundary - 1);
 }
-void ForEachMappedRegion(struct link_map *map, void (*cb)(const void *, uintptr_t)) {
+void ForEachMappedRegion(struct link_map *map, void (*cb)(const volatile void *, uintptr_t)) {
 #if !defined(_OS_FREEBSD_)
   typedef ElfW(Phdr) Elf_Phdr;
   typedef ElfW(Ehdr) Elf_Ehdr;
@@ -207,7 +207,7 @@ JL_DLLEXPORT JL_NO_SANITIZE void *jl_dlopen(const char *filename, unsigned flags
 #endif
                   );
 #if defined(_COMPILER_MSAN_ENABLED_) && defined(__GLIBC__)
-    link_map *map = (link_map*)handle;
+    struct link_map *map = (struct link_map*)hnd;
     if (filename && map)
       ForEachMappedRegion(map, __msan_unpoison);
 #endif
diff --git a/src/gc-pages.c b/src/gc-pages.c
@@ -316,6 +316,10 @@ void jl_gc_free_page(void *p) JL_NOTSAFEPOINT
 #else
     madvise(p, decommit_size, MADV_DONTNEED);
 #endif
+    /* TODO: Should we leave this poisoned and rather allow the GC to read poisoned pointers from
+     *       the page when it sweeps pools?
+     */
+    msan_unpoison(p, decommit_size);
 
 no_decommit:
     // new pages are now available starting at max of lb and pagetable_i32
diff --git a/src/gc.c b/src/gc.c
@@ -1275,6 +1275,7 @@ static inline jl_value_t *jl_gc_pool_alloc_inner(jl_ptls_t ptls, int pool_offset
             pg->nfree = 0;
             pg->has_young = 1;
         }
+        msan_allocated_memory(v, osize);
         return jl_valueof(v);
     }
     // if the freelist is empty we reuse empty but not freed pages
@@ -1299,6 +1300,7 @@ static inline jl_value_t *jl_gc_pool_alloc_inner(jl_ptls_t ptls, int pool_offset
         next = (jl_taggedvalue_t*)((char*)v + osize);
     }
     p->newpages = next;
+    msan_allocated_memory(v, osize);
     return jl_valueof(v);
 }
 
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
@@ -52,6 +52,58 @@ using namespace llvm;
 # include <llvm/ExecutionEngine/SectionMemoryManager.h>
 #endif
 
+#ifdef _COMPILER_MSAN_ENABLED_
+// TODO: This should not be necessary on ELF x86_64, but LLVM's implementation
+// of the TLS relocations is currently broken, so enable this unconditionally.
+#define MSAN_EMUTLS_WORKAROUND 1
+
+// See https://github.com/google/sanitizers/wiki/MemorySanitizerJIT
+namespace msan_workaround {
+
+extern "C" {
+    extern __thread unsigned long long __msan_param_tls[];
+    extern __thread unsigned int __msan_param_origin_tls[];
+    extern __thread unsigned long long __msan_retval_tls[];
+    extern __thread unsigned int __msan_retval_origin_tls;
+    extern __thread unsigned long long __msan_va_arg_tls[];
+    extern __thread unsigned int __msan_va_arg_origin_tls[];
+    extern __thread unsigned long long __msan_va_arg_overflow_size_tls;
+    extern __thread unsigned int __msan_origin_tls;
+}
+
+enum class MSanTLS
+{
+	param = 1,             // __msan_param_tls
+	param_origin,          //__msan_param_origin_tls
+	retval,                // __msan_retval_tls
+	retval_origin,         //__msan_retval_origin_tls
+	va_arg,                // __msan_va_arg_tls
+	va_arg_origin,         // __msan_va_arg_origin_tls
+	va_arg_overflow_size,  // __msan_va_arg_overflow_size_tls
+	origin,                //__msan_origin_tls
+};
+
+static void *getTLSAddress(void *control)
+{
+	auto tlsIndex = static_cast<MSanTLS>(reinterpret_cast<uintptr_t>(control));
+	switch(tlsIndex)
+	{
+	case MSanTLS::param: return reinterpret_cast<void *>(&__msan_param_tls);
+	case MSanTLS::param_origin: return reinterpret_cast<void *>(&__msan_param_origin_tls);
+	case MSanTLS::retval: return reinterpret_cast<void *>(&__msan_retval_tls);
+	case MSanTLS::retval_origin: return reinterpret_cast<void *>(&__msan_retval_origin_tls);
+	case MSanTLS::va_arg: return reinterpret_cast<void *>(&__msan_va_arg_tls);
+	case MSanTLS::va_arg_origin: return reinterpret_cast<void *>(&__msan_va_arg_origin_tls);
+	case MSanTLS::va_arg_overflow_size: return reinterpret_cast<void *>(&__msan_va_arg_overflow_size_tls);
+	case MSanTLS::origin: return reinterpret_cast<void *>(&__msan_origin_tls);
+	default:
+		assert(false && "BAD MSAN TLS INDEX");
+		return nullptr;
+	}
+}
+}
+#endif
+
 #define DEBUG_TYPE "jitlayers"
 
 // Snooping on which functions are being compiled, and how long it takes
@@ -823,6 +875,11 @@ namespace {
         // LLVM defaults to tls stack guard, which causes issues with Julia's tls implementation
         options.StackProtectorGuard = StackProtectorGuards::Global;
 #endif
+#if defined(MSAN_EMUTLS_WORKAROUND)
+        options.EmulatedTLS = true;
+        options.ExplicitEmulatedTLS = true;
+#endif
+
         Triple TheTriple(sys::getProcessTriple());
 #if defined(FORCE_ELF)
         TheTriple.setObjectFormat(Triple::ELF);
@@ -1135,6 +1192,28 @@ JuliaOJIT::JuliaOJIT()
         { mangle("__truncdfhf2"),   { mangle("julia__truncdfhf2"),   JITSymbolFlags::Exported } }
     };
     cantFail(GlobalJD.define(orc::symbolAliases(jl_crt)));
+
+#ifdef MSAN_EMUTLS_WORKAROUND
+    orc::SymbolMap msan_crt;
+    msan_crt[mangle("__emutls_get_address")] = JITEvaluatedSymbol::fromPointer(msan_workaround::getTLSAddress, JITSymbolFlags::Exported);
+    msan_crt[mangle("__emutls_v.__msan_param_tls")] = JITEvaluatedSymbol::fromPointer(
+        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::param)), JITSymbolFlags::Exported);
+    msan_crt[mangle("__emutls_v.__msan_param_origin_tls")] = JITEvaluatedSymbol::fromPointer(
+        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::param_origin)), JITSymbolFlags::Exported);
+    msan_crt[mangle("__emutls_v.__msan_retval_tls")] = JITEvaluatedSymbol::fromPointer(
+        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::retval)), JITSymbolFlags::Exported);
+    msan_crt[mangle("__emutls_v.__msan_retval_origin_tls")] = JITEvaluatedSymbol::fromPointer(
+        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::retval_origin)), JITSymbolFlags::Exported);
+    msan_crt[mangle("__emutls_v.__msan_va_arg_tls")] = JITEvaluatedSymbol::fromPointer(
+        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::va_arg)), JITSymbolFlags::Exported);
+    msan_crt[mangle("__emutls_v.__msan_va_arg_origin_tls")] = JITEvaluatedSymbol::fromPointer(
+        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::va_arg_origin)), JITSymbolFlags::Exported);
+    msan_crt[mangle("__emutls_v.__msan_va_arg_overflow_size_tls")] = JITEvaluatedSymbol::fromPointer(
+        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::va_arg_overflow_size)), JITSymbolFlags::Exported);
+    msan_crt[mangle("__emutls_v.__msan_origin_tls")] = JITEvaluatedSymbol::fromPointer(
+        reinterpret_cast<void *>(static_cast<uintptr_t>(msan_workaround::MSanTLS::origin)), JITSymbolFlags::Exported);
+    cantFail(GlobalJD.define(orc::absoluteSymbols(msan_crt)));
+#endif
 }
 
 orc::SymbolStringPtr JuliaOJIT::mangle(StringRef Name)
diff --git a/src/julia_internal.h b/src/julia_internal.h
@@ -65,6 +65,24 @@ static inline void asan_unpoison_stack_memory(uintptr_t addr, size_t size) {
 static inline void asan_unpoison_task_stack(jl_task_t *ct, jl_jmp_buf *buf) JL_NOTSAFEPOINT {}
 static inline void asan_unpoison_stack_memory(uintptr_t addr, size_t size) JL_NOTSAFEPOINT {}
 #endif
+#ifdef _COMPILER_MSAN_ENABLED_
+void __msan_unpoison(const volatile void *a, size_t size) JL_NOTSAFEPOINT;
+void __msan_allocated_memory(const volatile void *a, size_t size) JL_NOTSAFEPOINT;
+void __msan_unpoison_string(const volatile char *a) JL_NOTSAFEPOINT;
+static inline void msan_allocated_memory(const volatile void *a, size_t size) JL_NOTSAFEPOINT {
+    __msan_allocated_memory(a, size);
+}
+static inline void msan_unpoison(const volatile void *a, size_t size) JL_NOTSAFEPOINT {
+    __msan_unpoison(a, size);
+}
+static inline void msan_unpoison_string(const volatile char *a) JL_NOTSAFEPOINT {
+    __msan_unpoison_string(a);
+}
+#else
+static inline void msan_unpoison(const volatile void *a, size_t size) JL_NOTSAFEPOINT {}
+static inline void msan_allocated_memory(const volatile void *a, size_t size) JL_NOTSAFEPOINT {}
+static inline void msan_unpoison_string(const volatile char *a) JL_NOTSAFEPOINT {}
+#endif
 #ifdef _COMPILER_TSAN_ENABLED_
 void *__tsan_create_fiber(unsigned flags);
 void *__tsan_get_current_fiber(void);
diff --git a/src/options.h b/src/options.h
@@ -166,8 +166,12 @@
 // sanitizer defaults ---------------------------------------------------------
 
 // Automatically enable MEMDEBUG and KEEP_BODIES for the sanitizers
-#if defined(_COMPILER_ASAN_ENABLED_) || defined(_COMPILER_MSAN_ENABLED_)
+#if defined(_COMPILER_ASAN_ENABLED_)
+// No MEMDEBUG for msan - we just poison allocated memory directly.
 #define MEMDEBUG
+#endif
+
+#if defined(_COMPILER_ASAN_ENABLED_) || defined(_COMPILER_MSAN_ENABLED_)
 #define KEEP_BODIES
 #endif
 
diff --git a/src/support/platform.h b/src/support/platform.h
@@ -56,7 +56,7 @@
 #if __has_feature(memory_sanitizer)
 #define _COMPILER_MSAN_ENABLED_
 #undef JL_NO_MSAN
-#define JL_NO_MSAN __attribute__((no_sanitize("mempry")))
+#define JL_NO_MSAN __attribute__((no_sanitize("memory")))
 #endif
 #if __has_feature(thread_sanitizer)
 #if __clang_major__ < 11

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ int main(int argc, char * argv[])`
`36`	`36`	`{`
`37`	`37`	`#endif`
`38`	`38`
`39`		`-#if defined(_COMPILER_ASAN_ENABLED_) \|\| defined(_COMPILER_TSAN_ENABLED_)`
	`39`	`+#if defined(_COMPILER_ASAN_ENABLED_) \|\| defined(_COMPILER_TSAN_ENABLED_) \|\| defined(_COMPILER_MSAN_ENABLED_)`
`40`	`40`	`// ASAN/TSAN do not support RTLD_DEEPBIND`
`41`	`41`	`// https://github.com/google/sanitizers/issues/611`
`42`	`42`	`putenv("LBT_USE_RTLD_DEEPBIND=0");`