DebugAlloc.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
    #define _CRT_SECURE_NO_DEPRECATE
    #include <windows.h>    // dcl/Thread.h
#endif
 
#if __DCL_HAVE_ALLOC_DEBUG
 
#include <stdlib.h>     // malloc, free
#include <string.h>     // strcpy, strlen
#include <wchar.h>      // wcslen, wcscpy
 
#include <dcl/Object.h>
#include <dcl/Thread.h>
#include <dcl/Writer.h>
#include "LibState.h"
 
#define __strlen(s)     wcslen(s)
#define __strcpy(d, s)  wcscpy(d, s)
 
#undef new
#undef malloc
#undef realloc
#undef calloc
#undef free
 
#define __DCL_ASSERT_N(expr)    // no assert
 
#undef __THIS_FILE__
static const char_t __UNUSED__ __THIS_FILE__[] = __T("dcl/DebugAlloc.cpp");
 
__DCL_BEGIN_NAMESPACE
 
extern LibState* __LibState__;
 
// https://en.wikipedia.org/wiki/Thread-local_storage
#ifdef _MSC_VER
#define THREAD_LOCAL_STORAGE __declspec(thread)
#elif defined(__GNUC__)
#define THREAD_LOCAL_STORAGE __thread
#endif
 
static THREAD_LOCAL_STORAGE const char_t* __near_filename = NULL;
static THREAD_LOCAL_STORAGE unsigned int __near_line = 0;
 
__DCL_END_NAMESPACE
 
__DCL_USING_NAMESPACE
 
DCLCAPI void DCLDebugAllocEnterNear(
    const char_t* _filename,
    unsigned int    _line
)
{
    __near_filename = _filename;
    __near_line = _line;
}
 
DCLCAPI void* DCLDebugMalloc(
    size_t          _size,
    bool            _check,
    DCLAllocFunc    _func,
    const char_t* _filename,
    unsigned int    _line
)
{
    const char_t* filename = _filename;
    if (_filename == NULL) {
        filename = __near_filename;
        _line = __near_line;
    }
 
    if (_size == 0) {
        DCLDebugTrace(
            filename, _line,
            __T("MEMDBG Warning! malloc(size:%d)!\n"), _size
        );
 
        return NULL;
    }
 
    void* ptr = NULL;
 
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    lockAlloc.lock();
    ptr = listAlloc.allocAddTail(
        _size,
        _check,
        _func,
        filename,
        _line
    );
    lockAlloc.unlock();
 
    return ptr;
}
 
static const char_t* __AllocTypeStr(DCLAllocFunc func)
{
    switch(func) {
        case DCL_ALLOC_DEFAULT :
            return __T("default");
        case DCL_ALLOC_NEW :
            return __T("new");
        case DCL_ALLOC_NEW_ARRAY :
            return __T("new[]");
        case DCL_ALLOC_NEW_OBJECT :
            return __T("new object");
        case DCL_ALLOC_NEW_OBJECT_ARRAY :
            return __T("new[] object");
        case DCL_ALLOC_DELETE :
            return __T("delete");
        case DCL_ALLOC_DELETE_ARRAY :
            return __T("delete[]");
        case DCL_ALLOC_DELETE_OBJECT :
            return __T("delete object");
        case DCL_ALLOC_DELETE_OBJECT_ARRAY :
            return __T("delete[] object");
    }
 
    return __T("unknown!");
}
 
