#include <precomp.h>
#include <malloc.h>

Include dependency graph for heap.c:

Macros
#define	MSVCRT_size_t size_t

#define	MSVCRT_intptr_t intptr_t

#define	MSVCRT_wchar_t wchar_t

#define	MSVCRT__HEAPBADNODE _HEAPBADNODE

#define	MSVCRT__HEAPOK _HEAPOK

#define	MSVCRT__HEAPEND _HEAPEND

#define	MSVCRT__FREEENTRY _FREEENTRY

#define	MSVCRT__USEDENTRY _USEDENTRY

#define	MSVCRT__HEAPBADBEGIN _HEAPBADBEGIN

#define	MSVCRT_EINVAL EINVAL

#define	MSVCRT_ENOSYS ENOSYS

#define	MSVCRT_ENOMEM ENOMEM

#define	MSVCRT_ERANGE ERANGE

#define	MSVCRT__TRUNCATE _TRUNCATE

#define	MSVCRT__heapinfo _heapinfo

#define	MSVCRT__errno _errno

#define	MSVCRT_calloc calloc

#define	MSVCRT_malloc malloc

#define	MSVCRT_realloc realloc

#define	MSVCRT_free free

#define	MSVCRT_memcpy_s memcpy_s

#define	MSVCRT_memmove_s memmove_s

#define	MSVCRT_strncpy_s strncpy_s

#define	msvcrt_set_errno _dosmaperr

#define	LOCK_HEAP _lock( _HEAP_LOCK )

#define	UNLOCK_HEAP _unlock( _HEAP_LOCK )

#define	SAVED_PTR(x)

#define	ALIGN_PTR(ptr, alignment, offset)

#define	SB_HEAP_ALIGN 16

Typedefs
typedef int(CDECL *	MSVCRT_new_handler_func) (size_t size)

Functions
static void *	msvcrt_heap_alloc (DWORD flags, size_t size)

static void *	msvcrt_heap_realloc (DWORD flags, void *ptr, size_t size)

static BOOL	msvcrt_heap_free (void *ptr)

static size_t	msvcrt_heap_size (void *ptr)

int CDECL	_callnewh (size_t size)

void *CDECL DECLSPEC_HOTPATCH	operator_new (size_t size)

void *CDECL	operator_new_dbg (size_t size, int type, const char *file, int line)

void CDECL DECLSPEC_HOTPATCH	operator_delete (void *mem)

MSVCRT_new_handler_func CDECL	_query_new_handler (void)

int CDECL	_query_new_mode (void)

MSVCRT_new_handler_func CDECL	_set_new_handler (MSVCRT_new_handler_func func)

MSVCRT_new_handler_func CDECL	set_new_handler (void *func)

int CDECL	_set_new_mode (int mode)

void *CDECL	_expand (void *mem, size_t size)

int CDECL	_heapchk (void)

int CDECL	_heapmin (void)

int CDECL	_heapwalk (_HEAPINFO *next)

int CDECL	_heapset (unsigned int value)

int CDECL	_heapadd (void *mem, size_t size)

intptr_t CDECL	_get_heap_handle (void)

size_t CDECL	_msize (void *mem)

void *CDECL DECLSPEC_HOTPATCH	calloc (size_t count, size_t size)

void CDECL DECLSPEC_HOTPATCH	free (void *ptr)

void *CDECL	malloc (size_t size)

void *CDECL DECLSPEC_HOTPATCH	realloc (void *ptr, size_t size)

unsigned int *CDECL	__p__amblksiz (void)

size_t CDECL	_get_sbh_threshold (void)

int CDECL	_set_sbh_threshold (size_t threshold)

void CDECL	_aligned_free (void *memblock)

void *CDECL	_aligned_offset_malloc (size_t size, size_t alignment, size_t offset)

void *CDECL	_aligned_malloc (size_t size, size_t alignment)

void *CDECL	_aligned_offset_realloc (void *memblock, size_t size, size_t alignment, size_t offset)

void *CDECL	_aligned_realloc (void *memblock, size_t size, size_t alignment)

int CDECL	memmove_s (void dest, size_t numberOfElements, const void src, size_t count)

int CDECL	memcpy_s (void dest, size_t numberOfElements, const void src, size_t count)

int CDECL	strncpy_s (char dest, size_t numberOfElements, const char src, size_t count)

BOOL	msvcrt_init_heap (void)

void	msvcrt_destroy_heap (void)

Variables
static HANDLE	heap

static HANDLE	sb_heap

