cMem.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cMem_H
#define _INC_cMem_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "Index.h"
#include "StrConst.h"
#include "cValT.h"
#include "cUnitTestDecl.h"
#include "cDebugAssert.h"
 
namespace Gray
{
        struct GRAYCORE_LINK cMem       // static cSingleton
        {
 
                static VOLATILE uintptr_t sm_bDontOptimizeOut0; // static global byte to fool the optimizer into preserving this data.
                static VOLATILE uintptr_t sm_bDontOptimizeOutX; // static global byte to fool the optimizer into preserving this data.
 
#if ! defined(UNDER_CE) && ( ! defined(_DEBUG) || ! defined(_MSC_VER))
                static void __cdecl IsValidFailHandler(int nSig);       // JMP_t
#endif
 
                static ptrdiff_t inline Diff(const void* pEnd, const void* pStart) noexcept
                {
                        ptrdiff_t i = ((const BYTE*)pEnd - (const BYTE*)pStart);        // like INT_PTR
                        // ASSERT(i > -(INT_PTR)(cHeap::k_ALLOC_MAX) && i < (INT_PTR)(cHeap::k_ALLOC_MAX));     // k_ALLOC_MAX
                        return i;
                }
 
                static bool inline IsValidApp(const void* pData) noexcept
                {
 
                        if (((UINT_PTR)pData) < 16 * 1024)      // ASSUME memory in this range is never valid? Fail quickly. This is Kernel Space ONLY. <1G
                                return false;
#ifdef _WIN32
 
#endif
                        return true;
                }
 
                static bool GRAYCALL IsValid(const void* pData, size_t nSize = 1, bool bWriteAccess = false) noexcept;
                static inline bool IsCorrupt(const void* pData, size_t nSize = 1, bool bWriteAccess = false) noexcept
                {
                        if (pData == nullptr)   // nullptr is not corrupt.
                                return false;
                        return !IsValid(pData, nSize, bWriteAccess);
                }
                static inline bool IsZeros(const void* pData, size_t nSize) noexcept
                {
                        if (!IsValidApp(pData))
                                return true;
                        for (size_t i = 0; i < nSize; i++)
                        {
                                if (((const BYTE*)pData)[i] != 0)
                                        return false;
                        }
                        return true;
                }
 
                static inline COMPARE_t Compare(const void* p1, const void* p2, size_t nSizeBlock) noexcept
                {
                        return ::memcmp(p1, p2, nSizeBlock);
                }
 
                static inline COMPARE_t CompareSecure(const void* p1, const void* p2, size_t nSizeBlock) noexcept
                {
                        const BYTE* pB1 = (const BYTE*)p1;
                        const BYTE* pB2 = (const BYTE*)p2;
                        BYTE nDiff = 0;
                        for (size_t i = 0; i < nSizeBlock; i++)
                        {
                                nDiff |= pB1[i] ^ pB2[i];
                        }
                        return (COMPARE_t)nDiff;
                }
 
                static size_t GRAYCALL CompareIndex(const void* p1, const void* p2, size_t nSizeBlock);
 
                static inline void Zero(void* pData, size_t nSizeBlock) noexcept
                {
#ifdef _WIN32
                        ::ZeroMemory(pData, nSizeBlock);
#else
                        ::memset(pData, 0, nSizeBlock);
#endif
                }
                static inline void ZeroSecure(void* pData, size_t nSizeBlock) noexcept
                {
                        VOLATILE BYTE* p2 = (BYTE*)pData;       // 'volatile' will ensure it doesn't get optimized out.
                        while (nSizeBlock--)
                                *p2++ = 0;
                }
 
                static inline void Xor(BYTE* pDst, const BYTE* pSrc, size_t nBlockSize) noexcept
                {
                        // Xor with self.
                        for (size_t i = 0; i < nBlockSize; i++)
                                pDst[i] ^= pSrc[i];
                }
 
                static inline void Xor2(BYTE* pDst, const BYTE* pSrc1, const BYTE* pSrc2, size_t nBlockSize) noexcept
                {
                        for (size_t i = 0; i < nBlockSize; i++)
                                pDst[i] = pSrc1[i] ^ pSrc2[i];
                }
 
