Store alignmnet so that tail magic is computed correctly.

4 files changed, 38 insertions, 29 deletions

diff --git a/vespamalloc/src/tests/test1/new_test.cpp b/vespamalloc/src/tests/test1/new_test.cpp
index 5d31493aaf9..2400e41a1d9 100644
--- a/vespamalloc/src/tests/test1/new_test.cpp
+++ b/vespamalloc/src/tests/test1/new_test.cpp
@@ -12,8 +12,9 @@ void cmp(const void *base, size_t offset, const void *p) {
 }
 
 template <typename S>
-void veryfy_aligned(const S * p) {
+void veryfy_aligned(S * p) {
     EXPECT_TRUE((uintptr_t(p) % alignof(S)) == 0);
+    memset(p, 0, sizeof(S));
 }
 
 TEST("verify new with normal alignment") {
diff --git a/vespamalloc/src/vespamalloc/malloc/malloc.h b/vespamalloc/src/vespamalloc/malloc/malloc.h
index c3d67e3a5ae..27a195ebc5e 100644
--- a/vespamalloc/src/vespamalloc/malloc/malloc.h
+++ b/vespamalloc/src/vespamalloc/malloc/malloc.h
@@ -96,9 +96,7 @@ MemoryManager<MemBlockPtrT, ThreadListT>::MemoryManager(size_t logLimitAtStart)
 }
 
 template <typename MemBlockPtrT, typename ThreadListT>
-MemoryManager<MemBlockPtrT, ThreadListT>::~MemoryManager()
-{
-}
+MemoryManager<MemBlockPtrT, ThreadListT>::~MemoryManager() = default;
 
 template <typename MemBlockPtrT, typename ThreadListT>
 bool MemoryManager<MemBlockPtrT, ThreadListT>::initThisThread()
@@ -163,11 +161,11 @@ void * MemoryManager<MemBlockPtrT, ThreadListT>::malloc(size_t sz)
     MemBlockPtrT mem;
     ThreadPool & tp = _threadList.getCurrent();
     tp.malloc(mem.adjustSize(sz), mem);
+    mem.setExact(sz);
     if (!mem.validFree()) {
         fprintf(stderr, "Memory %p(%ld) has been tampered with after free.\n", mem.ptr(), mem.size());
         crash();
     }
-    mem.setExact(sz);
     mem.alloc(_prAllocLimit<=mem.adjustSize(sz));
     return mem.ptr();
 }
@@ -178,13 +176,13 @@ void * MemoryManager<MemBlockPtrT, ThreadListT>::malloc(size_t sz, std::align_va
     MemBlockPtrT mem;
     ThreadPool & tp = _threadList.getCurrent();
     tp.malloc(mem.adjustSize(sz, alignment), mem);
+    mem.setExact(sz, alignment);
     if (!mem.validFree()) {
         fprintf(stderr, "Memory %p(%ld) has been tampered with after free.\n", mem.ptr(), mem.size());
         crash();
     }
-    mem.setExact(sz);
     mem.alloc(_prAllocLimit<=mem.adjustSize(sz, alignment));
-    return mem.ptr(alignment);
+    return mem.ptr();
 }
 
 template <typename MemBlockPtrT, typename ThreadListT>
diff --git a/vespamalloc/src/vespamalloc/malloc/memblock.h b/vespamalloc/src/vespamalloc/malloc/memblock.h
index 8d20f064d39..e8d8e274678 100644
--- a/vespamalloc/src/vespamalloc/malloc/memblock.h
+++ b/vespamalloc/src/vespamalloc/malloc/memblock.h
@@ -25,11 +25,11 @@ public:
     void readjustAlignment(const T & segment)  { (void) segment; }
     void *rawPtr()            { return _ptr; }
     void *ptr()               { return _ptr; }
-    void *ptr(std::align_val_t) { return _ptr; }
     const void *ptr()   const { return _ptr; }
     bool validAlloc()   const { return true; }
     bool validFree()    const { return true; }
-    void setExact(size_t )    { }
+    void setExact(size_t)     { }
+    void setExact(size_t, std::align_val_t )    { }
     void alloc(bool )         { }
     void setThreadId(int )    { }
     void free()               { }
diff --git a/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h b/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
index 5906203d194..d64eb592b3b 100644
--- a/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
+++ b/vespamalloc/src/vespamalloc/malloc/memblockboundscheck.h
@@ -13,24 +13,17 @@ public:
     void * rawPtr()          { return _ptr; }
     void *ptr()              {
         char *p((char*)_ptr);
-        return p ? (p+preambleOverhead()) : nullptr;
+        return p ? (p+alignment()) : nullptr;
     }
     const void *ptr() const {
         const char *p((const char*)_ptr);
-        return p ? (p+preambleOverhead()) : nullptr;
-    }
-    void *ptr(std::align_val_t alignment) {
-        char *p((char*)_ptr);
-        return p ? (p+preambleOverhead(alignment)) : nullptr;
-    }
-    const void *ptr(std::align_val_t alignment) const {
-        const char *p((const char*)_ptr);
-        return p ? (p+preambleOverhead(alignment)) : nullptr;
+        return p ? (p+alignment()) : nullptr;
     }
 
     void setThreadId(int th)              { if (_ptr) { static_cast<uint32_t*>(_ptr)[2] = th; } }
