debug_new.cpp File Reference

(986a3bf)

#include "localconsts.h"
#include <new>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "debug/nvwa/_nvwa.h"
#include "debug/nvwa/c++11.h"
#include "debug/nvwa/fast_mutex.h"
#include "debug/nvwa/static_assert.h"
#include "debug/nvwa/debug_new.h"

Go to the source code of this file.

Data Structures
struct	new_ptr_list_t

Macros
#define	_DEBUG_NEW_REDEFINE_NEW   0
#define	_DEBUG_NEW_ALIGNMENT   16
#define	_DEBUG_NEW_CALLER_ADDRESS   _NULLPTR
#define	_DEBUG_NEW_ERROR_ACTION   abort()
#define	_DEBUG_NEW_FILENAME_LEN   44
#define	_DEBUG_NEW_PROGNAME   _NULLPTR
#define	_DEBUG_NEW_REMEMBER_STACK_TRACE   0
#define	_DEBUG_NEW_STD_OPER_NEW   1
#define	_DEBUG_NEW_TAILCHECK   0
#define	_DEBUG_NEW_USE_ADDR2LINE   0
#define	ALIGN(s)    (((s) + _DEBUG_NEW_ALIGNMENT - 1) & ~(_DEBUG_NEW_ALIGNMENT - 1))

Functions
static bool	print_position_from_addr (const void *)
static void	print_position (const void *ptr, int line)
static bool	is_leak_whitelisted (new_ptr_list_t *ptr)
static void *	alloc_mem (size_t size, const char *file, int line, bool is_array)
static void	free_pointer (void *usr_ptr, void *addr, bool is_array)
int	check_leaks ()
int	check_mem_corruption ()
void *	operator new (size_t size, const char *file, int line)
void *	operator new[] (size_t size, const char *file, int line)
void *	operator new (size_t size)
void *	operator new[] (size_t size)
void *	operator new (size_t size, const std::nothrow_t &) throw ()
void *	operator new[] (size_t size, const std::nothrow_t &) throw ()
void	operator delete (void *ptr) throw ()
void	operator delete[] (void *ptr) throw ()
void	operator delete (void *ptr, const char *file, int line) throw ()
void	operator delete[] (void *ptr, const char *file, int line) throw ()
void	operator delete (void *ptr, const std::nothrow_t &) throw ()
void	operator delete[] (void *ptr, const std::nothrow_t &) throw ()

Variables
static const unsigned	DEBUG_NEW_MAGIC = 0x4442474E
static const int	ALIGNED_LIST_ITEM_SIZE = ((( sizeof(new_ptr_list_t) ) + 16 - 1) & ~( 16 - 1))
static new_ptr_list_t	new_ptr_list
static fast_mutex	new_ptr_lock
static fast_mutex	new_output_lock
static size_t	total_mem_alloc = 0
bool	new_autocheck_flag = true
bool	new_verbose_flag = false
FILE *	new_output_fp = stderr
const char *	new_progname = ((void *)0)
stacktrace_print_callback_t	stacktrace_print_callback = ((void *)0)
leak_whitelist_callback_t	leak_whitelist_callback = ((void *)0)

Detailed Description

Implementation of debug versions of new and delete to check leakage.

Date

2016-10-14

Definition in file debug_new.cpp.

Macro Definition Documentation

_DEBUG_NEW_ALIGNMENT

#define _DEBUG_NEW_ALIGNMENT   16

_DEBUG_NEW_CALLER_ADDRESS

#define _DEBUG_NEW_CALLER_ADDRESS   _NULLPTR

The expression to return the caller address. nvwa::print_position will later on use this address to print the position information of memory operation points.

_DEBUG_NEW_ERROR_ACTION

#define _DEBUG_NEW_ERROR_ACTION   abort()

The action to take when an error occurs. The default behaviour is to call abort, unless _DEBUG_NEW_ERROR_CRASH is defined, in which case a segmentation fault will be triggered instead (which can be useful on platforms like Windows that do not generate a core dump when abort is called).

_DEBUG_NEW_FILENAME_LEN

#define _DEBUG_NEW_FILENAME_LEN   44

The length of file name stored if greater than zero. If it is zero, only a const char pointer will be stored. Currently the default value is non-zero (thus to copy the file name) on non-Windows platforms, because I once found that the exit leakage check could not access the address of the file name on Linux (in my case, a core dump occurred when check_leaks tried to access the file name in a shared library after a SIGINT). This value makes the size of new_ptr_list_t 64 on non-Windows 32-bit platforms (w/o stack backtrace).

