windows-server-2003/base/crts/crtw32/h/rtcpriv.h

/***
*rtcpriv.h - declarations and definitions for RTC use
*
*       Copyright (c) 1985-2001, Microsoft Corporation. All rights reserved.
*
*Purpose:
*       Contains the declarations and definitions for all RunTime Check
*       support.
*
*Revision History:
*       ??-??-??  KBF   Created implementation header for RTC
*       05-26-99  KBF   Removed RTCl & RTCv, added _RTC_ADVMEM stuff
*       10-14-99  PML   Replace InitializeCriticalSection with wrapper function
*                       __crtInitCritSecAndSpinCount
*
****/

#ifndef _INC_RTCPRIV
#define _INC_RTCPRIV

#ifdef  _RTC

#include <windows.h>
#include <winbase.h>
#include <malloc.h>

#include "rtcapi.h"

#pragma warning(disable:4710)
#pragma warning(disable:4711)
#ifndef __cplusplus
#error This header is only for use with the C++ compiler while building the RTC library code.
#endif

#ifdef  _MSC_VER
#pragma pack(push, 4)
#endif  /* _MSC_VER */

#ifndef _RTC_DEBUG
#pragma optimize("gb1", on)
#endif

// Multithreaded code locking stuff...

#define INIT_LOCK   __crtInitCritSecAndSpinCount(&_RTC_memlock, _CRT_SPINCOUNT)
#define LOCK        EnterCriticalSection(&_RTC_memlock)
#define UNLOCK      LeaveCriticalSection(&_RTC_memlock)
#define DEL_LOCK    DeleteCriticalSection(&_RTC_memlock)
#define TRY_LOCK    TryEnterCriticalSection(&_RTC_memlock)
extern CRITICAL_SECTION _RTC_memlock;

// Typedefs
struct  _RTC_globals;

#ifdef _RTC_ADVMEM
class   _RTC_SimpleHeap;
class   _RTC_Container;
class   _RTC_HeapBlock;    
class   _RTC_BinaryTree;
template<class T> class HashTable;
typedef unsigned char shadowtag;
typedef unsigned char index_elem;

#endif

// General global functions & symbols

extern int          _RTC_ErrorLevels[_RTC_ILLEGAL];
extern _RTC_globals *_RTC_globptr;

bool                _RTC_Lock();
void                _RTC_Unlock();
void                _RTC_Failure(void *retaddr, int errnum);
_RTC_error_fn       _RTC_GetErrorFunc(LPCVOID addr);
void                _RTC_StackFailure(void *retaddr, const char *varname);
BOOL                _RTC_GetSrcLine(DWORD address, char* source, int sourcelen,
                                    int* pline, char** moduleName);
extern "C" {
void __fastcall     _RTC_APISet(int on_off);
}
void                _RTC_NotifyOthersOfChange(void *addr);


// When this changes, you'd better be sure that everything still works with the old stuff!
#define _RTC_CURRENT_VERSION 1

// The order of the initial stuff here can't change AT ALL!!!
struct _RTC_Funcs {
    _RTC_error_fn err;
    void (*notify)(void);
    void *allocationBase;
    _RTC_Funcs *next;
#ifdef _RTC_ADVMEM
    int  (*shadowoff)(void);
#endif
};

// definitions of library globals
// The order of this stuff MUST STAY THE SAME BETWEEN VERSION!!!
struct _RTC_globals {
    int                         version;
    CRITICAL_SECTION            memlock;
    _RTC_Funcs                  *callbacks;
#ifdef _RTC_ADVMEM
    _RTC_SimpleHeap             *heap2;
    _RTC_SimpleHeap             *heap4;
    _RTC_SimpleHeap             *heap8;
    _RTC_Container              *memhier;
    shadowtag                   *shadow;
    index_elem                  *pageidx;
    HashTable<_RTC_HeapBlock>   *heapblocks;
    bool                        *pi_array;
    bool                        shadowmemory;
#endif
};
#define _RTC_GLOBALS_SIZE 1024

/* Shadow Memory stuff */
#ifdef _RTC_ADVMEM

