GTTF: cherry-pick memalign/realloc mismatch debug code

third_party/tcmalloc/chromium/src/debugallocation.cc

 // Copyright (c) 2000, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 725 matching lines @@
     // which is a fake header.  The following subtraction works for both zero
     // and non-zero values.
     return reinterpret_cast<MallocBlock *>(
                 reinterpret_cast<char *>(mb) - mb->offset_);
   }
   static const MallocBlock* FromRawPointer(const void* p) {
     // const-safe version: we just cast about
     return FromRawPointer(const_cast<void*>(p));
   }
 
+  // Return whether p points to memory returned by memalign.
+  // Requires that p be non-zero and has been checked for sanity with
+  // FromRawPointer().
+  static bool IsMemaligned(const void* p) {
+    const MallocBlock* mb = reinterpret_cast<const MallocBlock*>(
+        reinterpret_cast<const char*>(p) - MallocBlock::data_offset());
+    // If the offset is non-zero, the block was allocated by memalign
+    // (see FromRawPointer above).
+    return mb->offset_ != 0;

[jar (doing other things), 2013/01/16 00:59:32]

Why is this safe to call if you don't know if this is really a malloc block?

[Paweł Hajdan Jr., 2013/01/16 01:05:09]

1. Note this has been reviewed and committed Google-side. It's just a backport.
2. See the "Requires that... has been checked for sanity" comment, and we
actually call Check before calling IsMemaligned.

+  }
+
   void Check(int type) const {
     alloc_map_lock_.Lock();
     CheckLocked(type);
     alloc_map_lock_.Unlock();
   }
 
   static bool CheckEverything() {
     alloc_map_lock_.Lock();
     if (alloc_map_ != NULL)  alloc_map_->Iterate(CheckCallback, 0);
     alloc_map_lock_.Unlock();
@@ skipping 427 matching lines @@
   MallocHook::InvokeDeleteHook(ptr);
   DebugDeallocate(ptr, MallocBlock::kMallocType);
 }
 
 extern "C" PERFTOOLS_DLL_DECL void* tc_realloc(void* ptr, size_t size) __THROW {
   if (ptr == NULL) {
     ptr = do_debug_malloc_or_debug_cpp_alloc(size);
     MallocHook::InvokeNewHook(ptr, size);
     return ptr;
   }
+  MallocBlock* old = MallocBlock::FromRawPointer(ptr);
+  old->Check(MallocBlock::kMallocType);
+  if (MallocBlock::IsMemaligned(ptr)) {
+    RAW_LOG(FATAL, "realloc/memalign mismatch at %p: "
+            "non-NULL pointers passed to realloc must be obtained "
+            "from malloc, calloc, or realloc", ptr);
+  }
   if (size == 0) {
     MallocHook::InvokeDeleteHook(ptr);
     DebugDeallocate(ptr, MallocBlock::kMallocType);
     return NULL;
   }
-  MallocBlock* old = MallocBlock::FromRawPointer(ptr);
-  old->Check(MallocBlock::kMallocType);
   MallocBlock* p = MallocBlock::Allocate(size, MallocBlock::kMallocType);
 
   // If realloc fails we are to leave the old block untouched and
   // return null
   if (p == NULL)  return NULL;
 
   memcpy(p->data_addr(), old->data_addr(),
          (old->data_size() < size) ? old->data_size() : size);
   MallocHook::InvokeDeleteHook(ptr);
   MallocHook::InvokeNewHook(p->data_addr(), size);
@@ skipping 202 matching lines @@
 
 #ifdef HAVE_STRUCT_MALLINFO
 extern "C" PERFTOOLS_DLL_DECL struct mallinfo tc_mallinfo(void) __THROW {
   return BASE_MALLINFO();
 }
 #endif
 
 extern "C" PERFTOOLS_DLL_DECL size_t tc_malloc_size(void* ptr) __THROW {
   return MallocExtension::instance()->GetAllocatedSize(ptr);
 }