                static inline void Copy(void* pDst, const void* pSrc, size_t nSizeBlock) noexcept
                {
                        ::memcpy(pDst, pSrc, nSizeBlock);
                }
                static inline void CopyOverlap(void* pDst, const void* pSrc, size_t nSizeBlock) noexcept
                {
                        ::memmove(pDst, pSrc, nSizeBlock);
                }
                static inline void ReverseBytes(void* pDst, size_t nSizeBlock) noexcept
                {
                        register BYTE* pSrcB = (BYTE*)pDst;
                        register BYTE* pDstB = (BYTE*)pDst + nSizeBlock - 1;
                        nSizeBlock /= 2;
                        while (nSizeBlock--)
                        {
                                cValT::Swap(*pSrcB++, *pDstB--);
                        }
                }
                static inline void CopyReverse(void* pDst, const void* pSrc, size_t nSizeBlock) noexcept
                {
                        if (pDst == pSrc)
                        {
                                ReverseBytes(pDst, nSizeBlock);
                        }
                        else
                        {
                                register BYTE* pDstB = (BYTE*)pDst + nSizeBlock - 1;
                                register const BYTE* pSrcB = (const BYTE*)pSrc;
                                while (nSizeBlock--)
                                {
                                        *pDstB-- = *pSrcB++;
                                }
                        }
                }
 
                static inline void Fill(void* pDst, size_t nSize, BYTE bVal) noexcept
                {
                        for (size_t j = 0; j < nSize; j++)
                        {
                                ((BYTE*)pDst)[j] = bVal;
                        }
                }
                static inline void CopyRepeat(void* pDst, size_t nDstSize, const void* pSrc, size_t nSrcSize) noexcept
                {
                        for (size_t i = 0; i < nDstSize;)
                        {
                                for (size_t j = 0; j < nSrcSize && i < nDstSize; j++, i++)
                                {
                                        ((BYTE*)pDst)[i] = ((const BYTE*)pSrc)[j];
                                }
                        }
                }
 
                static inline void CopyHtoN(BYTE* pDst, const void* pSrc, size_t nSizeBlock) noexcept
                {
#ifdef USE_LITTLE_ENDIAN
                        cMem::CopyReverse(pDst, pSrc, nSizeBlock);
#else
                        cMem::Copy(pDst, pSrc, nSizeBlock);
#endif
                }
                static inline void CopyNtoH(void* pDst, const BYTE* pSrc, size_t nSizeBlock) noexcept
                {
#ifdef USE_LITTLE_ENDIAN
                        cMem::CopyReverse(pDst, pSrc, nSizeBlock);
#else
                        cMem::Copy(pDst, pSrc, nSizeBlock);
#endif
                }
 
                static inline void Swap(void* pvMem1, void* pvMem2, size_t nBlockSize) noexcept
                {
 
                        if (pvMem1 == pvMem2)   // no change.
                                return;
                        BYTE* pMem1 = (BYTE*)pvMem1;
                        BYTE* pMem2 = (BYTE*)pvMem2;
                        for (; nBlockSize--; pMem1++, pMem2++)
                        {
                                cValT::Swap(*pMem1, *pMem2);
                        }
                }
 
                // read/write a string of comma separated numbers.
                static StrLen_t GRAYCALL ConvertToString(char* pszDst, StrLen_t iSizeDstMax, const BYTE* pSrc, size_t iLenSrc);
                static size_t GRAYCALL ReadFromString(BYTE* pDst, size_t iLenBytesMax, const char* pszSrc);
 
                static inline StrLen_t GetHexDigestSize(size_t nSize) noexcept
                {
                        return (StrLen_t)((nSize * 2) + 1);
                }
                static StrLen_t GRAYCALL GetHexDigest(OUT char* pszHexString, const BYTE* pData, size_t nSizeData);
                static HRESULT GRAYCALL SetHexDigest(const char* pszHexString, OUT BYTE* pData, size_t nSizeData);
 