void            _RTC_MS_Init();
void            _RTC_MemFailure(void *retaddr, int errnum, const void *assign);
short           _RTC_MSAllocShadow(memptr addr, unsigned size, unsigned state);
void            _RTC_MSRestoreShadow(memptr addr, unsigned size, short id);
short           _RTC_MSRenumberShadow(memptr addr, unsigned size, short notID);
void            _RTC_MSFreeShadow(memptr addr, unsigned size);
void __cdecl    _RTC_MSAllocateGlobals(void);
void            _RTC_MSDecommitRange(memptr addr, unsigned size);
void            _RTC_MSCommitRange(memptr addr, unsigned size, unsigned state);
extern "C" {
void __fastcall _RTC_CheckMem_API(memref addr, unsigned size);
}

// Unknown MUST be 0
#define IDX_STATE_UNKNOWN         0
#define IDX_STATE_ILLEGAL         1
#define IDX_STATE_PARTIALLY_KNOWN 2
#define IDX_STATE_FULLY_KNOWN     3

extern _RTC_Container               *_RTC_memhier;
extern HashTable<_RTC_HeapBlock>    *_RTC_heapblocks;
extern _RTC_SimpleHeap              *_RTC_heap2;
extern _RTC_SimpleHeap              *_RTC_heap4;
extern _RTC_SimpleHeap              *_RTC_heap8;
extern shadowtag                    *_RTC_shadow;
extern index_elem                   *_RTC_pageidx;
extern bool                         *_RTC_pi_array;
extern bool                         _RTC_shadowmemory;


/**********************************/

#define ALLOC_SIZE 65536

class _RTC_SimpleHeap 
{
    struct FreeList 
    {
        FreeList *next;
    };
    struct HeapNode 
    {
        HeapNode *next; // next page in list (not necessarily free)
        FreeList *free; // node-local free-list
        union info 
        {
            struct topStuff 
            {   // Stuff that pertains only to the top node
                HeapNode *nxtFree;  // Pointer to node containing free items
                short wordSize;     // The size of blocks in this heap
                bool  freePage;     // True if there's a 100% free page
            } top;

            struct nonTopStuff 
            {   // Stuff that pertais only to non-top nodes
                unsigned freeCount; // The free count for this node
                HeapNode *prev;     // previous link
            } nontop;
        } inf;
    } head;

public:
    
    _RTC_SimpleHeap(unsigned blockSize) throw();
    ~_RTC_SimpleHeap() throw();

    void *operator new(unsigned) throw();
    void operator delete(void *addr) throw();
    
    void *alloc() throw();
    void free(void *addr) throw();
};

extern _RTC_SimpleHeap *_RTC_heap2;
extern _RTC_SimpleHeap *_RTC_heap4;
extern _RTC_SimpleHeap *_RTC_heap8;


#define DATA(type, name) \
private: \
    type _##name; \
