Update __sanitizer_get_allocated_begin to return const void*

[thurston]

Summary

D147005 introduced __sanitizer_get_allocated_begin, with a return
value of void*. This involved a few naughty casts that dropped the
const. This patch adds back the const qualifier.

[thurston]

I submitted this patch to unbreak the buildbot: https://lab.llvm.org/buildbot/#/builders/19/builds/15896/steps/2/logs/stdio

Please provide post-commit review as appropriate.

[vitalybuka]

In D147489#4242036, @thurston wrote:

I submitted this patch to unbreak the buildbot: https://lab.llvm.org/buildbot/#/builders/19/builds/15896/steps/2/logs/stdio

Please provide post-commit review as appropriate.

@kstoimenov FYI

For post-commit review, don't upload like this. UI has no tool for post-commit review. I'll have to reopen/review/close.

Instead git push, and then assign audit from commited revision https://reviews.llvm.org/diffusion/commit/edit/1984344/

compiler-rt/include/sanitizer/allocator_interface.h

#endif
   size_t __sanitizer_get_estimated_allocated_size(size_t size);
 
   /* Returns true if p was returned by the allocator and
      is not yet freed. */
   int __sanitizer_get_ownership(const volatile void *p);
 
   /* If a pointer lies within an allocation, it will return the start address
      of the allocation. Otherwise, it returns nullptr. */
-  void *__sanitizer_get_allocated_begin(const void *p);
+  const void *__sanitizer_get_allocated_begin(const void *p);
 
   /* Returns the number of bytes reserved for the pointer p.
      Requires (get_ownership(p) == true) or (p == 0). */
   size_t __sanitizer_get_allocated_size(const volatile void *p);
 
   /* Number of bytes, allocated and not yet freed by the application. */
   size_t __sanitizer_get_current_allocated_bytes(void);
 

compiler-rt/lib/asan/asan_allocator.cpp

IgnoreObjectResult IgnoreObjectLocked(const void *p) {
   return kIgnoreObjectSuccess;
 }
 
 }  // namespace __lsan
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __asan;
 
-void *AllocationBegin(const void *p) {
+const void *AllocationBegin(const void *p) {
   AsanChunk *m = __asan::instance.GetAsanChunkByAddr((uptr)p);
   if (!m)
     return nullptr;
   if (atomic_load(&m->chunk_state, memory_order_acquire) != CHUNK_ALLOCATED)
     return nullptr;
   if (m->UsedSize() == 0)
     return nullptr;
-  return (void *)(m->Beg());
+  return (const void *)(m->Beg());
 }
 
 // ASan allocator doesn't reserve extra bytes, so normally we would
 // just return "size". We don't want to expose our redzone sizes, etc here.
 uptr __sanitizer_get_estimated_allocated_size(uptr size) {
   return size;
 }
 
uptr __sanitizer_get_allocated_size(const void *p) {
   // Die if p is not malloced or if it is already freed.
   if (allocated_size == 0) {
     GET_STACK_TRACE_FATAL_HERE;
     ReportSanitizerGetAllocatedSizeNotOwned(ptr, &stack);
   }
   return allocated_size;
 }
 
-void *__sanitizer_get_allocated_begin(const void *p) {
+const void *__sanitizer_get_allocated_begin(const void *p) {
   return AllocationBegin(p);
 }
 
 void __sanitizer_purge_allocator() {
   GET_STACK_TRACE_MALLOC;
   instance.Purge(&stack);
 }
 
 int __asan_update_allocation_context(void* addr) {
   GET_STACK_TRACE_MALLOC;
   return instance.UpdateAllocationStack((uptr)addr, &stack);
 }

compiler-rt/lib/dfsan/dfsan_allocator.cpp

if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
     if (AllocatorMayReturnNull())
       return nullptr;
     BufferedStackTrace stack;
     ReportCallocOverflow(nmemb, size, &stack);
   }
   return DFsanAllocate(nmemb * size, sizeof(u64), true /*zeroise*/);
 }
 