                UNITTEST_FRIEND(cMem);
        };
 
        template <UINT32 _SIGVALID = 0xCA11AB1E>
        class DECLSPEC_NOVTABLE cMemSignature
        {
        public:
                static const UINT32 k_VALID = _SIGVALID;        
                static const UINT32 k_INVALID = 0xDEADBEA7;     
        private:
                UINT32 m_nSignature;    
        public:
                cMemSignature() noexcept
                        : m_nSignature(_SIGVALID)
                {
                }
                ~cMemSignature()
                {
                        ASSERT(isValidSignature());
                        m_nSignature = k_INVALID;       // Mark as invalid.
                }
                bool inline isValidSignature() const noexcept
                {
                        if (!cMem::IsValidApp(this))
                                return false;
                        if (m_nSignature != _SIGVALID)
                                return false;
                        return true;
                }
        };
 
        template<size_t TYPE_SIZE>
        class cMemStatic
        {
 
        public:
                static const size_t k_Size = TYPE_SIZE; 
                static const size_t k_SizeHexDigest = ((TYPE_SIZE * 2) + 1);    
 
                BYTE m_Data[TYPE_SIZE];         
 
        public:
                size_t get_DataLength() const noexcept
                {
                        return TYPE_SIZE;
                }
                const BYTE* get_DataBytes() const noexcept
                {
                        return m_Data;
                }
                operator const BYTE* () const noexcept
                {
                        return m_Data;
                }
        };
 
        class GRAYCORE_LINK cMemBlock
        {
 
        protected:
                size_t m_nSize;         
                void* m_pData;
 
        public:
                cMemBlock() noexcept
                        : m_nSize(0)
                        , m_pData(nullptr)
                {
                }
                cMemBlock(const void* pData, size_t nSize) noexcept
                        : m_nSize(nSize)
                        , m_pData(const_cast<void*>(pData))     // just assume we don't modify it?
                {
                }
                cMemBlock(const cMemBlock& block) noexcept
                        : m_nSize(block.m_nSize)
                        , m_pData(block.m_pData)
                {
                        // Just shared pointers. This may be dangerous!
                }
                cMemBlock(const cMemBlock* pBlock) noexcept
                        : m_nSize((pBlock == nullptr) ? 0 : pBlock->m_nSize)
                        , m_pData((pBlock == nullptr) ? nullptr : pBlock->m_pData)
                {
                        // Just shared pointers. This may be dangerous!
                }
 
                inline size_t get_DataSize() const noexcept
                {
                        return m_nSize;
                }
 
                inline void* get_Data() const noexcept
                {
                        return m_pData;
                }
                inline BYTE* get_DataBytes() const noexcept
                {
                        return (BYTE*)m_pData;
                }
                inline char* get_DataA() const noexcept
                {
                        return (char*)m_pData;
                }
 
                operator const BYTE* () const noexcept
                {
                        return get_DataBytes();
                }
 
                inline bool isValidPtr() const noexcept
                {
                        return m_pData != nullptr;
                }
                inline bool IsValidIndex(size_t i) const noexcept
                {
                        return IS_INDEX_GOOD(i, m_nSize);
                }
                bool IsValidIndex2(size_t i) const noexcept
                {
                        if (i == m_nSize)       // at end ?
                                return true;
                        return IS_INDEX_GOOD(i, m_nSize);
                }
                bool IsValidPtr(const void* p) const noexcept
                {
                        return IsValidIndex(cMem::Diff(p, get_Data()));
                }
                bool IsValidPtr2(const void* p) const noexcept
                {
                        return IsValidIndex2(cMem::Diff(p, get_Data()));
                }
 
                bool IsZeros() const noexcept
                {
                        return cMem::IsZeros(m_pData, m_nSize);
                }
 
                bool IsEqualData(const void* pData, size_t nSize) const noexcept
                {
                        return m_nSize == nSize && !::memcmp(m_pData, pData, nSize);
                }
                bool IsEqualData(const cMemBlock* pData) const noexcept
                {
                        if (pData == nullptr)
                                return false;
                        return IsEqualData(pData->m_pData, pData->m_nSize);
                }
                bool IsEqualData(const cMemBlock& data) const noexcept
                {
                        return IsEqualData(data.m_pData, data.m_nSize);
                }
 
#define IsEqualLiteral(x) IsEqualData( STRLIT2(x))
 
