debug_new_recorder Class Reference

#include <debug_new.h>

Public Member Functions
	debug_new_recorder (const char *file, int line)
template<class _Tp >
_Tp *	operator->* (_Tp *ptr)

Private Member Functions
void	_M_process (void *ptr)
	debug_new_recorder (const debug_new_recorder &)
debug_new_recorder &	operator= (const debug_new_recorder &)

Private Attributes
const char *	_M_file
const int	_M_line

Detailed Description

Recorder class to remember the call context.

The idea comes from Greg Herlihy's post in comp.lang.c++.moderated.

Definition at line 164 of file debug_new.h.

Constructor & Destructor Documentation

debug_new_recorder() [1/2]

debug_new_recorder::debug_new_recorder ( const char *  file, int  line  )

inline

Constructor to remember the call context. The information will be used in debug_new_recorder::operator->*.

Definition at line 174 of file debug_new.h.

 : _M_file(file), _M_line(line) {}

debug_new_recorder() [2/2]

debug_new_recorder::debug_new_recorder ( const debug_new_recorder &  )

private

Member Function Documentation

_M_process()

void debug_new_recorder::_M_process ( void *  usr_ptr )

private

Processes the allocated memory and inserts file/line informatin. It will only be done when it can ensure the memory is allocated by one of our operator new variants.

Parameters

usr_ptr

pointer returned by a new-expression

Definition at line 904 of file debug_new.cpp.

{
 if (usr_ptr == _NULLPTR)
 return;
 
 // In an expression `new NonPODType[size]', the pointer returned is
 // not the pointer returned by operator new[], but offset by size_t
 // to leave room for the size. It needs to be compensated here.
 size_t offset = (char*)usr_ptr - (char*)_NULLPTR;
 if (offset % PLATFORM_MEM_ALIGNMENT != 0) {
 offset -= sizeof(size_t);
 if (offset % PLATFORM_MEM_ALIGNMENT != 0) {
 fast_mutex_autolock lock(new_output_lock);
 fprintf(new_output_fp,
 "warning: memory unaligned; skipping processing (%s:%d)\n",
 _M_file, _M_line);
 return;
 }
 usr_ptr = (char*)usr_ptr - sizeof(size_t);
 }
 
 new_ptr_list_t* ptr =
 (new_ptr_list_t*)((char*)usr_ptr - ALIGNED_LIST_ITEM_SIZE);
 if (ptr->magic != DEBUG_NEW_MAGIC || ptr->line != 0)
 {
 fast_mutex_autolock lock(new_output_lock);
 fprintf(new_output_fp,
 "warning: debug_new used with placement new (%s:%d)\n",
 _M_file, _M_line);
 return;
 }
 if (new_verbose_flag) {
 fast_mutex_autolock lock(new_output_lock);
 fprintf(new_output_fp,
 "info: pointer %p allocated from %s:%d\n",
 usr_ptr, _M_file, _M_line);
 }
#if _DEBUG_NEW_FILENAME_LEN == 0
 ptr->file = _M_file;
#else
 strncpy(ptr->file, _M_file, _DEBUG_NEW_FILENAME_LEN - 1)
 [_DEBUG_NEW_FILENAME_LEN - 1] = '\0';
#endif
 ptr->line = _M_line;
#if _DEBUG_NEW_REMEMBER_STACK_TRACE == 2
 free(ptr->stacktrace);
 ptr->stacktrace = _NULLPTR;
#endif
}

References _DEBUG_NEW_FILENAME_LEN, _M_file, _M_line, _NULLPTR, 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, and new_verbose_flag.

Referenced by operator->*().

operator->*()

template<class _Tp >

_Tp* debug_new_recorder::operator->* ( _Tp *  ptr )

inline

Operator to write the context information to memory. operator->* is chosen because it has the right precedence, it is rarely used, and it looks good: so people can tell the special usage more quickly.

Definition at line 182 of file debug_new.h.

 { _M_process(ptr); return ptr; }

References _M_process().

operator=()

debug_new_recorder& debug_new_recorder::operator= ( const debug_new_recorder &  )

private

Field Documentation

_M_file

const char* debug_new_recorder::_M_file

private

Definition at line 166 of file debug_new.h.

Referenced by _M_process().

_M_line

const int debug_new_recorder::_M_line

private

Definition at line 167 of file debug_new.h.

Referenced by _M_process().

---

The documentation for this class was generated from the following files:

• src/debug/nvwa/debug_new.h (986a3bf)
• src/debug/nvwa/debug_new.cpp (986a3bf)