_DEBUG_NEW_PROGNAME

#define _DEBUG_NEW_PROGNAME   _NULLPTR

The program (executable) name to be set at compile time. It is better to assign the full program path to nvwa::new_progname in main (at run time) than to use this (compile-time) macro, but this macro serves well as a quick hack. Note also that double quotation marks need to be used around the program name, i.e., one should specify a command-line option like -D_DEBUG_NEW_PROGNAME=\"a.out\" in bash, or -D_DEBUG_NEW_PROGNAME=\"a.exe\" in the Windows command prompt.

_DEBUG_NEW_REDEFINE_NEW

#define _DEBUG_NEW_REDEFINE_NEW   0

_DEBUG_NEW_REMEMBER_STACK_TRACE

#define _DEBUG_NEW_REMEMBER_STACK_TRACE   0

Macro to indicate whether stack traces of allocations should be included in NVWA allocation information and be printed while leaks are reported. Useful to pinpoint leaks caused by strdup and other custom allocation functions. It is also very helpful in filtering out false positives caused by internal STL/C runtime operations. It is off by default because it is quite memory heavy. Set it to 1 to make all allocations have stack trace attached, or set to 2 to make only allocations that lack calling source code information (file and line) have the stack trace attached.

_DEBUG_NEW_STD_OPER_NEW

#define _DEBUG_NEW_STD_OPER_NEW   1

Macro to indicate whether the standard-conformant behaviour of operator new is wanted. It is on by default now, but the user may set it to 0 to revert to the old behaviour.

_DEBUG_NEW_TAILCHECK

#define _DEBUG_NEW_TAILCHECK   0

Macro to indicate whether a writing-past-end check will be performed. Define it to a positive integer as the number of padding bytes at the end of a memory block for checking.

_DEBUG_NEW_USE_ADDR2LINE

#define _DEBUG_NEW_USE_ADDR2LINE   0

Whether to use addr2line to convert a caller address to file/line information. Defining it to a non-zero value will enable the conversion (automatically done if GCC is detected). Defining it to zero will disable the conversion.

ALIGN

#define ALIGN

(

s

)

(((s) + _DEBUG_NEW_ALIGNMENT - 1) & ~(_DEBUG_NEW_ALIGNMENT - 1))

Function Documentation

alloc_mem()

static void* alloc_mem ( size_t  size, const char *  file, int  line, bool  is_array  )

static

Allocates memory and initializes control data.

Parameters

size	size of the required memory block
file	null-terminated string of the file name
line	line number
is_array	boolean value whether this is an array operation

Returns

pointer to the user-requested memory area; null if memory allocation is not successful

Definition at line 587 of file debug_new.cpp.