                BYTE* GetOffset(size_t nOffset) const
                {
                        ASSERT(IsValidIndex(nOffset));
                        return get_DataBytes() + nOffset;
                }
                const void* get_DataEnd() const noexcept
                {
                        return get_DataBytes() + m_nSize;
                }
 
                void put_DataPtr(void* pStart) noexcept
                {
                        // Set Data pointer but leave size.
                        m_pData = pStart;
                        // ASSERT(is pStart reasonable?)
                }
                void put_Size(size_t nSize) noexcept
                {
                        // Set size but leave data pointer.
                        m_nSize = nSize;
                }
 
                void SetBlock(void* pData, size_t nSize) noexcept
                {
                        m_pData = pData;
                        m_nSize = nSize;        // size does not apply if nullptr.
                }
                void SetEmptyBlock() noexcept
                {
                        m_pData = nullptr;
                        m_nSize = 0;
                }
 
                void InitZeros() noexcept
                {
                        cMem::ZeroSecure(m_pData, m_nSize);
                }
                StrLen_t ConvertToString(char* pszDst, StrLen_t iDstSizeMax) const
                {
                        return cMem::ConvertToString(pszDst, iDstSizeMax, get_DataBytes(), m_nSize);
                }
 
                static COMPARE_t GRAYCALL Compare(const void* pData1, size_t iLen1, const void* pData2, size_t iLen2);
        };
 
        struct GRAYCORE_LINK cMemT : public cValT       // Value of some type in memory.
        {
 
                template <class TYPE>
                static inline TYPE ReverseType(TYPE nVal) noexcept
                {
 
                        cMem::CopyReverse(&nVal, &nVal, sizeof(nVal));
                        return nVal;
                }
                template <typename TYPE>
                static inline TYPE HtoN(TYPE nVal) noexcept
                {
#ifdef USE_LITTLE_ENDIAN
                        return ReverseType(nVal);
#else
                        return nVal;    // no change needed.
#endif
                }
                template <typename TYPE>
                static inline TYPE NtoH(TYPE nVal) noexcept
                {
#ifdef USE_LITTLE_ENDIAN
                        return ReverseType(nVal);
#else
                        return nVal;    // no change needed.
#endif
                }
 
                template <typename TYPE>
                static inline TYPE HtoLE(TYPE nVal) noexcept
                {
#ifdef USE_LITTLE_ENDIAN
                        return nVal;    // no change needed.
#else
                        return ReverseType(nVal);
#endif
                }
                template <typename TYPE>
                static inline TYPE LEtoH(TYPE nVal) noexcept
                {
#ifdef USE_LITTLE_ENDIAN
                        return nVal;    // no change needed.
#else
                        return ReverseType(nVal);
#endif
                }
 
                template <typename TYPE>
                static inline TYPE GetUnaligned(const void* pData) noexcept
                {
#ifdef _MSC_VER
                        return *((const UNALIGNED TYPE*) pData);
#else
                        return *((const TYPE*)pData);
#endif
                }
                template <typename TYPE>
                static inline void SetUnaligned(void* pData, TYPE nVal) noexcept
                {
#ifdef _MSC_VER
                        * ((UNALIGNED TYPE*) pData) = nVal;
#else
                        * ((TYPE*)pData) = nVal;
#endif
                }
 
                template <typename TYPE>
                static inline TYPE GetLEtoH(const void* pData) noexcept
                {
                        return LEtoH(GetUnaligned<TYPE>(pData));
                }
                template <typename TYPE>
                static inline void SetHtoLE(void* pData, TYPE nVal) noexcept
                {
                        return SetUnaligned(pData, HtoLE(nVal));
                }
                template <typename TYPE>
                static inline TYPE GetNtoH(const void* pData) noexcept
                {
                        return NtoH(GetUnaligned<TYPE>(pData));
                }
                template <typename TYPE>
                static inline void SetHtoN(void* pData, TYPE nVal) noexcept
                {
                        return SetUnaligned(pData, HtoN(nVal));
                }
 
