align.cpp File Reference

#include <corecrt_internal.h>
#include <malloc.h>

Include dependency graph for align.cpp:

Go to the source code of this file.

Macros
#define	IS_2_POW_N(X)   ((X) != 0 && ((X) & ((X) - 1)) == 0)
#define	PTR_SZ   sizeof(void *)

Functions
static void	_aligned_free_base (_Pre_maybenull_ _Post_invalid_ void *block)
_Check_return_ _Ret_maybenull_	_Post_writable_byte_size_ (size) static void *_aligned_malloc_base(_In_ size_t size
static _Check_return_ size_t	_aligned_msize_base (_Pre_notnull_ void *block, _In_ size_t alignment, _In_ size_t offset)
	_Success_ (return !=0) _Check_return_ _Ret_maybenull_ _Post_writable_byte_size_(size) static void *_aligned_offset_realloc_base(_Pre_maybenull_ _Post_invalid_ void *block
static __forceinline void *__cdecl	_aligned_malloc_base (size_t const size, size_t const alignment)
static __forceinline void *__cdecl	_aligned_offset_malloc_base (size_t size, size_t align, size_t offset)
static __forceinline void *__cdecl	_aligned_realloc_base (void *const block, size_t const size, size_t const alignment)
static __forceinline void *__cdecl	_aligned_recalloc_base (void *const block, size_t const count, size_t const size, size_t const alignment)
static __forceinline void *__cdecl	_aligned_offset_realloc_base (void *block, size_t size, size_t align, size_t offset)
static __forceinline size_t __cdecl	_aligned_msize_base (void *block, size_t align, size_t offset)
static __forceinline void *__cdecl	_aligned_offset_recalloc_base (void *block, size_t count, size_t size, size_t align, size_t offset)
static __forceinline void __cdecl	_aligned_free_base (void *const block)
	__declspec (noinline) void __cdecl _aligned_free(void *const block)

Variables
_Check_return_ _Ret_maybenull_ _In_ size_t	alignment
_Check_return_ _Ret_maybenull_ _In_ size_t _In_ size_t	offset
_In_ size_t	size
_In_ size_t	count

Macro Definition Documentation

IS_2_POW_N

#define IS_2_POW_N

(

X

)

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

Definition at line 23 of file align.cpp.

PTR_SZ

#define PTR_SZ   sizeof(void *)

Definition at line 24 of file align.cpp.

Function Documentation

__declspec()

__declspec

(

noinline

)

const

Definition at line 538 of file align.cpp.

{
    #ifdef _DEBUG
    _aligned_free_dbg(block);
    #else
    _aligned_free_base(block);
    #endif
}

_aligned_free_base() [1/2]

static void _aligned_free_base ( _Pre_maybenull_ _Post_invalid_ void *  block )

static

Referenced by __declspec(), and _aligned_offset_realloc_base().

_aligned_free_base() [2/2]

static __forceinline void __cdecl _aligned_free_base ( void *const  block )

static

Definition at line 516 of file align.cpp.

{
    uintptr_t ptr;
 
    if (block == nullptr)
        return;
 
    ptr = (uintptr_t)block;
 
    /* ptr points to the pointer to starting of the memory block */
    ptr = (ptr & ~(PTR_SZ -1)) - PTR_SZ;
 
    /* ptr is the pointer to the start of memory block*/
    ptr = *((uintptr_t*)ptr);
    free((void *)ptr);
}

_aligned_malloc_base()

static __forceinline void *__cdecl _aligned_malloc_base ( size_t const  size, size_t const  alignment  )

static

Definition at line 117 of file align.cpp.

{
    return _aligned_offset_malloc_base(size, alignment, 0);
}

_aligned_msize_base() [1/2]

static _Check_return_ size_t _aligned_msize_base ( _Pre_notnull_ void *  block, _In_ size_t  alignment, _In_ size_t  offset  )

static

Referenced by _aligned_offset_recalloc_base().

_aligned_msize_base() [2/2]

static __forceinline size_t __cdecl _aligned_msize_base ( void *  block, size_t  align, size_t  offset  )

static

Definition at line 396 of file align.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 */
    uintptr_t ptr      = 0; /* computes the beginning of the allocated block */
 
    _VALIDATE_RETURN(block != nullptr, EINVAL, static_cast<size_t>(-1));
 
    /* HEADER SIZE + FOOTER SIZE = GAP + ALIGN + SIZE OF A POINTER*/
    /* HEADER SIZE + USER SIZE + FOOTER SIZE = TOTAL SIZE */
 
    ptr = (uintptr_t)block;            /* ptr points to the start of the aligned memory block */
    ptr = (ptr & ~(PTR_SZ - 1)) - PTR_SZ; /* ptr is one position behind memblock */
                                          /* the value in ptr is the start of the real allocated block */
    ptr = *((uintptr_t *)ptr);            /* after dereference ptr points to the beginning of the allocated block */
 
    total_size = _msize_base((void*)ptr);
    header_size = (uintptr_t) block - ptr;
    gap = (0 - offset) & (PTR_SZ - 1);
    /* Alignment cannot be less than sizeof(void*) */
    align = (align > PTR_SZ ? align : PTR_SZ) -1;
    footer_size = gap + align + PTR_SZ - header_size;
    user_size = total_size - header_size - footer_size;
 
    return user_size;
}

_aligned_offset_malloc_base()

static __forceinline void *__cdecl _aligned_offset_malloc_base ( size_t  size, size_t  align, size_t  offset  )

static

Definition at line 147 of file align.cpp.

{
    uintptr_t ptr, retptr, gap;
    size_t nonuser_size,block_size;
 
    /* validation section */
    _VALIDATE_RETURN(IS_2_POW_N(align), EINVAL, nullptr);
    _VALIDATE_RETURN(offset == 0 || offset < size, EINVAL, nullptr);
 
    align = (align > PTR_SZ ? align : PTR_SZ) -1;
 
    /* gap = number of bytes needed to round up offset to align with PTR_SZ*/
    gap = (0 - offset)&(PTR_SZ -1);
 
    nonuser_size = PTR_SZ +gap +align;
    block_size = nonuser_size + size;
    _VALIDATE_RETURN_NOEXC(size <= block_size, ENOMEM, nullptr)
 
    if ( (ptr =(uintptr_t)malloc(block_size)) == (uintptr_t)nullptr)
        return nullptr;
 
    retptr =((ptr +nonuser_size+offset)&~align)- offset;
    ((uintptr_t *)(retptr - gap))[-1] = ptr;
 
    return (void *)retptr;
}

Referenced by _aligned_malloc_base(), and _aligned_offset_realloc_base().

_aligned_offset_realloc_base()

static __forceinline void *__cdecl _aligned_offset_realloc_base ( void *  block, size_t  size, size_t  align, size_t  offset  )

static

Definition at line 283 of file align.cpp.

{
    uintptr_t ptr, retptr, gap, stptr, diff;
    uintptr_t movsz, reqsz;
    int bFree = 0;
 
    /* special cases */
    if (block == nullptr)
    {
        return _aligned_offset_malloc_base(size, align, offset);
    }
    if (size == 0)
    {
        _aligned_free_base(block);
        return nullptr;
    }
 
    /* validation section */
    _VALIDATE_RETURN(IS_2_POW_N(align), EINVAL, nullptr);
    _VALIDATE_RETURN(offset == 0 || offset < size, EINVAL, nullptr);
 
    stptr = (uintptr_t)block;
 
    /* ptr points to the pointer to starting of the memory block */
    stptr = (stptr & ~(PTR_SZ -1)) - PTR_SZ;
 
    /* ptr is the pointer to the start of memory block*/
    stptr = *((uintptr_t *)stptr);
 
    align = (align > PTR_SZ ? align : PTR_SZ) -1;
    /* gap = number of bytes needed to round up offset to align with PTR_SZ*/
    gap = (0 -offset)&(PTR_SZ -1);
 
    diff = (uintptr_t)block - stptr;
    /* Mov size is min of the size of data available and sizw requested.
     */
    #pragma warning(push)
    #pragma warning(disable: 22018) // Silence prefast about overflow/underflow
    movsz = _msize_base((void *)stptr) - ((uintptr_t)block - stptr);
    #pragma warning(pop)
 
    movsz = movsz > size ? size : movsz;
    reqsz = PTR_SZ + gap + align + size;
 
    _VALIDATE_RETURN_NOEXC(size <= reqsz, ENOMEM, nullptr);
 
    /* First check if we can expand(reducing or expanding using expand) data
     * safely, ie no data is lost. eg, reducing alignment and keeping size
     * same might result in loss of data at the tail of data block while
     * expanding.
     *
     * If no, use malloc to allocate the new data and move data.
     *
     * If yes, expand and then check if we need to move the data.
     */
    if ((stptr +align +PTR_SZ +gap)<(uintptr_t)block)
    {
        if ((ptr = (uintptr_t)malloc(reqsz)) == (uintptr_t) nullptr)
            return nullptr;
        bFree = 1;
    }
    else
    {
        /* we need to save errno, which can be modified by _expand */
        errno_t save_errno = errno;
        if ((ptr = (uintptr_t)_expand((void *)stptr, reqsz)) == (uintptr_t)nullptr)
        {
            errno = save_errno;
            if ((ptr = (uintptr_t)malloc(reqsz)) == (uintptr_t) nullptr)
                return nullptr;
            bFree = 1;
        }
        else
            stptr = ptr;
    }
 
 
    if ( ptr == ((uintptr_t)block - diff)
         && !( ((size_t)block + gap +offset) & ~(align) ))
    {
        return block;
    }
 
    retptr =((ptr +PTR_SZ +gap +align +offset)&~align)- offset;
    memmove((void *)retptr, (void *)(stptr + diff), movsz);
    if ( bFree)
        free ((void *)stptr);
 
    ((uintptr_t *)(retptr - gap))[-1] = ptr;
    return (void *)retptr;
}

Referenced by _aligned_offset_recalloc_base(), and _aligned_realloc_base().

_aligned_offset_recalloc_base()

static __forceinline void *__cdecl _aligned_offset_recalloc_base ( void *  block, size_t  count, size_t  size, size_t  align, size_t  offset  )

static

Definition at line 461 of file align.cpp.

{
    size_t user_size  = 0;    /* wanted size, passed to aligned realoc */
    size_t start_fill = 0;    /* location where aligned recalloc starts to fill with 0 */
                              /* filling must start from the end of the previous user block */
    void * retptr     = nullptr; /* result of aligned recalloc*/
 
    /* ensure that (size * num) does not overflow */
    if (count > 0)
    {
        _VALIDATE_RETURN_NOEXC((_HEAP_MAXREQ / count) >= size, ENOMEM, nullptr);
    }
 
    user_size = size * count;
 
    if (block != nullptr)
    {
        start_fill = _aligned_msize_base(block, align, offset);
    }
 
    retptr = _aligned_offset_realloc_base(block, user_size, align, offset);
 
    if (retptr != nullptr)
    {
        if (start_fill < user_size)
        {
            memset ((char*)retptr + start_fill, 0, user_size - start_fill);
        }
    }
    return retptr;
}

Referenced by _aligned_recalloc_base().

_aligned_realloc_base()

static __forceinline void *__cdecl _aligned_realloc_base ( void *const  block, size_t const  size, size_t const  alignment  )

static

Definition at line 206 of file align.cpp.

{
    return _aligned_offset_realloc_base(block, size, alignment, 0);
}

_aligned_recalloc_base()

static __forceinline void *__cdecl _aligned_recalloc_base ( void *const  block, size_t const  count, size_t const  size, size_t const  alignment  )

static

Definition at line 244 of file align.cpp.

{
    return _aligned_offset_recalloc_base(block, count, size, alignment, 0);
}

_Post_writable_byte_size_()

_Check_return_ _Ret_maybenull_ _Post_writable_byte_size_

(

size

)

_Success_()

_Success_

(

return !

= 0

)

Definition at line 1028 of file fsctrl.c.

{
    PLIST_ENTRY Link;
 
    PVPB Vpb = Vcb->Vpb;
    PVPB OldVpb;
 
    BOOLEAN Remount = FALSE;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER( IrpContext );
 
    //
    //  Check whether we are looking for a device only Mvcb.
    //
 
    for (Link = CdData.VcbQueue.Flink;
         Link != &CdData.VcbQueue;
         Link = Link->Flink) {
 
        *OldVcb = CONTAINING_RECORD( Link, VCB, VcbLinks );
 
        //
        //  Skip ourselves.
        //
 
        if (Vcb == *OldVcb) { continue; }
 
        //
        //  Look at the Vpb and state of the previous Vcb.
        //
 
        OldVpb = (*OldVcb)->Vpb;
 
        if ((OldVpb != Vpb) &&
            (OldVpb->RealDevice == Vpb->RealDevice) &&
            ((*OldVcb)->VcbCondition == VcbNotMounted)) {
 
            //
            //  If the current disk is a raw disk then it can match a previous music or
            //  raw disk.
            //
 
            if (FlagOn( Vcb->VcbState, VCB_STATE_AUDIO_DISK)) {
 
                if (FlagOn( (*OldVcb)->VcbState, VCB_STATE_AUDIO_DISK )) {
 
                    //
                    //  If we have both TOC then fail the remount if the lengths
                    //  are different or they don't match.
                    //
 
                    if ((Vcb->TocLength != (*OldVcb)->TocLength) ||
                        ((Vcb->TocLength != 0) &&
                         !RtlEqualMemory( Vcb->CdromToc,
                                          (*OldVcb)->CdromToc,
                                          Vcb->TocLength ))) {
 
                        continue;
                    }
 
                    Remount = TRUE;
                    break;
                }
 
            //
            //  The current disk is not a raw disk.  Go ahead and compare
            //  serial numbers, volume label and TOC.
            //
 
            }
            else if ((OldVpb->SerialNumber == Vpb->SerialNumber) &&
                     (Vcb->TocLength == (*OldVcb)->TocLength) &&
                     ((Vcb->TocLength == 0) || RtlEqualMemory( Vcb->CdromToc,
                                                               (*OldVcb)->CdromToc,
                                                               Vcb->TocLength )) &&
                     (Vpb->VolumeLabelLength == OldVpb->VolumeLabelLength) &&
                     (RtlEqualMemory( OldVpb->VolumeLabel,
                                        Vpb->VolumeLabel,
                                        Vpb->VolumeLabelLength ))) {
                //
                //  Remember the old Vcb.  Then set the return value to
                //  TRUE and break.
                //
 
                Remount = TRUE;
                break;
            }
        }
    }
 
    return Remount;
}

Variable Documentation

alignment

size_t const size_t const size_t const alignment

Initial value:

{
 
 
 
    return _aligned_malloc_base(size, alignment)

Definition at line 47 of file align.cpp.

Referenced by _aligned_malloc(), _aligned_malloc_base(), _aligned_malloc_dbg(), _aligned_msize_dbg(), _aligned_offset_malloc(), _aligned_offset_malloc_dbg(), _aligned_offset_realloc(), _aligned_offset_realloc_dbg(), _aligned_offset_recalloc_dbg(), _aligned_realloc(), _aligned_realloc_base(), _aligned_realloc_dbg(), _aligned_recalloc_base(), _aligned_recalloc_dbg(), add_typedef_typeinfo(), add_var_desc(), align(), align_the_pointer(), array_buffer_size(), array_memory_size(), array_read_variance_and_unmarshall(), array_write_variance_and_marshall(), bitcode_parse_alignment(), FxDmaEnabler::ConfigureBusMasterAdapters(), d3d11_device_context_set_constant_buffers(), dwritetextformat1_layout_SetOpticalAlignment(), dwritetextformat1_SetOpticalAlignment(), dwritetextformat_layout_SetParagraphAlignment(), dwritetextformat_layout_SetTextAlignment(), dwritetextformat_SetParagraphAlignment(), dwritetextformat_SetTextAlignment(), dwritetextlayout2_SetOpticalAlignment(), dwritetextlayout_SetParagraphAlignment(), dwritetextlayout_SetTextAlignment(), format_set_optical_alignment(), format_set_paralignment(), format_set_textalignment(), FT_Bitmap_Convert(), get_function_buffer_size(), get_parameter_fc(), get_required_buffer_size(), get_required_buffer_size_type(), StringFormat::GetAlignment(), StringFormat::GetLineAlignment(), gl_pixel_addr_in_image(), ICreateTypeInfo2_fnSetAlignment(), NdrVaryingArrayBufferSize(), NdrVaryingArrayMarshall(), NdrVaryingArrayMemorySize(), NdrVaryingArrayUnmarshall(), pipeline_state_desc_from_d3d12_stream_desc(), print_phase_basetype(), psh_blues_snap_stem(), ScsiFlopProcessError(), sm6_parser_declare_global(), sm6_parser_declare_indexable_temp(), sm6_parser_declare_tgsm_raw(), sm6_parser_declare_tgsm_structured(), sm6_parser_emit_alloca(), sm6_parser_emit_dx_raw_buffer_store(), sm6_parser_emit_load(), sm6_parser_emit_store(), spirv_compiler_emit_workgroup_memory(), test_aligned_malloc(), test_aligned_offset_malloc(), test_aligned_offset_realloc(), test_aligned_realloc(), test_CreateTypeLib(), testTDA(), UACPI_PACKED(), vertexdeclaration_init(), VfdOpenImage(), vio_modern_map_capability(), vio_modern_map_simple_capability(), vkd3d_create_vk_buffer_view(), vkd3d_get_required_texel_buffer_alignment(), vkd3d_gpu_va_allocator_allocate(), vkd3d_gpu_va_allocator_allocate_fallback(), wined3d_context_vk_create_slab_bo(), wined3d_format_calculate_pitch(), wined3d_format_calculate_size(), and write_remoting_arg().

count

size_t const count

Definition at line 75 of file align.cpp.

Referenced by _aligned_offset_recalloc_base().

offset

size_t const size_t const size_t const size_t const offset

Initial value:

{
 
 
 
    return _aligned_msize_base(block, alignment, offset)

Definition at line 61 of file align.cpp.

Referenced by _aligned_msize_base(), _aligned_offset_malloc_base(), and _aligned_offset_realloc_base().

size

size_t const size_t const size

Definition at line 67 of file align.cpp.

Referenced by _aligned_offset_malloc_base(), and _aligned_offset_realloc_base().