static MSVCRT_new_handler_func	MSVCRT_new_handler

static int	MSVCRT_new_mode

static unsigned int	MSVCRT_amblksiz = 16

static size_t	MSVCRT_sbh_threshold = 0

Macro Definition Documentation

◆ ALIGN_PTR

#define ALIGN_PTR	(	ptr,
		alignment,
		offset
	)

Value:

    ((void *) \
    ((((DWORD_PTR)((char *)ptr + alignment + sizeof(void *) + offset)) & \
      ~(alignment - 1)) - offset))

Definition at line 59 of file heap.c.

◆ LOCK_HEAP

#define LOCK_HEAP _lock( _HEAP_LOCK )

Definition at line 53 of file heap.c.

◆ MSVCRT__errno

#define MSVCRT__errno ( void ) _errno

Definition at line 42 of file heap.c.

◆ MSVCRT__FREEENTRY

#define MSVCRT__FREEENTRY _FREEENTRY

Definition at line 33 of file heap.c.

◆ MSVCRT__HEAPBADBEGIN

#define MSVCRT__HEAPBADBEGIN _HEAPBADBEGIN

Definition at line 35 of file heap.c.

◆ MSVCRT__HEAPBADNODE

#define MSVCRT__HEAPBADNODE _HEAPBADNODE

Definition at line 30 of file heap.c.

◆ MSVCRT__HEAPEND

#define MSVCRT__HEAPEND _HEAPEND

Definition at line 32 of file heap.c.

◆ MSVCRT__heapinfo

#define MSVCRT__heapinfo _heapinfo

Definition at line 41 of file heap.c.

◆ MSVCRT__HEAPOK

#define MSVCRT__HEAPOK _HEAPOK

Definition at line 31 of file heap.c.

◆ MSVCRT__TRUNCATE

#define MSVCRT__TRUNCATE _TRUNCATE

Definition at line 40 of file heap.c.

◆ MSVCRT__USEDENTRY

#define MSVCRT__USEDENTRY _USEDENTRY

Definition at line 34 of file heap.c.

◆ MSVCRT_calloc

#define MSVCRT_calloc calloc

Definition at line 43 of file heap.c.

◆ MSVCRT_EINVAL

#define MSVCRT_EINVAL EINVAL

Definition at line 36 of file heap.c.

◆ MSVCRT_ENOMEM

#define MSVCRT_ENOMEM ENOMEM

Definition at line 38 of file heap.c.

◆ MSVCRT_ENOSYS

#define MSVCRT_ENOSYS ENOSYS

Definition at line 37 of file heap.c.

◆ MSVCRT_ERANGE

#define MSVCRT_ERANGE ERANGE

Definition at line 39 of file heap.c.

◆ MSVCRT_free

#define MSVCRT_free free

Definition at line 46 of file heap.c.

◆ MSVCRT_intptr_t

#define MSVCRT_intptr_t intptr_t

Definition at line 28 of file heap.c.

◆ MSVCRT_malloc

#define MSVCRT_malloc malloc

Definition at line 44 of file heap.c.

◆ MSVCRT_memcpy_s

#define MSVCRT_memcpy_s memcpy_s

Definition at line 47 of file heap.c.

◆ MSVCRT_memmove_s

#define MSVCRT_memmove_s memmove_s

Definition at line 48 of file heap.c.

◆ MSVCRT_realloc

#define MSVCRT_realloc realloc

Definition at line 45 of file heap.c.

◆ msvcrt_set_errno

#define msvcrt_set_errno _dosmaperr

Definition at line 50 of file heap.c.

◆ MSVCRT_size_t

static MSVCRT_size_t size_t

Definition at line 27 of file heap.c.

◆ MSVCRT_strncpy_s

#define MSVCRT_strncpy_s strncpy_s

Definition at line 49 of file heap.c.

◆ MSVCRT_wchar_t

#define MSVCRT_wchar_t wchar_t

Definition at line 29 of file heap.c.

◆ SAVED_PTR

#define SAVED_PTR ( x )

Value:

((void *)((DWORD_PTR)((char *)x - sizeof(void *)) & \

~(sizeof(void *) - 1)))

x

GLint GLint GLint GLint GLint x

Definition: gl.h:1548

Definition at line 57 of file heap.c.

◆ SB_HEAP_ALIGN

#define SB_HEAP_ALIGN 16

Definition at line 63 of file heap.c.

◆ UNLOCK_HEAP