                static inline DWORD GetNVal3(const BYTE* p) noexcept
                {
                        return ((DWORD)p[0]) << 16 | ((DWORD)p[1]) << 8 | p[2];
                }
                static inline void SetNVal3(BYTE* p, DWORD nVal) noexcept
                {
                        p[0] = (BYTE)((nVal >> 16) & 0xFF);
                        p[1] = (BYTE)((nVal >> 8) & 0xFF);      // HIBYTE
                        p[2] = (BYTE)((nVal) & 0xFF);   // LOBYTE
                }
        };
 
        template <>
        inline WORD cMemT::ReverseType<WORD>(WORD nVal) noexcept // static
        {
                return (WORD)((nVal >> 8) | (nVal << 8));
        }
        template <>
        inline UINT32 cMemT::ReverseType<UINT32>(UINT32 nVal) noexcept // static
        {
                nVal = (nVal >> 16) | (nVal << 16);
                return ((nVal & 0xff00ff00UL) >> 8) | ((nVal & 0x00ff00ffUL) << 8);
        }
 
#ifdef USE_INT64
        template <>
        inline UINT64 cMemT::ReverseType<UINT64>(UINT64 nVal) noexcept // static
        {
                nVal = (nVal >> 32) | (nVal << 32);
                nVal = ((nVal & 0xff00ff00ff00ff00ULL) >> 8) | ((nVal & 0x00ff00ff00ff00ffULL) << 8);
                return ((nVal & 0xffff0000ffff0000ULL) >> 16) | ((nVal & 0x0000ffff0000ffffULL) << 16);
        }
#endif
#ifndef USE_LONG_AS_INT64
        template <>
        inline ULONG cMemT::ReverseType<ULONG>(ULONG nVal) noexcept // static
        {
                // return ReverseType<UINT64>(nVal);
                return ReverseType<UINT32>(nVal);
        }
#endif
 
#if 0 // USE_LITTLE_ENDIAN
        template <>
        inline UINT32 cMemT::GetNtoH<UINT32>(const void* pData)
        {
                const BYTE* p = (const BYTE*)pData;
                return ((UINT32)p[0] << 24)
                        | ((UINT32)p[1] << 16)
                        | ((UINT32)p[2] << 8)
                        | ((UINT32)p[3]);
        }
        template <>
        inline void cMemT::SetHtoN<UINT32>(void* pData, UINT32 nVal)
        {
                BYTE* p = (BYTE*)pData;
                p[0] = (BYTE)(nVal >> 24);
                p[1] = (BYTE)(nVal >> 16);
                p[2] = (BYTE)(nVal >> 8);
                p[3] = (BYTE)(nVal);
        }
 
        template <>
        inline UINT64 cMemT::GetNtoH<UINT64>(const void* pData)
        {
                const BYTE* p = (const BYTE*)pData;
                return ((UINT64)p[0] << 56)
                        | ((UINT64)p[1] << 48)
                        | ((UINT64)p[2] << 40)
                        | ((UINT64)p[3] << 32)
                        | ((UINT64)p[4] << 24)
                        | ((UINT64)p[5] << 16)
                        | ((UINT64)p[6] << 8)
                        | ((UINT64)p[7]);
        }
        template <>
        inline void cMemT::SetHtoN<UINT64>(void* pData, UINT64 nVal)
        {
                BYTE* p = (BYTE*)pData;
                p[0] = (BYTE)(nVal >> 56);
                p[1] = (BYTE)(nVal >> 48);
                p[2] = (BYTE)(nVal >> 40);
                p[3] = (BYTE)(nVal >> 32);
                p[4] = (BYTE)(nVal >> 24);
                p[5] = (BYTE)(nVal >> 16);
                p[6] = (BYTE)(nVal >> 8);
                p[7] = (BYTE)(nVal);
        }
#endif
 
}
#endif