debug_heap.cpp File Reference

#include <corecrt_internal.h>
#include <malloc.h>
#include <minmax.h>
#include <new.h>
#include <stdio.h>
#include <stdlib.h>

Include dependency graph for debug_heap.cpp:

Go to the source code of this file.

Classes
struct	_CrtMemBlockHeader
struct	_AlignMemBlockHdr

Macros
#define	_DEBUG
#define	_ALLOCATION_FILE_LINENUM   "\nMemory allocated at %hs(%d).\n"
#define	IS_2_POW_N(X)   ((X) != 0 && ((X) & ((X) - 1)) == 0)

Functions
int *	__p__crtDbgFlag ()
long *	__p__crtBreakAlloc ()
static unsigned char *__cdecl	block_from_header (_CrtMemBlockHeader *const header) throw ()
static _CrtMemBlockHeader *__cdecl	header_from_block (void const *const block) throw ()
static bool __cdecl	is_block_type_valid (int const block_use) throw ()
static bool __cdecl	check_bytes (unsigned char const *const first, unsigned char const value, size_t const size) throw ()
static bool __cdecl	is_bad_read_pointer (void const *const p, size_t const size) throw ()
static bool __cdecl	is_block_an_aligned_allocation (void const *const block) throw ()
static void __cdecl	validate_heap_if_required_nolock () throw ()
static void *__cdecl	heap_alloc_dbg_internal (size_t const size, int const block_use, char const *const file_name, int const line_number) throw ()
static void *__cdecl	heap_alloc_dbg (size_t const size, int const block_use, char const *const file_name, int const line_number) throw ()
	__declspec (noinline) void *__cdecl _malloc_dbg(size_t const size
	if (block) memset(block
static void *__cdecl	realloc_dbg_nolock (void *const block, size_t *const new_size, int const block_use, char const *const file_name, int const line_number, bool const reallocation_is_allowed) throw ()
	__acrt_lock (__acrt_heap_lock)
	if (!new_block) return nullptr
	if (old_allocation_size< new_allocation_size)
	if (requested_size > static_cast< size_t >(_HEAP_MAXREQ - no_mans_land_size - sizeof(_CrtMemBlockHeader)))
static void __cdecl	free_dbg_nolock (void *const block, int const block_use) throw ()
	free_dbg_nolock (block, actual_use)
	_VALIDATE_RETURN (block !=nullptr, EINVAL, static_cast< size_t >(-1))
	_ASSERTE (_CrtIsValidHeapPointer(block))
	_ASSERTE (is_block_type_valid(header->_block_use))
long __cdecl	_CrtSetBreakAlloc (long const new_break_alloc)
void __cdecl	_CrtSetDbgBlockType (void *const block, int const block_use)
_CRT_ALLOC_HOOK __cdecl	_CrtGetAllocHook ()
_CRT_ALLOC_HOOK __cdecl	_CrtSetAllocHook (_CRT_ALLOC_HOOK const new_hook)
static bool __cdecl	check_block (_CrtMemBlockHeader *const header) throw ()
int __cdecl	_CrtCheckMemory ()
int __cdecl	_CrtSetDbgFlag (int const new_bits)
void __cdecl	_CrtDoForAllClientObjects (_CrtDoForAllClientObjectsCallback const callback, void *const context)
int __cdecl	_CrtIsValidPointer (void const *const p, unsigned int const size_in_bytes, int const read_write)
int __cdecl	_CrtIsValidHeapPointer (void const *const block)
int __cdecl	_CrtIsMemoryBlock (void const *const block, unsigned const size, long *const request_number, char **const file_name, int *const line_number)
int	_CrtReportBlockType (void const *const block)
_CRT_DUMP_CLIENT __cdecl	_CrtGetDumpClient ()
_CRT_DUMP_CLIENT __cdecl	_CrtSetDumpClient (_CRT_DUMP_CLIENT const new_client)
void __cdecl	_CrtMemCheckpoint (_CrtMemState *const state)
int __cdecl	_CrtMemDifference (_CrtMemState *const state, _CrtMemState const *const old_state, _CrtMemState const *const new_state)
static void __cdecl	print_block_data (_locale_t const locale, _CrtMemBlockHeader *const header) throw ()
static void __cdecl	dump_all_object_since_nolock (_CrtMemState const *const state) throw ()
void __cdecl	_CrtMemDumpAllObjectsSince (_CrtMemState const *const state)
int __cdecl	_CrtDumpMemoryLeaks ()
void __cdecl	_CrtMemDumpStatistics (_CrtMemState const *const state)
void *__cdecl	_aligned_malloc_dbg (size_t const size, size_t const alignment, char const *const file_name, int const line_number)
void *__cdecl	_aligned_offset_malloc_dbg (size_t const size, size_t alignment, size_t const offset, char const *const file_name, int const line_number)
void *__cdecl	_aligned_realloc_dbg (void *const block, size_t const size, size_t const alignment, char const *const file_name, int const line_number)
void *__cdecl	_aligned_recalloc_dbg (void *const block, size_t const count, size_t const size, size_t const alignment, char const *const file_name, int const line_number)
void *__cdecl	_aligned_offset_realloc_dbg (void *block, size_t size, size_t alignment, size_t offset, const char *file_name, int line_number)
size_t __cdecl	_aligned_msize_dbg (void *const block, size_t alignment, size_t const offset)
void *__cdecl	_aligned_offset_recalloc_dbg (void *const block, size_t const count, size_t const element_size, size_t const alignment, size_t const offset, char const *const file_name, int const line_number)
void __cdecl	_aligned_free_dbg (void *const block)

Variables
static char const *const	block_use_names [_MAX_BLOCKS]
static unsigned char const	no_mans_land_fill {0xFD}
static unsigned char const	align_land_fill {0xED}
static unsigned char const	dead_land_fill {0xDD}
static unsigned char const	clean_land_fill {0xCD}
static size_t const	no_mans_land_size = 4
static size_t const	align_gap_size = sizeof(void *)
static long const	request_number_for_ignore_blocks {0}
static int const	line_number_for_ignore_blocks {static_cast<int>(0xFEDCBABC)}
static _CrtMemBlockHeader *	__acrt_first_block {nullptr}
static _CrtMemBlockHeader *	__acrt_last_block {nullptr}
static size_t	__acrt_total_allocations {0}
static size_t	__acrt_current_allocations {0}
static size_t	__acrt_max_allocations {0}
static unsigned	__acrt_check_frequency {0}
static unsigned	__acrt_check_counter {0}
static long	__acrt_current_request_number {1}
int	_crtDbgFlag {_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_DEFAULT_DF}
long	_crtBreakAlloc {-1}
_CRT_DUMP_CLIENT	_pfnDumpClient {nullptr}
static bool	heap_validation_pending {false}
int const	block_use
int const char const *const	file_name
int const char const *const int const	line_number
size_t const	element_size
size_t const	allocation_size {element_size * count}
void *const	block {heap_alloc_dbg(allocation_size, block_use, file_name, line_number)}
size_t const	requested_size
	__try
	new_block = realloc_dbg_nolock(block, &new_size, block_use, file_name, line_number, true)
	__finally
size_t const	count
size_t const	old_allocation_size {block ? _msize_dbg(block, block_use) : 0}
size_t const	new_allocation_size {element_size * count }
size_t	size {0}
_CrtMemBlockHeader *const	header {header_from_block(block)}

Macro Definition Documentation

_ALLOCATION_FILE_LINENUM

#define _ALLOCATION_FILE_LINENUM   "\nMemory allocated at %hs(%d).\n"

Definition at line 27 of file debug_heap.cpp.

_DEBUG

#define _DEBUG

Definition at line 10 of file debug_heap.cpp.

IS_2_POW_N

#define IS_2_POW_N

(

X

)

((X) != 0 && ((X) & ((X) - 1)) == 0)

Definition at line 1783 of file debug_heap.cpp.

Function Documentation

__acrt_lock()

__acrt_lock

(

__acrt_heap_lock

)

Referenced by __acrt_initialize_lowio(), __acrt_lowio_ensure_fh_exists(), __acrt_stdio_allocate_stream(), __acrt_update_thread_locale_data(), __tzset(), _alloc_osfhnd(), _cgets_s(), _cgetws_s(), _cputs(), _cputws(), _CrtCheckMemory(), _CrtDoForAllClientObjects(), _CrtIsMemoryBlock(), _CrtMemCheckpoint(), _CrtMemDumpAllObjectsSince(), _CrtSetDbgBlockType(), _CrtSetDbgFlag(), _fcloseall(), _free_locale(), _getch(), _getche(), _getwch(), _getwche(), _isindst(), _kbhit(), _pclose(), _query_new_handler(), _rmtmp(), _set_new_handler(), _tzset(), _ungetch(), _ungetwch(), _VCrtDbgReportA(), _VCrtDbgReportW(), common_getenv(), common_popen(), common_putenv(), compute_name(), ctrlevent_capture(), heap_alloc_dbg_internal(), raise(), signal(), and update_thread_multibyte_data_internal().

__declspec()

__declspec

(

noinline

)

const

__p__crtBreakAlloc()

long * __p__crtBreakAlloc

(

)

Definition at line 155 of file debug_heap.cpp.

{
    return &_crtBreakAlloc;
}

__p__crtDbgFlag()

int * __p__crtDbgFlag

(

)

Definition at line 150 of file debug_heap.cpp.

{
    return &_crtDbgFlag;
}

_aligned_free_dbg()

void __cdecl _aligned_free_dbg

(

void *const

block

)

Definition at line 1972 of file debug_heap.cpp.

{
    if (!block)
        return;
 
    _AlignMemBlockHdr* const header{reinterpret_cast<_AlignMemBlockHdr*>(
        reinterpret_cast<uintptr_t>(block) & ~(sizeof(uintptr_t) - 1)
    ) -1};
 
    if (check_bytes(static_cast<unsigned char*>(block) - no_mans_land_size, no_mans_land_fill, no_mans_land_size))
    {
        // We don't know where (file, linenum) block was allocated
        _RPTN(_CRT_ERROR, "The block at 0x%p was not allocated by _aligned routines, use free()", block);
        return;
    }
 
    if (!check_bytes(header->_gap, align_land_fill, align_gap_size))
    {
        // We don't know where (file, linenum) block was allocated
        _RPTN(_CRT_ERROR, "Damage before 0x%p which was allocated by aligned routine\n", block);
    }
 
    _free_dbg(header->_head, _NORMAL_BLOCK);
}

_aligned_malloc_dbg()

void *__cdecl _aligned_malloc_dbg	(	size_t const	size,
		size_t const	alignment,
		char const *const	file_name,
		int const	line_number
	)

Definition at line 1787 of file debug_heap.cpp.

{
    return _aligned_offset_malloc_dbg(size, alignment, 0, file_name, line_number);
}

_aligned_msize_dbg()

size_t __cdecl _aligned_msize_dbg	(	void *const	block,
		size_t	alignment,
		size_t const	offset
	)

Definition at line 1917 of file debug_heap.cpp.

{
    size_t header_size = 0; // Size of the header block
    size_t footer_size = 0; // Size of the footer block
    size_t total_size  = 0; // total size of the allocated block
    size_t user_size   = 0; // size of the user block
    uintptr_t gap      = 0; // keep the alignment of the data block
                            // after the sizeof(void*) aligned pointer
                            // to the beginning of the allocated block
 
    // HEADER SIZE + FOOTER SIZE = GAP + ALIGN + SIZE OF A POINTER
    // HEADER SIZE + USER SIZE + FOOTER SIZE = TOTAL SIZE
    _VALIDATE_RETURN (block != nullptr, EINVAL, static_cast<size_t>(-1));
 
    _AlignMemBlockHdr* header_from_block = nullptr; // points to the beginning of the allocated block
    header_from_block = (_AlignMemBlockHdr*)((uintptr_t)block & ~(sizeof(uintptr_t) - 1)) - 1;
    total_size = _msize_dbg(header_from_block->_head, _NORMAL_BLOCK);
    header_size = (uintptr_t)block - (uintptr_t)header_from_block->_head;
    gap = (0 - offset) & (sizeof(uintptr_t) - 1);
    // The alignment cannot be smaller than the sizeof(uintptr_t)
    alignment = (alignment > sizeof(uintptr_t) ? alignment : sizeof(uintptr_t)) - 1;
    footer_size = gap + alignment + sizeof(_AlignMemBlockHdr) - header_size;
    user_size = total_size - header_size - footer_size;
    return user_size;
}

_aligned_offset_malloc_dbg()

void *__cdecl _aligned_offset_malloc_dbg	(	size_t const	size,
		size_t	alignment,
		size_t const	offset,
		char const *const	file_name,
		int const	line_number
	)

Definition at line 1797 of file debug_heap.cpp.

{
    _VALIDATE_RETURN(IS_2_POW_N(alignment),        EINVAL, nullptr);
    _VALIDATE_RETURN(offset == 0 || offset < size, EINVAL, nullptr);
 
    alignment = (alignment > sizeof(uintptr_t) ? alignment : sizeof(uintptr_t)) - 1;
 
    uintptr_t const t_ptr = (0 -offset) & (sizeof(uintptr_t) -1);
 
    size_t const nonuser_size = t_ptr + alignment + sizeof(_AlignMemBlockHdr); // Cannot overflow
    size_t const block_size = size + nonuser_size;
    _VALIDATE_RETURN_NOEXC(size <= block_size, ENOMEM, nullptr);
 
    uintptr_t const ptr = reinterpret_cast<uintptr_t>(_malloc_dbg(block_size, _NORMAL_BLOCK, file_name, line_number));
    if (ptr == reinterpret_cast<uintptr_t>(nullptr))
        return nullptr;
 
    uintptr_t const r_ptr = ((ptr +nonuser_size +offset)&~alignment)-offset;
    _AlignMemBlockHdr* const header_from_block = reinterpret_cast<_AlignMemBlockHdr*>(r_ptr - t_ptr) - 1;
    memset(header_from_block->_gap, align_land_fill, align_gap_size);
    header_from_block->_head = reinterpret_cast<void*>(ptr);
    return reinterpret_cast<void*>(r_ptr);
}

_aligned_offset_realloc_dbg()

void *__cdecl _aligned_offset_realloc_dbg	(	void *	block,
		size_t	size,
		size_t	alignment,
		size_t	offset,
		const char *	file_name,
		int	line_number
	)

Definition at line 1850 of file debug_heap.cpp.

{
    uintptr_t ptr, r_ptr, t_ptr, mov_sz;
    _AlignMemBlockHdr *header_from_block, *s_header_from_block;
    size_t nonuser_size, block_size;
 
    if (block == nullptr)
    {
        return _aligned_offset_malloc_dbg(size, alignment, offset, file_name, line_number);
    }
    if (size == 0)
    {
        _aligned_free_dbg(block);
        return nullptr;
    }
 
    s_header_from_block = (_AlignMemBlockHdr *)((uintptr_t)block & ~(sizeof(uintptr_t) -1)) -1;
 
    if (check_bytes((unsigned char *)block -no_mans_land_size, no_mans_land_fill, no_mans_land_size))
    {
        // We don't know where (file, linenum) block was allocated
        _RPTN(_CRT_ERROR, "The block at 0x%p was not allocated by _aligned routines, use realloc()", block);
        errno = EINVAL;
        return nullptr;
    }
 
    if(!check_bytes(s_header_from_block->_gap, align_land_fill, align_gap_size))
    {
        // We don't know where (file, linenum) block was allocated
        _RPTN(_CRT_ERROR, "Damage before 0x%p which was allocated by aligned routine\n", block);
    }
 
    /* validation section */
    _VALIDATE_RETURN(IS_2_POW_N(alignment),        EINVAL, nullptr);
    _VALIDATE_RETURN(offset == 0 || offset < size, EINVAL, nullptr);
 
    mov_sz = _msize_dbg(s_header_from_block->_head, _NORMAL_BLOCK) - ((uintptr_t)block - (uintptr_t)s_header_from_block->_head);
 
    alignment = (alignment > sizeof(uintptr_t) ? alignment : sizeof(uintptr_t)) -1;
 
    t_ptr = (0 -offset) & (sizeof(uintptr_t) - 1);
 
    nonuser_size = t_ptr + alignment + sizeof(_AlignMemBlockHdr); // Cannot overflow
    block_size = size + nonuser_size;
    _VALIDATE_RETURN_NOEXC(size <= block_size, ENOMEM, nullptr);
 
    if ((ptr = (uintptr_t)_malloc_dbg(block_size, _NORMAL_BLOCK, file_name, line_number)) == (uintptr_t)nullptr)
        return nullptr;
 
    r_ptr = ((ptr + nonuser_size + offset) & ~alignment) - offset;
    header_from_block = (_AlignMemBlockHdr*)(r_ptr - t_ptr) - 1;
    memset(header_from_block->_gap, align_land_fill, align_gap_size);
    header_from_block->_head = reinterpret_cast<void*>(ptr);
 
    memcpy(reinterpret_cast<void*>(r_ptr), block, mov_sz > size ? size : mov_sz);
    _free_dbg(s_header_from_block->_head, _NORMAL_BLOCK);
 
    return (void *) r_ptr;
}

_aligned_offset_recalloc_dbg()

void *__cdecl _aligned_offset_recalloc_dbg	(	void *const	block,
		size_t const	count,
		size_t const	element_size,
		size_t const	alignment,
		size_t const	offset,
		char const *const	file_name,
		int const	line_number
	)

Definition at line 1947 of file debug_heap.cpp.

{
    _VALIDATE_RETURN_NOEXC(count == 0 || _HEAP_MAXREQ / count >= element_size, ENOMEM, nullptr);
 
    size_t const old_allocation_size{block ? _aligned_msize_dbg(block, alignment, offset) : 0};
    size_t const new_allocation_size{element_size * count};
 
    void* const new_block{_aligned_offset_realloc_dbg(block, new_allocation_size, alignment, offset, file_name, line_number)};
    if (!new_block)
        return nullptr;
 
    if (old_allocation_size < new_allocation_size)
        memset(static_cast<unsigned char*>(new_block) + old_allocation_size, 0, new_allocation_size - old_allocation_size);
 
    return new_block;
}

_aligned_realloc_dbg()

void *__cdecl _aligned_realloc_dbg	(	void *const	block,
		size_t const	size,
		size_t const	alignment,
		char const *const	file_name,
		int const	line_number
	)

Definition at line 1827 of file debug_heap.cpp.

{
    return _aligned_offset_realloc_dbg(block, size, alignment, 0, file_name, line_number);
}

_aligned_recalloc_dbg()

void *__cdecl _aligned_recalloc_dbg	(	void *const	block,
		size_t const	count,
		size_t const	size,
		size_t const	alignment,
		char const *const	file_name,
		int const	line_number
	)

Definition at line 1838 of file debug_heap.cpp.

{
    return _aligned_offset_recalloc_dbg(block, count, size, alignment, 0, file_name, line_number);
}

_ASSERTE() [1/2]

_ASSERTE

(

_CrtIsValidHeapPointer(block)

)

_ASSERTE() [2/2]

_ASSERTE

(

is_block_type_valid(header->_block_use)

)

_CrtCheckMemory()

int __cdecl _CrtCheckMemory

(

)

Definition at line 1256 of file debug_heap.cpp.

{
    if ((_crtDbgFlag & _CRTDBG_ALLOC_MEM_DF) == 0)
    {
        return TRUE;
    }
 
    bool all_okay{true};
 
    __acrt_lock(__acrt_heap_lock);
    __try
    {
        // First walk our allocated heap blocks and verify consistency of our
        // internal data structures.  We do this first because we can give
        // better diagnostics to client code than the underlying Windows heap
        // can (we have source file names and line numbers and other metadata).
        // We use Floyd's cycle finding algorithm to detect cycles in the block
        // list.
        _CrtMemBlockHeader* trail_it{__acrt_first_block};
        _CrtMemBlockHeader* lead_it {__acrt_first_block == nullptr ? nullptr : __acrt_first_block->_block_header_next};
        while (trail_it != nullptr)
        {
            all_okay &= check_block(trail_it);
 
            if (trail_it == lead_it)
            {
                _RPTN(_CRT_WARN,
                    "Cycle in block list detected while processing block located at 0x%p.\n",
                    trail_it);
                all_okay = false;
                break;
            }
 
            trail_it = trail_it->_block_header_next;
 
            // Advance the lead iterator twice as fast as the trail iterator:
            if (lead_it != nullptr)
            {
                lead_it = lead_it->_block_header_next == nullptr
                    ? nullptr
                    : lead_it->_block_header_next->_block_header_next;
            }
        }
 
        // Then check the underlying Windows heap:
        if (!HeapValidate(__acrt_heap, 0, nullptr))
        {
            _RPT0(_CRT_WARN, "Heap validation failed.\n");
            all_okay = false;
            __leave;
        }
    }
    __finally
    {
        __acrt_unlock(__acrt_heap_lock);
    }
    __endtry
 
    return all_okay ? TRUE : FALSE;
}

Referenced by validate_heap_if_required_nolock().

_CrtDoForAllClientObjects()

void __cdecl _CrtDoForAllClientObjects	(	_CrtDoForAllClientObjectsCallback const	callback,
		void *const	context
	)

Definition at line 1364 of file debug_heap.cpp.

{
    _VALIDATE_RETURN_VOID(callback != nullptr, EINVAL);
 
    if ((_crtDbgFlag & _CRTDBG_ALLOC_MEM_DF) == 0)
        return;
 
    __acrt_lock(__acrt_heap_lock);
    __try
    {
        for (_CrtMemBlockHeader* header{__acrt_first_block}; header != nullptr; header = header->_block_header_next)
        {
            if (_BLOCK_TYPE(header->_block_use) == _CLIENT_BLOCK)
                callback(block_from_header(header), context);
        }
    }
    __finally
    {
        __acrt_unlock(__acrt_heap_lock);
    }
    __endtry
}

_CrtDumpMemoryLeaks()

int __cdecl _CrtDumpMemoryLeaks

(

)

Definition at line 1727 of file debug_heap.cpp.

{
    _CrtMemState state;
    _CrtMemCheckpoint(&state);
 
    if (state.lCounts[_CLIENT_BLOCK] != 0 ||
        state.lCounts[_NORMAL_BLOCK] != 0 ||
        (_crtDbgFlag & _CRTDBG_CHECK_CRT_DF && state.lCounts[_CRT_BLOCK] != 0))
    {
        _RPT0(_CRT_WARN, "Detected memory leaks!\n");
 
        _CrtMemDumpAllObjectsSince(nullptr);
        return TRUE;
    }
 
    return FALSE;
}

_CrtGetAllocHook()

_CRT_ALLOC_HOOK __cdecl _CrtGetAllocHook

(

)

Definition at line 1132 of file debug_heap.cpp.

{
    return _pfnAllocHook;
}

_CrtGetDumpClient()

_CRT_DUMP_CLIENT __cdecl _CrtGetDumpClient

(

)

Definition at line 1504 of file debug_heap.cpp.

{
    return _pfnDumpClient;
}

_CrtIsMemoryBlock()

int __cdecl _CrtIsMemoryBlock	(	void const *const	block,
		unsigned const	size,
		long *const	request_number,
		char **const	file_name,
		int *const	line_number
	)

Definition at line 1429 of file debug_heap.cpp.

{
    if (request_number)
        *request_number = 0;
 
    if (file_name)
        *file_name = nullptr;
 
    if (line_number)
        *line_number = 0;
 
    if (!block)
        return FALSE;
 
    int result{FALSE};
 
    __acrt_lock(__acrt_heap_lock);
    __try
    {
        _CrtMemBlockHeader* const header{header_from_block(block)};
        if (!is_block_type_valid(header->_block_use))
            __leave;
 
        if (!_CrtIsValidPointer(block, size, TRUE))
            __leave;
 
        if (header->_data_size != size)
            __leave;
 
        if (header->_request_number > __acrt_current_request_number)
            __leave;
 
        // The block is valid
        if (request_number)
            *request_number = header->_request_number;
 
        if (file_name)
            *file_name = const_cast<char*>(header->_file_name);
 
        if (line_number)
            *line_number = header->_line_number;
 
        result = TRUE;
    }
    __finally
    {
        __acrt_unlock(__acrt_heap_lock);
    }
    __endtry
 
    return result;
}

_CrtIsValidHeapPointer()

int __cdecl _CrtIsValidHeapPointer

(

void const *const

block

)

Definition at line 1414 of file debug_heap.cpp.

{
    if (!block)
        return FALSE;
 
    return HeapValidate(__acrt_heap, 0, header_from_block(block));
}

_CrtIsValidPointer()

int __cdecl _CrtIsValidPointer	(	void const *const	p,
		unsigned int const	size_in_bytes,
		int const	read_write
	)

Definition at line 1394 of file debug_heap.cpp.

{
    UNREFERENCED_PARAMETER(size_in_bytes);
    UNREFERENCED_PARAMETER(read_write);
 
    return p != nullptr;
}

_CrtMemCheckpoint()

void __cdecl _CrtMemCheckpoint

(

_CrtMemState *const

state

)

Definition at line 1520 of file debug_heap.cpp.

{
    _VALIDATE_RETURN_VOID(state != nullptr, EINVAL);
 
    __acrt_lock(__acrt_heap_lock);
    __try
    {
        state->pBlockHeader = __acrt_first_block;
 
        for (unsigned use{0}; use < _MAX_BLOCKS; ++use)
        {
            state->lCounts[use] = 0;
            state->lSizes [use] = 0;
        }
 
        for (_CrtMemBlockHeader* header{__acrt_first_block}; header != nullptr; header = header->_block_header_next)
        {
            if (_BLOCK_TYPE(header->_block_use) >= 0 && _BLOCK_TYPE(header->_block_use) < _MAX_BLOCKS)
            {
                ++state->lCounts[_BLOCK_TYPE(header->_block_use)];
                state->lSizes[_BLOCK_TYPE(header->_block_use)] += header->_data_size;
            }
            else if (header->_file_name)
            {
                _RPTN(_CRT_WARN, "Bad memory block found at 0x%p.\n" _ALLOCATION_FILE_LINENUM,
                    header,
                    header->_file_name,
                    header->_line_number);
            }
            else
            {
                _RPTN(_CRT_WARN, "Bad memory block found at 0x%p.\n", header);
            }
        }
 
        state->lHighWaterCount = __acrt_max_allocations;
        state->lTotalCount     = __acrt_total_allocations;
    }
    __finally
    {
        __acrt_unlock(__acrt_heap_lock);
    }
    __endtry
}

_CrtMemDifference()

int __cdecl _CrtMemDifference	(	_CrtMemState *const	state,
		_CrtMemState const *const	old_state,
		_CrtMemState const *const	new_state
	)

Definition at line 1571 of file debug_heap.cpp.

{
    _VALIDATE_RETURN(state     != nullptr, EINVAL, FALSE);
    _VALIDATE_RETURN(old_state != nullptr, EINVAL, FALSE);
    _VALIDATE_RETURN(new_state != nullptr, EINVAL, FALSE);
 
    bool significant_difference_found{false};
    for (int use{0}; use < _MAX_BLOCKS; ++use)
    {
        state->lSizes[use]  = new_state->lSizes[use]  - old_state->lSizes[use];
        state->lCounts[use] = new_state->lCounts[use] - old_state->lCounts[use];
 
        if (state->lSizes[use] == 0 && state->lCounts[use] == 0)
            continue;
 
        if (use == _FREE_BLOCK)
            continue;
 
        if (use == _CRT_BLOCK && (_crtDbgFlag & _CRTDBG_CHECK_CRT_DF) == 0)
            continue;
 
        significant_difference_found = true;
    }
 
    state->lHighWaterCount = new_state->lHighWaterCount - old_state->lHighWaterCount;
    state->lTotalCount     = new_state->lTotalCount     - old_state->lTotalCount;
    state->pBlockHeader    = nullptr;
 
    return significant_difference_found ? 1 : 0;
}

_CrtMemDumpAllObjectsSince()

void __cdecl _CrtMemDumpAllObjectsSince

(

_CrtMemState const *const

state

)

Definition at line 1706 of file debug_heap.cpp.

{
    __acrt_lock(__acrt_heap_lock);
    __try
    {
        dump_all_object_since_nolock(state);
    }
    __finally
    {
        __acrt_unlock(__acrt_heap_lock);
    }
    __endtry
 
    _RPT0(_CRT_WARN, "Object dump complete.\n");
}

_CrtMemDumpStatistics()

void __cdecl _CrtMemDumpStatistics

(

_CrtMemState const *const

state

)

Definition at line 1748 of file debug_heap.cpp.

{
    _VALIDATE_RETURN_VOID(state != nullptr, EINVAL);
 
    for (unsigned use{0}; use < _MAX_BLOCKS; ++use)
    {
        _RPTN(_CRT_WARN, "%Id bytes in %Id %hs Blocks.\n",
            state->lSizes[use],
            state->lCounts[use],
            block_use_names[use]);
    }
 
    _RPTN(_CRT_WARN, "Largest number used: %Id bytes.\n", state->lHighWaterCount);
    _RPTN(_CRT_WARN, "Total allocations: %Id bytes.\n",   state->lTotalCount);
}

_CrtReportBlockType()

int _CrtReportBlockType

(

void const *const

block

)

Definition at line 1492 of file debug_heap.cpp.

{
    if (!_CrtIsValidHeapPointer(block))
        return -1;
 
    return header_from_block(block)->_block_use;
}

_CrtSetAllocHook()

_CRT_ALLOC_HOOK __cdecl _CrtSetAllocHook

(

_CRT_ALLOC_HOOK const

new_hook

)

Definition at line 1137 of file debug_heap.cpp.

{
    _CRT_ALLOC_HOOK const old_hook{_pfnAllocHook};
    _pfnAllocHook = new_hook;
    return old_hook;
}

_CrtSetBreakAlloc()

long __cdecl _CrtSetBreakAlloc

(

long const

new_break_alloc

)

Definition at line 1094 of file debug_heap.cpp.

{
    long const old_break_alloc{_crtBreakAlloc};
    _crtBreakAlloc = new_break_alloc;
    return old_break_alloc;
}

_CrtSetDbgBlockType()

void __cdecl _CrtSetDbgBlockType	(	void *const	block,
		int const	block_use
	)

Definition at line 1104 of file debug_heap.cpp.

{
    __acrt_lock(__acrt_heap_lock);
    __try
    {
        if (!_CrtIsValidHeapPointer(block))
            __leave;
 
        _CrtMemBlockHeader* const header{header_from_block(block)};
 
        _ASSERTE(is_block_type_valid(header->_block_use));
 
        header->_block_use = block_use;
    }
    __finally
    {
        __acrt_unlock(__acrt_heap_lock);
    }
    __endtry
}

_CrtSetDbgFlag()

int __cdecl _CrtSetDbgFlag

(

int const

new_bits

)

Definition at line 1322 of file debug_heap.cpp.

{
    int const valid_flags{
        _CRTDBG_ALLOC_MEM_DF      |
        _CRTDBG_DELAY_FREE_MEM_DF |
        _CRTDBG_CHECK_ALWAYS_DF   |
        _CRTDBG_CHECK_CRT_DF      |
        _CRTDBG_LEAK_CHECK_DF};
 
    bool const new_bits_have_only_valid_flags = (new_bits & 0xffff & ~valid_flags) == 0;
    _VALIDATE_RETURN(new_bits == _CRTDBG_REPORT_FLAG || new_bits_have_only_valid_flags, EINVAL, _crtDbgFlag);
 
    int old_bits{0};
 
    __acrt_lock(__acrt_heap_lock);
    __try
    {
        old_bits = _crtDbgFlag;
 
        if (new_bits == _CRTDBG_REPORT_FLAG)
            __leave;
 
        if (new_bits & _CRTDBG_CHECK_ALWAYS_DF)
            __acrt_check_frequency = 1;
        else
            __acrt_check_frequency = (new_bits >> 16) & 0x0ffff;
 
        __acrt_check_counter = 0;
        _crtDbgFlag = new_bits;
    }
    __finally
    {
        __acrt_unlock(__acrt_heap_lock);
    }
    __endtry
 
    return old_bits;
}

_CrtSetDumpClient()

_CRT_DUMP_CLIENT __cdecl _CrtSetDumpClient

(

_CRT_DUMP_CLIENT const

new_client

)

Definition at line 1509 of file debug_heap.cpp.

{
    _CRT_DUMP_CLIENT const old_client{_pfnDumpClient};
    _pfnDumpClient = new_client;
    return old_client;
}

_VALIDATE_RETURN()

_VALIDATE_RETURN	(	block !	= nullptr,
		EINVAL	,
		static_cast< size_t >	-1
	)

block_from_header()

static unsigned char *__cdecl block_from_header ( _CrtMemBlockHeader *const  header ) throw ( )

static

Definition at line 167 of file debug_heap.cpp.

{
    return reinterpret_cast<unsigned char*>(header + 1);
}

Referenced by _CrtDoForAllClientObjects(), check_block(), dump_all_object_since_nolock(), free_dbg_nolock(), heap_alloc_dbg_internal(), print_block_data(), and realloc_dbg_nolock().

check_block()

static bool __cdecl check_block ( _CrtMemBlockHeader *const  header ) throw ( )

static

Definition at line 1149 of file debug_heap.cpp.

{
    bool this_block_okay{true};
    char const* block_use{nullptr};
 
    if (is_block_type_valid(header->_block_use))
    {
        block_use = block_use_names[_BLOCK_TYPE(header->_block_use)];
    }
    else
    {
        block_use = "DAMAGED";
    }
 
    // Check the no-man's-land gaps:
    if (!check_bytes(header->_gap, no_mans_land_fill, no_mans_land_size))
    {
        if (header->_file_name)
        {
            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: before %hs block (#%d) at 0x%p.\n"
                "CRT detected that the application wrote to memory before start of heap buffer.\n"
                _ALLOCATION_FILE_LINENUM,
                block_use,
                header->_request_number,
                block_from_header(header),
                header->_file_name,
                header->_line_number);
        }
        else
        {
            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: before %hs block (#%d) at 0x%p.\n"
                "CRT detected that the application wrote to memory before start of heap buffer.\n",
                block_use, header->_request_number, block_from_header(header));
        }
 
        this_block_okay = false;
    }
 
    if (!check_bytes(block_from_header(header) + header->_data_size, no_mans_land_fill, no_mans_land_size))
    {
        if (header->_file_name)
        {
            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: after %hs block (#%d) at 0x%p.\n"
                "CRT detected that the application wrote to memory after end of heap buffer.\n"
                _ALLOCATION_FILE_LINENUM,
                block_use,
                header->_request_number,
                block_from_header(header),
                header->_file_name,
                header->_line_number);
        }
        else
        {
            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: after %hs block (#%d) at 0x%p.\n"
                "CRT detected that the application wrote to memory after end of heap buffer.\n",
                block_use, header->_request_number, block_from_header(header));
        }
 
        this_block_okay = false;
    }
 
    // Free blocks should remain undisturbed:
    if (header->_block_use == _FREE_BLOCK && !check_bytes(block_from_header(header), dead_land_fill, header->_data_size))
    {
        if (header->_file_name)
        {
            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: on top of Free block at 0x%p.\n"
                "CRT detected that the application wrote to a heap buffer that was freed.\n"
                _ALLOCATION_FILE_LINENUM,
                block_from_header(header),
                header->_file_name,
                header->_line_number);
        }
        else
        {
            _RPTN(_CRT_WARN, "HEAP CORRUPTION DETECTED: on top of Free block at 0x%p.\n"
                "CRT detected that the application wrote to a heap buffer that was freed.\n",
                block_from_header(header));
        }
 
        this_block_okay = false;
    }
 
    if (!this_block_okay)
    {
        // Report statistics about the broken object:
        if (header->_file_name)
        {
            _RPTN(_CRT_WARN,
                "%hs located at 0x%p is %Iu bytes long.\n"
                _ALLOCATION_FILE_LINENUM,
                block_use,
                block_from_header(header),
                header->_data_size,
                header->_file_name,
                header->_line_number);
        }
        else
        {
            _RPTN(_CRT_WARN, "%hs located at 0x%p is %Iu bytes long.\n",
                block_use, block_from_header(header), header->_data_size);
        }
    }
 
    return this_block_okay;
}

Referenced by _CrtCheckMemory().

check_bytes()

static bool __cdecl check_bytes ( unsigned char const *const  first, unsigned char const  value, size_t const  size  ) throw ( )

static

Definition at line 187 of file debug_heap.cpp.

{
    unsigned char const* const last{first + size};
    for (unsigned char const* it{first}; it != last; ++it)
    {
        if (*it != value)
            return false;
    }
 
    return true;
}

Referenced by _aligned_free_dbg(), _aligned_offset_realloc_dbg(), check_block(), free_dbg_nolock(), and is_block_an_aligned_allocation().

dump_all_object_since_nolock()

static void __cdecl dump_all_object_since_nolock ( _CrtMemState const *const  state ) throw ( )

static

Definition at line 1635 of file debug_heap.cpp.

{
    _LocaleUpdate locale_update{nullptr};
    _locale_t     locale{locale_update.GetLocaleT()};
 
    _RPT0(_CRT_WARN, "Dumping objects ->\n");
 
    _CrtMemBlockHeader* const stop_block{state ? state->pBlockHeader : nullptr};
 
    for (_CrtMemBlockHeader* header{__acrt_first_block}; header != nullptr && header != stop_block; header = header->_block_header_next)
    {
        if (_BLOCK_TYPE(header->_block_use) == _IGNORE_BLOCK)
            continue;
 
        if (_BLOCK_TYPE(header->_block_use) == _FREE_BLOCK)
            continue;
 
        if (_BLOCK_TYPE(header->_block_use) == _CRT_BLOCK && (_crtDbgFlag & _CRTDBG_CHECK_CRT_DF) == 0)
            continue;
 
        if (header->_file_name != nullptr)
        {
            if (!_CrtIsValidPointer(header->_file_name, 1, FALSE) || is_bad_read_pointer(header->_file_name, 1))
            {
                _RPTN(_CRT_WARN, "#File Error#(%d) : ", header->_line_number);
            }
            else
            {
                _RPTN(_CRT_WARN, "%hs(%d) : ", header->_file_name, header->_line_number);
            }
        }
 
        _RPTN(_CRT_WARN, "{%ld} ", header->_request_number);
 
        if (_BLOCK_TYPE(header->_block_use) == _CLIENT_BLOCK)
        {
            _RPTN(_CRT_WARN, "client block at 0x%p, subtype %x, %Iu bytes long.\n",
                block_from_header(header),
                _BLOCK_SUBTYPE(header->_block_use),
                header->_data_size);
 
            if (_pfnDumpClient && !is_bad_read_pointer(block_from_header(header), header->_data_size))
            {
                _pfnDumpClient(block_from_header(header), header->_data_size);
            }
            else
            {
                print_block_data(locale, header);
            }
        }
        else if (header->_block_use == _NORMAL_BLOCK)
        {
            _RPTN(_CRT_WARN, "normal block at 0x%p, %Iu bytes long.\n",
                block_from_header(header),
                header->_data_size);
 
            print_block_data(locale, header);
        }
        else if (_BLOCK_TYPE(header->_block_use) == _CRT_BLOCK)
        {
            _RPTN(_CRT_WARN, "crt block at 0x%p, subtype %x, %Iu bytes long.\n",
                block_from_header(header),
                _BLOCK_SUBTYPE(header->_block_use),
                header->_data_size);
 
            print_block_data(locale, header);
        }
    }
}

Referenced by _CrtMemDumpAllObjectsSince().

free_dbg_nolock() [1/2]

free_dbg_nolock	(	block	,
		actual_use
	)

free_dbg_nolock() [2/2]

static void __cdecl free_dbg_nolock ( void *const  block, int const  block_use  ) throw ( )

static

Definition at line 849 of file debug_heap.cpp.

{
    validate_heap_if_required_nolock();
 
    if (block == nullptr)
        return;
 
    #if _UCRT_HEAP_MISMATCH_DETECTION && (defined _M_IX86 || defined _M_AMD64)
 
    if (!_CrtIsValidHeapPointer(block))
    {
        HANDLE const msvcrt_heap_handle = __acrt_get_msvcrt_heap_handle();
        if (msvcrt_heap_handle)
        {
            if (HeapValidate(msvcrt_heap_handle, 0, block))
            {
                _RPT1(_CRT_WARN, "CRTHEAP: ucrt: Attempt to free a pointer (0x%p) that belongs to MSVCRT's private heap, not the process heap.\n", block);
 
                #if _UCRT_HEAP_MISMATCH_BREAK
                _CrtDbgBreak();
                #endif // _UCRT_HEAP_MISMATCH_BREAK
 
                #if _UCRT_HEAP_MISMATCH_RECOVERY
                if (HeapFree(msvcrt_heap_handle, 0, block))
                {
                    _RPT1(_CRT_WARN, "CRTHEAP: ucrt: Successfully free'd 0x%p\n", block);
                    return;
                }
                else
                {
                    _RPT1(_CRT_ERROR, "CRTHEAP: ucrt: Unable to free 0x%p\n", block);
                    _CrtDbgBreak(); // Force break.
                }
                #endif // _UCRT_HEAP_MISMATCH_RECOVERY
            }
        }
    }
 
    #endif // _UCRT_HEAP_MISMATCH_DETECTION && (defined _M_IX86 || defined _M_AMD64)
 
    // Check to ensure that the block was not allocated by _aligned routines
    if (block_use == _NORMAL_BLOCK && is_block_an_aligned_allocation(block))
    {
        // We don't know (yet) where (file, linenum) block was allocated
        _RPTN(_CRT_ERROR, "The Block at 0x%p was allocated by aligned routines, use _aligned_free()", block);
        errno = EINVAL;
        return;
    }
 
    // Forced failure handling
    if (_pfnAllocHook && !_pfnAllocHook(_HOOK_FREE, block, 0, block_use, 0, nullptr, 0))
    {
        _RPT0(_CRT_WARN, "Client hook free failure.\n");
        return;
    }
 
    // If this assertion fails, a bad pointer has been passed in.  It may be
    // totally bogus, or it may have been allocated from another heap.  The
    // pointer must have been allocated from the CRT heap.
    _ASSERTE(_CrtIsValidHeapPointer(block));
 
    // Get a pointer to memory block header:
    _CrtMemBlockHeader* const header = header_from_block(block);
    _ASSERTE(is_block_type_valid(header->_block_use));
 
    // If we didn't already check entire heap, at least check this object by
    // verifying that its no-man's land areas have not been trashed:
    if (!(_crtDbgFlag & _CRTDBG_CHECK_ALWAYS_DF))
    {
        if (!check_bytes(header->_gap, no_mans_land_fill, no_mans_land_size))
        {
            if (header->_file_name)
            {
                _RPTN(_CRT_ERROR, "HEAP CORRUPTION DETECTED: before %hs block (#%d) at 0x%p.\n"
                    "CRT detected that the application wrote to memory before start of heap buffer.\n"
                    _ALLOCATION_FILE_LINENUM,
                    block_use_names[_BLOCK_TYPE(header->_block_use)],
                    header->_request_number,
                    block_from_header(header),
                    header->_file_name,
                    header->_line_number);
            }
            else
            {
                _RPTN(_CRT_ERROR, "HEAP CORRUPTION DETECTED: before %hs block (#%d) at 0x%p.\n"
                    "CRT detected that the application wrote to memory before start of heap buffer.\n",
                    block_use_names[_BLOCK_TYPE(header->_block_use)],
                    header->_request_number,
                    block_from_header(header));
            }
        }
 
        if (!check_bytes(block_from_header(header) + header->_data_size, no_mans_land_fill, no_mans_land_size))
        {
            if (header->_file_name)
            {
                _RPTN(_CRT_ERROR, "HEAP CORRUPTION DETECTED: after %hs block (#%d) at 0x%p.\n"
                    "CRT detected that the application wrote to memory after end of heap buffer.\n"
                    _ALLOCATION_FILE_LINENUM,
                    block_use_names[_BLOCK_TYPE(header->_block_use)],
                    header->_request_number,
                    block_from_header(header),
                    header->_file_name,
                    header->_line_number);
            }
            else
            {
                _RPTN(_CRT_ERROR, "HEAP CORRUPTION DETECTED: after %hs block (#%d) at 0x%p.\n"
                    "CRT detected that the application wrote to memory after end of heap buffer.\n",
                    block_use_names[_BLOCK_TYPE(header->_block_use)],
                    header->_request_number,
                    block_from_header(header));
            }
        }
    }
 
    // If this block was ignored when it was allocated, we can just free it:
    if (header->_block_use == _IGNORE_BLOCK)
    {
        _ASSERTE(header->_line_number == line_number_for_ignore_blocks && header->_request_number == request_number_for_ignore_blocks);
        memset(header, dead_land_fill, sizeof(_CrtMemBlockHeader) + header->_data_size + no_mans_land_size);
        _free_base(header);
        return;
    }
 
    // Ensure that we were called with the right block use.  CRT blocks can be
    // freed as NORMAL blocks.
    _ASSERTE(header->_block_use == block_use || header->_block_use == _CRT_BLOCK && block_use == _NORMAL_BLOCK);
 
    __acrt_current_allocations -= header->_data_size;
 
    // Optionally reclaim memory:
    if ((_crtDbgFlag & _CRTDBG_DELAY_FREE_MEM_DF) == 0)
    {
        // Unlink this allocation from the global linked list:
        if (header->_block_header_next)
        {
            header->_block_header_next->_block_header_prev = header->_block_header_prev;
        }
        else
        {
            _ASSERTE(__acrt_last_block == header);
            __acrt_last_block = header->_block_header_prev;
        }
 
        if (header->_block_header_prev)
        {
            header->_block_header_prev->_block_header_next = header->_block_header_next;
        }
        else
        {
            _ASSERTE(__acrt_first_block == header);
            __acrt_first_block = header->_block_header_next;
        }
 
        memset(header, dead_land_fill, sizeof(_CrtMemBlockHeader) + header->_data_size + no_mans_land_size);
        _free_base(header);
    }
    else
    {
        header->_block_use = _FREE_BLOCK;
 
        // Keep memory around as dead space:
        memset(block_from_header(header), dead_land_fill, header->_data_size);
    }
}

header_from_block()

static _CrtMemBlockHeader *__cdecl header_from_block ( void const *const  block ) throw ( )

static

Definition at line 172 of file debug_heap.cpp.

{
    return static_cast<_CrtMemBlockHeader*>(const_cast<void*>(block)) - 1;
}

Referenced by _aligned_msize_dbg(), _aligned_offset_malloc_dbg(), _aligned_offset_realloc_dbg(), _CrtIsMemoryBlock(), _CrtIsValidHeapPointer(), _CrtReportBlockType(), _CrtSetDbgBlockType(), free_dbg_nolock(), and realloc_dbg_nolock().

heap_alloc_dbg()

static void *__cdecl heap_alloc_dbg ( size_t const  size, int const  block_use, char const *const  file_name, int const  line_number  ) throw ( )

static

Definition at line 445 of file debug_heap.cpp.

{
    bool const should_call_new_handler{_query_new_mode() != 0};
    for (;;)
    {
        void* const block{heap_alloc_dbg_internal(size, block_use, file_name, line_number)};
        if (block)
            return block;
 
        if (!should_call_new_handler || !_callnewh(size))
        {
            errno_t* const global_errno{_errno()};
            if (global_errno)
                *global_errno = ENOMEM;
 
            return nullptr;
        }
 
        // The new handler was successful -- try to allocate again
    }
}

heap_alloc_dbg_internal()

static void *__cdecl heap_alloc_dbg_internal ( size_t const  size, int const  block_use, char const *const  file_name, int const  line_number  ) throw ( )

static

Definition at line 304 of file debug_heap.cpp.

{
    void* block{nullptr};
 
    __acrt_lock(__acrt_heap_lock);
    __try
    {
        validate_heap_if_required_nolock();
 
        long const request_number{__acrt_current_request_number};
 
        // Handle break-on-request and forced failure:
        if (_crtBreakAlloc != -1 && request_number == _crtBreakAlloc)
        {
            _CrtDbgBreak();
        }
 
        if (_pfnAllocHook && !_pfnAllocHook(
            _HOOK_ALLOC,
            nullptr,
            size,
            block_use,
            request_number,
            reinterpret_cast<unsigned char const*>(file_name),
            line_number))
        {
            if (file_name)
                _RPTN(_CRT_WARN, "Client hook allocation failure at file %hs line %d.\n", file_name, line_number);
            else
                _RPT0(_CRT_WARN, "Client hook allocation failure.\n");
 
            __leave;
        }
 
#pragma warning(suppress:__WARNING_UNUSED_ASSIGNMENT) // 28931
        bool const ignore_block{_BLOCK_TYPE(block_use) != _CRT_BLOCK && !(_crtDbgFlag & _CRTDBG_ALLOC_MEM_DF)};
 
        // Diagnostic memory allocation from this point on...
        if (size > static_cast<size_t>(_HEAP_MAXREQ - no_mans_land_size - sizeof(_CrtMemBlockHeader)))
        {
            errno_t* const global_errno{_errno()};
            if (global_errno)
                *global_errno = ENOMEM;
 
            __leave;
        }
 
        if (!is_block_type_valid(block_use))
        {
            _RPT0(_CRT_ERROR, "Error: memory allocation: bad memory block type.\n");
        }
 
        size_t const block_size{sizeof(_CrtMemBlockHeader) + size + no_mans_land_size};
 
        _CrtMemBlockHeader* const header{static_cast<_CrtMemBlockHeader*>(HeapAlloc(__acrt_heap, 0, block_size))};
        if (!header)
        {
            errno_t* const global_errno{_errno()};
            if (global_errno)
                *global_errno = ENOMEM;
 
            __leave;
        }
 
        // Commit the allocation by linking the block into the global list:
        ++__acrt_current_request_number;
 
        if (ignore_block)
        {
            header->_block_header_next = nullptr;
            header->_block_header_prev = nullptr;
            header->_file_name         = nullptr;
            header->_line_number       = line_number_for_ignore_blocks;
            header->_data_size         = size;
            header->_block_use         = _IGNORE_BLOCK;
            header->_request_number    = request_number_for_ignore_blocks;
        }
        else
        {
            // Keep track of total amount of memory allocated:
            if (SIZE_MAX - __acrt_total_allocations > size)
            {
                __acrt_total_allocations += size;
            }
            else
            {
                __acrt_total_allocations = SIZE_MAX;
            }
 
            __acrt_current_allocations += size;
 
            if (__acrt_current_allocations > __acrt_max_allocations)
                __acrt_max_allocations = __acrt_current_allocations;
 
            if (__acrt_first_block)
            {
                __acrt_first_block->_block_header_prev = header;
            }
            else
            {
                __acrt_last_block = header;
            }
 
            header->_block_header_next = __acrt_first_block;
            header->_block_header_prev = nullptr;
            header->_file_name         = file_name;
            header->_line_number       = line_number;
            header->_data_size         = size;
            header->_block_use         = block_use;
            header->_request_number    = request_number;
 
            __acrt_first_block = header;
        }
 
        // Fill the gap before and after the data block:
        memset(header->_gap,                     no_mans_land_fill, no_mans_land_size);
        memset(block_from_header(header) + size, no_mans_land_fill, no_mans_land_size);
 
        // Fill the data block with a silly (but non-zero) value:
        memset(block_from_header(header), clean_land_fill, size);
 
        block = block_from_header(header);
    }
    __finally
    {
        __acrt_unlock(__acrt_heap_lock);
    }
    __endtry
 
    return block;
}

Referenced by heap_alloc_dbg().

if() [1/4]

if

(

!

new_block

)

Definition at line 2998 of file btrfs.c.

            {
        ERR("out of memory\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }

if() [2/4]

if

(

block

)

if() [3/4]

if

(

)

Definition at line 798 of file debug_heap.cpp.

    {
        memset(
            static_cast<unsigned char*>(new_block) + old_allocation_size,
            0,
            new_allocation_size - old_allocation_size);
    }

if() [4/4]

if	(	requested_size	,
		static_cast< size_t >	_HEAP_MAXREQ - no_mans_land_size - sizeof(_CrtMemBlockHeader)
	)

Definition at line 824 of file debug_heap.cpp.

    {
        errno = ENOMEM;
        return nullptr;
    }

is_bad_read_pointer()

static bool __cdecl is_bad_read_pointer ( void const *const  p, size_t const  size  ) throw ( )

static

Definition at line 206 of file debug_heap.cpp.

{
    SYSTEM_INFO system_info{};
    GetSystemInfo(&system_info);
    DWORD const page_size{system_info.dwPageSize};
 
    // If the structure has zero length, then do not probe the structure for
    // read accessibility or alignment.
    if (size == 0)
        return false;
 
    // A null pointer can never be read from:
    if (!p)
        return true;
 
    char const* start_address{static_cast<char const*>(p)};
    char const* end_address  {start_address + size - 1   };
    if (end_address < start_address)
        return true;
 
    __try
    {
        *(volatile char*)start_address;
 
        long const mask{~(static_cast<long>(page_size) - 1)};
 
        start_address = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(start_address) & mask);
        end_address   = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(end_address)   & mask);
        while (start_address != end_address)
        {
            start_address = start_address + page_size;
            *reinterpret_cast<const volatile char*>(start_address);
        }
    }
    __except(EXCEPTION_EXECUTE_HANDLER)
    {
        return true;
    }
    __endtry
 
    return false;
}

Referenced by dump_all_object_since_nolock().

is_block_an_aligned_allocation()

static bool __cdecl is_block_an_aligned_allocation ( void const *const  block ) throw ( )

static

Definition at line 249 of file debug_heap.cpp.

{
    unsigned char const* const possible_alignment_gap{reinterpret_cast<unsigned char const*>(
        reinterpret_cast<uintptr_t>(block) & (~sizeof(uintptr_t) - 1)) - align_gap_size};
 
    return check_bytes(possible_alignment_gap, align_land_fill, align_gap_size);
}

Referenced by free_dbg_nolock(), and realloc_dbg_nolock().

is_block_type_valid()

static bool __cdecl is_block_type_valid ( int const  block_use ) throw ( )

static

Definition at line 177 of file debug_heap.cpp.

{
    return _BLOCK_TYPE(block_use) == _CLIENT_BLOCK
        || _BLOCK_TYPE(block_use) == _CRT_BLOCK
        || block_use              == _NORMAL_BLOCK
        || block_use              == _IGNORE_BLOCK;
}

Referenced by _CrtIsMemoryBlock(), _CrtSetDbgBlockType(), check_block(), free_dbg_nolock(), and heap_alloc_dbg_internal().

print_block_data()

static void __cdecl print_block_data ( _locale_t const  locale, _CrtMemBlockHeader *const  header  ) throw ( )

static

Definition at line 1609 of file debug_heap.cpp.

{
    _LocaleUpdate locale_update{locale};
 
    static size_t const max_print = 16;
 
    char print_buffer[max_print     + 1];
    char value_buffer[max_print * 3 + 1];
 
    size_t i{0};
    for (; i < min(header->_data_size, max_print); ++i)
    {
        unsigned char const c{block_from_header(header)[i]};
 
        print_buffer[i] = _isprint_l(c, locale_update.GetLocaleT()) ? c : ' ';
        _ERRCHECK_SPRINTF(sprintf_s(value_buffer + i * 3, _countof(value_buffer) - (i * 3), "%.2X ", c));
    }
 
    print_buffer[i] = '\0';
    _RPTN(_CRT_WARN, " Data: <%s> %s\n", print_buffer, value_buffer);
}

Referenced by dump_all_object_since_nolock().

realloc_dbg_nolock()

static void *__cdecl realloc_dbg_nolock ( void *const  block, size_t *const  new_size, int const  block_use, char const *const  file_name, int const  line_number, bool const  reallocation_is_allowed  ) throw ( )

static

Definition at line 535 of file debug_heap.cpp.

{
    // realloc(nullptr, size) is equivalent to malloc(size):
    if (!block)
    {
        return _malloc_dbg(*new_size, block_use, file_name, line_number);
    }
 
    // realloc(block, 0) is equivalent to free(block):
    if (reallocation_is_allowed && *new_size == 0)
    {
        _free_dbg(block, block_use);
        return nullptr;
    }
 
    validate_heap_if_required_nolock();
 
    // Handle break-on-request and forced failure:
    long const request_number{__acrt_current_request_number};
    if (_crtBreakAlloc != -1 && request_number == _crtBreakAlloc)
    {
        _CrtDbgBreak();
    }
 
    if (_pfnAllocHook && !_pfnAllocHook(
        _HOOK_REALLOC,
        block,
        *new_size,
        block_use,
        request_number,
        reinterpret_cast<unsigned char const*>(file_name),
        line_number))
    {
        if (file_name)
            _RPTN(_CRT_WARN, "Client hook re-allocation failure at file %hs line %d.\n", file_name, line_number);
        else
            _RPT0(_CRT_WARN, "Client hook re-allocation failure.\n");
 
        return nullptr;
    }
 
    // Ensure the block type matches what is expected and isn't an aligned allocation:
    if (block_use != _NORMAL_BLOCK && _BLOCK_TYPE(block_use) != _CLIENT_BLOCK && _BLOCK_TYPE(block_use) != _CRT_BLOCK)
    {
        if (file_name)
        {
            _RPTN(_CRT_ERROR,
                "Error: memory allocation: bad memory block type.\n" _ALLOCATION_FILE_LINENUM,
                file_name, line_number);
        }
        else
        {
            _RPT0(_CRT_ERROR, "Error: memory allocation: bad memory block type.\n");
        }
    }
    else if (is_block_an_aligned_allocation(block))
    {
        // We don't know (yet) where (file, linenum) block was allocated
        _RPTN(_CRT_ERROR, "The Block at 0x%p was allocated by aligned routines, use _aligned_realloc()", block);
        errno = EINVAL;
 
        return nullptr;
    }
 
    // If this assertion fails, a bad pointer has been passed in.  It may be
    // totally bogus, or it may have been allocated from another heap.  The
    // pointer must have been allocated from the debug heap.
    _ASSERTE(_CrtIsValidHeapPointer(block));
 
    _CrtMemBlockHeader* const old_head{header_from_block(block)};
 
    bool const is_ignore_block{old_head->_block_use == _IGNORE_BLOCK};
    if (is_ignore_block)
    {
        _ASSERTE(old_head->_line_number == line_number_for_ignore_blocks && old_head->_request_number == request_number_for_ignore_blocks);
    }
    else if (__acrt_total_allocations < old_head->_data_size)
    {
        _RPTN(_CRT_ERROR, "Error: possible heap corruption at or near 0x%p", block);
        errno = EINVAL;
        return nullptr;
    }
 
    // Ensure the new requested size is not too large:
    if (*new_size > static_cast<size_t>(_HEAP_MAXREQ - no_mans_land_size - sizeof(_CrtMemBlockHeader)))
    {
        errno = ENOMEM;
        return nullptr;
    }
 
    // Note that all header values will remain valid and the minimum of the old
    // size and the new size of data will remain valid.
    size_t const new_internal_size{sizeof(_CrtMemBlockHeader) + *new_size + no_mans_land_size};
 
    _CrtMemBlockHeader* new_head{nullptr};
    if (reallocation_is_allowed)
    {
        new_head = static_cast<_CrtMemBlockHeader*>(_realloc_base(old_head, new_internal_size));
        if (!new_head)
            return nullptr;
    }
    else
    {
        new_head = static_cast<_CrtMemBlockHeader*>(_expand_base(old_head, new_internal_size));
        if (!new_head)
            return nullptr;
 
        // On Win64, the heap does not try to resize the block if it is shrinking
        // because of the use of the low-fragmentation heap.  It just returns the
        // original block.  We make sure that our own header tracks that properly:
        #ifdef _WIN64
        *new_size = static_cast<size_t>(HeapSize(__acrt_heap, 0, new_head)
            - sizeof(_CrtMemBlockHeader)
            - no_mans_land_size);
        #endif
    }
 
    _Analysis_assume_(new_head->_data_size == old_head->_data_size);
 
    // Account for the current allocation and track the total amount of memory
    // that is currently allocated:
    ++__acrt_current_request_number;
    if (!is_ignore_block)
    {
        if (__acrt_total_allocations < SIZE_MAX)
        {
            __acrt_total_allocations -= new_head->_data_size;
            __acrt_total_allocations += SIZE_MAX - __acrt_total_allocations > *new_size
                ? *new_size
                : SIZE_MAX;
        }
 
        __acrt_current_allocations -= new_head->_data_size;
        __acrt_current_allocations += *new_size;
 
        if (__acrt_current_allocations > __acrt_max_allocations)
            __acrt_max_allocations = __acrt_current_allocations;
    }
 
    unsigned char* const new_block{block_from_header(new_head)};
 
    // If the block grew, fill the "extension" with the land fill value:
    if (*new_size > new_head->_data_size)
    {
        memset(new_block + new_head->_data_size, clean_land_fill, *new_size - new_head->_data_size);
    }
 
    // Fill in the gap after the client block:
    memset(new_block + *new_size, no_mans_land_fill, no_mans_land_size);
 
    if (!is_ignore_block)
    {
        new_head->_file_name      = file_name;
        new_head->_line_number    = line_number;
        new_head->_request_number = request_number;
    }
 
    new_head->_data_size = *new_size;
 
    _ASSERTE(reallocation_is_allowed || (!reallocation_is_allowed && new_head == old_head));
 
    // If the block did not move or is ignored, we are done:
    if (new_head == old_head || is_ignore_block)
        return new_block;
 
    // Swap out the old block from the linked list and link in the new block:
    if (new_head->_block_header_next)
    {
        new_head->_block_header_next->_block_header_prev = new_head->_block_header_prev;
    }
    else
    {
        _ASSERTE(__acrt_last_block == old_head);
        __acrt_last_block = new_head->_block_header_prev;
    }
 
    if (new_head->_block_header_prev)
    {
        new_head->_block_header_prev->_block_header_next = new_head->_block_header_next;
    }
    else
    {
        _ASSERTE(__acrt_first_block == old_head);
        __acrt_first_block = new_head->_block_header_next;
    }
 
    if (__acrt_first_block)
    {
        __acrt_first_block->_block_header_prev = new_head;
    }
    else
    {
        __acrt_last_block = new_head;
    }
 
    new_head->_block_header_next = __acrt_first_block;
    new_head->_block_header_prev = nullptr;
    __acrt_first_block = new_head;
 
    return new_block;
}

validate_heap_if_required_nolock()

static void __cdecl validate_heap_if_required_nolock ( ) throw ( )

static

Definition at line 262 of file debug_heap.cpp.

{
    if (__acrt_check_frequency == 0)
    {
        return;
    }
 
    if (__acrt_check_counter != __acrt_check_frequency - 1)
    {
        ++__acrt_check_counter;
        return;
    }
 
    if (heap_validation_pending)
    {
        return;
    }
 
    heap_validation_pending = true;
    __try
    {
        _ASSERTE(_CrtCheckMemory());
    }
    __finally
    {
        heap_validation_pending = false;
    }
    __endtry
 
    __acrt_check_counter = 0;
}

Referenced by free_dbg_nolock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

Variable Documentation

__acrt_check_counter

unsigned __acrt_check_counter {0}

static

Definition at line 128 of file debug_heap.cpp.

Referenced by _CrtSetDbgFlag(), and validate_heap_if_required_nolock().

__acrt_check_frequency

unsigned __acrt_check_frequency {0}

static

Definition at line 127 of file debug_heap.cpp.

Referenced by _CrtSetDbgFlag(), and validate_heap_if_required_nolock().

__acrt_current_allocations

size_t __acrt_current_allocations {0}

static

Definition at line 122 of file debug_heap.cpp.

Referenced by free_dbg_nolock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

__acrt_current_request_number

long __acrt_current_request_number {1}

static

Definition at line 132 of file debug_heap.cpp.

Referenced by _CrtIsMemoryBlock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

__acrt_first_block

_CrtMemBlockHeader* __acrt_first_block {nullptr}

static

Definition at line 114 of file debug_heap.cpp.

Referenced by _CrtCheckMemory(), _CrtDoForAllClientObjects(), _CrtMemCheckpoint(), dump_all_object_since_nolock(), free_dbg_nolock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

__acrt_last_block

_CrtMemBlockHeader* __acrt_last_block {nullptr}

static

Definition at line 115 of file debug_heap.cpp.

Referenced by free_dbg_nolock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

__acrt_max_allocations

size_t __acrt_max_allocations {0}

static

Definition at line 123 of file debug_heap.cpp.

Referenced by _CrtMemCheckpoint(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

__acrt_total_allocations

size_t __acrt_total_allocations {0}

static

Definition at line 121 of file debug_heap.cpp.

Referenced by _CrtMemCheckpoint(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

__finally

__finally

Initial value:

{
        __acrt_unlock(__acrt_heap_lock)

Definition at line 765 of file debug_heap.cpp.

Referenced by _CrtCheckMemory(), _CrtDoForAllClientObjects(), _CrtIsMemoryBlock(), _CrtMemCheckpoint(), _CrtMemDumpAllObjectsSince(), _CrtSetDbgBlockType(), _CrtSetDbgFlag(), heap_alloc_dbg_internal(), and validate_heap_if_required_nolock().

__try

__try

Initial value:

{
        size_t new_size{requested_size}

Definition at line 760 of file debug_heap.cpp.

Referenced by _CrtCheckMemory(), _CrtDoForAllClientObjects(), _CrtIsMemoryBlock(), _CrtMemCheckpoint(), _CrtMemDumpAllObjectsSince(), _CrtSetDbgBlockType(), _CrtSetDbgFlag(), heap_alloc_dbg_internal(), is_bad_read_pointer(), and validate_heap_if_required_nolock().

_crtBreakAlloc

long _crtBreakAlloc {-1}

Definition at line 146 of file debug_heap.cpp.

Referenced by __p__crtBreakAlloc(), _CrtSetBreakAlloc(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

_crtDbgFlag

int _crtDbgFlag {_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_DEFAULT_DF}

Definition at line 145 of file debug_heap.cpp.

Referenced by __p__crtDbgFlag(), _CrtCheckMemory(), _CrtDoForAllClientObjects(), _CrtDumpMemoryLeaks(), _CrtMemDifference(), _CrtSetDbgFlag(), dump_all_object_since_nolock(), free_dbg_nolock(), and heap_alloc_dbg_internal().

_pfnDumpClient

_CRT_DUMP_CLIENT _pfnDumpClient {nullptr}

Definition at line 147 of file debug_heap.cpp.

Referenced by _CrtGetDumpClient(), _CrtSetDumpClient(), and dump_all_object_since_nolock().

align_gap_size

size_t const align_gap_size = sizeof(void *)

static

Definition at line 66 of file debug_heap.cpp.

Referenced by _aligned_free_dbg(), _aligned_offset_malloc_dbg(), _aligned_offset_realloc_dbg(), and is_block_an_aligned_allocation().

align_land_fill

unsigned char const align_land_fill {0xED}

static

Definition at line 60 of file debug_heap.cpp.

Referenced by _aligned_free_dbg(), _aligned_offset_malloc_dbg(), _aligned_offset_realloc_dbg(), and is_block_an_aligned_allocation().

allocation_size

allocation_size {element_size * count}

Definition at line 518 of file debug_heap.cpp.

Referenced by cache_container_is_valid().

block

return block {heap_alloc_dbg(allocation_size, block_use, file_name, line_number)}

Definition at line 523 of file debug_heap.cpp.

Referenced by _aligned_free_dbg(), _aligned_msize_dbg(), _aligned_offset_realloc_dbg(), _aligned_offset_recalloc_dbg(), _aligned_realloc_dbg(), _aligned_recalloc_dbg(), _CrtIsMemoryBlock(), _CrtIsValidHeapPointer(), _CrtReportBlockType(), _CrtSetDbgBlockType(), free_dbg_nolock(), header_from_block(), heap_alloc_dbg(), heap_alloc_dbg_internal(), is_block_an_aligned_allocation(), and realloc_dbg_nolock().

block_use

__endtry int const block_use

Initial value:

{
    __acrt_lock(__acrt_heap_lock)

Definition at line 495 of file debug_heap.cpp.

Referenced by _CrtSetDbgBlockType(), check_block(), free_dbg_nolock(), heap_alloc_dbg(), heap_alloc_dbg_internal(), is_block_type_valid(), and realloc_dbg_nolock().

block_use_names

char const* const block_use_names[_MAX_BLOCKS]

static

Initial value:

{
    "Free",
    "Normal",
    "CRT",
    "Ignore",
    "Client",
}

Definition at line 33 of file debug_heap.cpp.

Referenced by _CrtMemDumpStatistics(), check_block(), and free_dbg_nolock().

clean_land_fill

unsigned char const clean_land_fill {0xCD}

static

Definition at line 62 of file debug_heap.cpp.

Referenced by heap_alloc_dbg_internal(), and realloc_dbg_nolock().

count

size_t const count

Definition at line 781 of file debug_heap.cpp.

dead_land_fill

unsigned char const dead_land_fill {0xDD}

static

Definition at line 61 of file debug_heap.cpp.

Referenced by check_block(), and free_dbg_nolock().

element_size

size_t const size_t const element_size

Definition at line 510 of file debug_heap.cpp.

Referenced by _aligned_offset_recalloc_dbg(), _fread_nolock(), _fread_nolock_s(), _fwrite_nolock(), _fwrite_nolock_internal(), d3dcompiler_parse_signature(), d3drm_array_reserve(), debugsymbols_GetSourcePathElement(), debugsymbols_GetSourcePathElementWide(), DECLARE_INTERFACE_(), empty_image(), fill_image(), fread(), fread_s(), gluBuild2DMipmapLevelsCore(), halve1Dimage_byte(), halve1Dimage_float(), halve1Dimage_int(), halve1Dimage_short(), halve1Dimage_ubyte(), halve1Dimage_uint(), halve1Dimage_ushort(), halveImage_byte(), halveImage_float(), halveImage_int(), halveImage_short(), halveImage_ubyte(), halveImage_uint(), halveImage_ushort(), scale_internal_byte(), scale_internal_float(), scale_internal_int(), scale_internal_short(), scale_internal_ubyte(), scale_internal_uint(), scale_internal_ushort(), scaleInternalPackedPixel(), and validate_resource_view().

file_name

size_t const int const char const* const file_name

Definition at line 496 of file debug_heap.cpp.

Referenced by _aligned_malloc_dbg(), _aligned_offset_malloc_dbg(), _aligned_offset_realloc_dbg(), _aligned_offset_recalloc_dbg(), _aligned_realloc_dbg(), _aligned_recalloc_dbg(), _CrtIsMemoryBlock(), heap_alloc_dbg(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

header

_CrtMemBlockHeader* const header {header_from_block(block)}

Definition at line 1069 of file debug_heap.cpp.

Referenced by heap_alloc_dbg_internal().

heap_validation_pending

bool heap_validation_pending {false}

static

Definition at line 260 of file debug_heap.cpp.

Referenced by validate_heap_if_required_nolock().

line_number

size_t const int const char const *const int const line_number

Initial value:

{
    return heap_alloc_dbg(size, block_use, file_name, line_number)

Definition at line 497 of file debug_heap.cpp.

Referenced by __acrt_MessageWindowA(), __acrt_MessageWindowW(), _aligned_malloc_dbg(), _aligned_offset_malloc_dbg(), _aligned_offset_realloc_dbg(), _aligned_offset_recalloc_dbg(), _aligned_realloc_dbg(), _aligned_recalloc_dbg(), _assert(), _CrtDbgReport(), _CrtDbgReportW(), _CrtDefaultAllocHook(), _CrtIsMemoryBlock(), _invoke_watson_if_error(), _invoke_watson_if_oneof(), _strdup(), _wassert(), _wcsdup(), common_assert(), common_assert_to_message_box(), common_assert_to_message_box_build_string(), common_assert_to_stderr_direct(), common_dupenv_s_nolock(), common_message_window(), compute_shader_probe9(), File::enum_lines(), find_str(), heap_alloc_dbg(), heap_alloc_dbg_internal(), pp_internal_error(), hhp_reader::read(), realloc_dbg_nolock(), test_IActiveScriptError(), throw(), and xmlreader_GetLineNumber().

line_number_for_ignore_blocks

int const line_number_for_ignore_blocks {static_cast<int>(0xFEDCBABC)}

static

Definition at line 70 of file debug_heap.cpp.

Referenced by free_dbg_nolock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

new_allocation_size

size_t const new_allocation_size {element_size * count }

Definition at line 791 of file debug_heap.cpp.

Referenced by _aligned_offset_recalloc_dbg(), and if().

new_block

return new_block = realloc_dbg_nolock(block, &new_size, block_use, file_name, line_number, true)

Definition at line 763 of file debug_heap.cpp.

Referenced by _aligned_offset_recalloc_dbg(), for(), if(), and realloc_dbg_nolock().

no_mans_land_fill

unsigned char const no_mans_land_fill {0xFD}

static

Definition at line 59 of file debug_heap.cpp.

Referenced by _aligned_free_dbg(), _aligned_offset_realloc_dbg(), check_block(), free_dbg_nolock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

no_mans_land_size

size_t const no_mans_land_size = 4

static

Definition at line 65 of file debug_heap.cpp.

Referenced by _aligned_free_dbg(), _aligned_offset_realloc_dbg(), check_block(), free_dbg_nolock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

old_allocation_size

size_t const old_allocation_size {block ? _msize_dbg(block, block_use) : 0}

Definition at line 790 of file debug_heap.cpp.

Referenced by _aligned_offset_recalloc_dbg(), and if().

request_number_for_ignore_blocks

long const request_number_for_ignore_blocks {0}

static

Definition at line 69 of file debug_heap.cpp.

Referenced by free_dbg_nolock(), heap_alloc_dbg_internal(), and realloc_dbg_nolock().

requested_size

size_t const requested_size

Definition at line 751 of file debug_heap.cpp.

Referenced by __crt_win32_buffer< Character, ResizePolicy >::allocate().

size

__endtry return size {0}

Definition at line 1057 of file debug_heap.cpp.

Referenced by heap_alloc_dbg_internal().