static bool __IsValidAllocFunction(
    DCLAllocFunc _allocType,
    DCLAllocFunc _freeType
)
{
    switch(_allocType) {
        case DCL_ALLOC_DEFAULT :
            return DCL_ALLOC_DEFAULT == _freeType;
        case DCL_ALLOC_NEW :
            return DCL_ALLOC_DELETE == _freeType;
        case DCL_ALLOC_NEW_ARRAY :
            return DCL_ALLOC_DELETE_ARRAY == _freeType;
        case DCL_ALLOC_NEW_OBJECT :
            return DCL_ALLOC_DELETE_OBJECT == _freeType;
        case DCL_ALLOC_NEW_OBJECT_ARRAY :
            return DCL_ALLOC_DELETE_OBJECT_ARRAY == _freeType;
        // not used for GCC warnings
        case DCL_ALLOC_DELETE :
            return DCL_ALLOC_NEW == _freeType;
        case DCL_ALLOC_DELETE_ARRAY :
            return DCL_ALLOC_NEW_ARRAY == _freeType;
        case DCL_ALLOC_DELETE_OBJECT :
            return DCL_ALLOC_NEW_OBJECT == _freeType;
        case DCL_ALLOC_DELETE_OBJECT_ARRAY :
            return DCL_ALLOC_NEW_OBJECT_ARRAY == _freeType;
    }
    return false;
}
 
DCLCAPI void DCLDebugFree(
    void*           _ptr,
    DCLAllocFunc    _func,
    const char_t* _filename,
    unsigned int    _line
)
{
    if (!_ptr) {
        DCLDebugTrace(
            _filename, _line,
            __T("MEMDBG Error! free(ptr:NULL) ptr is NULL assigned!\n")
        );
 
        DCLDebugAssert(_filename, _line, __T("ptr != NULL"),  __T("free(ptr:NULL)"));
        // throw or abort
    }
 
    // DCLDebugAssert, DCLDebugTrace의 출력은 메모리를 할당하는 Writer을 사용하기 때문에
    // 다음의 lock() ... unlock() 내부에서 DCLDebugAssert와 DCLDebugTrace를 사용할 수 없다.
    // lock() ... unlock() 에서는 메지시를 만들고 마지막에서 출력한다.
 
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    AllocList::Node* node = NULL;
    bool validFunc;
    char_t filename[512];
    int line;
    DCLAllocFunc func;
 
    lockAlloc.lock();
    node = listAlloc.rfind(_ptr);
    if (node) {
        validFunc = __IsValidAllocFunction(node->func, _func);
        if (!validFunc) {
            __strcpy(filename, node->filename);
            line = node->line;
            func = node->func;
        }
        listAlloc.erase(node);
    }
    lockAlloc.unlock();
 
    if (_filename == NULL)
        _filename = __T("delete location");
 
    if (node == NULL)
        DCLDebugTrace(_filename, _line, __T("MEMDBG Error! Cannot found prev alloc!!\n"));
    else if (!validFunc)
        DCLDebugTrace(_filename, _line,
            __T("MEMDBG Error! No Match func!! alloc:%ls:%d:%ls ==> free:%ls\n"),
            filename, line, __AllocTypeStr(func),
            __AllocTypeStr(_func)
        );
}
 
DCLCAPI void* DCLDebugCalloc(
    size_t          _count,
    size_t          _size,
    bool            _check,
    const char_t* _filename,
    unsigned int    _line
)
{
    if ((_count == 0) || (_size == 0)) {
        DCLDebugTrace(
            _filename, _line,
            __T("MEMDBG Warning! calloc(count:%d, size:%d)! %ls(%d)\n"),
            _count, _size
        );
        return NULL;
    }
 
    size_t total = _count * _size;
    void* ptr = DCLDebugMalloc(
        total,
        _check,
        DCL_ALLOC_DEFAULT,
        _filename,
        _line
    );
 
    memset(ptr, 0, total);
    return ptr;
}
 