#define UNLOCK_HEAP _unlock( _HEAP_LOCK )

Definition at line 54 of file heap.c.

Typedef Documentation

◆ MSVCRT_new_handler_func

typedef int(CDECL * MSVCRT_new_handler_func) (size_t size)

Definition at line 67 of file heap.c.

Function Documentation

◆ pamblksiz()

unsigned int *CDECL __p__amblksiz ( void )

Definition at line 528 of file heap.c.

{
  return &MSVCRT_amblksiz;
}

◆ _aligned_free()

void CDECL _aligned_free ( void * memblock )

Definition at line 567 of file heap.c.

{
    TRACE("(%p)\n", memblock);
 
    if (memblock)
    {
        void **saved = SAVED_PTR(memblock);
        free(*saved);
    }
}

Referenced by _aligned_offset_realloc().

◆ _aligned_malloc()

void *CDECL _aligned_malloc	(	size_t	size,
		size_t	alignment
	)

Definition at line 624 of file heap.c.

{
    TRACE("(%Iu, %Iu)\n", size, alignment);
    return _aligned_offset_malloc(size, alignment, 0);
}

◆ _aligned_offset_malloc()

void *CDECL _aligned_offset_malloc	(	size_t	size,
		size_t	alignment,
		size_t	offset
	)

Definition at line 581 of file heap.c.

{
    void *memblock, *temp, **saved;
    TRACE("(%Iu, %Iu, %Iu)\n", size, alignment, offset);
 
    /* alignment must be a power of 2 */
    if ((alignment & (alignment - 1)) != 0)
    {
        *_errno() = EINVAL;
        return NULL;
    }
 
    /* offset must be less than size */
    if (offset && offset >= size)
    {
        *_errno() = EINVAL;
        return NULL;
    }
 
    /* don't align to less than void pointer size */
    if (alignment < sizeof(void *))
        alignment = sizeof(void *);
 
    /* allocate enough space for void pointer and alignment */
    temp = malloc(size + alignment + sizeof(void *));
 
    if (!temp)
        return NULL;
 
    /* adjust pointer for proper alignment and offset */
    memblock = ALIGN_PTR(temp, alignment, offset);
 
    /* Save the real allocation address below returned address */
    /* so it can be found later to free. */
    saved = SAVED_PTR(memblock);
    *saved = temp;
 
    return memblock;
}

Referenced by _aligned_malloc(), and _aligned_offset_realloc().

◆ _aligned_offset_realloc()

void *CDECL _aligned_offset_realloc	(	void *	memblock,
		size_t	size,
		size_t	alignment,
		size_t	offset
	)

Definition at line 633 of file heap.c.

{
    void * temp, **saved;
    size_t old_padding, new_padding, old_size;
    TRACE("(%p, %Iu, %Iu, %Iu)\n", memblock, size, alignment, offset);
 
    if (!memblock)
        return _aligned_offset_malloc(size, alignment, offset);
 
    /* alignment must be a power of 2 */
    if ((alignment & (alignment - 1)) != 0)
    {
        *_errno() = EINVAL;
        return NULL;
    }
 
    /* offset must be less than size */
    if (offset >= size)
    {
        *_errno() = EINVAL;
        return NULL;
    }
 
    if (size == 0)
    {
        _aligned_free(memblock);
        return NULL;
    }
 
    /* don't align to less than void pointer size */
    if (alignment < sizeof(void *))
        alignment = sizeof(void *);
 
    /* make sure alignment and offset didn't change */
    saved = SAVED_PTR(memblock);
    if (memblock != ALIGN_PTR(*saved, alignment, offset))
    {
        *_errno() = EINVAL;
        return NULL;
    }
 
    old_padding = (char *)memblock - (char *)*saved;
 
    /* Get previous size of block */
    old_size = _msize(*saved);
    if (old_size == -1)
    {
        /* It seems this function was called with an invalid pointer. Bail out. */
        return NULL;
    }
 
    /* Adjust old_size to get amount of actual data in old block. */
    if (old_size < old_padding)
    {
        /* Shouldn't happen. Something's weird, so bail out. */
        return NULL;
    }
    old_size -= old_padding;
 
    temp = realloc(*saved, size + alignment + sizeof(void *));
 
    if (!temp)
        return NULL;
 
    /* adjust pointer for proper alignment and offset */
    memblock = ALIGN_PTR(temp, alignment, offset);
 
    /* Save the real allocation address below returned address */
    /* so it can be found later to free. */
    saved = SAVED_PTR(memblock);
 
    new_padding = (char *)memblock - (char *)temp;
 
/*
   Memory layout of old block is as follows:
   +-------+---------------------+-+--------------------------+-----------+
   |  ...  | "old_padding" bytes | | ... "old_size" bytes ... |    ...    |
   +-------+---------------------+-+--------------------------+-----------+
           ^                     ^ ^
           |                     | |
        *saved               saved memblock
 
   Memory layout of new block is as follows:
   +-------+-----------------------------+-+----------------------+-------+
   |  ...  |    "new_padding" bytes      | | ... "size" bytes ... |  ...  |
   +-------+-----------------------------+-+----------------------+-------+
           ^                             ^ ^
           |                             | |
          temp                       saved memblock
 
   However, in the new block, actual data is still written as follows
   (because it was copied by realloc):
   +-------+---------------------+--------------------------------+-------+
   |  ...  | "old_padding" bytes |   ... "old_size" bytes ...     |  ...  |
   +-------+---------------------+--------------------------------+-------+
           ^                             ^ ^
           |                             | |
          temp                       saved memblock
 
   Therefore, min(old_size,size) bytes of actual data have to be moved
   from the offset they were at in the old block (temp + old_padding),
   to the offset they have to be in the new block (temp + new_padding == memblock).
*/
    if (new_padding != old_padding)
        memmove((char *)memblock, (char *)temp + old_padding, (old_size < size) ? old_size : size);
 
    *saved = temp;
 
    return memblock;
}

