corecrt_malloc.h File Reference

#include <corecrt.h>

Include dependency graph for corecrt_malloc.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
_ACRTIMP void *__cdecl	calloc (size_t, size_t)
_ACRTIMP void __cdecl	free (void *)
_ACRTIMP void *__cdecl	malloc (size_t)
_ACRTIMP void *__cdecl	realloc (void *, size_t)
_ACRTIMP void *__cdecl	_recalloc (void *, size_t, size_t) __WINE_ALLOC_SIZE(2
_ACRTIMP void *__cdecl	__WINE_DEALLOC (free)
_ACRTIMP void *__cdecl	_expand (void *, size_t)
_ACRTIMP size_t __cdecl	_msize (void *)
_ACRTIMP void __cdecl	_aligned_free (void *)
_ACRTIMP void *__cdecl	_aligned_malloc (size_t, size_t) __WINE_ALLOC_SIZE(1) __WINE_DEALLOC(_aligned_free) __WINE_MALLOC
_ACRTIMP void *__cdecl	_aligned_offset_malloc (size_t, size_t, size_t) __WINE_ALLOC_SIZE(1) __WINE_DEALLOC(_aligned_free) __WINE_MALLOC
_ACRTIMP void *__cdecl	_aligned_realloc (void *, size_t, size_t) __WINE_ALLOC_SIZE(2) __WINE_DEALLOC(_aligned_free)
_ACRTIMP void *__cdecl	_aligned_offset_realloc (void *, size_t, size_t, size_t) __WINE_ALLOC_SIZE(2) __WINE_DEALLOC(_aligned_free)

Function Documentation

__WINE_DEALLOC()

_ACRTIMP void *__cdecl __WINE_DEALLOC

(

free

)

_aligned_free()

_ACRTIMP void __cdecl _aligned_free

(

void *

memblock

)

Definition at line 546 of file heap.c.

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

Referenced by _aligned_offset_realloc().

_aligned_malloc()

_ACRTIMP void *__cdecl _aligned_malloc	(	size_t	size,
		size_t	alignment
	)

Definition at line 603 of file heap.c.

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

_aligned_offset_malloc()

_ACRTIMP void *__cdecl _aligned_offset_malloc	(	size_t	size,
		size_t	alignment,
		size_t	offset
	)

Definition at line 560 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()

_ACRTIMP void *__cdecl _aligned_offset_realloc	(	void *	memblock,
		size_t	size,
		size_t	alignment,
		size_t	offset
	)

Definition at line 612 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()

_ACRTIMP void *__cdecl _aligned_realloc	(	void *	memblock,
		size_t	size,
		size_t	alignment
	)

Definition at line 727 of file heap.c.

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

_expand()

_ACRTIMP void *__cdecl _expand	(	void *	mem,
		size_t	size
	)

Definition at line 236 of file heap.c.

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

Referenced by _aligned_offset_realloc_base().

_msize()

_ACRTIMP size_t __cdecl _msize

(

void *

mem

)

Definition at line 354 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(), and test__o_malloc().

_recalloc()

_ACRTIMP void *__cdecl _recalloc	(	void *	,
		size_t	,
		size_t
	)

calloc()

_ACRTIMP void *__cdecl calloc	(	size_t	nmemb,
		size_t	size
	)

Definition at line 157 of file cabinet.c.

{
    return (void *)RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, nmemb * size);
}

free()

_ACRTIMP void __cdecl free

(

void *

ptr

)

Definition at line 151 of file cabinet.c.

{
    RtlFreeHeap(ProcessHeap, 0, ptr);
}

malloc()

_ACRTIMP void *__cdecl malloc

(

size_t

size

)

Definition at line 145 of file cabinet.c.

{
    return RtlAllocateHeap(ProcessHeap, HEAP_ZERO_MEMORY, size);
}

realloc()

_ACRTIMP void *__cdecl realloc	(	void *	ptr,
		size_t	size
	)

Definition at line 459 of file heap.c.

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