DCLCAPI void* DCLDebugRealloc(
    void*           _ptr,
    size_t          _size,
    bool            _check,
    const char_t* _filename,
    unsigned int    _line
)
{
    if ((_ptr == NULL) || (_size == 0)) {
        DCLDebugTrace(
            _filename, _line,
            __T("MEMDBG Warning! realloc(ptr[%p], newsize[%zd])\n"),
            _ptr,
            _size
        );
    }
 
    void* newptr = NULL;
    AllocList::Node* oldNode = NULL;
    char_t oldFilename[512];
    int oldLine;
    DCLAllocFunc oldFunc = DCL_ALLOC_DEFAULT;
 
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    lockAlloc.lock();
    if (_ptr) {
        oldNode = listAlloc.rfind(_ptr);
        if (oldNode) {
            if (_size == 0) {
                // _size가 0 이다. 노드를 삭제하고
                // return NULL
                listAlloc.erase(oldNode);
            }
            else {
                if (oldNode->func != DCL_ALLOC_DEFAULT) {
                    __strcpy(oldFilename, oldNode->filename);
                    oldLine = oldNode->line;
                    oldFunc = oldNode->func;
                }
                else {
                    // 노드를 realloc하고 update한다.
                    AllocList::Node* newNode =
                        listAlloc.reallocNode(
                            oldNode,
                            _size,
                            _filename,
                            _line
                        );
                    if (newNode)
                        newptr = newNode->data;
                }
            }
        }
    }
    else { //   NULL == oldptr
        if (_size)
            newptr = listAlloc.allocAddTail(
                _size,
                _check,
                DCL_ALLOC_DEFAULT,  // func
                _filename,
                _line
            );
    }
    lockAlloc.unlock();
 
    if (oldNode == NULL)
        DCLDebugTrace(_filename, _line, __T("MEMDBG Error! Cannot found prev alloc!!\n"));
    else if (oldFunc != DCL_ALLOC_DEFAULT)
        DCLDebugTrace(_filename, _line,
            __T("MEMDBG Error! Invalid realloc!! prev:%ls:%d:%ls ==> realloc\n"),
            oldFilename, oldLine, __AllocTypeStr(oldFunc)
        );
 
    return newptr;
}
 
DCLCAPI bool DCLDebugAllocIsValid(const void* _ptr)
{
    bool found = false;
 
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    lockAlloc.lock();
    found = listAlloc.find(_ptr) != NULL;
    lockAlloc.unlock();
 
    return found;
}
 
DCLCAPI void DCLDebugAllocSetCheckFlag(
    const void*     _ptr,
    bool            _check
)
{
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    lockAlloc.lock();
    AllocList::Node* node = listAlloc.rfind(_ptr);
    if (node)
        node->check = _check;
    lockAlloc.unlock();
}
 
DCLCAPI bool DCLDebugAllocGetPosition(
    const void*     _ptr,
    char_t*           _filename,
    size_t          _buflen,
    unsigned int*   _line
)
{
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    lockAlloc.lock();
    AllocList::Node* node = listAlloc.rfind(_ptr);
    if (node) {
        wcsncpy(_filename, node->filename, _buflen);
        *_line = node->line;
    }
    lockAlloc.unlock();
 
    return node != NULL;
}
 
/* 
return : _thread가 할당한 마지막 포지션 항목이 없으면 NULL
*/
DCLCAPI const void* DCLDebugGetLastAllocPosition(
    thread_t _thread
)
{
    const void* ptr = NULL;
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    lockAlloc.lock();
    AllocList::Node* node = listAlloc.end();
    while(node) {
        if (node->thread == _thread) {
            ptr = (const void*)node;
            break;
        }
 
        listAlloc.prev(node);
    }
    lockAlloc.unlock();
 
    return ptr;
}
 