Referenced by _aligned_realloc().

◆ _aligned_realloc()

void *CDECL _aligned_realloc	(	void *	memblock,
		size_t	size,
		size_t	alignment
	)

Definition at line 748 of file heap.c.

{
    TRACE("(%p, %Iu, %Iu)\n", memblock, size, alignment);
    return _aligned_offset_realloc(memblock, size, alignment, 0);
}

◆ _callnewh()

int CDECL _callnewh ( size_t size )

Definition at line 152 of file heap.c.

{
  int ret = 0;
  MSVCRT_new_handler_func handler = MSVCRT_new_handler;
  if(handler)
    ret = (*handler)(size) ? 1 : 0;
  return ret;
}

Referenced by malloc(), and operator_new().

◆ _expand()

void *CDECL _expand	(	void *	mem,
		size_t	size
	)

Definition at line 257 of file heap.c.

{
  return msvcrt_heap_realloc(HEAP_REALLOC_IN_PLACE_ONLY, mem, size);
}

◆ _get_heap_handle()

intptr_t CDECL _get_heap_handle ( void )

Definition at line 367 of file heap.c.

{
    return (intptr_t)heap;
}

◆ _get_sbh_threshold()

size_t CDECL _get_sbh_threshold ( void )

Definition at line 536 of file heap.c.

{
  return MSVCRT_sbh_threshold;
}

Referenced by test_sbheap().

◆ _heapadd()

int CDECL _heapadd	(	void *	mem,
		size_t	size
	)

Definition at line 357 of file heap.c.

{
  TRACE("(%p,%Iu) unsupported in Win32\n", mem,size);
  *_errno() = ENOSYS;
  return -1;
}

◆ _heapchk()

int CDECL _heapchk ( void )

Definition at line 265 of file heap.c.

{
  if (!HeapValidate(heap, 0, NULL) ||
          (sb_heap && !HeapValidate(sb_heap, 0, NULL)))
  {
    msvcrt_set_errno(GetLastError());
    return _HEAPBADNODE;
  }
  return _HEAPOK;
}

◆ _heapmin()

int CDECL _heapmin ( void )

Definition at line 279 of file heap.c.

{
  if (!HeapCompact( heap, 0 ) ||
          (sb_heap && !HeapCompact( sb_heap, 0 )))
  {
    if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
      msvcrt_set_errno(GetLastError());
    return -1;
  }
  return 0;
}

◆ _heapset()

int CDECL _heapset ( unsigned int value )

Definition at line 338 of file heap.c.

{
  int retval;
  _HEAPINFO heap;
 
  memset( &heap, 0, sizeof(heap) );
  LOCK_HEAP;
  while ((retval = _heapwalk(&heap)) == _HEAPOK)
  {
    if (heap._useflag == _FREEENTRY)
      memset(heap._pentry, value, heap._size);
  }
  UNLOCK_HEAP;
  return retval == _HEAPEND ? _HEAPOK : retval;
}

◆ _heapwalk()