{
    assert(line >= 0);
#if _DEBUG_NEW_TYPE == 1
    STATIC_ASSERT(_DEBUG_NEW_ALIGNMENT >= PLATFORM_MEM_ALIGNMENT,
                  Alignment_too_small);
#endif
    STATIC_ASSERT((_DEBUG_NEW_ALIGNMENT & (_DEBUG_NEW_ALIGNMENT - 1)) == 0,
                  Alignment_must_be_power_of_two);
    STATIC_ASSERT(_DEBUG_NEW_TAILCHECK >= 0, Invalid_tail_check_length);
    size_t s = size + ALIGNED_LIST_ITEM_SIZE + _DEBUG_NEW_TAILCHECK;
    new_ptr_list_t* ptr = (new_ptr_list_t*)malloc(s);
    if (ptr == _NULLPTR)
    {
#if _DEBUG_NEW_STD_OPER_NEW
        return _NULLPTR;
#else
        fast_mutex_autolock lock(new_output_lock);
        fprintf(new_output_fp,
                "Out of memory when allocating %lu bytes\n",
                (unsigned long)size);
        fflush(new_output_fp);
        _DEBUG_NEW_ERROR_ACTION;
#endif
    }
    void* usr_ptr = (char*)ptr + ALIGNED_LIST_ITEM_SIZE;
#if _DEBUG_NEW_FILENAME_LEN == 0
    ptr->file = file;
#else
    if (line)
        strncpy(ptr->file, file, _DEBUG_NEW_FILENAME_LEN - 1)
                [_DEBUG_NEW_FILENAME_LEN - 1] = '\0';
    else
        ptr->addr = (void*)file;
#endif
    ptr->line = line;
#if _DEBUG_NEW_REMEMBER_STACK_TRACE
    ptr->stacktrace = _NULLPTR;
 
#if _DEBUG_NEW_REMEMBER_STACK_TRACE == 2
    if (line == 0)
#endif
    {
        void* buffer [255];
        size_t buffer_length = sizeof(buffer) / sizeof(*buffer);
 
#if NVWA_UNIX
        int stacktrace_length = backtrace(buffer, int(buffer_length));
#endif
 
#if NVWA_WINDOWS
        USHORT stacktrace_length = CaptureStackBackTrace(
            0, DWORD(buffer_length), buffer, _NULLPTR);
#endif
 
        size_t stacktrace_size = stacktrace_length * sizeof(void*);
        ptr->stacktrace = (void**)malloc(stacktrace_size + sizeof(void*));
 
        if (ptr->stacktrace != _NULLPTR)
        {
            memcpy(ptr->stacktrace, buffer, stacktrace_size);
            ptr->stacktrace[stacktrace_length] = _NULLPTR;
        }
    }
#endif
    ptr->is_array = is_array;
    ptr->size = size;
    ptr->magic = DEBUG_NEW_MAGIC;
    {
        fast_mutex_autolock lock(new_ptr_lock);
        ptr->prev = new_ptr_list.prev;
        ptr->next = &new_ptr_list;
        new_ptr_list.prev->next = ptr;
        new_ptr_list.prev = ptr;
    }
#if _DEBUG_NEW_TAILCHECK
    memset((char*)usr_ptr + size, _DEBUG_NEW_TAILCHECK_CHAR,
                                  _DEBUG_NEW_TAILCHECK);
#endif
    if (new_verbose_flag)
    {
        fast_mutex_autolock lock(new_output_lock);
        fprintf(new_output_fp,
                "new%s: allocated %p (size %lu, ",
                is_array ? "[]" : "",
                usr_ptr, (unsigned long)size);
        if (line != 0)
            print_position(ptr->file, ptr->line);
        else
            print_position(ptr->addr, ptr->line);
        fprintf(new_output_fp, ")\n");
    }
    total_mem_alloc += size;
    return usr_ptr;
}

References _DEBUG_NEW_ALIGNMENT, _DEBUG_NEW_ERROR_ACTION, _DEBUG_NEW_FILENAME_LEN, _DEBUG_NEW_TAILCHECK, _NULLPTR, new_ptr_list_t::addr, ALIGNED_LIST_ITEM_SIZE, DEBUG_NEW_MAGIC, new_ptr_list_t::file, new_ptr_list_t::is_array, new_ptr_list_t::line, new_ptr_list_t::magic, new_output_fp, new_output_lock, new_ptr_list, new_ptr_lock, new_verbose_flag, new_ptr_list_t::next, new_ptr_list_t::prev, print_position(), new_ptr_list_t::size, EmoteDB::size(), STATIC_ASSERT, and total_mem_alloc.

Referenced by operator new(), and operator new[]().

check_leaks()

int check_leaks

(

)

Checks for memory leaks.

Returns

zero if no leakage is found; the number of leaks otherwise

Definition at line 769 of file debug_new.cpp.

