improve ptr_unalign check

Author: daanx

include/mimalloc/internal.h

@@ -349,7 +349,7 @@ mi_decl_restrict void* _mi_theap_malloc_sampled(mi_theap_t* theap, size_t req_si
 size_t        _mi_theap_update_sample_rate(mi_theap_t* theap);
 
 mi_decl_restrict void* _mi_theap_malloc_profiled(mi_theap_t* theap, size_t size, uint64_t requested_since_last_sample, bool zero, mi_page_t** ppage) mi_attr_noexcept;
-void          _mi_page_profile_free(mi_page_t* page, mi_block_t* block, void* p);
+void          _mi_page_profile_on_free(mi_page_t* page, mi_block_t* block, void* p);
 size_t        _mi_theap_set_profile_sample_rate(mi_theap_t* theap, size_t sample_rate);
 
 
@@ -1516,7 +1516,7 @@ static mi_decl_forceinline void* _mi_memzero_block(mi_block_t* dst, size_t bsize
   // fast memzero for small sizes based on overlapping writes (and assuming non-zero size_t-multiple size, and size_t aligned)
   // assumes constant memset(p,0,N) gets optimized to fast simd stores by the compiler
   // (compile with -DMI_USE_MEMZERO16X=0 to disable this)
-  #if !defined(MI_USE_MEMZERO16X) || (MI_USE_MEMZERO16X != 0) // 16x MI_SIZE_SIZE 
+  #if !defined(MI_USE_MEMZERO16X) || (MI_USE_MEMZERO16X != 0) // 16x MI_SIZE_SIZE (128 bytes on 64-bit)
     if mi_unlikely(bsize < 2*MI_SIZE_SIZE) { // bsize < 16 (8)
       *((size_t*)dst) = 0;
       return dst;

src/free.c

@@ -97,7 +97,7 @@ static inline void mi_free_block_mt(mi_page_t* page, mi_block_t* block, bool was
 // note: this can be called from `mi_free_generic_mt` where a non-owning thread accesses the
 // `page_woffset` and `block_size` fields; however these are constant and the page won't be
 // deallocated (as the block we are freeing keeps it alive) and thus safe to read concurrently.
-mi_block_t* _mi_page_ptr_unalign(const mi_page_t* page, const void* p) {
+static inline mi_block_t* mi_page_ptr_unalign_ex(const mi_page_t* page, const void* p, size_t* poffset) {
   mi_assert_internal(page!=NULL && p!=NULL);
 
   const size_t diff = (uint8_t*)p - mi_page_start(page);
@@ -106,9 +106,14 @@ mi_block_t* _mi_page_ptr_unalign(const mi_page_t* page, const void* p) {
   if mi_unlikely(!_mi_is_power_of_two(block_size)) {
     adjust = diff % block_size;     
   }
+  if (poffset!=NULL) { *poffset = adjust; }
   return (mi_block_t*)((uintptr_t)p - adjust);
 }
 
+mi_block_t* _mi_page_ptr_unalign(const mi_page_t* page, const void* p) {
+  return mi_page_ptr_unalign_ex(page,p,NULL);
+}
+
 static inline mi_block_t* mi_validate_block_from_ptr( const mi_page_t* page, const void* p ) {
   mi_assert(_mi_page_ptr_unalign(page,p) == (mi_block_t*)p); // should never be an interior pointer
   #if MI_SECURE > 0
@@ -126,13 +131,13 @@ static inline mi_block_t* mi_page_ptr_block_check(mi_page_t* page, void* p, bool
     return mi_validate_block_from_ptr(page,p);
   }
   else {
-    mi_block_t* const block = _mi_page_ptr_unalign(page,p);
+    size_t offset;
+    mi_block_t* const block = mi_page_ptr_unalign_ex(page,p,&offset);
     #if MI_GUARDED || MI_PROFILE
-    const size_t offset = (uint8_t*)p - (uint8_t*)block;
     if (offset >= sizeof(mi_block_t)) {
       #if MI_PROFILE
       if (block->next == MI_BLOCK_TAG_PROFILED) {
-        _mi_page_profile_free(page,block,p); 
+        _mi_page_profile_on_free(page,block,p); 
       }
       else 
       #endif
@@ -141,8 +146,9 @@ static inline mi_block_t* mi_page_ptr_block_check(mi_page_t* page, void* p, bool
         _mi_page_block_unguard(page, block, p); 
         *was_guarded = true; 
       }
+      else
       #else
-      { }
+      { /* nothing */}
       #endif
     }
     #endif

src/sample-profile.c

@@ -179,7 +179,7 @@ mi_decl_noinline mi_decl_restrict void* _mi_theap_malloc_profiled(mi_theap_t* th
   return p;
 }
 
-void _mi_page_profile_free(mi_page_t* page, mi_block_t* block, void* p) {
+void _mi_page_profile_on_free(mi_page_t* page, mi_block_t* block, void* p) {
   mi_assert_internal(mi_block_ptr_is_sampled(block,p));
 
   // get the heap and profiler