int CDECL _heapwalk ( _HEAPINFO * next )

Definition at line 294 of file heap.c.

{
  PROCESS_HEAP_ENTRY phe;
 
  if (sb_heap)
      FIXME("small blocks heap not supported\n");
 
  LOCK_HEAP;
  phe.lpData = next->_pentry;
  phe.cbData = (DWORD)next->_size;
  phe.wFlags = next->_useflag == _USEDENTRY ? PROCESS_HEAP_ENTRY_BUSY : 0;
 
  if (phe.lpData && phe.wFlags & PROCESS_HEAP_ENTRY_BUSY &&
      !HeapValidate( heap, 0, phe.lpData ))
  {
    UNLOCK_HEAP;
    msvcrt_set_errno(GetLastError());
    return _HEAPBADNODE;
  }
 
  do
  {
    if (!HeapWalk( heap, &phe ))
    {
      UNLOCK_HEAP;
      if (GetLastError() == ERROR_NO_MORE_ITEMS)
         return _HEAPEND;
      msvcrt_set_errno(GetLastError());
      if (!phe.lpData)
        return _HEAPBADBEGIN;
      return _HEAPBADNODE;
    }
  } while (phe.wFlags & (PROCESS_HEAP_REGION|PROCESS_HEAP_UNCOMMITTED_RANGE));
 
  UNLOCK_HEAP;
  next->_pentry = phe.lpData;
  next->_size = phe.cbData;
  next->_useflag = phe.wFlags & PROCESS_HEAP_ENTRY_BUSY ? _USEDENTRY : _FREEENTRY;
  return _HEAPOK;
}

Referenced by _heapset().

◆ _msize()

size_t CDECL _msize ( void * mem )

Definition at line 375 of file heap.c.

{
  size_t size = msvcrt_heap_size(mem);
  if (size == ~(size_t)0)
  {
    WARN(":Probably called with non wine-allocated memory, ret = -1\n");
    /* At least the Win32 crtdll/msvcrt also return -1 in this case */
  }
  return size;
}

Referenced by _aligned_offset_realloc().

◆ _query_new_handler()

MSVCRT_new_handler_func CDECL _query_new_handler ( void )

Definition at line 208 of file heap.c.

{
  return MSVCRT_new_handler;
}

◆ _query_new_mode()

int CDECL _query_new_mode ( void )

Definition at line 217 of file heap.c.

{
  return MSVCRT_new_mode;
}

◆ _set_new_handler()

MSVCRT_new_handler_func CDECL _set_new_handler ( MSVCRT_new_handler_func func )

Definition at line 225 of file heap.c.

{
  MSVCRT_new_handler_func old_handler;
  LOCK_HEAP;
  old_handler = MSVCRT_new_handler;
  MSVCRT_new_handler = func;
  UNLOCK_HEAP;
  return old_handler;
}

Referenced by set_new_handler().

◆ _set_new_mode()

int CDECL _set_new_mode ( int mode )

Definition at line 248 of file heap.c.

{
  if(!MSVCRT_CHECK_PMT(mode == 0 || mode == 1)) return -1;
  return InterlockedExchange((long*)&MSVCRT_new_mode, mode);
}

◆ _set_sbh_threshold()

int CDECL _set_sbh_threshold ( size_t threshold )

Definition at line 544 of file heap.c.

{
#ifdef _WIN64
  return 0;
#else
  if(threshold > 1016)
     return 0;
 
  if(!sb_heap)
  {
      sb_heap = HeapCreate(0, 0, 0);
      if(!sb_heap)
          return 0;
  }
 
  MSVCRT_sbh_threshold = (threshold+0xf) & ~0xf;
  return 1;
#endif
}

◆ calloc()

void *CDECL DECLSPEC_HOTPATCH calloc	(	size_t	count,
		size_t	size
	)

Definition at line 407 of file heap.c.

{
  size_t bytes = count*size;
 
  if (size && bytes / size != count)
  {
    *_errno() = ENOMEM;
    return NULL;
  }
 
  return msvcrt_heap_alloc(HEAP_ZERO_MEMORY, bytes);
}

◆ free()

void CDECL DECLSPEC_HOTPATCH free ( void * ptr )

Definition at line 433 of file heap.c.

{
  msvcrt_heap_free(ptr);
}

◆ malloc()

void *CDECL malloc ( size_t size )

Definition at line 451 of file heap.c.