{
    int leak_cnt = 0;
    int whitelisted_leak_cnt = 0;
    fast_mutex_autolock lock_ptr(new_ptr_lock);
    fast_mutex_autolock lock_output(new_output_lock);
    new_ptr_list_t* ptr = new_ptr_list.next;
 
    while (ptr != &new_ptr_list)
    {
        const char* const usr_ptr = (char*)ptr + ALIGNED_LIST_ITEM_SIZE;
        if (ptr->magic != DEBUG_NEW_MAGIC)
        {
            fprintf(new_output_fp,
                    "warning: heap data corrupt near %p\n",
                    usr_ptr);
        }
#if _DEBUG_NEW_TAILCHECK
        if (!check_tail(ptr))
        {
            fprintf(new_output_fp,
                    "warning: overwritten past end of object at %p\n",
                    usr_ptr);
        }
#endif
 
        if (is_leak_whitelisted(ptr))
        {
            ++whitelisted_leak_cnt;
        }
        else
        {
            fprintf(new_output_fp,
                    "Leaked object at %p (size %lu, ",
                    usr_ptr,
                    (unsigned long)ptr->size);
 
            if (ptr->line != 0)
                print_position(ptr->file, ptr->line);
            else
                print_position(ptr->addr, ptr->line);
 
            fprintf(new_output_fp, ")\n");
 
#if _DEBUG_NEW_REMEMBER_STACK_TRACE
            if (ptr->stacktrace != _NULLPTR)
                print_stacktrace(ptr->stacktrace);
#endif
        }
 
        ptr = ptr->next;
        ++leak_cnt;
    }
    if (new_verbose_flag || leak_cnt)
    {
        if (whitelisted_leak_cnt > 0)
        {
            fprintf(new_output_fp, "*** %d leaks found (%d whitelisted)\n",
                leak_cnt, whitelisted_leak_cnt);
        }
        else
        {
            fprintf(new_output_fp, "*** %d leaks found\n", leak_cnt);
        }
    }
 
    return leak_cnt;
}

References _NULLPTR, new_ptr_list_t::addr, ALIGNED_LIST_ITEM_SIZE, DEBUG_NEW_MAGIC, new_ptr_list_t::file, is_leak_whitelisted(), new_ptr_list_t::line, new_ptr_list_t::magic, new_output_fp, new_output_lock, new_ptr_list, new_ptr_lock, new_verbose_flag, new_ptr_list_t::next, print_position(), and new_ptr_list_t::size.

Referenced by debug_new_counter::~debug_new_counter().

check_mem_corruption()

int check_mem_corruption

(

)

Checks for heap corruption.

Returns

zero if no problem is found; the number of found memory corruptions otherwise

Definition at line 844 of file debug_new.cpp.

{
    int corrupt_cnt = 0;
    fast_mutex_autolock lock_ptr(new_ptr_lock);
    fast_mutex_autolock lock_output(new_output_lock);
    fprintf(new_output_fp, "*** Checking for memory corruption: START\n");
    for (new_ptr_list_t* ptr = new_ptr_list.next;
            ptr != &new_ptr_list;
            ptr = ptr->next)
    {
        const char* const usr_ptr = (char*)ptr + ALIGNED_LIST_ITEM_SIZE;
        if (ptr->magic == DEBUG_NEW_MAGIC
#if _DEBUG_NEW_TAILCHECK
                && check_tail(ptr)
#endif
                )
            continue;
#if _DEBUG_NEW_TAILCHECK
        if (ptr->magic != DEBUG_NEW_MAGIC)
        {
#endif
            fprintf(new_output_fp,
                    "Heap data corrupt near %p (size %lu, ",
                    usr_ptr,
                    (unsigned long)ptr->size);
#if _DEBUG_NEW_TAILCHECK
        }
        else
        {
            fprintf(new_output_fp,
                    "Overwritten past end of object at %p (size %lu, ",
                    usr_ptr,
                    (unsigned long)ptr->size);
        }
#endif
        if (ptr->line != 0)
            print_position(ptr->file, ptr->line);
        else
            print_position(ptr->addr, ptr->line);
        fprintf(new_output_fp, ")\n");
 
#if _DEBUG_NEW_REMEMBER_STACK_TRACE
        if (ptr->stacktrace != _NULLPTR)
            print_stacktrace(ptr->stacktrace);
#endif
 
        ++corrupt_cnt;
    }
    fprintf(new_output_fp, "*** Checking for memory corruption: %d FOUND\n",
            corrupt_cnt);
    return corrupt_cnt;
}

References _DEBUG_NEW_TAILCHECK, _NULLPTR, new_ptr_list_t::addr, ALIGNED_LIST_ITEM_SIZE, DEBUG_NEW_MAGIC, new_ptr_list_t::file, new_ptr_list_t::line, new_ptr_list_t::magic, new_output_fp, new_output_lock, new_ptr_list, new_ptr_lock, new_ptr_list_t::next, print_position(), and new_ptr_list_t::size.

Referenced by free_pointer().

free_pointer()

static void free_pointer ( void *  usr_ptr, void *  addr, bool  is_array  )

static

Frees memory and adjusts pointers.

Parameters

usr_ptr	pointer to the previously allocated memory
addr	pointer to the caller
is_array	flag indicating whether it is invoked by a delete[] call