/* 
_thread의 _startPosition에서 처음까지의 메모리 누출 보고
return : 메모리 누출 항목의 갯수 >= 0
*/
DCLCAPI size_t DCLDebugDumpThreadMemoryLeak(
    thread_t _thread,
    const void* _startPosition,
    DCLAllocLeakDumpLevel _level,
    __DCL_NAMESPACE Writer* _writer
)
{
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    lockAlloc.lock();
    AllocList::Node* startNode = listAlloc.begin();
    AllocList::Node* node = startNode;
    if (_startPosition) {
        while(node) {
            if (_startPosition == (const void*)node) {
                listAlloc.next(node);
                startNode = node;
                break;
            }
            listAlloc.next(node);
        }
    }
 
    // _thread인 노드 갯수
    size_t count = 0;
    node = startNode;
    while(node) {
        if (node->thread == _thread) {
            count++;
        }
        listAlloc.next(node);
    }
 
    AllocList::Node* leeks = NULL;
    if (count) {
        // 메모리 누출이 있으면 이를 출력할 임시 버퍼를 할당한다.
        // pWriter에서 메모리할당을 할 경우 그대로 사용하면 deadlock이 발생한다.
        // lockAlloc 이 lock 되어 있다.
        leeks = (AllocList::Node*) malloc(AllocList::Node::SIZE() * count);
        if (!leeks) {
            // 메모리를 할당할 수 없다.
            lockAlloc.unlock();
            return -1;
        }
 
        node = startNode;
        int i = 0;
        while(node) {
            if (node->thread == _thread)
                memcpy(&leeks[i++], node, AllocList::Node::SIZE());
 
            listAlloc.next(node);
        }
        __DCL_ASSERT_N(i  == count);
    }
    lockAlloc.unlock();
 
    // lockAlloc이 unlock 되었으므로 Writer는 출력 중에 메모리를 할당할 수 있다.
    if (count) {
        bool header = false;
        bool print = false;
 
        node = leeks;
        for(size_t i = 0; i < count; i++) {
            switch(_level) {
                default :
                case DCL_ALLOC_DUMP_ALL :
                    print = true;
                    break;
                case DCL_ALLOC_DUMP_INTERNAL :
                    print = !(node->check);
                    break;
                case DCL_ALLOC_DUMP_USER :
                    print = node->check;
                    break;
            }
 
            if (print) {
                if (!header) {
                    _writer->printf(
                        __T("Thread memory leak!\n  thread:%zd\n"),
                        (size_t)_thread
                    );
                    header = true;
                }
 
                try {
                    _writer->printf(L"  %2d:%lc:%ls:%d:%ls:%zdbytes:%p\n",
                        i + 1,
                        node->check ? L'U' : L'I',
                        *(node->filename) ? node->filename : L"(unknown)",
                        node->line,
                        __AllocTypeStr(node->func),
                        node->size,
                        node->data
                    );
            }
                catch(IOException* _e) {
                    _e->destroy();
                    // Writer 출력중에 에러가 발생했다.
                    count = -1;
                    break;
                }
            }
            node++;
        }   // end of for
        free(leeks);
    }
 
    return count;
}
 
DCLCAPI size_t DCLDebugDumpGlobalMemoryLeak(
    DCLAllocLeakDumpLevel _level,
    __DCL_NAMESPACE Writer* _writer
)
{
    AllocList::Node* node = NULL;
    AllocList::Node* leeks = NULL;
 
    AllocList& listAlloc = __LibState__->listAlloc;
    InternalMutex& lockAlloc = __LibState__->lockAlloc;
 
    lockAlloc.lock();
    size_t count = listAlloc.count();
    if (count > 0) {
        // 메모리 누출이 있으면 이를 출력할 임시 버퍼를 할당한다.
        // pWriter에서 메모리할당을 할 경우 그대로 사용하면 deadlock이 발생한다.
        // lockAlloc 이 lock 되어 있다.
        leeks = (AllocList::Node*)malloc(AllocList::Node::SIZE() * count);
        if (!leeks) {
            // 메모리를 할당할 수 없다.
            lockAlloc.unlock();
            return -1;
        }
 
        node = listAlloc.begin();
        size_t i = 0;
        while(node) {
            memcpy(&leeks[i++], node, AllocList::Node::SIZE());
            listAlloc.next(node);
        }
        __DCL_ASSERT_N(i == count);
    }
    lockAlloc.unlock();
 
    // lockAlloc이 unlock 되었으므로 Writer는 출력 중에 메모리를 할당할 수 있다.
    if (count) {
        bool header = false;
        bool print = false;
 
        node = leeks;
        for(size_t i = 0; i < count; i++) {
            switch(_level) {
                default :
                case DCL_ALLOC_DUMP_ALL :
                    print = true;
                    break;
                case DCL_ALLOC_DUMP_INTERNAL :
                    print = !(node->check);
                    break;
                case DCL_ALLOC_DUMP_USER :
                    print = node->check;
                    break;
            }
 
            if (print) {
                if (!header) {
                    _writer->printf(L"Global memory leak!\n");
                    header = true;
                }
 
                try {
                    _writer->printf(L"  %2d:%zd:%lc:%ls:%d:%ls:%zdbytes:%p\n",
                        i + 1,
                        (size_t)(node->thread),
                        node->check ? L'U' : L'I',
                        *(node->filename) ? node->filename : L"(unknown)",
                        node->line,
                        __AllocTypeStr(node->func),
                        node->size,
                        node->data
                    );
                }
                catch(IOException* _e) {
                    _e->destroy();
                    // Writer 출력중에 에러가 발생했다.
                    count = -1;
                    break;
                }
            }
            node++;
        }
        free(leeks);
    }
 
    return count;
}

