[asan, myriad] Implement aligned local pool allocation

[waltl]

Summary

Extend the local pool allocation support to posix_memalign.

[alekseyshl]

Are you solving a particular problem or you're just anticipating one?

compiler-rt/lib/asan/asan_malloc_linux.cc

175 ↗

(On Diff #149492)

Let's do it for all platforms, for simplicity and match the malloc implementation.

[waltl]

In D47642#1119518, @alekseyshl wrote:

Are you solving a particular problem or you're just anticipating one?

It's a problem I encountered on RTEMS, where we use this memory for a different purpose. See https://reviews.llvm.org/D46465.

compiler-rt/lib/asan/asan_malloc_linux.cc

175 ↗

(On Diff #149492)

Ok.

[waltl]

Do it for all platforms.

[alekseyshl]

compiler-rt/lib/asan/asan_malloc_linux.cc

195 ↗

(On Diff #149546)

While you're here, please remove this printf too.

[waltl]

Remove printf.

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

 // We simply define functions like malloc, free, realloc, etc.
 // They will replace the corresponding libc functions automagically.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_common/sanitizer_platform.h"
 #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_stack.h"
 
 // ---------------------- Replacement functions ---------------- {{{1
 using namespace __asan;  // NOLINT

 static void *AllocateFromLocalPool(uptr size_in_bytes) {
   uptr size_in_words = RoundUpTo(size_in_bytes, kWordSize) / kWordSize;
   void *mem = (void*)&alloc_memory_for_dlsym[allocated_for_dlsym];
   allocated_for_dlsym += size_in_words;
   CHECK_LT(allocated_for_dlsym, kDlsymAllocPoolSize);
   return mem;
 }
 
+static int PosixMemalignFromLocalPool(void **memptr, uptr alignment,
+                                      uptr size_in_bytes) {
+  if (UNLIKELY(!CheckPosixMemalignAlignment(alignment)))
+    return errno_EINVAL;
+
+  CHECK(alignment >= kWordSize);
+
+  uptr addr = (uptr)&alloc_memory_for_dlsym[allocated_for_dlsym];
+  uptr aligned_addr = RoundUpTo(addr, alignment);
+  uptr aligned_size = RoundUpTo(size_in_bytes, kWordSize);
+
+  uptr *end_mem = (uptr*)(aligned_addr + aligned_size);
+  uptr allocated = end_mem - alloc_memory_for_dlsym;
+  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);
 }
 
 static INLINE bool MaybeInDlsym() {
   // Fuchsia doesn't use dlsym-based interceptors.

 }
 
 INTERCEPTOR(int, mallopt, int cmd, int value) {
   return -1;
 }
 #endif // SANITIZER_INTERCEPT_MALLOPT_AND_MALLINFO
 
 INTERCEPTOR(int, posix_memalign, void **memptr, uptr alignment, uptr size) {
+  if (UNLIKELY(UseLocalPool()))
+    return PosixMemalignFromLocalPool(memptr, alignment, size);
   GET_STACK_TRACE_MALLOC;
-  // Printf("posix_memalign: %zx %zu\n", alignment, size);
   return asan_posix_memalign(memptr, alignment, size, &stack);
 }
 
 INTERCEPTOR(void*, valloc, uptr size) {
   GET_STACK_TRACE_MALLOC;
   return asan_valloc(size, &stack);
 }