Definition at line 691 of file debug_new.cpp.

{
    if (usr_ptr == _NULLPTR)
        return;
    new_ptr_list_t* ptr =
            (new_ptr_list_t*)((char*)usr_ptr - ALIGNED_LIST_ITEM_SIZE);
    if (ptr->magic != DEBUG_NEW_MAGIC)
    {
        {
            fast_mutex_autolock lock(new_output_lock);
            fprintf(new_output_fp, "delete%s: invalid pointer %p (",
                    is_array ? "[]" : "", usr_ptr);
            print_position(addr, 0);
            fprintf(new_output_fp, ")\n");
        }
        check_mem_corruption();
        fflush(new_output_fp);
        _DEBUG_NEW_ERROR_ACTION;
    }
    if (is_array != ptr->is_array)
    {
        const char* msg;
        if (is_array)
            msg = "delete[] after new";
        else
            msg = "delete after new[]";
        fast_mutex_autolock lock(new_output_lock);
        fprintf(new_output_fp,
                "%s: pointer %p (size %lu)\n\tat ",
                msg,
                (char*)ptr + ALIGNED_LIST_ITEM_SIZE,
                (unsigned long)ptr->size);
        print_position(addr, 0);
        fprintf(new_output_fp, "\n\toriginally allocated at ");
        if (ptr->line != 0)
            print_position(ptr->file, ptr->line);
        else
            print_position(ptr->addr, ptr->line);
        fprintf(new_output_fp, "\n");
        fflush(new_output_fp);
        _DEBUG_NEW_ERROR_ACTION;
    }
#if _DEBUG_NEW_TAILCHECK
    if (!check_tail(ptr))
    {
        check_mem_corruption();
        fflush(new_output_fp);
        _DEBUG_NEW_ERROR_ACTION;
    }
#endif
    {
        fast_mutex_autolock lock(new_ptr_lock);
        total_mem_alloc -= ptr->size;
        ptr->magic = 0;
        ptr->prev->next = ptr->next;
        ptr->next->prev = ptr->prev;
    }
    if (new_verbose_flag)
    {
        fast_mutex_autolock lock(new_output_lock);
        fprintf(new_output_fp,
                "delete%s: freed %p (size %lu, %lu bytes still allocated)\n",
                is_array ? "[]" : "",
                (char*)ptr + ALIGNED_LIST_ITEM_SIZE,
                (unsigned long)ptr->size, (unsigned long)total_mem_alloc);
    }
#if _DEBUG_NEW_REMEMBER_STACK_TRACE
    free(ptr->stacktrace);
#endif
    free(ptr);
    return;
}

References _DEBUG_NEW_ERROR_ACTION, _NULLPTR, new_ptr_list_t::addr, ALIGNED_LIST_ITEM_SIZE, check_mem_corruption(), DEBUG_NEW_MAGIC, new_ptr_list_t::file, new_ptr_list_t::is_array, new_ptr_list_t::line, new_ptr_list_t::magic, Actions::msg(), new_output_fp, new_output_lock, new_ptr_lock, new_verbose_flag, new_ptr_list_t::next, new_ptr_list_t::prev, print_position(), new_ptr_list_t::size, and total_mem_alloc.

Referenced by operator delete(), and operator delete[]().

is_leak_whitelisted()

static bool is_leak_whitelisted ( new_ptr_list_t *  ptr )

static

Checks whether a leak should be ignored. Its runtime performance depends on the callback nvwa::leak_whitelist_callback.

Parameters

ptr	pointer to a new_ptr_list_t struct

Returns

true if the leak should be whitelisted; false otherwise

Definition at line 540 of file debug_new.cpp.

{
    if (leak_whitelist_callback == _NULLPTR)
        return false;
 
    char const* file = ptr->line != 0 ? ptr->file : _NULLPTR;
    int line = ptr->line;
    void* addr = ptr->line == 0 ? ptr->addr : _NULLPTR;
#if _DEBUG_NEW_REMEMBER_STACK_TRACE
    void** stacktrace = ptr->stacktrace;
#else
    void** stacktrace = _NULLPTR;
#endif
 
    return leak_whitelist_callback(file, line, addr, stacktrace);
}

References _NULLPTR, new_ptr_list_t::addr, new_ptr_list_t::file, leak_whitelist_callback, and new_ptr_list_t::line.

Referenced by check_leaks().

