Re: Detecting pointer on the heap

There was a non portable way (only on x86 nt based Windows systems) to
detect a stack based pointer, which can be used for exclusion of
pointers. It works by determining the TIB (thread information block)
which has stack base and stack top information fields.

bool IsPointerOnStack(const void* p)
{
     //_CrtIsValidHeapPointer() returns always true for pointers on
stack
     PTIB pTib = NULL;
     WORD fsSel = 0;

     __asm
     {
         mov eax, fs:[18h]
         mov [pTib], eax
         mov [fsSel], fs
     }

     //sanity check, if it fires tib structure is probably changed
     _ASSERT(static_cast<void*>(pTib->ptibSelf) ==
static_cast<void*>(pTib));

     //note: works only on on NT:
     if (GetCurrentThreadId() != pTib->TIB_UNION2.WINNT.threadID)
     {
         //dangerous to use pointers on stack for diff. thread
         _ASSERT(false);
         return false;
     }

     if ((pTib->pvStackUserBase < p) && ( p < pTib->pvStackUserTop))
     {
         return true;
     }

     return false;
}

//from Matt Pietrek:
#pragma pack(1)

typedef struct _TIB
{
    PEXCEPTION_REGISTRATION_RECORD pvExcept; // 00h Head of
exception record list
    PVOID pvStackUserTop; // 04h Top of
user stack
    PVOID pvStackUserBase; // 08h Base of
user stack

    union // 0Ch (NT/Win95 differences)
    {
       struct // Win95 fields
       {
          WORD pvTDB; // 0Ch TDB
          WORD pvThunkSS; // 0Eh SS selector used for thunking
to 16 bits
          DWORD unknown1; // 10h
       } WIN95;

       struct // WinNT fields
       {
          PVOID SubSystemTib; // 0Ch
          ULONG FiberData; // 10h
       } WINNT;
    } TIB_UNION1;

    PVOID pvArbitrary; // 14h Available for application use
    struct _tib* ptibSelf; // 18h Linear address of TIB structure

    union // 1Ch (NT/Win95 differences)
    {
       struct // Win95 fields
       {
          WORD TIBFlags; // 1Ch
          WORD Win16MutexCount; // 1Eh
          DWORD DebugContext; // 20h
          DWORD pCurrentPriority; // 24h
          DWORD pvQueue; // 28h Message Queue selector
       } WIN95;

       struct // WinNT fields
       {
          DWORD unknown1; // 1Ch
          DWORD processID; // 20h
          DWORD threadID; // 24h
          DWORD unknown2; // 28h
       } WINNT;
    } TIB_UNION2;

    PVOID* pvTLSArray; // 2Ch Thread Local Storage array

    union // 30h (NT/Win95 differences)
    {
       struct // Win95 fields
       {
          PVOID* pProcess; // 30h Pointer to owning process
database
       } WIN95;
    } TIB_UNION3;
} TIB, *PTIB;

#pragma pack()

However I also agree with other users, that u should really rethink
why u want to use this in the first place. Consider garbage collectors
or shared_ptr's if u have problems tracking down ownership of pointers.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]