-void *AllocationBegin(const void *p) {
+const void *AllocationBegin(const void *p) {
   if (!p)
     return nullptr;
   void *beg = allocator.GetBlockBegin(p);
   if (!beg)
     return nullptr;
   Metadata *b = (Metadata *)allocator.GetMetaData(beg);
   if (!b)
     return nullptr;
   if (b->requested_size == 0)
     return nullptr;
-  return (void *)beg;
+  return (const void *)beg;
 }
 
 static uptr AllocationSize(const void *p) {
   if (!p)
     return 0;
   const void *beg = allocator.GetBlockBegin(p);
   if (beg != p)
     return 0;

 uptr __sanitizer_get_free_bytes() { return 1; }
 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
-void *__sanitizer_get_allocated_begin(const void *p) {
+const void *__sanitizer_get_allocated_begin(const void *p) {
   return AllocationBegin(p);
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }

compiler-rt/lib/hwasan/hwasan_allocator.cpp

HwasanChunkView FindHeapChunkByAddress(uptr address) {
   void *block = allocator.GetBlockBegin(reinterpret_cast<void*>(address));
   if (!block)
     return HwasanChunkView();
   Metadata *metadata =
       reinterpret_cast<Metadata*>(allocator.GetMetaData(block));
   return HwasanChunkView(reinterpret_cast<uptr>(block), metadata);
 }
 
-void *AllocationBegin(const void *p) {
+const void *AllocationBegin(const void *p) {
   const void *untagged_ptr = UntagPtr(p);
   if (!untagged_ptr)
     return nullptr;
 
   const void *beg = allocator.GetBlockBegin(untagged_ptr);
   if (!beg)
     return nullptr;
 
   Metadata *b = (Metadata *)allocator.GetMetaData(beg);
   if (b->GetRequestedSize() == 0)
     return nullptr;
 
   tag_t tag = GetTagFromPointer((uptr)p);
-  return (void *)AddTagToPointer((uptr)beg, tag);
+  return (const void *)AddTagToPointer((uptr)beg, tag);
 }
 
 static uptr AllocationSize(const void *tagged_ptr) {
   const void *untagged_ptr = UntagPtr(tagged_ptr);
   if (!untagged_ptr) return 0;
   const void *beg = allocator.GetBlockBegin(untagged_ptr);
   Metadata *b = (Metadata *)allocator.GetMetaData(untagged_ptr);
   if (beg != untagged_ptr) return 0;

 uptr __sanitizer_get_free_bytes() { return 1; }
 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
-void *__sanitizer_get_allocated_begin(const void *p) {
+const void *__sanitizer_get_allocated_begin(const void *p) {
   return AllocationBegin(p);
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }

compiler-rt/lib/lsan/lsan_allocator.cpp

void *Reallocate(const StackTrace &stack, void *p, uptr new_size,
   return new_p;
 }
 
 void GetAllocatorCacheRange(uptr *begin, uptr *end) {
   *begin = (uptr)GetAllocatorCache();
   *end = *begin + sizeof(AllocatorCache);
 }
 
-void *GetMallocBegin(const void *p) {
+const void *GetMallocBegin(const void *p) {
   if (!p)
     return nullptr;
   void *beg = allocator.GetBlockBegin(p);
   if (!beg)
     return nullptr;
   ChunkMetadata *m = Metadata(beg);
   if (!m)
     return nullptr;
   if (!m->allocated)
     return nullptr;
   if (m->requested_size == 0)
     return nullptr;
-  return (void *)beg;
+  return (const void *)beg;
 }
 
 uptr GetMallocUsableSize(const void *p) {
   if (!p)
     return 0;
   ChunkMetadata *m = Metadata(p);
   if (!m) return 0;
   return m->requested_size;

 
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __sanitizer_get_ownership(const void *p) { return Metadata(p) != nullptr; }
 
 SANITIZER_INTERFACE_ATTRIBUTE
-void * __sanitizer_get_allocated_begin(const void *p) {
+const void * __sanitizer_get_allocated_begin(const void *p) {
   return GetMallocBegin(p);
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_allocated_size(const void *p) {
   return GetMallocUsableSize(p);
 }
 
 } // extern "C"

compiler-rt/lib/memprof/memprof_allocator.cpp

int memprof_posix_memalign(void **memptr, uptr alignment, uptr size,
   if (UNLIKELY(!ptr))
     // OOM error is already taken care of by Allocate.
     return errno_ENOMEM;
   CHECK(IsAligned((uptr)ptr, alignment));
   *memptr = ptr;
   return 0;
 }
 
-void *memprof_malloc_begin(const void *p) {
+const void *memprof_malloc_begin(const void *p) {
   u64 user_requested_size;
   MemprofChunk *m =
       instance.GetMemprofChunkByAddr((uptr)p, user_requested_size);
   if (!m)
     return nullptr;
   if (user_requested_size == 0)
     return nullptr;
 
-  return (void *)m->Beg();
+  return (const void *)m->Beg();
 }
 
 uptr memprof_malloc_usable_size(const void *ptr, uptr pc, uptr bp) {
   if (!ptr)
     return 0;
   uptr usable_size = instance.AllocationSize(reinterpret_cast<uptr>(ptr));
   return usable_size;
 }
 
 } // namespace __memprof
 
 // ---------------------- Interface ---------------- {{{1
 using namespace __memprof;
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) {
   return memprof_malloc_usable_size(p, 0, 0) != 0;
 }
 
-void *__sanitizer_get_allocated_begin(const void *p) {
+const void *__sanitizer_get_allocated_begin(const void *p) {
   return memprof_malloc_begin(p);
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) {
   return memprof_malloc_usable_size(p, 0, 0);
 }
 
 int __memprof_profile_dump() {
   instance.FinishAndWrite();
   // In the future we may want to return non-zero if there are any errors
   // detected during the dumping process.
   return 0;
 }

compiler-rt/lib/msan/msan_allocator.cpp

static void *MsanCalloc(StackTrace *stack, uptr nmemb, uptr size) {
   if (UNLIKELY(CheckForCallocOverflow(size, nmemb))) {
     if (AllocatorMayReturnNull())
       return nullptr;
     ReportCallocOverflow(nmemb, size, stack);
   }
   return MsanAllocate(stack, nmemb * size, sizeof(u64), true);
 }
 
-void *AllocationBegin(const void *p) {
+const void *AllocationBegin(const void *p) {
   if (!p)
     return nullptr;
   void *beg = allocator.GetBlockBegin(p);
   if (!beg)
     return nullptr;
   Metadata *b = (Metadata *)allocator.GetMetaData(beg);
   if (!b)
     return nullptr;
   if (b->requested_size == 0)
     return nullptr;
 
-  return (void *)beg;
+  return (const void *)beg;
 }
 
 static uptr AllocationSize(const void *p) {
   if (!p) return 0;
   const void *beg = allocator.GetBlockBegin(p);
   if (beg != p) return 0;
   Metadata *b = (Metadata *)allocator.GetMetaData(p);
   return b->requested_size;

 uptr __sanitizer_get_free_bytes() { return 1; }
 
 uptr __sanitizer_get_unmapped_bytes() { return 1; }
 
 uptr __sanitizer_get_estimated_allocated_size(uptr size) { return size; }
 
 int __sanitizer_get_ownership(const void *p) { return AllocationSize(p) != 0; }
 
-void *__sanitizer_get_allocated_begin(const void *p) {
+const void *__sanitizer_get_allocated_begin(const void *p) {
   return AllocationBegin(p);
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) { return AllocationSize(p); }

compiler-rt/lib/sanitizer_common/sanitizer_allocator_interface.h

 #include "sanitizer_internal_defs.h"
 
 using __sanitizer::uptr;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE
 uptr __sanitizer_get_estimated_allocated_size(uptr size);
 SANITIZER_INTERFACE_ATTRIBUTE int __sanitizer_get_ownership(const void *p);
-SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE void *
+SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE const void *
 __sanitizer_get_allocated_begin(const void *p);
 SANITIZER_INTERFACE_ATTRIBUTE uptr
 __sanitizer_get_allocated_size(const void *p);
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_current_allocated_bytes();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_heap_size();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_free_bytes();
 SANITIZER_INTERFACE_ATTRIBUTE uptr __sanitizer_get_unmapped_bytes();
 

compiler-rt/lib/tsan/rtl/tsan_mman.cpp

if (UNLIKELY(CheckForPvallocOverflow(sz, PageSize))) {
     GET_STACK_TRACE_FATAL(thr, pc);
     ReportPvallocOverflow(sz, &stack);
   }
   // pvalloc(0) should allocate one page.
   sz = sz ? RoundUpTo(sz, PageSize) : PageSize;
   return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, PageSize));
 }
 
-void *user_alloc_begin(const void *p) {
+const void *user_alloc_begin(const void *p) {
   if (p == nullptr || !IsAppMem((uptr)p))
     return nullptr;
   void *beg = allocator()->GetBlockBegin(p);
   if (!beg)
     return nullptr;
 
   MBlock *b = ctx->metamap.GetBlock((uptr)beg);
   if (!b)
     return nullptr;  // Not a valid pointer.
 
-  return (void *)beg;
+  return (const void *)beg;
 }
 
 uptr user_alloc_usable_size(const void *p) {
   if (p == 0 || !IsAppMem((uptr)p))
     return 0;
   MBlock *b = ctx->metamap.GetBlock((uptr)p);
   if (!b)
     return 0;  // Not a valid pointer.

 uptr __sanitizer_get_estimated_allocated_size(uptr size) {
   return size;
 }
 
 int __sanitizer_get_ownership(const void *p) {
   return allocator()->GetBlockBegin(p) != 0;
 }
 
-void *__sanitizer_get_allocated_begin(const void *p) {
+const void *__sanitizer_get_allocated_begin(const void *p) {
   return user_alloc_begin(p);
 }
 
 uptr __sanitizer_get_allocated_size(const void *p) {
   return user_alloc_usable_size(p);
 }
 
 void __tsan_on_thread_idle() {
   ThreadState *thr = cur_thread();
   allocator()->SwallowCache(&thr->proc()->alloc_cache);
   internal_allocator()->SwallowCache(&thr->proc()->internal_alloc_cache);
   ctx->metamap.OnProcIdle(thr->proc());
 }
 }  // extern "C"

compiler-rt/test/sanitizer_common/TestCases/get_allocated_begin.cpp

for (int i = 0; i < sizeof(sizes) / sizeof(int); i++) {
 
     char *array = reinterpret_cast<char *>(malloc(sizes[i]));
     int *int_ptr = new int;
     printf("array: %p\n", array);
     printf("int_ptr: %p\n", int_ptr);
 
     // Bogus value to unpoison start. Calling __sanitizer_get_allocated_begin
     // does not unpoison it.
-    void *start = NULL;
+    const void *start = NULL;
     for (int j = 0; j < sizes[i]; j++) {
       printf("j: %d\n", j);
 
       start = __sanitizer_get_allocated_begin(array + j);
       printf("Start: %p (expected: %p)\n", start, array);
       fflush(stdout);
       assert(array == start);
     }