operator delete() [1/3]

void operator delete	(	void *	ptr	)
throw	(
	)

Deallocates memory.

Parameters

ptr	pointer to the previously allocated memory

Definition at line 1094 of file debug_new.cpp.

{
    free_pointer(ptr, _DEBUG_NEW_CALLER_ADDRESS, false);
}

References _DEBUG_NEW_CALLER_ADDRESS, and free_pointer().

operator delete() [2/3]

void operator delete	(	void *	ptr,
		const char *	file,
		int	line
	)
throw	(
	)

Placement deallocation function. For details, please check Section 5.3.4 of the C++ 1998 or 2011 Standard.

Parameters

ptr	pointer to the previously allocated memory
file	null-terminated string of the file name
line	line number

See also

http://www.csci.csusb.edu/dick/c++std/cd2/expr.html#expr.new

http://wyw.dcweb.cn/leakage.htm

Definition at line 1134 of file debug_new.cpp.

{
    if (new_verbose_flag)
    {
        fast_mutex_autolock lock(new_output_lock);
        fprintf(new_output_fp,
                "info: exception thrown on initializing object at %p (",
                ptr);
        print_position(file, line);
        fprintf(new_output_fp, ")\n");
    }
    operator delete(ptr);
}

References new_output_fp, new_output_lock, new_verbose_flag, and print_position().

operator delete() [3/3]

void operator delete	(	void *	ptr,
		const std::nothrow_t &
	)
throw	(
	)

Placement deallocation function. For details, please check Section 5.3.4 of the C++ 1998 or 2011 Standard.

Parameters

ptr	pointer to the previously allocated memory

Definition at line 1176 of file debug_new.cpp.

{
    operator delete(ptr, (char*)_DEBUG_NEW_CALLER_ADDRESS, 0);
}

References _DEBUG_NEW_CALLER_ADDRESS.

operator delete[]() [1/3]

void operator delete[]	(	void *	ptr	)
throw	(
	)

Deallocates array memory.

Parameters

ptr	pointer to the previously allocated memory

Definition at line 1104 of file debug_new.cpp.

{
    free_pointer(ptr, _DEBUG_NEW_CALLER_ADDRESS, true);
}

References _DEBUG_NEW_CALLER_ADDRESS, and free_pointer().

operator delete[]() [2/3]

void operator delete[]	(	void *	ptr,
		const char *	file,
		int	line
	)
throw	(
	)

Placement deallocation function. For details, please check Section 5.3.4 of the C++ 1998 or 2011 Standard.

Parameters

ptr	pointer to the previously allocated memory
file	null-terminated string of the file name
line	line number

Definition at line 1156 of file debug_new.cpp.

{
    if (new_verbose_flag)
    {
        fast_mutex_autolock lock(new_output_lock);
        fprintf(new_output_fp,
                "info: exception thrown on initializing objects at %p (",
                ptr);
        print_position(file, line);
        fprintf(new_output_fp, ")\n");
    }
    operator delete[](ptr);
}

References new_output_fp, new_output_lock, new_verbose_flag, and print_position().

operator delete[]() [3/3]

void operator delete[]	(	void *	ptr,
		const std::nothrow_t &
	)
throw	(
	)

Placement deallocation function. For details, please check Section 5.3.4 of the C++ 1998 or 2011 Standard.

Parameters

ptr	pointer to the previously allocated memory

Definition at line 1187 of file debug_new.cpp.

{
    operator delete[](ptr, (char*)_DEBUG_NEW_CALLER_ADDRESS, 0);
}

References _DEBUG_NEW_CALLER_ADDRESS.

operator new() [1/3]

void* operator new

(

size_t

size

)

Allocates memory without file/line information.

Parameters

size	size of the required memory block

Returns

pointer to the memory allocated; or null if memory is insufficient (_DEBUG_NEW_STD_OPER_NEW is 0)

Exceptions

bad_alloc

memory is insufficient (_DEBUG_NEW_STD_OPER_NEW is 1)

Definition at line 1047 of file debug_new.cpp.

{
    return operator new(size, (char*)_DEBUG_NEW_CALLER_ADDRESS, 0);
}

References _DEBUG_NEW_CALLER_ADDRESS, and EmoteDB::size().

operator new() [2/3]

void* operator new	(	size_t	size,
		const char *	file,
		int	line
	)