-    bool allocated()                const { return (static_cast<unsigned*>(_ptr)[3] == ALLOC_MAGIC); }
-    size_t size()                   const { return static_cast<const uint64_t *>(_ptr)[0]; }
+    bool allocated()                const { return (static_cast<uint32_t*>(_ptr)[3] == ALLOC_MAGIC); }
+    size_t size()                   const { return static_cast<const uint32_t *>(_ptr)[0]; }
+    size_t alignment()              const { return static_cast<const uint32_t *>(_ptr)[1]; }
     int threadId()                  const { return static_cast<int*>(_ptr)[2]; }
     Stack * callStack()                   { return reinterpret_cast<Stack *>((char *)_ptr + size() + 4*sizeof(unsigned)); }
     const Stack * callStack()       const { return reinterpret_cast<const Stack *>((const char *)_ptr + size() + 4*sizeof(unsigned)); }
@@ -58,7 +51,11 @@ protected:
     MemBlockBoundsCheckBaseTBase(void * p) : _ptr(p) { }
     void verifyFill() const __attribute__((noinline));
 
-    void setSize(size_t sz) { static_cast<uint64_t *>(_ptr)[0] = sz; }
+    void setSize(size_t sz) {
+        assert(sz < 0x100000000ul);
+        static_cast<uint32_t *>(_ptr)[0] = sz;
+    }
+    void setAlignment(size_t alignment) { static_cast<uint32_t *>(_ptr)[1] = alignment; }
     static constexpr size_t preambleOverhead(std::align_val_t alignment) {
         return std::max(preambleOverhead(), size_t(alignment));
     }
@@ -89,15 +86,22 @@ public:
         MaxSizeClassMultiAlloc = MaxSizeClassMultiAllocC,
         SizeClassSpan = (MaxSizeClassMultiAllocC-5)
     };
-    MemBlockBoundsCheckBaseT() : MemBlockBoundsCheckBaseTBase(NULL) { }
-    MemBlockBoundsCheckBaseT(void * p) : MemBlockBoundsCheckBaseTBase(p ? (unsigned *)p-4 : NULL) { }
-    MemBlockBoundsCheckBaseT(void * p, size_t sz) : MemBlockBoundsCheckBaseTBase(p) { setSize(sz); }
+    MemBlockBoundsCheckBaseT() : MemBlockBoundsCheckBaseTBase(nullptr) { }
+    MemBlockBoundsCheckBaseT(void * p)
+        : MemBlockBoundsCheckBaseTBase(p ? static_cast<char *>(p) - preambleOverhead() : nullptr)
+    { }
+    MemBlockBoundsCheckBaseT(void * p, size_t sz)
+        : MemBlockBoundsCheckBaseTBase(p)
+    {
+        setSize(sz);
+        setAlignment(preambleOverhead());
+    }
     MemBlockBoundsCheckBaseT(void * p, size_t, bool) : MemBlockBoundsCheckBaseTBase(p) { }
     bool validCommon() const {
         const unsigned *p(reinterpret_cast<const unsigned*>(_ptr));
         return p
             && ((p[3] == ALLOC_MAGIC) || (p[3] == FREE_MAGIC))
-            && *(reinterpret_cast<const unsigned *> ((const char*)_ptr + size() + 4*sizeof(unsigned) + StackTraceLen*sizeof(void *))) == TAIL_MAGIC;
+            && *(reinterpret_cast<const unsigned *> ((const char*)_ptr + size() + alignment() + StackTraceLen*sizeof(void *))) == TAIL_MAGIC;
     }
     bool validAlloc1() const {
         unsigned *p((unsigned*)_ptr);
@@ -130,7 +134,12 @@ public:
         fillMemory(size());
         setTailMagic();
     }
-    void setExact(size_t sz)              { init(sz); }
+    void setExact(size_t sz) {
+        init(sz, preambleOverhead());
+    }
+    void setExact(size_t sz, std::align_val_t alignment) {
+        init(sz, preambleOverhead(alignment));
+    }
     size_t callStackLen()           const {
         const Stack * stack = callStack();
         // Use int to avoid compiler warning about always true.
@@ -158,10 +167,11 @@ protected:
     static constexpr size_t overhead(std::align_val_t alignment) {
         return preambleOverhead(alignment) + postambleOverhead();
     }
-    void setTailMagic() { *(reinterpret_cast<unsigned *> ((char*)_ptr + size() + preambleOverhead() + StackTraceLen*sizeof(void *))) = TAIL_MAGIC; }
-    void init(size_t sz) {
+    void setTailMagic() { *(reinterpret_cast<unsigned *> ((char*)_ptr + size() + alignment() + StackTraceLen*sizeof(void *))) = TAIL_MAGIC; }
+    void init(size_t sz, size_t alignment) {
         if (_ptr) {
             setSize(sz);
+            setAlignment(alignment);
             setTailMagic();
         }
     }