public: \
    type name() const { return _##name; }\
    void name(type a) { _##name = a; }

class _RTC_HeapBlock
{
    DATA(void *, addr);             // The memory block address
    DATA(unsigned, size);           // The size of the block
    DATA(_RTC_HeapBlock *, next);   // The next element
    DATA(_RTC_HeapBlock **,list);   // The head list pointer
    DATA(short, id);                // The level ID of the block (for tiers)
    DATA(short, tag);               // The shadow tag of the block in shadow memory

public:

    _RTC_HeapBlock(void *address, short lev) 
        : _addr(address), _id(lev) , _next(0), _list(0) {}
    
    _RTC_HeapBlock(void *MemAddress, short Identifier, unsigned Size)
        : _addr(MemAddress), _id(Identifier), _size(Size), _next(0), _list(0) {}

    ~_RTC_HeapBlock() throw() 
    {
        if (_list) del(_list); 
    }

    void *operator new(unsigned) throw() 
    { 
        return _RTC_heap8->alloc(); 
    }
    
    void operator delete(void *addr) throw() 
    {
       _RTC_heap8->free(addr); 
    }
           
    int operator<(const _RTC_HeapBlock &h) const
    {
        return _addr < h._addr;
    }

    int operator==(const _RTC_HeapBlock &h) const
    {
        return h._addr == _addr && h._id == _id;
    }
    
    bool contains(const _RTC_HeapBlock &h) const 
    {
        return ((unsigned)_addr <= (unsigned)h._addr) &&
                ((unsigned)h._addr < (unsigned)_addr + _size);
    }
    
    unsigned hash(unsigned sz) const 
    {
        return (((unsigned)_addr) ^ _id) % sz;
    }

    void add(_RTC_HeapBlock **lstHead) throw() 
    {
        this->next(*lstHead);
        this->list(lstHead);
        *lstHead = this;
    }

    void del(_RTC_HeapBlock **lstHead) throw() 
    {
        _RTC_HeapBlock *head = *lstHead;
        _RTC_HeapBlock *prev = 0;
        while (head != this)
        {
            prev = head;
            head = head->next();
        }
        if (prev)
            prev->next(this->next());
        else
            *lstHead = this->next();
        next(0);
        list(0);
    }
};

#undef DATA

class _RTC_BinaryTree 
{
public:

    class BinaryNode 
    {
    public:
        BinaryNode *l, *r;
        _RTC_Container *val;

        void *operator new(unsigned) throw()
        { 
            return _RTC_heap4->alloc();      
        }

        void operator delete(void *addr) throw() 
        { 
            _RTC_heap4->free(addr); 
        }
        
        BinaryNode(BinaryNode *L, BinaryNode *R, _RTC_Container *V)
            : l(L), r(R), val(V) {}

        void kill() throw();
    };

private:

    BinaryNode *tree;

public:

    _RTC_BinaryTree(_RTC_Container *i) throw() 
        : tree(new BinaryNode(0, 0,  i)) {}
    
    ~_RTC_BinaryTree() throw() 
    { 
        if (tree) 
        {
            tree->kill(); 
            delete tree;
        } 
    }

    void *operator new(unsigned) throw() 
    { 
        return _RTC_heap2->alloc(); 
    }
    
    void operator delete(void *addr) throw() { _RTC_heap2->free(addr); }

    // This will return either the container or null
    _RTC_Container *get(_RTC_HeapBlock *) throw();

    // This just adds to the current sib list
    _RTC_Container* add(_RTC_HeapBlock *) throw();

    // This just removes the item from the current sib list
    _RTC_Container *del(_RTC_HeapBlock *) throw();

    // Here's an iterator
    class iter 
    {
        _RTC_Container **allSibs;
        int curSib;
        int totSibs;
        friend class _RTC_BinaryTree;
    
    public:
        // This thing should never be allocated...
        void *operator new(unsigned) 
        { 
            return 0; 
        }
    };

    _RTC_Container *FindFirst(iter *) throw();
    _RTC_Container *FindNext(iter *) throw();
};

class _RTC_Container 
{
    // kids - the item that has all the children
    _RTC_BinaryTree *kids;
    // inf - the item that specifies containment
    _RTC_HeapBlock *inf;

    // This kills this container, and all contained info
    void kill() throw();
public:
    _RTC_Container(_RTC_HeapBlock *hb) 
        : inf(hb), kids(0) {}
    
    ~_RTC_Container() throw() 
    {
        if (inf || kids)
            kill();
    }
    
    _RTC_HeapBlock *info() const 
    {
        return inf;
    }

    bool contains(const _RTC_HeapBlock *i) const throw() 
    {
        return inf ? inf->contains(*i) : true;
    }

    // Returns the parent container
    _RTC_Container *DelChild(_RTC_HeapBlock *i) throw();

    // Add this item as a child inside this container
    // It may or may not be a direct child
    // It returns the parent container
    _RTC_Container *AddChild(_RTC_HeapBlock *i) throw();

    // Find the container that contains the data given
    _RTC_Container *FindChild(_RTC_HeapBlock *i) throw();

    typedef _RTC_HeapBlock data;
    void *operator new(unsigned) throw() { return _RTC_heap2->alloc(); }
    void operator delete(void *addr) throw() { _RTC_heap2->free(addr); }
};


template <class T>
class HashTable 
{
    unsigned size;
    T **elems;

public:

    HashTable(unsigned s, void *mem) 
        : elems((T**)mem), size(s) 
    {
        memset(elems, 0, size * sizeof(T*)); 
    }
    
    ~HashTable() {}

    void *operator new(unsigned) throw() 
    { 
        return _RTC_heap2->alloc(); 
    }
    
    void operator delete(void *addr) throw() 
    { 
        _RTC_heap2->free(addr); 
    }
    
    T *find(T *key) throw() 
    {
        unsigned hkey = key->hash(size);
        T *elem = elems[hkey];
        while (elem && !(*elem == *key))
            elem = elem->next();
        return elem;
    }
    
    void add(T *itm) throw() 
    {
        unsigned hkey = itm->hash(size);
        itm->add(&elems[hkey]);
    }   
    
    void del(T *key) throw() 
    {
        unsigned hkey = key->hash(size);
        T *elem = elems[hkey];
        while (elem && !(*elem == *key))
            elem = elem->next();
        elem->del(&elems[hkey]);
    }
};
#endif


// Stuff for the debugger exception mechanism
// Swiped fro vcexcept.h in the LangAPI
#if !defined(_vcexcept_h)
#define _vcexcept_h

// the facility code we have chosen is based on the fact that we already
// use an exception of 'msc' when we throw C++ exceptions

#define FACILITY_VISUALCPP  ((LONG)0x6D)

#define VcppException(sev,err)  ((sev) | (FACILITY_VISUALCPP<<16) | err)

/////////////////////////////////////////////////////////////////
// define all exceptions here, so we don't mess with each other
/////////////////////////////////////////////////////////////////

// used by CRTs for C++ exceptions, really defined in ehdata.h
//#define EH_EXCEPTION_NUMBER   VcppException( 3<<30, 0x7363 )      // SEV_ERROR, used by CRTs for C++

// used by debugger to do e.g. SetThreadName call
#define EXCEPTION_VISUALCPP_DEBUGGER    VcppException(1<<30, 5000)      // SEV_INFORMATIONAL

#endif  // _vcexcept_h
// Ping the VC debugger
#define HelloVC( exinfo )   \
    RaiseException( EXCEPTION_VISUALCPP_DEBUGGER, 0, sizeof(exinfo)/sizeof(DWORD), (DWORD*)&exinfo )

enum EXCEPTION_DEBUGGER_ENUM
{
    EXCEPTION_DEBUGGER_NAME_THREAD  =   0x1000,
    EXCEPTION_DEBUGGER_PROBE        =   0x1001,
    EXCEPTION_DEBUGGER_RUNTIMECHECK =   0x1002,

    EXCEPTION_DEBUGGER_MAX = 0x1002 // largest value this debugger understands
};

// must be convertible to DWORDs for use by RaiseException
typedef struct tagEXCEPTION_VISUALCPP_DEBUG_INFO
{
    DWORD   dwType;                     // one of the enums from above
    union
    {
        struct
        {
            LPCSTR  szName;             // pointer to name (in user addr space)
            DWORD   dwThreadID;         // thread ID (-1=caller thread)
            DWORD   dwFlags;            // reserved for future use (eg User thread, System thread)
        } SetName;

        struct
        {
            DWORD   dwLevelRequired;    // 0 = do you understand this private exception, else max value of enum
            PBYTE   pbDebuggerPresent;  // debugger puts a non-zero value in this address if there
        } DebuggerProbe;

        struct
        {
            DWORD   dwRuntimeNumber;    // the type of the runtime check
            BOOL    bRealBug;           // TRUE if never a false-positive
            PVOID   pvReturnAddress;    // caller puts a return address in here
            PBYTE   pbDebuggerPresent;  // debugger puts a non-zero value in this address if handled it
            LPCWSTR pwRuntimeMessage;   // pointer to Unicode message (or NULL)
        } RuntimeError;
    };
} EXCEPTION_VISUALCPP_DEBUG_INFO;



#ifdef  _MSC_VER
#pragma pack(pop)
#endif  /* _MSC_VER */

#endif

#endif  /* _INC_RTCPRIV */