Allocates memory with file/line information.

Parameters

size	size of the required memory block
file	null-terminated string of the file name
line	line number

Returns

pointer to the memory allocated; or null if memory is insufficient (_DEBUG_NEW_STD_OPER_NEW is 0)

Exceptions

bad_alloc

memory is insufficient (_DEBUG_NEW_STD_OPER_NEW is 1)

Definition at line 1003 of file debug_new.cpp.

{
    void* ptr = alloc_mem(size, file, line, false);
#if _DEBUG_NEW_STD_OPER_NEW
    if (ptr)
        return ptr;
    else
        throw std::bad_alloc();
#else
    return ptr;
#endif
}

References alloc_mem(), and EmoteDB::size().

operator new() [3/3]

void* operator new	(	size_t	size,
		const std::nothrow_t &
	)
throw	(
	)

Allocates memory with no-throw guarantee.

Parameters

size	size of the required memory block

Returns

pointer to the memory allocated; or null if memory is insufficient

Definition at line 1072 of file debug_new.cpp.

{
    return alloc_mem(size, (char*)_DEBUG_NEW_CALLER_ADDRESS, 0, false);
}

References _DEBUG_NEW_CALLER_ADDRESS, alloc_mem(), and EmoteDB::size().

operator new[]() [1/3]

void* operator new[]

(

size_t

size

)

Allocates array memory without file/line information.

Parameters

size	size of the required memory block

Returns

pointer to the memory allocated; or null if memory is insufficient (_DEBUG_NEW_STD_OPER_NEW is 0)

Exceptions

bad_alloc

memory is insufficient (_DEBUG_NEW_STD_OPER_NEW is 1)

Definition at line 1060 of file debug_new.cpp.

{
    return operator new[](size, (char*)_DEBUG_NEW_CALLER_ADDRESS, 0);
}

References _DEBUG_NEW_CALLER_ADDRESS, and EmoteDB::size().

operator new[]() [2/3]

void* operator new[]	(	size_t	size,
		const char *	file,
		int	line
	)

Allocates array memory with file/line information.

Parameters

size	size of the required memory block
file	null-terminated string of the file name
line	line number

Returns

pointer to the memory allocated; or null if memory is insufficient (_DEBUG_NEW_STD_OPER_NEW is 0)

Exceptions

bad_alloc

memory is insufficient (_DEBUG_NEW_STD_OPER_NEW is 1)

Definition at line 1026 of file debug_new.cpp.

{
    void* ptr = alloc_mem(size, file, line, true);
#if _DEBUG_NEW_STD_OPER_NEW
    if (ptr)
        return ptr;
    else
        throw std::bad_alloc();
#else
    return ptr;
#endif
}

References alloc_mem(), and EmoteDB::size().

operator new[]() [3/3]

void* operator new[]	(	size_t	size,
		const std::nothrow_t &
	)
throw	(
	)

Allocates array memory with no-throw guarantee.

Parameters

size	size of the required memory block

Returns

pointer to the memory allocated; or null if memory is insufficient

Definition at line 1084 of file debug_new.cpp.

{
    return alloc_mem(size, (char*)_DEBUG_NEW_CALLER_ADDRESS, 0, true);
}

References _DEBUG_NEW_CALLER_ADDRESS, alloc_mem(), and EmoteDB::size().

print_position()

static void print_position ( const void *  ptr, int  line  )

static

Prints the position information of a memory operation point. When _DEBUG_NEW_USE_ADDR2LINE is defined to a non-zero value, this function will try to convert a given caller address to file/line information with addr2line.

Parameters

ptr	source file name if line is non-zero; caller address otherwise
line	source line number if non-zero; indication that ptr is the caller address otherwise

Definition at line 488 of file debug_new.cpp.

{
    if (line != 0)             // Is file/line information present?
    {
        fprintf(new_output_fp, "%s:%d", (const char*)ptr, line);
    }
    else if (ptr != _NULLPTR)  // Is caller address present?
    {
        if (!print_position_from_addr(ptr)) // Fail to get source position?
            fprintf(new_output_fp, "%p", ptr);
    }
    else                       // No information is present
    {
        fprintf(new_output_fp, "<Unknown>");
    }
}

References _NULLPTR, new_output_fp, and print_position_from_addr().

Referenced by alloc_mem(), check_leaks(), check_mem_corruption(), free_pointer(), operator delete(), and operator delete[]().