{
    void *ret;
 
    do
    {
        ret = msvcrt_heap_alloc(0, size);
        if (ret || !MSVCRT_new_mode)
            break;
    } while(_callnewh(size));
 
    if (!ret)
        *_errno() = ENOMEM;
    return ret;
}

◆ memcpy_s()

int CDECL memcpy_s	(	void *	dest,
		size_t	numberOfElements,
		const void *	src,
		size_t	count
	)

Definition at line 800 of file heap.c.

{
    TRACE("(%p %Iu %p %Iu)\n", dest, numberOfElements, src, count);
 
    if(!count)
        return 0;
 
    if (!MSVCRT_CHECK_PMT(dest != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(src != NULL))
    {
        memset(dest, 0, numberOfElements);
        return EINVAL;
    }
    if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, ERANGE ))
    {
        memset(dest, 0, numberOfElements);
        return ERANGE;
    }
 
    memmove(dest, src, count);
    return 0;
}

◆ memmove_s()

int CDECL memmove_s	(	void *	dest,
		size_t	numberOfElements,
		const void *	src,
		size_t	count
	)

Definition at line 757 of file heap.c.

{
    TRACE("(%p %Iu %p %Iu)\n", dest, numberOfElements, src, count);
 
    if(!count)
        return 0;
 
    if (!MSVCRT_CHECK_PMT(dest != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT_ERR( count <= numberOfElements, ERANGE )) return ERANGE;
 
    memmove(dest, src, count);
    return 0;
}

◆ msvcrt_destroy_heap()

void msvcrt_destroy_heap ( void )

Definition at line 899 of file heap.c.

{
    HeapDestroy(heap);
    if(sb_heap)
        HeapDestroy(sb_heap);
}

◆ msvcrt_heap_alloc()

static void * msvcrt_heap_alloc	(	DWORD	flags,
		size_t	size
	)

static

Definition at line 77 of file heap.c.

{
    if(size < MSVCRT_sbh_threshold)
    {
        void *memblock, *temp, **saved;
 
        temp = HeapAlloc(sb_heap, flags, size+sizeof(void*)+SB_HEAP_ALIGN);
        if(!temp) return NULL;
 
        memblock = ALIGN_PTR(temp, SB_HEAP_ALIGN, 0);
        saved = SAVED_PTR(memblock);
        *saved = temp;
        return memblock;
    }
 
    return HeapAlloc(heap, flags, size);
}

Referenced by calloc(), malloc(), and operator_new().

◆ msvcrt_heap_free()

static BOOL msvcrt_heap_free ( void * ptr )

static

Definition at line 127 of file heap.c.

{
    if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
    {
        void **saved = SAVED_PTR(ptr);
        return HeapFree(sb_heap, 0, *saved);
    }
 
    return HeapFree(heap, 0, ptr);
}

Referenced by free(), and operator_delete().

◆ msvcrt_heap_realloc()

static void * msvcrt_heap_realloc	(	DWORD	flags,
		void *	ptr,
		size_t	size
	)

static

Definition at line 95 of file heap.c.

{
    if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
    {
        /* TODO: move data to normal heap if it exceeds sbh_threshold limit */
        void *memblock, *temp, **saved;
        size_t old_padding, new_padding, old_size;
 
        saved = SAVED_PTR(ptr);
        old_padding = (char*)ptr - (char*)*saved;
        old_size = HeapSize(sb_heap, 0, *saved);
        if(old_size == -1)
            return NULL;
        old_size -= old_padding;
 
        temp = HeapReAlloc(sb_heap, flags, *saved, size+sizeof(void*)+SB_HEAP_ALIGN);
        if(!temp) return NULL;
 
        memblock = ALIGN_PTR(temp, SB_HEAP_ALIGN, 0);
        saved = SAVED_PTR(memblock);
        new_padding = (char*)memblock - (char*)temp;
 
        if(new_padding != old_padding)
            memmove(memblock, (char*)temp+old_padding, old_size>size ? size : old_size);
 
        *saved = temp;
        return memblock;
    }
 
    return HeapReAlloc(heap, flags, ptr, size);
}

Referenced by _expand(), and realloc().

◆ msvcrt_heap_size()

static size_t msvcrt_heap_size ( void * ptr )

static

Definition at line 138 of file heap.c.

{
    if(sb_heap && ptr && !HeapValidate(heap, 0, ptr))
    {
        void **saved = SAVED_PTR(ptr);
        return HeapSize(sb_heap, 0, *saved);
    }
 
    return HeapSize(heap, 0, ptr);
}

Referenced by _msize().

◆ msvcrt_init_heap()

BOOL msvcrt_init_heap ( void )

Definition at line 889 of file heap.c.

{
#ifdef __REACTOS__
    heap = GetProcessHeap();
#else
    heap = HeapCreate(0, 0, 0);
#endif
    return heap != NULL;
}

Referenced by crt_process_init(), and DllMain().

◆ operator_delete()

void CDECL DECLSPEC_HOTPATCH operator_delete ( void * mem )

Definition at line 198 of file heap.c.

{
  TRACE("(%p)\n", mem);
  msvcrt_heap_free(mem);
}

Referenced by __non_rtti_object_scalar_dtor(), __non_rtti_object_vector_dtor(), bad_cast_scalar_dtor(), bad_cast_vector_dtor(), bad_typeid_scalar_dtor(), bad_typeid_vector_dtor(), and exception_scalar_dtor().

◆ operator_new()

void *CDECL DECLSPEC_HOTPATCH operator_new ( size_t size )

Definition at line 164 of file heap.c.

{
  void *retval;
 
  do
  {
    retval = msvcrt_heap_alloc(0, size);
    if(retval)
    {
      TRACE("(%Iu) returning %p\n", size, retval);
      return retval;
    }
  } while(_callnewh(size));
 
  TRACE("(%Iu) out of memory\n", size);
#if _MSVCR_VER >= 80
  throw_bad_alloc();
#endif
  return NULL;
}

Referenced by operator_new_dbg().

◆ operator_new_dbg()

void *CDECL operator_new_dbg	(	size_t	size,
		int	type,
		const char *	file,
		int	line
	)

Definition at line 189 of file heap.c.

{
    return operator_new( size );
}

◆ realloc()

void *CDECL DECLSPEC_HOTPATCH realloc	(	void *	ptr,
		size_t	size
	)

Definition at line 480 of file heap.c.

{
  if (!ptr) return malloc(size);
  if (size) return msvcrt_heap_realloc(0, ptr, size);
  free(ptr);
  return NULL;
}

◆ set_new_handler()

MSVCRT_new_handler_func CDECL set_new_handler ( void * func )

Definition at line 238 of file heap.c.

{
  TRACE("(%p)\n",func);
  _set_new_handler(NULL);
  return NULL;
}

◆ strncpy_s()

int CDECL strncpy_s	(	char *	dest,
		size_t	numberOfElements,
		const char *	src,
		size_t	count
	)

Definition at line 854 of file heap.c.

{
    size_t i, end;
 
    TRACE("(%p %Iu %s %Iu)\n", dest, numberOfElements, debugstr_a(src), count);
 
    if(!count) {
        if(dest && numberOfElements)
            *dest = 0;
        return 0;
    }
 
    if (!MSVCRT_CHECK_PMT(dest != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(src != NULL)) return EINVAL;
    if (!MSVCRT_CHECK_PMT(numberOfElements != 0)) return EINVAL;
 
    if(count!=_TRUNCATE && count<numberOfElements)
        end = count;
    else
        end = numberOfElements-1;
 
    for(i=0; i<end && src[i]; i++)
        dest[i] = src[i];
 
    if(!src[i] || end==count || count==_TRUNCATE) {
        dest[i] = '\0';
        return 0;
    }
 
    MSVCRT_INVALID_PMT("dest[numberOfElements] is too small", EINVAL);
    dest[0] = '\0';
    return EINVAL;
}

Referenced by __Named_exception::__Named_exception(), and __Named_exception::operator=().

Variable Documentation

◆ heap

HANDLE heap

static

Definition at line 65 of file heap.c.

Referenced by _get_heap_handle(), _heapchk(), _heapmin(), _heapset(), _heapwalk(), add_dynamic_var(), alloc_bstr(), AllocateAndGetIfTableFromStack(), AllocateAndGetIpAddrTableFromStack(), AllocateAndGetIpForwardTableFromStack(), AllocateAndGetIpNetTableFromStack(), AllocateAndGetTcpExTable2FromStack(), AllocateAndGetTcpExTableFromStack(), AllocateAndGetTcpTableFromStack(), AllocateAndGetUdpExTable2FromStack(), AllocateAndGetUdpExTableFromStack(), AllocateAndGetUdpTableFromStack(), CloseDevice(), constant_heap_free(), constant_heap_init(), CreateSession(), DestroySession(), DrvGetDirectDrawInfo(), heap_pool_alloc(), heap_pool_clear(), heap_pool_free(), heap_pool_grow(), heap_pool_init(), heap_pool_mark(), HEAP_strdupAtoW(), main(), msvcrt_destroy_heap(), msvcrt_heap_alloc(), msvcrt_heap_free(), msvcrt_heap_realloc(), msvcrt_heap_size(), msvcrt_init_heap(), NBCmdQueueCreate(), NBNameCacheCreate(), OpenDevice(), PlayNote(), RunTraceRoute(), shader_glsl_load_constants_f(), shader_glsl_update_float_pixel_constants(), shader_glsl_update_float_vertex_constants(), StopNote(), SysFreeString(), test_child_heap(), test_HeapCreate(), update_heap_entry(), walk_constant_heap(), and walk_constant_heap_clamped().

◆ MSVCRT_amblksiz

unsigned int MSVCRT_amblksiz = 16

static

Definition at line 73 of file heap.c.

Referenced by __p__amblksiz().

◆ MSVCRT_new_handler

MSVCRT_new_handler_func MSVCRT_new_handler

static

Definition at line 69 of file heap.c.

Referenced by _callnewh(), _query_new_handler(), and _set_new_handler().

◆ MSVCRT_new_mode

int MSVCRT_new_mode

static

Definition at line 70 of file heap.c.

Referenced by _query_new_mode(), _set_new_mode(), and malloc().

◆ MSVCRT_sbh_threshold

size_t MSVCRT_sbh_threshold = 0

static

Definition at line 75 of file heap.c.

Referenced by _get_sbh_threshold(), _set_sbh_threshold(), and msvcrt_heap_alloc().

◆ sb_heap

HANDLE sb_heap

static

Definition at line 65 of file heap.c.

Referenced by _heapchk(), _heapmin(), _heapwalk(), _set_sbh_threshold(), msvcrt_destroy_heap(), msvcrt_heap_alloc(), msvcrt_heap_free(), msvcrt_heap_realloc(), and msvcrt_heap_size().

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ ALIGN_PTR

◆ LOCK_HEAP

◆ MSVCRT__errno

◆ MSVCRT__FREEENTRY

◆ MSVCRT__HEAPBADBEGIN

◆ MSVCRT__HEAPBADNODE

◆ MSVCRT__HEAPEND

◆ MSVCRT__heapinfo

◆ MSVCRT__HEAPOK

◆ MSVCRT__TRUNCATE

◆ MSVCRT__USEDENTRY

◆ MSVCRT_calloc

◆ MSVCRT_EINVAL

◆ MSVCRT_ENOMEM

◆ MSVCRT_ENOSYS

◆ MSVCRT_ERANGE

◆ MSVCRT_free

◆ MSVCRT_intptr_t

◆ MSVCRT_malloc

◆ MSVCRT_memcpy_s

◆ MSVCRT_memmove_s

◆ MSVCRT_realloc

◆ msvcrt_set_errno

◆ MSVCRT_size_t

◆ MSVCRT_strncpy_s

◆ MSVCRT_wchar_t

◆ SAVED_PTR

◆ SB_HEAP_ALIGN

◆ UNLOCK_HEAP

Typedef Documentation

◆ MSVCRT_new_handler_func

Function Documentation

◆ __p__amblksiz()

◆ _aligned_free()

◆ _aligned_malloc()

◆ _aligned_offset_malloc()

◆ _aligned_offset_realloc()

◆ _aligned_realloc()

◆ _callnewh()

◆ _expand()

◆ _get_heap_handle()

◆ _get_sbh_threshold()

◆ _heapadd()

◆ _heapchk()

◆ _heapmin()

◆ _heapset()

◆ _heapwalk()

◆ _msize()

◆ _query_new_handler()

◆ _query_new_mode()

◆ _set_new_handler()

◆ _set_new_mode()

◆ _set_sbh_threshold()

◆ calloc()

◆ free()

◆ malloc()

◆ memcpy_s()

◆ memmove_s()

◆ msvcrt_destroy_heap()

◆ msvcrt_heap_alloc()

◆ msvcrt_heap_free()

◆ msvcrt_heap_realloc()

◆ msvcrt_heap_size()

◆ msvcrt_init_heap()

◆ operator_delete()

◆ operator_new()

◆ operator_new_dbg()

◆ realloc()

◆ set_new_handler()

◆ strncpy_s()

Variable Documentation

◆ heap

◆ MSVCRT_amblksiz

◆ MSVCRT_new_handler

◆ MSVCRT_new_mode

◆ pamblksiz()