// C++ new/delete
 
DCLCAPI void* operator new(
    size_t          _size,
    bool            _check,
    const char_t* _filename,
    unsigned int    _line
)
{
    return DCLDebugMalloc(
        _size == 0 ? 1 : _size,
        _check,
        DCL_ALLOC_NEW, 
        _filename,
        _line
    );
}
 
DCLCAPI void* operator new[](
    size_t          _size,
    bool            _check,
    const char_t* _filename,
    unsigned int    _line
)
{
    return DCLDebugMalloc(
        _size == 0 ? 1 : _size,
        _check,
        DCL_ALLOC_NEW_ARRAY,
        _filename,
        _line
    );
}
 
DCLCAPI void operator delete(
    void*           _ptr,
    bool            ,// _check
    const char_t* _filename,
    unsigned int    _line
) noexcept
{
    DCLDebugFree(
        _ptr,
        DCL_ALLOC_DELETE,
        _filename,
        _line
    );
}
 
DCLCAPI void operator delete[](
    void*           _ptr,
    bool            ,// _check
    const char_t* _filename,
    unsigned int    _line
) noexcept
{
    DCLDebugFree(
        _ptr,
        DCL_ALLOC_DELETE_ARRAY,
        _filename,
        _line
    );
}
 
#ifdef __WINNT__
    #ifdef _DLL
    __WINNT_NEW_DELETE_OVERRIDE
    #endif
#else
// MinGW clang++ 및 UNIX g++, clang++
DCLCAPI void* operator new(size_t _size)
{
    void* r = DCLDebugMalloc(
        _size == 0 ? 1 : _size,
        true,
        DCL_ALLOC_NEW,
        NULL,
        0
    );
#if __DCL_TRACE_INTNAL_
    fprintf(stderr, "%ls:%d new %zd %p\n",
        __near_filename ? __near_filename : L"(unknown)",
        __near_line, _size, r
    );
#endif
    return r;
}
 
DCLCAPI void* operator new[](size_t _size)
{
    void* r = DCLDebugMalloc(
        _size == 0 ? 1 : _size,
        true,
        DCL_ALLOC_NEW_ARRAY,
        NULL,
        0
    );
#if __DCL_TRACE_INTNAL_
    fprintf(stderr, "%ls:%d new[] %zd %p\n",
        __near_filename ? __near_filename : L"(unknown)",
        __near_line, _size, r
    );
#endif
    return r;
}
 
DCLCAPI void operator delete(void* _ptr) noexcept
{
#if __DCL_TRACE_INTNAL_
    fprintf(stderr, "%ls:%d delete %p\n",
        __near_filename ? __near_filename : L"(unknown)",
        __near_line, _ptr
    );
#endif
    DCLDebugFree(_ptr, DCL_ALLOC_DELETE, NULL, 0);
}
 
DCLCAPI void operator delete[](void* _ptr) noexcept
{
#if __DCL_TRACE_INTNAL_
    fprintf(stderr, "%ls:%d delete[] %p\n",
        __near_filename ? __near_filename : L"(unknown)",
        __near_line, _ptr
    );
#endif
    DCLDebugFree(_ptr, DCL_ALLOC_DELETE_ARRAY, NULL, 0);
}
 
#endif
 
#endif  // __DCL_HAVE_ALLOC_DEBUG