print_position_from_addr()

static bool print_position_from_addr ( const void *  )

static

Tries printing the position information from an instruction address. This is the stub version that does nothing at all.

Returns

false always

Definition at line 471 of file debug_new.cpp.

{
    return false;
}

Referenced by print_position().

Variable Documentation

ALIGNED_LIST_ITEM_SIZE

const int ALIGNED_LIST_ITEM_SIZE = ((( sizeof(new_ptr_list_t) ) + 16 - 1) & ~( 16 - 1))

static

The extra memory allocated by operator new.

Definition at line 290 of file debug_new.cpp.

Referenced by debug_new_recorder::_M_process(), alloc_mem(), check_leaks(), check_mem_corruption(), and free_pointer().

DEBUG_NEW_MAGIC

const unsigned DEBUG_NEW_MAGIC = 0x4442474E

static

Definition of the constant magic number used for error detection.

Definition at line 285 of file debug_new.cpp.

Referenced by debug_new_recorder::_M_process(), alloc_mem(), check_leaks(), check_mem_corruption(), and free_pointer().

leak_whitelist_callback

leak_whitelist_callback_t leak_whitelist_callback = ((void *)0)

Pointer to the callback used to filter out false positives from leak reports. A null value means the lack of filtering.

Definition at line 368 of file debug_new.cpp.

Referenced by is_leak_whitelisted().

new_autocheck_flag

bool new_autocheck_flag = true

Flag to control whether nvwa::check_leaks will be automatically called on program exit.

Definition at line 333 of file debug_new.cpp.

Referenced by debug_new_counter::~debug_new_counter().

new_output_fp

FILE* new_output_fp = stderr

Pointer to the output stream. The default output is stderr, and one may change it to a user stream if needed (say, new_verbose_flag is true and there are a lot of (de)allocations).

Definition at line 345 of file debug_new.cpp.

Referenced by debug_new_recorder::_M_process(), alloc_mem(), check_leaks(), check_mem_corruption(), free_pointer(), operator delete(), operator delete[](), print_position(), and debug_new_counter::~debug_new_counter().

new_output_lock

fast_mutex new_output_lock

static

The mutex guard to protect simultaneous output to new_output_fp.

Definition at line 322 of file debug_new.cpp.

Referenced by debug_new_recorder::_M_process(), alloc_mem(), check_leaks(), check_mem_corruption(), free_pointer(), operator delete(), and operator delete[]().

new_progname

const char* new_progname = ((void *)0)

Pointer to the program name. Its initial value is the macro _DEBUG_NEW_PROGNAME. You should try to assign the program path to it early in your application. Assigning argv[0] to it in main is one way. If you use bash or ksh (or similar), the following statement is probably what you want: ‘new_progname = getenv("_");’.

Definition at line 355 of file debug_new.cpp.

new_ptr_list

new_ptr_list_t new_ptr_list

static

Initial value:

= {
    &new_ptr_list,
    &new_ptr_list,
    0,
    {
 
 
 
        ""
 
    },
    0,
    0,
 
 
 
    DEBUG_NEW_MAGIC
}

List of all new'd pointers.

Definition at line 295 of file debug_new.cpp.

Referenced by alloc_mem(), check_leaks(), and check_mem_corruption().

new_ptr_lock

fast_mutex new_ptr_lock

static

The mutex guard to protect simultaneous access to the pointer list.

Definition at line 317 of file debug_new.cpp.

Referenced by alloc_mem(), check_leaks(), check_mem_corruption(), and free_pointer().

new_verbose_flag

bool new_verbose_flag = false

Flag to control whether verbose messages are output.

Definition at line 338 of file debug_new.cpp.

Referenced by debug_new_recorder::_M_process(), alloc_mem(), check_leaks(), free_pointer(), operator delete(), operator delete[](), and debug_new_counter::~debug_new_counter().

stacktrace_print_callback

stacktrace_print_callback_t stacktrace_print_callback = ((void *)0)

Pointer to the callback used to print the stack backtrace in case of a memory problem. A null value causes the default stack trace printing routine to be used.

Definition at line 362 of file debug_new.cpp.

total_mem_alloc

size_t total_mem_alloc = 0

static

Total memory allocated in bytes.

Definition at line 327 of file debug_new.cpp.

Referenced by alloc_mem(), and free_pointer().