[asan, myriad] Use local pool for new/delete when ASan run-time is not up

[waltl]

Summary

This can happen on Myriad RTEMS so needs to be handled.

[waltl]

Let me redo this and resubmit.

[waltl]

Reopening as the updated version only requires a minor tweak.

[waltl]

Fix an issue after dropping a patch this depends on. This patch
should now stand on its own.

[alekseyshl]

compiler-rt/lib/asan/asan_malloc_linux.cc

79 ↗

(On Diff #150444)

IsFromLocalPool

compiler-rt/lib/asan/asan_malloc_local.h

35 ↗

(On Diff #150444)

I'd prefer to have this if in operator new and let the compiler to remove the code in non-rtems case.

Maybe for the symmetry do this:

#define ALLOCATE_FROM_LOCAL_POOL UNLIKELY(EarlyMalloc())
#define ALLOCATE_FROM_LOCAL_POOL 0

if (ALLOCATE_FROM_LOCAL_POOL)

return MemalignFromLocalPool(alignment, size);

You also probably want to die in !nothrow case

if (ALLOCATE_FROM_LOCAL_POOL) {

void *res = MemalignFromLocalPool(alignment, size);
if (!nothrow) CHECK(res);
return res;

}

37 ↗

(On Diff #150444)

How about calling it IS_FROM_LOCAL_POOL

and have an explicit control flow in deletes:
if (IS_FROM_LOCAL_POOL) return;

compiler-rt/lib/asan/asan_new_delete.cc

74 ↗

(On Diff #150444)

Mimic our new behavior here, pass SHADOW_GRANULARITY as an alignment (and add a comment why).

[waltl]

Address CR comments.

[waltl]

Thanks for the quick review (for this and other patches).

[alekseyshl]

compiler-rt/lib/asan/asan_new_delete.cc

145 ↗

(On Diff #150553)

It looks quite puzzling, let's add a parameter to the macro: if (IS_FROM_LOCAL_POOL(ptr))

[waltl]

Address CR comments

[dmajor]

This broke Windows debug builds where MemalignFromLocalPool becomes an unresolved external. (I guess in optimized builds the call within the if(0) gets optimized away.)

[rnk]

compiler-rt/lib/asan/asan_malloc_local.h

35 ↗

(On Diff #150444)

I want to undo this change to put it in the operator new body because this code fails to link in debug builds on Windows, which I happened to do today. I'll send a review.

[dmajor]

compiler-rt/lib/asan/asan_malloc_local.h

35 ↗

(On Diff #150444)

I want to undo this change to put it in the operator new body because this code fails to link in debug builds on Windows, which I happened to do today. I'll send a review.

Out of curiosity, did this end up happening?

[rnk]

compiler-rt/lib/asan/asan_malloc_local.h

35 ↗

(On Diff #150444)

Unfortunately, no, I didn't end up finding time to do it. Want to take a stab at it?

[dmajor]

No rush, I don't have any pressing need for a fix. I was just curious.

compiler-rt/trunk/lib/asan/asan_malloc_linux.cc

#if SANITIZER_FREEBSD || SANITIZER_FUCHSIA || SANITIZER_LINUX || \
     SANITIZER_NETBSD || SANITIZER_RTEMS || SANITIZER_SOLARIS
 
 #include "sanitizer_common/sanitizer_allocator_checks.h"
 #include "sanitizer_common/sanitizer_errno.h"
 #include "sanitizer_common/sanitizer_tls_get_addr.h"
 #include "asan_allocator.h"
 #include "asan_interceptors.h"
 #include "asan_internal.h"
+#include "asan_malloc_local.h"
 #include "asan_stack.h"
 
 // ---------------------- Replacement functions ---------------- {{{1
 using namespace __asan;  // NOLINT
 
 static uptr allocated_for_dlsym;
 static const uptr kDlsymAllocPoolSize = SANITIZER_RTEMS ? 4096 : 1024;
 static uptr alloc_memory_for_dlsym[kDlsymAllocPoolSize];
static int PosixMemalignFromLocalPool(void **memptr, uptr alignment,
   if (allocated >= kDlsymAllocPoolSize)
     return errno_ENOMEM;
 
   allocated_for_dlsym = allocated;
   *memptr = (void*)aligned_addr;
   return 0;
 }
 
-// On RTEMS, we use the local pool to handle memory allocation before
-// the ASan run-time has been initialized.
-static INLINE bool EarlyMalloc() {
-  return SANITIZER_RTEMS && (!asan_inited || asan_init_is_running);
+#if SANITIZER_RTEMS
+void* MemalignFromLocalPool(uptr alignment, uptr size) {
+  void *ptr = nullptr;
+  alignment = Max(alignment, kWordSize);
+  PosixMemalignFromLocalPool(&ptr, alignment, size);
+  return ptr;
 }
 
+bool IsFromLocalPool(const void *ptr) {
+  return IsInDlsymAllocPool(ptr);
+}
+#endif
+
 static INLINE bool MaybeInDlsym() {
   // Fuchsia doesn't use dlsym-based interceptors.
   return !SANITIZER_FUCHSIA && asan_init_is_running;
 }
 
 static INLINE bool UseLocalPool() {
   return EarlyMalloc() || MaybeInDlsym();
 }

compiler-rt/trunk/lib/asan/asan_malloc_local.h

+//===-- asan_malloc_local.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of AddressSanitizer, an address sanity checker.
+//
+// Provide interfaces to check for and handle local pool memory allocation.
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_MALLOC_LOCAL_H
+#define ASAN_MALLOC_LOCAL_H
+
+#include "sanitizer_common/sanitizer_platform.h"
+#include "asan_internal.h"
+
+// On RTEMS, we use the local pool to handle memory allocation when the ASan
+// run-time is not up.
+static INLINE bool EarlyMalloc() {
+  return SANITIZER_RTEMS && (!__asan::asan_inited ||
+                             __asan::asan_init_is_running);
+}
+
+void* MemalignFromLocalPool(uptr alignment, uptr size);
+
+#if SANITIZER_RTEMS
+
+bool IsFromLocalPool(const void *ptr);
+
+#define ALLOCATE_FROM_LOCAL_POOL UNLIKELY(EarlyMalloc())
+#define IS_FROM_LOCAL_POOL(ptr) UNLIKELY(IsFromLocalPool(ptr))
+
+#else  // SANITIZER_RTEMS
+
+#define ALLOCATE_FROM_LOCAL_POOL 0
+#define IS_FROM_LOCAL_POOL(ptr) 0
+
+#endif  // SANITIZER_RTEMS
+
+#endif  // ASAN_MALLOC_LOCAL_H

compiler-rt/trunk/lib/asan/asan_new_delete.cc

 //===-- asan_interceptors.cc ----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of AddressSanitizer, an address sanity checker.
 //
 // Interceptors for operators new and delete.
 //===----------------------------------------------------------------------===//
 
 #include "asan_allocator.h"
 #include "asan_internal.h"
+#include "asan_malloc_local.h"
 #include "asan_report.h"
 #include "asan_stack.h"
 
 #include "interception/interception.h"
 
 #include <stddef.h>
 
 // C++ operators can't have dllexport attributes on Windows. We export them

 
 // Fake std::nothrow_t and std::align_val_t to avoid including <new>.
 namespace std {
 struct nothrow_t {};
 enum class align_val_t: size_t {};
 }  // namespace std
 
 // TODO(alekseyshl): throw std::bad_alloc instead of dying on OOM.
+// For local pool allocation, align to SHADOW_GRANULARITY to match asan
+// allocator behavior.
 #define OPERATOR_NEW_BODY(type, nothrow) \
+  if (ALLOCATE_FROM_LOCAL_POOL) {\
+    void *res = MemalignFromLocalPool(SHADOW_GRANULARITY, size);\
+    if (!nothrow) CHECK(res);\
+    return res;\
+  }\
   GET_STACK_TRACE_MALLOC;\
   void *res = asan_memalign(0, size, &stack, type);\
   if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
   return res;
 #define OPERATOR_NEW_BODY_ALIGN(type, nothrow) \
+  if (ALLOCATE_FROM_LOCAL_POOL) {\
+    void *res = MemalignFromLocalPool((uptr)align, size);\
+    if (!nothrow) CHECK(res);\
+    return res;\
+  }\
   GET_STACK_TRACE_MALLOC;\
   void *res = asan_memalign((uptr)align, size, &stack, type);\
   if (!nothrow && UNLIKELY(!res)) ReportOutOfMemory(size, &stack);\
   return res;
 
 // On OS X it's not enough to just provide our own 'operator new' and
 // 'operator delete' implementations, because they're going to be in the
 // runtime dylib, and the main executable will depend on both the runtime
INTERCEPTOR(void *, _ZnwmRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
   OPERATOR_NEW_BODY(FROM_NEW, true /*nothrow*/);
 }
 INTERCEPTOR(void *, _ZnamRKSt9nothrow_t, size_t size, std::nothrow_t const&) {
   OPERATOR_NEW_BODY(FROM_NEW_BR, true /*nothrow*/);
 }
 #endif  // !SANITIZER_MAC
 
 #define OPERATOR_DELETE_BODY(type) \
+  if (IS_FROM_LOCAL_POOL(ptr)) return;\
   GET_STACK_TRACE_FREE;\
   asan_delete(ptr, 0, 0, &stack, type);
 
 #define OPERATOR_DELETE_BODY_SIZE(type) \
+  if (IS_FROM_LOCAL_POOL(ptr)) return;\
   GET_STACK_TRACE_FREE;\
   asan_delete(ptr, size, 0, &stack, type);
 
 #define OPERATOR_DELETE_BODY_ALIGN(type) \
+  if (IS_FROM_LOCAL_POOL(ptr)) return;\
   GET_STACK_TRACE_FREE;\
   asan_delete(ptr, 0, static_cast<uptr>(align), &stack, type);
 
 #define OPERATOR_DELETE_BODY_SIZE_ALIGN(type) \
+  if (IS_FROM_LOCAL_POOL(ptr)) return;\
   GET_STACK_TRACE_FREE;\
   asan_delete(ptr, size, static_cast<uptr>(align), &stack, type);
 
 #if !SANITIZER_MAC
 CXX_OPERATOR_ATTRIBUTE
 void operator delete(void *ptr) NOEXCEPT
 { OPERATOR_DELETE_BODY(FROM_NEW); }
 CXX_OPERATOR_ATTRIBUTE