dacdbiimpl.cpp

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

//*****************************************************************************
// File: DacDbiImpl.cpp
//
// Implement DAC/DBI interface
//*****************************************************************************

#include "stdafx.h"

#include "dacdbiinterface.h"

#include "typestring.h"
#include "holder.h"
#include "debuginfostore.h"
#include "peimagelayout.inl"
#include "encee.h"
#include "switches.h"
#include "generics.h"
#include "stackwalk.h"
#include "virtualcallstub.h"

#include "dacdbiimpl.h"

#ifdef FEATURE_COMINTEROP
#include "runtimecallablewrapper.h"
#include "comcallablewrapper.h"
#endif // FEATURE_COMINTEROP

#include "request_common.h"
#include "conditionalweaktable.h"

#ifndef USE_DAC_TABLE_RVA
#include <clrconfignocache.h>
#define CAN_USE_CDAC
#endif

//-----------------------------------------------------------------------------
// Have standard enter and leave macros at the DacDbi boundary to enforce
// standard behavior.
// 1. Methods return HRESULT and wrap their bodies with EX_TRY/EX_CATCH_HRESULT
//    to catch exceptions inside the DAC and convert them to HRESULTs before
//    crossing the DSO boundary.
// 2. provide a space to hook logging and transitions.
// 3. provide a hook to verify return values.
//
// Usage notes:
// - use this at the DacDbi boundary; but not at internal functions
// - it's ok to Return from the middle.
//
// Expected usage is:
//  Foo()
//  {
//      DD_ENTER_MAY_THROW
//      HRESULT hr = S_OK;
//      EX_TRY
//      {
//          ...
//          if (...) { ThrowHR(E_SOME_FAILURE); }
//          ...
//      }
//      EX_CATCH_HRESULT(hr);
//      return hr;
//  }
//-----------------------------------------------------------------------------




// Global allocator for DD. Access is protected under the g_dacMutex lock.
IDacDbiInterface::IAllocator * g_pAllocator = NULL;

//---------------------------------------------------------------------------------------
//
// Extra sugar for wrapping IAllocator under friendly New/Delete operators.
//
// Sample usage:
//     void Foo(TestClass ** ppOut)
//     {
//        *ppOut = NULL;
//        TestClass * p = new (forDbi) TestClass();
//        ...
//        if (ok)
//        {
//            *ppOut = p;
//            return; // DBI will then free this memory.
//        }
//        ...
//        DeleteDbiMemory(p); // DeleteDbiMemory(p, len); if it was an array allocation.
//     }
//
//     Be very careful when using this on classes since Dbi and DAC may be in
//     separate dlls. This is best used when operating on blittable data-structures.
//     (no ctor/dtor, plain data fields) to guarantee the proper DLL isolation.
//     You don't want to call the ctor in DAC's context and the dtor in DBI's context
//     unless you really know what you're doing and that it's safe.
//

// Need a class to serve as a tag that we can use to overload New/Delete.
forDbiWorker forDbi;

void * operator new(size_t lenBytes, const forDbiWorker &)
{
    _ASSERTE(g_pAllocator != NULL);
    void *result = g_pAllocator->Alloc(lenBytes);
    if (result == NULL)
    {
        ThrowOutOfMemory();
    }
    return result;
}

void * operator new[](size_t lenBytes, const forDbiWorker &)
{
    _ASSERTE(g_pAllocator != NULL);
    void *result = g_pAllocator->Alloc(lenBytes);
    if (result == NULL)
    {
        ThrowOutOfMemory();
    }
    return result;
}

// Note: there is no C++ syntax for manually invoking this, but if a constructor throws an exception I understand that
// this delete operator will be invoked automatically to destroy the object.
void operator delete(void *p, const forDbiWorker &)
{
    if (p == NULL)
    {
        return;
    }

    _ASSERTE(g_pAllocator != NULL);
    g_pAllocator->Free((BYTE*) p);

}

// Note: there is no C++ syntax for manually invoking this, but if a constructor throws an exception I understand that
// this delete operator will be invoked automatically to destroy the object.
void operator delete[](void *p, const forDbiWorker &)
{
    if (p == NULL)
    {
        return;
    }

    _ASSERTE(g_pAllocator != NULL);
    g_pAllocator->Free((BYTE*) p);
}

// @dbgtodo  dac support: determine how to handle an array of class instances to ensure the dtors get
// called correctly or document that they won't
// Delete memory and invoke dtor for memory allocated with 'operator (forDbi) new'
template<class T> void DeleteDbiMemory(T *p)
{
    if (p == NULL)
    {
        return;
    }
    p->~T();

    _ASSERTE(g_pAllocator != NULL);
    g_pAllocator->Free((BYTE*) p);
}

void* AllocDbiMemory(size_t size)
{
    void *result;
    if (g_pAllocator != nullptr)
    {
        result = g_pAllocator->Alloc(size);
    }
    else
    {
        result = new (nothrow) BYTE[size];
    }
    if (result == NULL)
    {
        ThrowOutOfMemory();
    }
    return result;
}

void DeleteDbiMemory(void* p)
{
    if (p == NULL)
    {
        return;
    }
    if (g_pAllocator != nullptr)
    {
        g_pAllocator->Free((BYTE*)p);
    }
    else
    {
        ::delete [] (BYTE*)p;
    }
}

// Delete memory and invoke dtor for memory allocated with 'operator (forDbi) new[]'
// There's an inherent risk here - where each element's destructor will get called within
// the context of the DAC. If the destructor tries to use the CRT allocator logic expecting
// to hit the DBI's, we could be in trouble. Those objects need to use an export allocator like this.
template<class T> void DeleteDbiArrayMemory(T *p, int count)
{
    if (p == NULL)
    {
        return;
    }

    for (T *cur = p; cur < p + count; cur++)
    {
        cur->~T();
    }

    _ASSERTE(g_pAllocator != NULL);
    g_pAllocator->Free((BYTE*) p);
}

//---------------------------------------------------------------------------------------
// Creates the DacDbiInterface object, used by Dbi.
//
// Arguments:
//    pTarget     - pointer to a Data-Target
//    baseAddress - non-zero base address of mscorwks in target to debug.
//    pAllocator  - pointer to client allocator object. This lets DD allocate objects and
//                  pass them out back to the client, which can then delete them.
//                  DD takes a weak ref to this, so client must keep it alive until it
//                  calls Release.
//    pMetadataLookup - callback interface to do internal metadata lookup. This is because
//                  metadata is not dac-ized.
//    ppInterface - mandatory out-parameter
//
// Return Value:
//    S_OK on success.
//
//
// Notes:
//    On Windows, this is public function that can be retrieved by GetProcAddress.

//    On Mac, this is used internally by DacDbiMarshalStubInstance below
//    This will yield an IDacDbiInterface to provide structured access to the
//    data-target.
//
//    Must call Release on interface to free its resources.
//
//---------------------------------------------------------------------------------------
STDAPI
DLLEXPORT
DacDbiInterfaceInstance(
    ICorDebugDataTarget * pTarget,
    CORDB_ADDRESS baseAddress,
    CLRDATA_ADDRESS contractDescriptorAddress,
    IDacDbiInterface::IAllocator * pAllocator,
    IDacDbiInterface::IMetaDataLookup * pMetaDataLookup,
    IDacDbiInterface ** ppInterface)
{
#ifndef CAN_USE_CDAC
    // Consumed only by the cDAC path, which is compiled out here.
    (void)contractDescriptorAddress;
#endif

    // No marshalling is done by the instantiationf function - we just need to setup the infrastructure.
    // We don't want to warn if this involves creating and accessing undacized data structures,
    // because it's for the infrastructure, not DACized code itself.
    SUPPORTS_DAC_HOST_ONLY;

    // Since this is public, verify it.
    if ((ppInterface == NULL) || (pTarget == NULL) || (baseAddress == 0))
    {
        return E_INVALIDARG;
    }

    *ppInterface = NULL;

    //
    // Actually allocate the real object and initialize it.
    //
    DacDbiInterfaceImpl * pDac = new (nothrow) DacDbiInterfaceImpl(pTarget, baseAddress, pAllocator, pMetaDataLookup);
    if (!pDac)
    {
        return E_OUTOFMEMORY;
    }

    HRESULT hrStatus = pDac->Initialize();

    if (FAILED(hrStatus))
    {
        delete pDac;
        return hrStatus;
    }

#ifdef CAN_USE_CDAC
    CLRConfigNoCache enable = CLRConfigNoCache::Get("ENABLE_CDAC");
    if (enable.IsSet())
    {
        DWORD val;
        if (enable.TryAsInteger(10, val) && val == 1)
        {
            uint64_t contractDescriptorAddr = contractDescriptorAddress;
            if (contractDescriptorAddr != 0)
            {
                IUnknown* legacyImpl;
                HRESULT qiRes = pDac->QueryInterface(IID_IUnknown, (void**)&legacyImpl);
                _ASSERTE(SUCCEEDED(qiRes));

                CDAC& cdac = pDac->m_cdac;
                cdac = CDAC::Create(contractDescriptorAddr, pDac->m_pTarget, legacyImpl);
                if (cdac.IsValid())
                {
                    ReleaseHolder<IUnknown> cdacInterface;
                    cdac.CreateDacDbiInterface(&cdacInterface);
                    if (cdacInterface != nullptr)
                    {
                        IDacDbiInterface* pCDacDbi = nullptr;
                        HRESULT hr = cdacInterface->QueryInterface(__uuidof(IDacDbiInterface), (void**)&pCDacDbi);
                        if (SUCCEEDED(hr))
                        {
                            // Lifetime is now managed by cDAC implementation
                            pDac->Release();
                            // Release the AddRef from the QI for legacyImpl
                            pDac->Release();
                            *ppInterface = pCDacDbi;
                            return S_OK;
                        }
                    }
                }

                // Release the AddRef from the QI for legacyImpl
                pDac->Release();
            }

            // If we requested to use the cDAC, but failed to create the cDAC interface, return failure
            pDac->Release();
            return E_FAIL;
        }
    }
#endif

    *ppInterface = pDac;
    return hrStatus;
}


//---------------------------------------------------------------------------------------
// Constructor. Instantiates a DAC/DBI interface around a DataTarget.
//
// Arguments:
//    pTarget     - pointer to a Data-Target
//    baseAddress - non-zero base address of mscorwks in target to debug.
//    pAllocator  - pointer to client allocator object. This lets DD allocate objects and
//                  pass them out back to the client, which can then delete them.
//                  DD takes a weak ref to this, so client must keep it alive until it
//                  calls Release.
//    pMetadataLookup - callback interface to do internal metadata lookup. This is because
//                  metadata is not dac-ized.
//
// Notes:
//    pAllocator is a weak reference.
//---------------------------------------------------------------------------------------
DacDbiInterfaceImpl::DacDbiInterfaceImpl(
    ICorDebugDataTarget* pTarget,
    CORDB_ADDRESS baseAddress,
    IAllocator * pAllocator,
    IMetaDataLookup * pMetaDataLookup
) : ClrDataAccess(pTarget),
    m_pAllocator(pAllocator),
    m_pMetaDataLookup(pMetaDataLookup),
    m_pCachedPEAssembly(VMPTR_PEAssembly::NullPtr()),
    m_pCachedImporter(NULL),
    m_isCachedHijackFunctionValid(FALSE)
{
    _ASSERTE(baseAddress != (CORDB_ADDRESS)NULL);
    m_globalBase = CORDB_ADDRESS_TO_TADDR(baseAddress);

    _ASSERTE(pMetaDataLookup != NULL);
    _ASSERTE(pAllocator != NULL);
    _ASSERTE(pTarget != NULL);
}

//-----------------------------------------------------------------------------
// Destructor.
//
// Notes:
//    This gets invoked when the ref count drops to 0 via Release().
//-----------------------------------------------------------------------------
DacDbiInterfaceImpl::~DacDbiInterfaceImpl()
{
    SUPPORTS_DAC_HOST_ONLY;
    // This will automatically chain to the base class dtor
}

//-----------------------------------------------------------------------------
// Called from DAC-ized code to get a IMDInternalImport
//
// Arguments:
//    pPEAssembly - PE file for which to get importer for
//    fThrowEx - if true, throw instead of returning NULL.
//
// Returns:
//    an Internal importer object for this file.
//    May return NULL or throw (depending on fThrowEx).
//    May throw in exceptional circumstances (eg, corrupt debuggee).
//
// Assumptions:
//    This is called from DAC-ized code within the VM, which
//    was in turn called from some DD primitive. The returned importer will
//    be used by the DAC-ized code in the callstack, but it won't be cached.
//
// Notes:
//    This is an Internal importer, not a public Metadata importer.
//
interface IMDInternalImport* DacDbiInterfaceImpl::GetMDImport(
    const PEAssembly* pPEAssembly,
    const ReflectionModule * pReflectionModule,
    bool fThrowEx)
{
    // Since this is called from an existing DAC-primitive, we already hold the g_dacMutex lock.
    // The lock conveniently protects our cache.
    SUPPORTS_DAC;

    IDacDbiInterface::IMetaDataLookup * pLookup = m_pMetaDataLookup;
    _ASSERTE(pLookup != NULL);

    VMPTR_PEAssembly vmPEAssembly = VMPTR_PEAssembly::NullPtr();

    if (pPEAssembly != NULL)
    {
        vmPEAssembly.SetHostPtr(pPEAssembly);
    }
    else if (pReflectionModule != NULL)
    {
        // SOS and ClrDataAccess rely on special logic to find the metadata for methods in dynamic modules.
        // We don't need to.  The RS has already taken care of the special logic for us.
        // So here we just grab the PEAssembly off of the ReflectionModule and continue down the normal
        // code path.  See code:ClrDataAccess::GetMDImport for comparison.
        vmPEAssembly.SetHostPtr(pReflectionModule->GetPEAssembly());
    }

    // Optimize for the case where the VM queries the same Importer many times in a row.
    if (m_pCachedPEAssembly == vmPEAssembly)
    {
        return m_pCachedImporter;
    }

    // Go to DBI to find the metadata.
    IMDInternalImport * pInternal = NULL;
    EX_TRY
    {
        // This is the new codepath that uses ICorDebugMetaDataLookup.
        // To get the old codepath that uses the v2 metadata lookup methods,
        // you'd have to load DAC only and then you'll get ClrDataAccess's implementation
        // of this function.
        pInternal = pLookup->LookupMetaData(vmPEAssembly);
    }
    EX_CATCH
    {
        // Any expected error we should ignore.
        if ((GET_EXCEPTION()->GetHR() != HRESULT_FROM_WIN32(ERROR_PARTIAL_COPY)) &&
            (GET_EXCEPTION()->GetHR() != CORDBG_E_READVIRTUAL_FAILURE) &&
            (GET_EXCEPTION()->GetHR() != CORDBG_E_SYMBOLS_NOT_AVAILABLE) &&
            (GET_EXCEPTION()->GetHR() != CORDBG_E_MODULE_LOADED_FROM_DISK))
        {
            EX_RETHROW;
        }
    }
    EX_END_CATCH

    if (pInternal == NULL)
    {
        SIMPLIFYING_ASSUMPTION(!"MD lookup failed");
        if (fThrowEx)
        {
            ThrowHR(E_FAIL);
        }
        return NULL;
    }
    else
    {
        // Cache it such that it we look for the exact same Importer again, we'll return it.
        m_pCachedPEAssembly   = vmPEAssembly;
        m_pCachedImporter = pInternal;
    }

    return pInternal;
}

//-----------------------------------------------------------------------------
// Implementation of IDacDbiInterface
// See DacDbiInterface.h for full descriptions of all of these functions
//-----------------------------------------------------------------------------

// IUnknown implementation for DacDbiInterfaceImpl.
// Delegates to ClrDataAccess's ref-counting and adds support for IDacDbiInterface IID.
STDMETHODIMP
DacDbiInterfaceImpl::QueryInterface(THIS_ IN REFIID interfaceId, OUT PVOID* iface)
{
    if (iface == NULL)
        return E_POINTER;

    if (IsEqualIID(interfaceId, __uuidof(IDacDbiInterface)))
    {
        AddRef();
        *iface = static_cast<IDacDbiInterface*>(this);
        return S_OK;
    }
    return ClrDataAccess::QueryInterface(interfaceId, iface);
}

STDMETHODIMP_(ULONG)
DacDbiInterfaceImpl::AddRef(THIS)
{
    return ClrDataAccess::AddRef();
}

STDMETHODIMP_(ULONG)
DacDbiInterfaceImpl::Release(THIS)
{
    return ClrDataAccess::Release();
}

// Flush the DAC cache. This should be called when target memory changes.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::FlushCache()
{
    // Non-reentrant. We don't want to flush cached instances from a callback.
    // That would remove host DAC instances while they're being used.
    DD_NON_REENTRANT_MAY_THROW;

    m_pCachedPEAssembly = VMPTR_PEAssembly::NullPtr();
    m_pCachedImporter = NULL;
    m_isCachedHijackFunctionValid = FALSE;

    HRESULT hr  = ClrDataAccess::Flush();

    // Current impl of Flush() should always succeed. If it ever fails, we want to know.
    _ASSERTE(SUCCEEDED(hr));
    return hr;
}

// enable or disable DAC target consistency checks
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::DacSetTargetConsistencyChecks(BOOL fEnableAsserts)
{
    HRESULT hr = S_OK;
    EX_TRY
    {
        // forward on to our ClrDataAccess base class
        ClrDataAccess::SetTargetConsistencyChecks(fEnableAsserts);
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Query if Left-side is started up?
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsLeftSideInitialized(OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if (g_pDebugger != NULL)
        {
            // This check is "safe".
            // The initialize order in the left-side is:
            // 1) g_pDebugger is an RVA based global initialized to NULL when the module is loaded.
            // 2) Allocate a "Debugger" object.
            // 3) run the ctor, which will set m_fLeftSideInitialized = FALSE.
            // 4) assign the object to g_pDebugger.
            // 5) later, LS initialization code will assign g_pDebugger->m_fLeftSideInitialized = TRUE.
            //
            // The memory write in #5 is atomic.  There is no window where we're reading uninitialized data.

            *pResult = (g_pDebugger->m_fLeftSideInitialized != 0);
        }
        else
        {
            *pResult = FALSE;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// Gets whether the specified address is managed code.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsManagedCode(CORDB_ADDRESS address, OUT BOOL * pIsManaged)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        TADDR taAddr = CORDB_ADDRESS_TO_TADDR(address);
        *pIsManaged = FALSE;

        if (IsPossibleCodeAddress(taAddr) == S_OK && ExecutionManager::IsManagedCode(taAddr))
        {
            *pIsManaged = TRUE;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// Get the AppDomain ID for an AppDomain.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetAppDomainId(VMPTR_AppDomain vmAppDomain, OUT ULONG * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if (vmAppDomain.IsNull())
        {
            *pRetVal = 0;
        }
        else
        {
            AppDomain * pAppDomain = vmAppDomain.GetDacPtr();
            *pRetVal = DefaultADID;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Get the full AD friendly name for the given EE AppDomain.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetAppDomainFullName(VMPTR_AppDomain vmAppDomain, IStringHolder * pStrName)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        AppDomain * pAppDomain = vmAppDomain.GetDacPtr();

        // Get the AppDomain name from the VM without changing anything
        IfFailThrow(pStrName->AssignCopy(pAppDomain->GetFriendlyName()));
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// JIT Compiler Flags
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// Get the values of the JIT Optimization and EnC flags.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetCompilerFlags(VMPTR_Assembly vmAssembly, OUT BOOL * pfAllowJITOpts, OUT BOOL * pfEnableEnC)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Assembly * pAssembly = vmAssembly.GetDacPtr();

        if (pAssembly == NULL)
        {
            ThrowHR(E_FAIL);
        }

        Module * pModule = pAssembly->GetModule();
        *pfAllowJITOpts = !pModule->AreJITOptimizationsDisabled();
        *pfEnableEnC = pModule->IsEditAndContinueEnabled();


    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//-----------------------------------------------------------------------------
// Helper function for SetCompilerFlags to set EnC status.
// Arguments:
//     Input:
//         pModule - The runtime module for which flags are being set.
//
// Return value:
//   true if the Enc bits can be set on this module
//-----------------------------------------------------------------------------

bool DacDbiInterfaceImpl::CanSetEnCBits(Module * pModule)
{
    _ASSERTE(pModule != NULL);
#ifdef FEATURE_METADATA_UPDATER
    // If we're using explicit sequence points (from the PDB), then we can't do EnC
    // because EnC won't get updated pdbs and so the sequence points will be wrong.
    bool fIgnorePdbs = ((pModule->GetDebuggerInfoBits() & DACF_IGNORE_PDBS) != 0);

    bool fAllowEnc = pModule->IsEditAndContinueCapable() &&

#ifdef PROFILING_SUPPORTED_DATA
        !CORProfilerPresent() && // this queries target
#endif
        fIgnorePdbs;
#else   // ! FEATURE_METADATA_UPDATER
    // Enc not supported on any other platforms.
    bool fAllowEnc = false;
#endif

    return fAllowEnc;
} // DacDbiInterfaceImpl::SetEnCBits

// Set the values of the JIT optimization and EnC flags.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::SetCompilerFlags(VMPTR_Assembly vmAssembly,
                                           BOOL             fAllowJitOpts,
                                           BOOL             fEnableEnC)
{
    DD_ENTER_MAY_THROW;

    DWORD      dwBits    = 0;
    Assembly * pAssembly = vmAssembly.GetDacPtr();
    Module *   pModule   = pAssembly->GetModule();
    HRESULT    hr        = S_OK;


    _ASSERTE(pModule != NULL);

    // Initialize dwBits.
    dwBits = (pModule->GetDebuggerInfoBits() & ~(DACF_ALLOW_JIT_OPTS | DACF_ENC_ENABLED));
    dwBits &= DACF_CONTROL_FLAGS_MASK;

    if (fAllowJitOpts)
    {
        dwBits |= DACF_ALLOW_JIT_OPTS;
    }
    if (fEnableEnC)
    {
        if (CanSetEnCBits(pModule))
        {
            dwBits |= DACF_ENC_ENABLED;
        }
        else
        {
            hr = CORDBG_S_NOT_ALL_BITS_SET;
        }
    }

    // set flags. This will write back to the target
    pModule->SetDebuggerInfoBits((DebuggerAssemblyControlFlags)dwBits);


    LOG((LF_CORDB, LL_INFO100, "D::HIPCE, Changed Jit-Debug-Info: fOpt=%d, fEnableEnC=%d, new bits=0x%08x\n",
           (dwBits & DACF_ALLOW_JIT_OPTS) != 0,
           (dwBits & DACF_ENC_ENABLED) != 0,
            dwBits));

    _ASSERTE(SUCCEEDED(hr));
    return hr;

} // DacDbiInterfaceImpl::SetCompilerFlags


//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// sequence points and var info
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// Allocator to pass to the debug-info-stores...
static BYTE* InfoStoreNew(void * pData, size_t cBytes)
{
    return new (nothrow) BYTE[cBytes];
}

// Get the native/IL sequence points and native var info for a function via callbacks.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetNativeCodeSequencePointsAndVarInfo(VMPTR_MethodDesc vmMethodDesc, CORDB_ADDRESS startAddress, BOOL fCodeAvailable, OUT ULONG32 * pFixedArgCount, FP_NATIVEVARINFO_CALLBACK fpVarInfoCallback, FP_SEQUENCEPOINT_CALLBACK fpSeqPointCallback, CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(!vmMethodDesc.IsNull());

        MethodDesc * pMD = vmMethodDesc.GetDacPtr();

        _ASSERTE(fCodeAvailable != 0);

        // Return the fixed argument count
        if (pFixedArgCount != NULL)
        {
            *pFixedArgCount = (ULONG32)GetArgCount(pMD);
        }

        DebugInfoRequest request;
        request.InitFromStartingAddr(pMD, CORDB_ADDRESS_TO_TADDR(startAddress));

        // Retrieve sequence points and native variable info in a single request
        NewArrayHolder<ICorDebugInfo::OffsetMapping> mapCopy(NULL);
        NewArrayHolder<ICorDebugInfo::NativeVarInfo> nativeVars(NULL);
        ULONG32 seqEntryCount = 0;
        ULONG32 varEntryCount = 0;

        BOOL success = DebugInfoManager::GetBoundariesAndVars(request,
                                                    InfoStoreNew, NULL,
                                                    BoundsType::Uninstrumented,
                                                    &seqEntryCount, &mapCopy,
                                                    &varEntryCount, &nativeVars);
        if (!success)
            ThrowHR(E_FAIL);

        // Invoke the native variable info callback for each entry
        if (fpVarInfoCallback != NULL)
        {
            for (ULONG32 i = 0; i < varEntryCount; i++)
            {
                fpVarInfoCallback(&nativeVars[i], pUserData);
            }
        }

        // Invoke the sequence point callback for each entry
        if (fpSeqPointCallback != NULL)
        {
            for (ULONG32 i = 0; i < seqEntryCount; i++)
            {
                fpSeqPointCallback(&mapCopy[i], pUserData);
            }
        }

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//-----------------------------------------------------------------------------
// Get the number of fixed arguments to a function, i.e., the explicit args and the "this" pointer.
// This does not include other implicit arguments or varargs. This is used to compute a variable ID
// (see comment in CordbJITILFrame::ILVariableToNative for more detail)
// Arguments:
//    input:  pMD    pointer to the method desc for the function
//    output: none
// Return value:
//    the number of fixed arguments to the function
//-----------------------------------------------------------------------------
SIZE_T DacDbiInterfaceImpl::GetArgCount(MethodDesc * pMD)
{

    // Create a MetaSig for the given method's sig. (Easier than
    // picking the sig apart ourselves.)
    PCCOR_SIGNATURE pCallSig;
    DWORD cbCallSigSize;

    pMD->GetSig(&pCallSig, &cbCallSigSize);

    if (pCallSig == NULL)
    {
        // Sig should only be null if the image is corrupted. (Even for lightweight-codegen)
        // We expect the jit+verifier to catch this, so that we never land here.
        // But just in case ...
        CONSISTENCY_CHECK_MSGF(false, ("Corrupted image, null sig.(%s::%s)",
                               pMD->m_pszDebugClassName, pMD->m_pszDebugMethodName));
        return 0;
    }

    MetaSig msig(pCallSig, cbCallSigSize, pMD->GetAssembly()->GetModule(), NULL, MetaSig::sigMember);

    // Get the arg count.
    UINT32 NumArguments = msig.NumFixedArgs();

    // Account for the 'this' argument.
    if (!pMD->IsStatic())
    {
        NumArguments++;
    }
/*
    SigParser sigParser(pCallSig, cbCallSigSize);
    sigParser.SkipMethodHeaderSignature(&m_allArgsCount);
*/
    return NumArguments;
} //GetArgCount


//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Function Data
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


// GetILCodeAndSig returns the function's ILCode and SigToken given
// a module and a token. The info will come from a MethodDesc, if
// one exists or from metadata.
//
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetILCodeAndSig(VMPTR_Assembly vmAssembly, mdToken functionToken, OUT TargetBuffer * pCodeInfo, OUT mdToken * pLocalSigToken)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Assembly * pAssembly  = vmAssembly.GetDacPtr();
        Module *   pModule    = pAssembly->GetModule();
        RVA        methodRVA  = 0;
        DWORD      implFlags;

        // preinitialize out params
        pCodeInfo->Clear();
        *pLocalSigToken = mdSignatureNil;

        // Get the RVA and impl flags for this method.
        IfFailThrow(pModule->GetMDImport()->GetMethodImplProps(functionToken,
                                                               &methodRVA,
                                                               &implFlags));

        MethodDesc* pMethodDesc =
            FindLoadedMethodRefOrDef(pModule, functionToken);

        // If the RVA is 0 or it's native, then the method is not IL
        if (methodRVA == 0)
        {
            LOG((LF_CORDB,LL_INFO100000, "DDI::GICAS: Function is not IL - methodRVA == NULL!\n"));
            // return (CORDBG_E_FUNCTION_NOT_IL);
            // Sanity check this....

            if(!pMethodDesc || !pMethodDesc->IsIL())
            {
                LOG((LF_CORDB,LL_INFO100000, "DDI::GICAS: And the MD agrees..\n"));
                ThrowHR(CORDBG_E_FUNCTION_NOT_IL);
            }
            else
            {
                LOG((LF_CORDB,LL_INFO100000, "DDI::GICAS: But the MD says it's IL..\n"));
            }

            if (pMethodDesc != NULL && pMethodDesc->GetRVA() == 0)
            {
                LOG((LF_CORDB,LL_INFO100000, "DDI::GICAS: Actually, MD says RVA is 0 too - keep going...!\n"));
            }
        }
        if (IsMiNative(implFlags))
        {
            LOG((LF_CORDB,LL_INFO100000, "DDI::GICAS: Function is not IL - IsMiNative!\n"));
            ThrowHR(CORDBG_E_FUNCTION_NOT_IL);
        }

        *pLocalSigToken = GetILCodeAndSigHelper(pModule, pMethodDesc, functionToken, methodRVA, pCodeInfo);

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//---------------------------------------------------------------------------------------
//
// This is just a worker function for GetILCodeAndSig.  It returns the function's ILCode and SigToken
// given a module, a token, and the RVA.  If a MethodDesc is provided, it has to be consistent with
// the token and the RVA.
//
// Arguments:
//    pModule       - the Module containing the specified method
//    pMD           - the specified method; can be NULL
//    mdMethodToken - the MethodDef token of the specified method
//    methodRVA     - the RVA of the IL for the specified method
//    pIL           - out parameter; return the target address and size of the IL of the specified method
//
// Return Value:
//    Return the local variable signature token of the specified method.  Can be mdSignatureNil.
//

mdSignature DacDbiInterfaceImpl::GetILCodeAndSigHelper(Module *       pModule,
                                                       MethodDesc *   pMD,
                                                       mdMethodDef    mdMethodToken,
                                                       RVA            methodRVA,
                                                       TargetBuffer * pIL)
{
    _ASSERTE(pModule != NULL);

    // If a MethodDesc is provided, it has to be consistent with the MethodDef token and the RVA.
    _ASSERTE((pMD == NULL) || ((pMD->GetMemberDef() == mdMethodToken) && (pMD->GetRVA() == methodRVA)));

    TADDR pTargetIL = pModule->GetDynamicIL(mdMethodToken);

    // Method not overridden - get the original copy of the IL by going to the PE file/RVA
    // If this is in a dynamic module then don't even attempt this since ReflectionModule::GetIL isn't
    // implemented for DAC.
    if (pTargetIL == 0 && !pModule->IsReflectionEmit())
    {
        pTargetIL = (TADDR)pModule->GetIL(methodRVA);
    }

    mdSignature mdSig = mdSignatureNil;
    if (pTargetIL == 0)
    {
        // Currently this should only happen for LCG methods (including IL stubs).
        // LCG methods have a 0 RVA, and so we don't currently have any way to get the IL here.
        _ASSERTE(pMD->IsDynamicMethod());
        _ASSERTE(pMD->AsDynamicMethodDesc()->IsLCGMethod()||
                 pMD->AsDynamicMethodDesc()->IsILStub());

        // Clear the buffer.
        pIL->Clear();
    }
    else
    {
        // Now we have the target address of the IL blob, we need to bring it over to the host.
        // DacGetILMethod will copy the COR_ILMETHOD information that we need
        COR_ILMETHOD * pHostIL = DacGetIlMethod(pTargetIL);     // host address of start of IL blob
        COR_ILMETHOD_DECODER header(pHostIL);                   // host address of header


        // Get the IL code info. We need the address of the IL itself, which will be beyond the header
        // at the beginning of the blob. We ultimately need the target address. To get this, we take
        // target address of the target IL blob and add the offset from the beginning of the host IL blob
        // (the header) to the beginning of the IL itself (we get this information from the header).
        pIL->pAddress = pTargetIL + ((SIZE_T)(header.Code) - (SIZE_T)pHostIL);
        pIL->cbSize = header.GetCodeSize();

        // Now we get the signature token
        if (header.LocalVarSigTok != mdTokenNil)
        {
            mdSig = header.GetLocalVarSigTok();
        }
        else
        {
            mdSig = mdSignatureNil;
        }
    }

    return mdSig;
}


HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetModuleMetaDataFileInfo(VMPTR_Module vmModule, DWORD * pTimeStamp, DWORD * pImageSize, IStringHolder* pStrFilename, OUT BOOL * pResult)
{
    if (pTimeStamp == NULL || pImageSize == NULL || pStrFilename == NULL || pResult == NULL)
        return E_POINTER;

    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        DWORD dwDataSize;
        DWORD dwRvaHint;
        Module * pModule = vmModule.GetDacPtr();
        _ASSERTE(pModule != NULL);
        if (pModule == NULL)
        {
            *pResult = FALSE;
            return E_FAIL;
        }
        else
        {
        WCHAR wszFilePath[MAX_LONGPATH] = {0};
        DWORD cchFilePath = MAX_LONGPATH;
        bool ret = ClrDataAccess::GetMetaDataFileInfoFromModule(pModule,
                                                                *pTimeStamp,
                                                                *pImageSize,
                                                                dwDataSize,
                                                                dwRvaHint,
                                                                wszFilePath,
                                                                cchFilePath);

        IfFailThrow(pStrFilename->AssignCopy(wszFilePath));
        *pResult = ret;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Get start addresses and sizes for hot and cold regions for a native code blob.
// Arguments:
//    Input:
//        pMethodDesc - method desc for the function we are inspecting
//    Output (required):
//        pCodeInfo   - initializes the m_rgCodeRegions field of this structure
//                      if the native code is available. Otherwise,
//                      pCodeInfo->IsValid() is false.

void DacDbiInterfaceImpl::GetMethodRegionInfo(MethodDesc *             pMethodDesc,
                                              NativeCodeFunctionData * pCodeInfo)
{
    CONTRACTL
    {
        GC_NOTRIGGER;
        PRECONDITION(CheckPointer(pCodeInfo));
    }
    CONTRACTL_END;

    IJitManager::MethodRegionInfo methodRegionInfo = {(TADDR)NULL, 0, (TADDR)NULL, 0};
    PCODE functionAddress = pMethodDesc->GetCodeForInterpreterOrJitted();

    // get the start address of the hot region and initialize the jit manager
    pCodeInfo->m_rgCodeRegions[kHot].pAddress = CORDB_ADDRESS(PCODEToPINSTR(functionAddress));

    // if the start address is NULL, the code isn't available yet, so just return
    if (functionAddress != (PCODE)NULL)
    {
        EECodeInfo codeInfo(functionAddress);
        _ASSERTE(codeInfo.IsValid());

        codeInfo.GetMethodRegionInfo(&methodRegionInfo);

        // now get the rest of the region information
        pCodeInfo->m_rgCodeRegions[kHot].cbSize = (ULONG)methodRegionInfo.hotSize;
        pCodeInfo->m_rgCodeRegions[kCold].Init(PCODEToPINSTR(methodRegionInfo.coldStartAddress),
                                               (ULONG)methodRegionInfo.coldSize);
        _ASSERTE(pCodeInfo->IsValid());
    }
    else
    {
        _ASSERTE(!pCodeInfo->IsValid());
    }
} // GetMethodRegionInfo


// Gets the following information about a native code blob:
//    - its method desc
//    - whether it's an instantiated generic
//    - its EnC version number
//    - hot and cold region information.
// If the hot region start address is NULL at the end, it means the native code
// isn't currently available. In this case, all values in pCodeInfo will be
// cleared.

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetNativeCodeInfo(VMPTR_Assembly vmAssembly, mdToken functionToken, OUT NativeCodeFunctionData * pCodeInfo)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(pCodeInfo != NULL);

        // pre-initialize:
        pCodeInfo->Clear();

        Assembly * pAssembly = vmAssembly.GetDacPtr();
        Module *   pModule   = pAssembly->GetModule();

        MethodDesc* pMethodDesc = FindLoadedMethodRefOrDef(pModule, functionToken);
        if (pMethodDesc != NULL && pMethodDesc->IsAsyncThunkMethod())
        {
            MethodDesc* pAsyncVariant = pMethodDesc->GetAsyncVariantNoCreate();
            if (pAsyncVariant != NULL)
            {
                pMethodDesc = pAsyncVariant;
            }
        }
        pCodeInfo->vmNativeCodeMethodDescToken.SetHostPtr(pMethodDesc);

        // if we are loading a module and trying to bind a previously set breakpoint, we may not have
        // a method desc yet, so check for that situation
        if(pMethodDesc != NULL)
        {
            GetMethodRegionInfo(pMethodDesc, pCodeInfo);
            if (pCodeInfo->m_rgCodeRegions[kHot].pAddress != (CORDB_ADDRESS)NULL)
            {
                pCodeInfo->isInstantiatedGeneric = pMethodDesc->HasClassOrMethodInstantiation();
                LookupEnCVersions(pModule,
                                  pCodeInfo->vmNativeCodeMethodDescToken,
                                  functionToken,
                                  pCodeInfo->m_rgCodeRegions[kHot].pAddress,
                                  &(pCodeInfo->encVersion));
            }
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Gets the following information about a native code blob:
//    - its method desc
//    - whether it's an instantiated generic
//    - its EnC version number
//    - hot and cold region information
//    - its module
//    - its metadata token.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetNativeCodeInfoForAddr(CORDB_ADDRESS codeAddress, NativeCodeFunctionData * pCodeInfo, VMPTR_Module * pVmModule, mdToken * pFunctionToken)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(pCodeInfo != NULL);

        if (codeAddress == (CORDB_ADDRESS)NULL)
        {
            // if the start address is NULL, the code isn't available yet, so just return
            _ASSERTE(!pCodeInfo->IsValid());
            return S_OK;
        }

        IJitManager::MethodRegionInfo methodRegionInfo = {(TADDR)NULL, 0, (TADDR)NULL, 0};
        TADDR codeAddr = CORDB_ADDRESS_TO_TADDR(codeAddress);

        EX_TRY_ALLOW_DATATARGET_MISSING_MEMORY
        {
            codeAddr = GetInterpreterCodeFromEntryPointIfPresent(codeAddr);
        }
        EX_END_CATCH_ALLOW_DATATARGET_MISSING_MEMORY;

    #ifdef TARGET_ARM
        // TADDR should not have the thumb code bit set.
        _ASSERTE((codeAddr & THUMB_CODE) == 0);
        codeAddr &= ~THUMB_CODE;
    #endif

        EECodeInfo codeInfo(codeAddr);
        _ASSERTE(codeInfo.IsValid());

        TADDR codeStartAddr = codeInfo.GetStartAddress();

        // We may not have the memory for the cold code region in a minidump.
        // Do not fail stackwalking because of this.
        EX_TRY_ALLOW_DATATARGET_MISSING_MEMORY
        {
            codeInfo.GetMethodRegionInfo(&methodRegionInfo);
        }
        EX_END_CATCH_ALLOW_DATATARGET_MISSING_MEMORY;

        // Even if GetMethodRegionInfo() fails to retrieve the cold code region info,
        // we should still be able to get the hot code region info.  We are counting on this for
        // stackwalking to work in dump debugging scenarios.
        _ASSERTE(methodRegionInfo.hotStartAddress == codeStartAddr);

        // now get the rest of the region information
        pCodeInfo->m_rgCodeRegions[kHot].Init(PCODEToPINSTR(methodRegionInfo.hotStartAddress),
                                              (ULONG)methodRegionInfo.hotSize);
        pCodeInfo->m_rgCodeRegions[kCold].Init(PCODEToPINSTR(methodRegionInfo.coldStartAddress),
                                                   (ULONG)methodRegionInfo.coldSize);
        _ASSERTE(pCodeInfo->IsValid());

        VMPTR_MethodDesc vmMethodDesc;
        vmMethodDesc.SetHostPtr(codeInfo.GetMethodDesc());
        MethodDesc* pMethodDesc = vmMethodDesc.GetDacPtr();
        pCodeInfo->isInstantiatedGeneric = pMethodDesc->HasClassOrMethodInstantiation();
        pCodeInfo->vmNativeCodeMethodDescToken = vmMethodDesc;

        SIZE_T unusedLatestEncVersion;
        Module * pModule = pMethodDesc->GetModule();
        _ASSERTE(pModule != NULL);
        LookupEnCVersions(pModule,
                          vmMethodDesc,
                          pMethodDesc->GetMemberDef(),
                          codeStartAddr,
                          &unusedLatestEncVersion, //unused by caller
                          &(pCodeInfo->encVersion));

        if (pVmModule != NULL)
        {
            pVmModule->SetDacTargetPtr(dac_cast<TADDR>(pModule));
        }

        if (pFunctionToken != NULL)
        {
            *pFunctionToken = pMethodDesc->GetMemberDef();
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//
// Functions to get Type and Class information
//
//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
//-----------------------------------------------------------------------------
//DacDbiInterfaceImpl::GetTypeHandles
// Get the approximate and exact type handles for a type
// Arguments:
//     input:
//         vmThExact            - VMPTR of the exact type handle. If this method is called
//                                to get information for a new generic instantiation, this will already
//                                be initialized. If it's called to get type information for an arbitrary
//                                 type (i.e., called to initialize an instance of CordbClass), it will be NULL
//         vmThApprox           - VMPTR of the approximate type handle. If this method is called
//                                to get information for a new generic instantiation, this will already
//                                be initialized. If it's called to get type information for an arbitrary
//                                type (i.e., called to initialize an instance of CordbClass), it will be NULL
//     output:
//         pThExact             - handle for exact type information for a generic instantiation
//         pThApprox            - handle for type information
// Notes:
//    pThExact and pTHApprox must be pointers to existing memory.
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::GetTypeHandles(VMPTR_TypeHandle  vmThExact,
                                         VMPTR_TypeHandle  vmThApprox,
                                         TypeHandle *      pThExact,
                                         TypeHandle *      pThApprox)
 {
     _ASSERTE((pThExact != NULL) && (pThApprox != NULL));

     *pThExact = TypeHandle::FromPtr(vmThExact.GetDacPtr());
     *pThApprox = TypeHandle::FromPtr(vmThApprox.GetDacPtr());

    // If we can't find the class, return the proper HR to the right side.
    if (pThApprox->IsNull())
    {
        LOG((LF_CORDB, LL_INFO10000, "D::GASCI: class isn't loaded.\n"));
        ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
    }
 }  // DacDbiInterfaceImpl::GetTypeHandles

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetStaticsBases
// Gets the base table addresses for both GC and non-GC statics
// Arguments:
//     input:  thExact            - exact type handle for the class
//     output: ppGCStaticsBase    - base pointer for GC statics
//             ppNonGCStaticsBase - base pointer for non GC statics
// Notes:
// If this is a non-generic type, or an instantiated type, then we'll be able to get the static var bases
// If the typeHandle represents a generic type constructor (i.e. an uninstantiated generic class), then
// the static bases will be null (since statics are per-instantiation).
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::GetStaticsBases(TypeHandle thExact,
                                         PTR_BYTE *  ppGCStaticsBase,
                                         PTR_BYTE *  ppNonGCStaticsBase)
 {
    MethodTable * pMT = thExact.GetMethodTable();
    *ppGCStaticsBase = pMT->GetGCStaticsBasePointer();
    *ppNonGCStaticsBase = pMT->GetNonGCStaticsBasePointer();
} // DacDbiInterfaceImpl::GetStaticsBases

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::ComputeFieldData
// Computes the field info for pFD and stores it in pcurrentFieldData
// Arguments:
//     input:  pFD               - FieldDesc used to get necessary information
//             pGCStaticsBase    - base table address for GC statics
//             pNonGCStaticsBase - base table address for non-GC statics
//     output: pCurrentFieldData - contains fields to be initialized
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::ComputeFieldData(PTR_FieldDesc pFD,
                                           PTR_BYTE    pGCStaticsBase,
                                           PTR_BYTE    pNonGCStaticsBase,
                                           FieldData * pCurrentFieldData)
{
    pCurrentFieldData->Initialize(pFD->IsStatic(), pFD->IsPrimitive(), pFD->GetMemberDef());

#ifdef FEATURE_METADATA_UPDATER
    // If the field was newly introduced via EnC, and hasn't yet
    // been fixed up, then we'll send back a marker indicating
    // that it isn't yet available.
    if (pFD->IsEnCNew())
    {
        // @dbgtodo Microsoft inspection: eliminate the debugger token when ICDClass and ICDType are
        // completely DACized
        pCurrentFieldData->m_vmFieldDesc.SetHostPtr(pFD);
        pCurrentFieldData->m_fFldStorageAvailable = FALSE;
        pCurrentFieldData->m_fFldIsTLS = FALSE;
        pCurrentFieldData->m_fFldIsRVA = FALSE;
        pCurrentFieldData->m_fFldIsCollectibleStatic = FALSE;
    }
    else
#endif // FEATURE_METADATA_UPDATER
    {
        // Otherwise, we'll compute the info & send it back.
        pCurrentFieldData->m_fFldStorageAvailable = TRUE;
        // @dbgtodo Microsoft inspection: eliminate the debugger token when ICDClass and ICDType are
        // completely DACized
        pCurrentFieldData->m_vmFieldDesc.SetHostPtr(pFD);
        pCurrentFieldData->m_fFldIsTLS = (pFD->IsThreadStatic() == TRUE);
        pCurrentFieldData->m_fFldIsRVA = (pFD->IsRVA() == TRUE);
        pCurrentFieldData->m_fFldIsCollectibleStatic = (pFD->IsStatic() == TRUE &&
            pFD->GetEnclosingMethodTable()->Collectible());

        // Compute the address of the field
        if (pFD->IsStatic())
        {
            // statics are addressed using an absolute address.
            if (pFD->IsRVA())
            {
                // RVA statics are relative to a base module address
                PTR_VOID addr = pFD->GetStaticAddressHandle(NULL);
                if (pCurrentFieldData->OkToGetOrSetStaticAddress())
                {
                    pCurrentFieldData->SetStaticAddress(PTR_TO_CORDB_ADDRESS(dac_cast<TADDR>(addr)));
                }
            }
            else if (pFD->IsThreadStatic() ||
                pCurrentFieldData->m_fFldIsCollectibleStatic)
            {
                // this is a special type of static that must be queried using DB_IPCE_GET_SPECIAL_STATIC
            }
            else
            {
                // This is a normal static variable in the GC or Non-GC static base table
                PTR_BYTE base = pFD->IsPrimitive() ? pNonGCStaticsBase : pGCStaticsBase;
                if (base == NULL)
                {
                    // static var not available.  This may be an open generic class (not an instantiated type),
                    // or we might only have approximate type information because the type hasn't been
                    // initialized yet.

                    if (pCurrentFieldData->OkToGetOrSetStaticAddress())
                    {
                        pCurrentFieldData->SetStaticAddress((CORDB_ADDRESS)NULL);
                    }
                }
                else
                {
                    if (pCurrentFieldData->OkToGetOrSetStaticAddress())
                    {
                        // calculate the absolute address using the base and the offset from the base
                        pCurrentFieldData->SetStaticAddress(PTR_TO_CORDB_ADDRESS(dac_cast<TADDR>(base)) + pFD->GetOffset());
                    }
                }
            }
        }
        else
        {
            // instance variables are addressed using an offset within the instance
            if (pCurrentFieldData->OkToGetOrSetInstanceOffset())
            {
                pCurrentFieldData->SetInstanceOffset(pFD->GetOffset());
            }
        }
    }

} // DacDbiInterfaceImpl::ComputeFieldData

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::CollectFields
// Reports per-field FieldData entries for a given type to the supplied callback.
// Arguments:
//     input:  thExact     - used to determine whether we need to get statics base tables
//             thApprox    - used to get the field desc iterator
//             fpCallback  - invoked once per field. Must not throw.
//             pUserData   - opaque user data passed back to the callback.
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::CollectFields(TypeHandle                   thExact,
                                        TypeHandle                   thApprox,
                                        FP_FIELDDATA_CALLBACK        fpCallback,
                                        CALLBACK_DATA                pUserData)
{
    PTR_BYTE pGCStaticsBase = NULL;
    PTR_BYTE pNonGCStaticsBase = NULL;
    if (!thExact.IsNull() && !thExact.GetMethodTable()->Collectible())
    {
        // get base tables for static fields
        GetStaticsBases(thExact, &pGCStaticsBase, &pNonGCStaticsBase);
    }

    // <TODO> we are losing exact type information for static fields in generic types. We have
    // field desc iterators only for approximate types, but statics are per instantiation, so we
    // need an exact type to be able to handle these correctly. We need to use
    // FieldDesc::GetExactDeclaringType to get at the correct field. This requires the exact
    // TypeHandle. </TODO>
    EncApproxFieldDescIterator fdIterator(thApprox.GetMethodTable(),
                                          ApproxFieldDescIterator::ALL_FIELDS); // don't fixup EnC (we can't, we're stopped)

    PTR_FieldDesc pCurrentFD;
    while ((pCurrentFD = fdIterator.Next()) != NULL)
    {
        FieldData currentFieldData;
        ComputeFieldData(pCurrentFD, pGCStaticsBase, pNonGCStaticsBase, &currentFieldData);
        fpCallback(&currentFieldData, pUserData);
    }

} // DacDbiInterfaceImpl::CollectFields


// Determine if a type is a ValueType
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsValueType(VMPTR_TypeHandle th, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        TypeHandle typeHandle = TypeHandle::FromPtr(th.GetDacPtr());
        *pResult = typeHandle.IsValueType();
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Determine if a type has generic parameters
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::HasTypeParams(VMPTR_TypeHandle th, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        TypeHandle typeHandle = TypeHandle::FromPtr(th.GetDacPtr());
        *pResult = typeHandle.ContainsGenericVariables();
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DacDbi API: Enumerate the FieldData entries for a class.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateClassFields(VMPTR_TypeHandle thExact,
                                                                    OUT SIZE_T *pObjectSize,
                                                                    FP_FIELDDATA_CALLBACK fpCallback,
                                                                    CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        TypeHandle  typeHandleExact;
        TypeHandle  thApprox;

        GetTypeHandles(thExact, thExact, &typeHandleExact, &thApprox);

        // For Generic classes you must get the object size via the type handle, which
        // will get you to the right information for the particular instantiation
        // you're working with...
        *pObjectSize = 0;
        if (!thApprox.GetNumGenericArgs())
        {
            *pObjectSize = thApprox.GetMethodTable()->GetNumInstanceFieldBytes();
        }

        CollectFields(typeHandleExact, thApprox, fpCallback, pUserData);
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DacDbi API: Enumerate the FieldData entries for an instantiated generic type
//             and report its instantiation-specific object size.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateInstantiationFields(VMPTR_Assembly vmAssembly,
                                                                            VMPTR_TypeHandle vmThExact,
                                                                            VMPTR_TypeHandle vmThApprox,
                                                                            OUT SIZE_T *pObjectSize,
                                                                            FP_FIELDDATA_CALLBACK fpCallback,
                                                                            CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        TypeHandle  thExact;
        TypeHandle  thApprox;

        GetTypeHandles(vmThExact, vmThApprox, &thExact, &thApprox);

        *pObjectSize = thApprox.GetMethodTable()->GetNumInstanceFieldBytes();

        CollectFields(thExact, thApprox, fpCallback, pUserData);

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//-----------------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk member functions
//-----------------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// TypeDataWalk constructor--initialize the buffer and number of remaining items from input data
// Arguments: pData - pointer to a list of records containing information about type parameters for an
//                    instantiated type
//            nData - number of entries in pData
//-----------------------------------------------------------------------------
DacDbiInterfaceImpl::TypeDataWalk::TypeDataWalk(DebuggerIPCE_TypeArgData * pData, unsigned int nData)
{
    m_pCurrentData = pData;
    m_nRemaining = nData;
} // DacDbiInterfaceImpl::TypeDataWalk::TypeDataWalk

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::ReadOne
// read and return a single node from the list of type parameters
// Arguments: none (uses internal state)
// Return value: information about the next type parameter in m_pCurrentData
//-----------------------------------------------------------------------------
DebuggerIPCE_TypeArgData * DacDbiInterfaceImpl::TypeDataWalk::ReadOne()
{
    LIMITED_METHOD_CONTRACT;
    if (m_nRemaining)
    {
        m_nRemaining--;
        return m_pCurrentData++;
    }
    else
    {
        return NULL;
    }
} // DacDbiInterfaceImpl::TypeDataWalk::ReadOne

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::Skip
// Skip a single node from the list of type handles along with any children it might have
// Arguments: none  (uses internal state)
// Return value: none (updates internal state)
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::TypeDataWalk::Skip()
{
    LIMITED_METHOD_CONTRACT;

    DebuggerIPCE_TypeArgData * pData = ReadOne();
    if (pData)
    {
        for (unsigned int i = 0; i < pData->numTypeArgs; i++)
        {
            Skip();
        }
    }
} // DacDbiInterfaceImpl::TypeDataWalk::Skip

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeArg
// Read a type handle when it is used in the position of a generic argument or
// argument of an array or address type.  Take into account generic code sharing if we
// have been requested to find the canonical representation amongst a set of shared-
// code generic types.  That is, if generics code sharing is enabled then return "Object"
// for all reference types, and canonicalize underneath value types, e.g. V<string> --> V<object>.
// Return TypeHandle() if any of the type handles are not loaded.
//
// Arguments: retrieveWhich - indicates whether to retrieve a canonical representation or
//                            an exact representation
// Return value: the type handle for the type parameter
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeArg(TypeHandleReadType retrieveWhich)
{
    CONTRACTL
    {
        NOTHROW;
        GC_NOTRIGGER;
    }
    CONTRACTL_END;

#if !defined(FEATURE_SHARE_GENERIC_CODE)
    return ReadLoadedTypeHandle(kGetExact);
#else

    if (retrieveWhich == kGetExact)
        return ReadLoadedTypeHandle(kGetExact);

    // This nasty bit of code works out what the "canonicalization" of a
    // parameter to a generic is once we take into account generics code sharing.
    //
    // This logic is somewhat a duplication of logic in vm\typehandle.cpp, though
    // that logic operates on a TypeHandle format, i.e. assumes we're finding the
    // canonical form of a type that has already been loaded.  Here we are finding
    // the canonical form of a type that may not have been loaded (but where we expect
    // its canonical form to have been loaded).
    //
    // Ideally this logic would not be duplicated in this way, but it is difficult
    // to arrange for that.
    DebuggerIPCE_TypeArgData * pData = ReadOne();
    if (!pData)
        return TypeHandle();

    // If we have code sharing then the process of canonicalizing is trickier.
    // unfortunately we have to include the exact specification of compatibility at
    // this point.
    CorElementType elementType = pData->data.elementType;

    switch (elementType)
    {
        case ELEMENT_TYPE_PTR:
            _ASSERTE(pData->numTypeArgs == (UINT)1);
            return PtrOrByRefTypeArg(pData, retrieveWhich);
            break;

        case ELEMENT_TYPE_CLASS:
        case ELEMENT_TYPE_VALUETYPE:
            return ClassTypeArg(pData, retrieveWhich);
            break;

        case ELEMENT_TYPE_FNPTR:
            return FnPtrTypeArg(pData, retrieveWhich);
            break;

        default:
            return ObjRefOrPrimitiveTypeArg(pData, elementType);
            break;
    }

#endif // FEATURE_SHARE_GENERIC_CODE
} // DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeArg

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeHandles
// Iterate through the type argument data, creating type handles as we go.
//
// Arguments:
//     input:  retrieveWhich - indicates whether we can return a canonical type handle
//                             or we must return an exact type handle
//             nTypeArgs     - number of type arguments to be read
//     output: ppResults     - pointer to a list of TypeHandles that will hold the type handles
//                             for each type parameter
//
// Return Value: FALSE iff any of the type handles are not loaded.
//-----------------------------------------------------------------------------
BOOL DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeHandles(TypeHandleReadType retrieveWhich,
                                                              unsigned int       nTypeArgs,
                                                              TypeHandle *       ppResults)
{
    WRAPPER_NO_CONTRACT;

    BOOL allOK = true;
    for (unsigned int i = 0; i < nTypeArgs; i++)
    {
        ppResults[i] = ReadLoadedTypeArg(retrieveWhich);
        allOK &= !ppResults[i].IsNull();
    }
    return allOK;
} // DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeHandles

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedInstantiation
// Read an instantiation of a generic type if it has already been created.
//
// Arguments:
//     input:  retrieveWhich - indicates whether we can return a canonical type handle
//                             or we must return an exact type handle
//             pModule       - module in which the instantiated type is loaded
//             mdToken       - metadata token for the type
//             nTypeArgs     - number of type arguments to be read
// Return value: the type handle for the instantiated type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedInstantiation(TypeHandleReadType retrieveWhich,
                                                                      Module *           pModule,
                                                                      mdTypeDef          mdToken,
                                                                      unsigned int       nTypeArgs)
{
    WRAPPER_NO_CONTRACT;

    NewArrayHolder<TypeHandle> pInst(new TypeHandle[nTypeArgs]);

    // get the type handle for each of the type parameters
    if (!ReadLoadedTypeHandles(retrieveWhich, nTypeArgs, pInst))
    {
        return TypeHandle();
    }

    // get the type handle for the particular instantiation that corresponds to
    // the given type parameters
    return FindLoadedInstantiation(pModule, mdToken, nTypeArgs, pInst);

} // DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedInstantiation


//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeHandle
//
// Compute the type handle for a given type.
// This is the top-level function that will return the type handle  for an
// arbitrary type. It uses mutual recursion with ReadLoadedTypeArg to get
// the type handle for a (possibly parameterized) type. Note that the referent of
// address types or the element type of an array type are viewed as type parameters.
//
// For example, assume that we are retrieving only exact types, and we have as our
// top level type an array defined as int [][].
// We start by noting that the type is an array type, so we call ReadLoadedTypeArg to
// get the element type. We find that the element type is also an array:int [].
// ReadLoadedTypeArg will call ReadLoadedTypeHandle with this type information.
// Again, we determine that the top-level type is an array, so we call ReadLoadedTypeArg
// to get the element type, int. ReadLoadedTypeArg will again call ReadLoadedTypeHandle
// which will find that this time, the top-level type is a primitive type. It will request
// the loaded type handle from the loader and return it. On return, we get the type handle
// for an array of int from the loader. We return again and request the type handle for an
// array of arrays of int. This is the type handle we will return.
//
// Arguments:
//      input: retrieveWhich - determines whether we can return the type handle for
//                             a canonical type or only for an exact type
//             we use the list of type data stored in the TypeDataWalk data members
//             for other input information
// Return value:  type handle for the current type.
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeHandle(TypeHandleReadType retrieveWhich)
{
    CONTRACTL
    {
        NOTHROW;
        GC_NOTRIGGER;
    }
    CONTRACTL_END;

    // get the type information at the head of the list m_pCurrentData
    DebuggerIPCE_TypeArgData * pData = ReadOne();
    if (!pData)
      return TypeHandle();

    // get the type handle that corresponds to its elementType
    TypeHandle typeHandle;
    switch (pData->data.elementType)
    {
        case ELEMENT_TYPE_ARRAY:
        case ELEMENT_TYPE_SZARRAY:
            typeHandle = ArrayTypeArg(pData, retrieveWhich);
            break;

        case ELEMENT_TYPE_PTR:
        case ELEMENT_TYPE_BYREF:
            typeHandle = PtrOrByRefTypeArg(pData, retrieveWhich);
            break;
        case ELEMENT_TYPE_CLASS:
        case ELEMENT_TYPE_VALUETYPE:
            {
                Module * pModule = pData->data.ClassTypeData.vmAssembly.GetDacPtr()->GetModule();
                typeHandle = ReadLoadedInstantiation(retrieveWhich,
                                                     pModule,
                                                     pData->data.ClassTypeData.metadataToken,
                                                     pData->numTypeArgs);
            }
            break;

        case ELEMENT_TYPE_FNPTR:
            {
                typeHandle = FnPtrTypeArg(pData, retrieveWhich);
            }
            break;

    default:
            typeHandle = FindLoadedElementType(pData->data.elementType);
        break;
    }
    return typeHandle;
} // DacDbiInterfaceImpl::TypeDataWalk::ReadLoadedTypeHandle

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::ArrayTypeArg
// get a loaded type handle for an array type (E_T_ARRAY or E_T_SZARRAY)
//
// Arguments:
//     input: pArrayTypeInfo - type information for an array type
//                             Although this is in fact a pointer (in)to a list, we treat it here
//                             simply as a pointer to a single instance of DebuggerIPCE_TypeArgData
//                             which holds type information for an array.
//                             This is the most recent type node (for an array type) retrieved
//                             by TypeDataWalk::ReadOne(). The call to ReadLoadedTypeArg will
//                             result in call(s) to ReadOne to retrieve one or more type nodes
//                             that are needed to compute the type handle for the
//                             element type of the array. When we return from that call, we pass
//                             pArrayTypeInfo along with arrayElementTypeArg to FindLoadedArrayType
//                             to get the type handle for this particular array type.
//                             Note:
//                             On entry, we know that pArrayTypeInfo is the same as m_pCurrentData - 1,
//                             but by the time we need to use it, this is no longer true. Because
//                             we can't predict how many nodes will be consumed by the call to
//                             ReadLoadedTypeArg, we can't compute this value from the member fields
//                             of TypeDataWalk and therefore pass it as a parameter.
//            retrieveWhich -  determines whether we can return the type handle for
//                             a canonical type or only for an exact type
// Return value: the type handle corresponding to the array type
//-----------------------------------------------------------------------------

TypeHandle DacDbiInterfaceImpl::TypeDataWalk::ArrayTypeArg(DebuggerIPCE_TypeArgData * pArrayTypeInfo,
                                                           TypeHandleReadType         retrieveWhich)
{
    TypeHandle arrayElementTypeArg = ReadLoadedTypeArg(retrieveWhich);
    if (!arrayElementTypeArg.IsNull())
    {
        return FindLoadedArrayType(pArrayTypeInfo->data.elementType,
                                   arrayElementTypeArg,
                                   pArrayTypeInfo->data.ArrayTypeData.arrayRank);
    }
    return TypeHandle();
} // DacDbiInterfaceImpl::TypeDataWalk::ArrayTypeArg


//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::PtrOrByRefTypeArg
// get a loaded type handle for an address type (E_T_PTR or E_T_BYREF)
//
// Arguments:
//     input: pPtrOrByRefTypeInfo - type information for a pointer or byref type
//                             Although this is in fact a pointer (in)to a list, we treat it here
//                             simply as a pointer to a single instance of DebuggerIPCE_TypeArgData
//                             which holds type information for a pointer or byref type.
//                             This is the most recent type node (for a pointer or byref type) retrieved
//                             by TypeDataWalk::ReadOne(). The call to ReadLoadedTypeArg will
//                             result in call(s) to ReadOne to retrieve one or more type nodes
//                             that are needed to compute the type handle for the
//                             referent type of the pointer. When we return from that call, we pass
//                             pPtrOrByRefTypeInfo along with referentTypeArg to FindLoadedPointerOrByrefType
//                             to get the type handle for this particular pointer or byref type.
//                             Note:
//                             On entry, we know that pPtrOrByRefTypeInfo is the same as m_pCurrentData - 1,
//                             but by the time we need to use it, this is no longer true. Because
//                             we can't predict how many nodes will be consumed by the call to
//                             ReadLoadedTypeArg, we can't compute this value from the member fields
//                             of TypeDataWalk and therefore pass it as a parameter.
//            retrieveWhich - determines whether we can return the type handle for
//                            a canonical type or only for an exact type
// Return value: the type handle corresponding to the address type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::TypeDataWalk::PtrOrByRefTypeArg(DebuggerIPCE_TypeArgData * pPtrOrByRefTypeInfo,
                                                                TypeHandleReadType         retrieveWhich)
{
    TypeHandle referentTypeArg = ReadLoadedTypeArg(retrieveWhich);
    if (!referentTypeArg.IsNull())
    {
        return FindLoadedPointerOrByrefType(pPtrOrByRefTypeInfo->data.elementType, referentTypeArg);
    }

    return TypeHandle();

} // DacDbiInterfaceImpl::TypeDataWalk::PtrOrByRefTypeArg

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::ClassTypeArg
// get a loaded type handle for a class type (E_T_CLASS or E_T_VALUETYPE)
//
// Arguments:
//     input: pClassTypeInfo - type information for a class type
//                             Although this is in fact a pointer (in)to a list, we treat it here
//                             simply as a pointer to a single instance of DebuggerIPCE_TypeArgData
//                             which holds type information for a pointer or byref type.
//                             This is the most recent type node (for a pointer or byref type) retrieved
//                             by TypeDataWalk::ReadOne(). The call to ReadLoadedInstantiation will
//                             result in call(s) to ReadOne to retrieve one or more type nodes
//                             that are needed to compute the type handle for the type parameters
//                             for the class. If we can't find an exact loaded type for the class, we will
//                             instead return a canonical method table. In this case, we need to skip
//                             the type parameter information for each actual parameter to the class.
//                             This is necessary because we may be getting a type handle for a class which is
//                             in turn an argument to a parent type. If the parent type has more arguments, we
//                             need to be at the right place in the list when we return. We use
//                             pClassTypeInfo to get the number of type arguments that we need to skip.
//            retrieveWhich - determines whether we can return the type handle for
//                            a canonical type or only for an exact type
// Return value: the type handle corresponding to the class type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::TypeDataWalk::ClassTypeArg(DebuggerIPCE_TypeArgData * pClassTypeInfo,
                                                           TypeHandleReadType         retrieveWhich)
{
    Module * pModule = pClassTypeInfo->data.ClassTypeData.vmAssembly.GetDacPtr()->GetModule();
    TypeHandle   typeDef = ClassLoader::LookupTypeDefOrRefInModule(pModule,
                                                                   pClassTypeInfo->data.ClassTypeData.metadataToken);

    if ((!typeDef.IsNull() && typeDef.IsValueType()) || (pClassTypeInfo->data.elementType == ELEMENT_TYPE_VALUETYPE))
    {
        return ReadLoadedInstantiation(retrieveWhich,
                                       pModule,
                                       pClassTypeInfo->data.ClassTypeData.metadataToken,
                                       pClassTypeInfo->numTypeArgs);
    }
    else
    {
        _ASSERTE(retrieveWhich == kGetCanonical);
        // skip the instantiation - no need to look at it since the type canonicalizes to "Object"
        for (unsigned int i = 0; i < pClassTypeInfo->numTypeArgs; i++)
        {
            Skip();
        }
        return TypeHandle(g_pCanonMethodTableClass);
    }
}// DacDbiInterfaceImpl::TypeDataWalk::ClassTypeArg

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::FnPtrTypeArg
// get a loaded type handle for a function pointer type (E_T_FNPTR)
//
// Arguments:
//     input: pFnPtrTypeInfo - type information for a pointer or byref type
//                             Although this is in fact a pointer (in)to a list, we treat it here
//                             simply as a pointer to a single instance of DebuggerIPCE_TypeArgData
//                             which holds type information for a function pointer type.
//                             This is the most recent type node (for a function pointer type) retrieved
//                             by TypeDataWalk::ReadOne(). The call to ReadLoadedTypeHandles will
//                             result in call(s) to ReadOne to retrieve one or more type nodes
//                             that are needed to compute the type handle for the return type and
//                             parameter types of the function. When we return from that call, we pass
//                             pFnPtrTypeInfo along with pInst to FindLoadedFnptrType
//                             to get the type handle for this particular function pointer type.
//            retrieveWhich - determines whether we can return the type handle for
//                            a canonical type or only for an exact type
// Return value: the type handle corresponding to the function pointer type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::TypeDataWalk::FnPtrTypeArg(DebuggerIPCE_TypeArgData * pFnPtrTypeInfo,
                                                           TypeHandleReadType         retrieveWhich)
{
    // allocate space to store a list of type handles, one for the return type and one for each
    // of the parameter types of the function to which the FnPtr type refers.
    NewArrayHolder<TypeHandle> pInst(new TypeHandle[sizeof(TypeHandle) * pFnPtrTypeInfo->numTypeArgs]);

    if (ReadLoadedTypeHandles(retrieveWhich, pFnPtrTypeInfo->numTypeArgs, pInst))
    {
        return FindLoadedFnptrType(pFnPtrTypeInfo->numTypeArgs, pInst);
    }

    return TypeHandle();

} // DacDbiInterfaceImpl::TypeDataWalk::FnPtrTypeArg

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeDataWalk::ObjRefOrPrimitiveTypeArg
// get a loaded type handle for a primitive type or ObjRef
//
// Arguments:
//     input: pArgInfo      - type information for an objref or primitive type.
//                            This is called only when the objref or primitive type
//                            is a type argument for a parent type. In this case,
//                            we treat all objrefs the same, that is, we don't care
//                            about type parameters for the referent. Instead, we will
//                            simply return the canonical object type handle as the type
//                            of the referent. <@dbgtodo Microsoft: why is this?>
//                            If this is a primitive type, we'll simply get the
//                            type handle for that type.
//            elementType   - type of the argument
// Return value: the type handle corresponding to the elementType
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::TypeDataWalk::ObjRefOrPrimitiveTypeArg(DebuggerIPCE_TypeArgData * pArgInfo,
                                                                       CorElementType             elementType)
{
    // If there are any type args (e.g. for arrays) they can be skipped.  The thing
    // is a reference type anyway.
    for (unsigned int i = 0; i < pArgInfo->numTypeArgs; i++)
    {
        Skip();
    }

    // for an ObjRef, just return the CLASS____CANON type handle
    if (CorTypeInfo::IsObjRef_NoThrow(elementType))
    {
        return TypeHandle(g_pCanonMethodTableClass);
    }
    else
    {
        return FindLoadedElementType(elementType);
    }
} // DacDbiInterfaceImpl::TypeDataWalk::ObjRefOrPrimitiveTypeArg


//-------------------------------------------------------------------------
// end of TypeDataWalk implementations
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
// functions to use loader to get type handles
// ------------------------------------------------------------------------

// Note, in these functions, the use of ClassLoader::DontLoadTypes was chosen
// instead of FailIfNotLoaded because, although we may want to debug unrestored
// VCs, we can't do it because the debug API is not set up to handle them.
//
//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::FindLoadedArrayType
// Use ClassLoader to find a loaded type handle for an array type (E_T_ARRAY or E_T_SZARRAY)
// Arguments:
//     input: arrayType - type of the array
//            TypeArg   - type handle for the base type
//            rank      - array rank
// Return Value: type handle for the array type
//-----------------------------------------------------------------------------
// static
TypeHandle DacDbiInterfaceImpl::FindLoadedArrayType(CorElementType arrayType,
                                                    TypeHandle     typeArg,
                                                    unsigned       rank)
{
    // Lookup operations run the class loader in non-load mode.
    ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();

    if (typeArg.IsNull())
    {
        return TypeHandle();
    }
    else
    {
        return ClassLoader::LoadArrayTypeThrowing(typeArg,
                                                  arrayType,
                                                  rank,
                                                  ClassLoader::DontLoadTypes );
    }
} // DacDbiInterfaceImpl::FindLoadedArrayType;

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::FindLoadedPointerOrByrefType
// Use ClassLoader to find a loaded type handle for an address type (E_T_PTR or E_T_BYREF)
// Arguments:
//     input: addressType - type of the address type
//            TypeArg     - type handle for the base type
// Return Value: type handle for the address type
//-----------------------------------------------------------------------------
// static
TypeHandle DacDbiInterfaceImpl::FindLoadedPointerOrByrefType(CorElementType addressType, TypeHandle typeArg)
{
    // Lookup operations run the class loader in non-load mode.
    ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();

    return ClassLoader::LoadPointerOrByrefTypeThrowing(addressType,
                                                       typeArg,
                                                       ClassLoader::DontLoadTypes);
} // DacDbiInterfaceImpl::FindLoadedPointerOrByrefType

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::FindLoadedFnptrType
// Use ClassLoader to find a loaded type handle for a function pointer type (E_T_FNPTR)
// Arguments:
//     input: pInst       - type handles of the function's return value and arguments
//            numTypeArgs - number of type handles in pInst
// Return Value: type handle for the function pointer type
//-----------------------------------------------------------------------------
// static
TypeHandle DacDbiInterfaceImpl::FindLoadedFnptrType(DWORD numTypeArgs, TypeHandle * pInst)
{
    // Lookup operations run the class loader in non-load mode.
    ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();

    // @dbgtodo : Do we need to worry about calling convention here?
    // LoadFnptrTypeThrowing expects the count of arguments, not
    // including return value, so we subtract 1 from numTypeArgs.
    return  ClassLoader::LoadFnptrTypeThrowing(0,
                                               numTypeArgs - 1,
                                               pInst,
                                               ClassLoader::DontLoadTypes);
} // DacDbiInterfaceImpl::FindLoadedFnptrType

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::FindLoadedInstantiation
// Use ClassLoader to find a loaded type handle for a particular instantiation of a
// class type (E_T_CLASS or E_T_VALUECLASS)
//
// Arguments:
//     input: pModule   - module in which the type is loaded
//            mdToken   - metadata token for the type
//            nTypeArgs - number of type arguments in pInst
//            pInst     - list of type handles for the type parameters
// Return value: type handle for the instantiated class type
//-----------------------------------------------------------------------------
// static
TypeHandle DacDbiInterfaceImpl::FindLoadedInstantiation(Module *     pModule,
                                                        mdTypeDef    mdToken,
                                                        DWORD        nTypeArgs,
                                                        TypeHandle * pInst)
{
    // Lookup operations run the class loader in non-load mode.
    ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();

    return ClassLoader::LoadGenericInstantiationThrowing(pModule,
                                                         mdToken,
                                                         Instantiation(pInst,nTypeArgs),
                                                         ClassLoader::DontLoadTypes);

} // DacDbiInterfaceImpl::FindLoadedInstantiation

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::FindLoadedElementType
// Get the type handle for a primitive type
// Arguments:
//     input: elementType - type of the primitive type
// Return Value: Type handle for the primitive type
//-----------------------------------------------------------------------------
// static
TypeHandle DacDbiInterfaceImpl::FindLoadedElementType(CorElementType elementType)
{
    // Lookup operations run the class loader in non-load mode.
    ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();

    MethodTable * pMethodTable = (&g_CoreLib)->GetElementType(elementType);

    return TypeHandle(pMethodTable);
} // DacDbiInterfaceImpl::FindLoadedElementType


//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetArrayTypeInfo
// Gets additional information to convert a type handle to an instance of CordbType if the type is E_T_ARRAY.
// Specifically, we get the rank and the type of the array elements
//
// Arguments:
//     input:  typeHandle - type handle for the array type
//     output: pTypeInfo  - information for the array rank and element type
//
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::GetArrayTypeInfo(TypeHandle                      typeHandle,
                                           DebuggerIPCE_ExpandedTypeData * pTypeInfo)
{
    _ASSERTE(typeHandle.IsArray());
    pTypeInfo->ArrayTypeData.arrayRank = typeHandle.GetRank();
    TypeHandleToBasicTypeInfo(typeHandle.GetArrayElementTypeHandle(),
                              &(pTypeInfo->ArrayTypeData.arrayTypeArg));
} // DacDbiInterfaceImpl::GetArrayTypeInfo

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetPtrTypeInfo
// Gets additional information to convert a type handle to an instance of CordbType if the type is
// E_T_PTR or E_T_BYREF. Specifically, we get the type for the referent of the address type
//
// Arguments:
//     input:  boxed      - indicates what, if anything, is boxed (see code:AreValueTypesBoxed for
//                          more specific information)
//             typeHandle - type handle for the address type
//     output: pTypeInfo  - information for the referent type
//
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::GetPtrTypeInfo(AreValueTypesBoxed              boxed,
                                         TypeHandle                      typeHandle,
                                         DebuggerIPCE_ExpandedTypeData * pTypeInfo)
{
    if (boxed == AllBoxed)
    {
        GetClassTypeInfo(typeHandle, pTypeInfo);
    }
    else
    {
        _ASSERTE(typeHandle.IsTypeDesc());
        TypeHandleToBasicTypeInfo(typeHandle.AsTypeDesc()->GetTypeParam(),
                                  &(pTypeInfo->UnaryTypeData.unaryTypeArg));
    }
} // DacDbiInterfaceImpl::GetPtrTypeInfo

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetFnPtrTypeInfo
// Gets additional information to convert a type handle to an instance of CordbType if the type is
// E_T_FNPTR, specifically the typehandle for the referent.
//
// Arguments
//     input:  boxed      - indicates what, if anything, is boxed (see code:AreValueTypesBoxed for
//                          more specific information)
//             typeHandle - type handle for the address type
//     output: pTypeInfo  - information for the referent type
//
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::GetFnPtrTypeInfo(AreValueTypesBoxed              boxed,
                                           TypeHandle                      typeHandle,
                                           DebuggerIPCE_ExpandedTypeData * pTypeInfo)
{
    if (boxed == AllBoxed)
    {
        GetClassTypeInfo(typeHandle, pTypeInfo);
    }
    else
    {
        pTypeInfo->NaryTypeData.typeHandle.SetDacTargetPtr(typeHandle.AsTAddr());
    }
} // DacDbiInterfaceImpl::GetFnPtrTypeInfo


//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetClassTypeInfo
// Gets additional information to convert a type handle to an instance of CordbType if the type is
// E_T_CLASS or E_T_VALUETYPE
//
// Arguments
//     input:  typeHandle - type handle for the address type
//     output: pTypeInfo  - information for the referent type
//
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::GetClassTypeInfo(TypeHandle                      typeHandle,
                                           DebuggerIPCE_ExpandedTypeData * pTypeInfo)
{
    typeHandle = typeHandle.UpCastTypeIfNeeded();
    Module * pModule = typeHandle.GetModule();

    if (typeHandle.HasInstantiation()) // the type handle represents a generic instantiation
    {
        pTypeInfo->ClassTypeData.typeHandle.SetDacTargetPtr(typeHandle.AsTAddr());
    }
    else // non-generic
    {
        pTypeInfo->ClassTypeData.typeHandle = VMPTR_TypeHandle::NullPtr();
    }

    pTypeInfo->ClassTypeData.metadataToken = typeHandle.GetCl();

    _ASSERTE(pModule);
    pTypeInfo->ClassTypeData.vmAssembly.SetDacTargetPtr(PTR_HOST_TO_TADDR(pModule->GetAssembly()));
} // DacDbiInterfaceImpl::GetClassTypeInfo

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetElementType
// Gets the correct CorElementType value from a type handle
//
// Arguments
//     input:  typeHandle - type handle for the address type
// Return Value: the CorElementType enum value for the type handle
//-----------------------------------------------------------------------------
CorElementType DacDbiInterfaceImpl::GetElementType (TypeHandle typeHandle)
{
    if (typeHandle.IsNull())
    {
        return ELEMENT_TYPE_VOID;
    }
    else if (typeHandle.GetMethodTable() == g_pObjectClass)
    {
       return ELEMENT_TYPE_OBJECT;
    }
    else if (typeHandle.GetMethodTable() == g_pStringClass)
    {
        return ELEMENT_TYPE_STRING;
    }
    else
    {
        // GetSignatureCorElementType returns E_T_CLASS for E_T_STRING... :-(
        return typeHandle.GetSignatureCorElementType();
    }

} // DacDbiInterfaceImpl::GetElementType

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::TypeHandleToBasicTypeInfo
// Gets additional information to convert a type handle to an instance of CordbType for the referent of an
// E_T_BYREF or E_T_PTR or for the element type of an E_T_ARRAY or E_T_SZARRAY
//
// Arguments:
//     input:  typeHandle - type handle for the address type
//     output: pTypeInfo  - information for the referent type
//
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::TypeHandleToBasicTypeInfo(TypeHandle                   typeHandle,
                                                    DebuggerIPCE_BasicTypeData * pTypeInfo)
{
    pTypeInfo->elementType = GetElementType(typeHandle);

    switch (pTypeInfo->elementType)
    {
        case ELEMENT_TYPE_ARRAY:
        case ELEMENT_TYPE_SZARRAY:
        case ELEMENT_TYPE_FNPTR:
        case ELEMENT_TYPE_PTR:
        case ELEMENT_TYPE_BYREF:
            pTypeInfo->vmTypeHandle.SetDacTargetPtr(typeHandle.AsTAddr());
            pTypeInfo->metadataToken = mdTokenNil;
            pTypeInfo->vmAssembly = VMPTR_Assembly::NullPtr();
            break;

        case ELEMENT_TYPE_CLASS:
        case ELEMENT_TYPE_VALUETYPE:
        {
            typeHandle = typeHandle.UpCastTypeIfNeeded();

            Module * pModule = typeHandle.GetModule();
            if (typeHandle.HasInstantiation()) // only set if instantiated
            {
                pTypeInfo->vmTypeHandle.SetDacTargetPtr(typeHandle.AsTAddr());
            }
            else
            {
                pTypeInfo->vmTypeHandle = VMPTR_TypeHandle::NullPtr();
            }

            pTypeInfo->metadataToken = typeHandle.GetCl();
            _ASSERTE(pModule);
            pTypeInfo->vmAssembly.SetDacTargetPtr(PTR_HOST_TO_TADDR(pModule->GetAssembly()));
            break;
        }

        default:
            pTypeInfo->vmTypeHandle = VMPTR_TypeHandle::NullPtr();
            pTypeInfo->metadataToken = mdTokenNil;
            pTypeInfo->vmAssembly = VMPTR_Assembly::NullPtr();
            break;
    }
    return;
} // DacDbiInterfaceImpl::TypeHandleToBasicTypeInfo


HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetObjectExpandedTypeInfo(AreValueTypesBoxed boxed, CORDB_ADDRESS addr, OUT DebuggerIPCE_ExpandedTypeData * pTypeInfo)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        PTR_Object obj(TO_TADDR(addr));
        TypeHandleToExpandedTypeInfoImpl(boxed, obj->GetGCSafeTypeHandle(), pTypeInfo);
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DacDbi API: use a type handle to get the information needed to create the corresponding RS CordbType instance
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::TypeHandleToExpandedTypeInfo(AreValueTypesBoxed boxed, CORDB_ADDRESS vmTypeHandle, DebuggerIPCE_ExpandedTypeData * pTypeInfo)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        TypeHandle typeHandle = TypeHandle::FromPtr((TADDR)vmTypeHandle);
        TypeHandleToExpandedTypeInfoImpl(boxed, typeHandle, pTypeInfo);
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


void DacDbiInterfaceImpl::TypeHandleToExpandedTypeInfoImpl(AreValueTypesBoxed              boxed,
                                                        TypeHandle                      typeHandle,
                                                        DebuggerIPCE_ExpandedTypeData * pTypeInfo)
{
    *pTypeInfo = {};
    pTypeInfo->elementType = GetElementType(typeHandle);

    switch (pTypeInfo->elementType)
    {
        case ELEMENT_TYPE_ARRAY:
        case ELEMENT_TYPE_SZARRAY:
            GetArrayTypeInfo(typeHandle, pTypeInfo);
            break;

        case ELEMENT_TYPE_PTR:
        case ELEMENT_TYPE_BYREF:
            GetPtrTypeInfo(boxed, typeHandle, pTypeInfo);
            break;

        case ELEMENT_TYPE_VALUETYPE:
            if (boxed == OnlyPrimitivesUnboxed || boxed == AllBoxed)
            {
                pTypeInfo->elementType = ELEMENT_TYPE_CLASS;
            }
            GetClassTypeInfo(typeHandle, pTypeInfo);
            break;

        case ELEMENT_TYPE_CLASS:
            GetClassTypeInfo(typeHandle, pTypeInfo);
            break;

        case ELEMENT_TYPE_FNPTR:
            GetFnPtrTypeInfo(boxed, typeHandle, pTypeInfo);
            break;
        default:
            if (boxed == AllBoxed)
            {
                pTypeInfo->elementType = ELEMENT_TYPE_CLASS;
                GetClassTypeInfo(typeHandle, pTypeInfo);
            }
            // else the element type is sufficient
            break;
    }
    LOG((LF_CORDB, LL_INFO10000, "D::THTETI: converted left-side type handle to expanded right-side type info, pTypeInfo->ClassTypeData.typeHandle = 0x%08x.\n", pTypeInfo->ClassTypeData.typeHandle.GetRawPtr()));
    return;
} // DacDbiInterfaceImpl::TypeHandleToExpandedTypeInfo

// Get type handle for a TypeDef token, if one exists. For generics this returns the open type.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetTypeHandle(VMPTR_Module vmModule, mdTypeDef metadataToken, OUT VMPTR_TypeHandle * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        Module* pModule = vmModule.GetDacPtr();
        VMPTR_TypeHandle vmTypeHandle = VMPTR_TypeHandle::NullPtr();

        TypeHandle th = ClassLoader::LookupTypeDefOrRefInModule(pModule, metadataToken);
        if (th.IsNull())
        {
            LOG((LF_CORDB, LL_INFO10000, "D::GTH: class isn't loaded.\n"));
            ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
        }

        vmTypeHandle.SetDacTargetPtr(th.AsTAddr());
        *pRetVal = vmTypeHandle;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DacDbi API: GetAndSendApproxTypeHandle finds the type handle for the layout of the instance fields of an
// instantiated type if it is available.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetApproxTypeHandle(TypeInfoList * pTypeData, OUT VMPTR_TypeHandle * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        LOG((LF_CORDB, LL_INFO10000, "D::GATH: getting info.\n"));


        TypeDataWalk walk(&((*pTypeData)[0]), pTypeData->Count());
        TypeHandle typeHandle = walk.ReadLoadedTypeHandle(TypeDataWalk::kGetCanonical);
        VMPTR_TypeHandle vmTypeHandle = VMPTR_TypeHandle::NullPtr();

        vmTypeHandle.SetDacTargetPtr(typeHandle.AsTAddr());
        if (!typeHandle.IsNull())
        {
            vmTypeHandle.SetDacTargetPtr(typeHandle.AsTAddr());
        }
        else
        {
            ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
        }

        LOG((LF_CORDB, LL_INFO10000,
            "D::GATH: sending result, result = 0x%0x8\n",
            typeHandle));
        *pRetVal = vmTypeHandle;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DacDbiInterface API: Get the exact type handle from type data
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetExactTypeHandle(DebuggerIPCE_ExpandedTypeData * pTypeData,
                                                ArgInfoList *   pArgInfo,
                                                VMPTR_TypeHandle * pVmTypeHandle)
{
    if (pVmTypeHandle == NULL)
        return E_POINTER;

    DD_ENTER_MAY_THROW;

    LOG((LF_CORDB, LL_INFO10000, "D::GETH: getting info.\n"));

    HRESULT hr = S_OK;

    EX_TRY
    {
        *pVmTypeHandle = VMPTR_TypeHandle::NullPtr();

        // convert the type information to a type handle
        TypeHandle typeHandle = ExpandedTypeInfoToTypeHandle(pTypeData, pArgInfo);
        _ASSERTE(!typeHandle.IsNull());
        pVmTypeHandle->SetDacTargetPtr(typeHandle.AsTAddr());
    }
    EX_CATCH_HRESULT(hr);

    return hr;
} // DacDbiInterfaceImpl::GetExactTypeHandle

// Retrieve the generic type params for a given MethodDesc.  This function is specifically
// for stackwalking because it requires the generic type token on the stack.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateMethodDescParams(VMPTR_MethodDesc vmMethodDesc, GENERICS_TYPE_TOKEN genericsToken, OUT UINT32 * pcGenericClassTypeParams, FP_TYPEPARAM_CALLBACK fpCallback, CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if (vmMethodDesc.IsNull())
        {
            ThrowHR(E_INVALIDARG);
        }

        _ASSERTE((pcGenericClassTypeParams != NULL) && (fpCallback != NULL));

        MethodDesc * pMD = vmMethodDesc.GetDacPtr();

        // Retrieve the number of type parameters for the class and
        // the number of type parameters for the method itself.
        // For example, the method Foo<T, U>::Bar<V>() has 2 class type parameters and 1 method type parameters.
        UINT32 cGenericClassTypeParams  = pMD->GetNumGenericClassArgs();
        UINT32 cGenericMethodTypeParams = pMD->GetNumGenericMethodArgs();
        UINT32 cTotalGenericTypeParams  = cGenericClassTypeParams + cGenericMethodTypeParams;

        // Set the out parameter.
        *pcGenericClassTypeParams = cGenericClassTypeParams;

        TypeHandle   thSpecificClass;
        MethodDesc * pSpecificMethod = NULL;

        // Try to retrieve a more specific MethodDesc and TypeHandle via the generics type token.
        // The generics token is not always guaranteed to be available.
        // For example, it may be unavailable in prologs and epilogs.
        // In dumps, not available can also mean a thrown exception for missing memory.
        BOOL fExact = FALSE;
        ALLOW_DATATARGET_MISSING_MEMORY(
            fExact = Generics::GetExactInstantiationsOfMethodAndItsClassFromCallInformation(
                pMD,
                PTR_VOID((TADDR)genericsToken),
                &thSpecificClass,
                &pSpecificMethod);
                );
        if (!fExact ||
            !thSpecificClass.GetMethodTable()->SanityCheck() ||
            !pSpecificMethod->GetMethodTable()->SanityCheck())
        {
            // Use the canonical MethodTable and MethodDesc if the exact generics token is not available.
            thSpecificClass = TypeHandle(pMD->GetMethodTable());
            pSpecificMethod = pMD;
        }

        // Retrieve the array of class type parameters and the array of method type parameters.
        Instantiation classInst  = pSpecificMethod->GetExactClassInstantiation(thSpecificClass);
        Instantiation methodInst = pSpecificMethod->GetMethodInstantiation();

        _ASSERTE((classInst.IsEmpty())  == (cGenericClassTypeParams  == 0));
        _ASSERTE((methodInst.IsEmpty()) == (cGenericMethodTypeParams == 0));

        for (UINT32 i = 0; i < cTotalGenericTypeParams; i++)
        {
            // Retrieve the current type parameter depending on the index.
            TypeHandle thCurrent;
            if (i < cGenericClassTypeParams)
            {
                thCurrent = classInst[i];
            }
            else
            {
                thCurrent = methodInst[i - cGenericClassTypeParams];
            }

            DebuggerIPCE_ExpandedTypeData entry;

            // There is the possibility that we'll get this far with a dump and not fail, but still
            // not be able to get full info for a particular param.
            EX_TRY_ALLOW_DATATARGET_MISSING_MEMORY_WITH_HANDLER
            {
                // Fill in the struct using the TypeHandle of the current type parameter if we can.
                IfFailThrow(TypeHandleToExpandedTypeInfo(NoValueTypeBoxing,
                                                         (CORDB_ADDRESS)thCurrent.AsTAddr(),
                                                         &entry));
            }
            EX_CATCH_ALLOW_DATATARGET_MISSING_MEMORY_WITH_HANDLER
            {
                // On failure for a particular type, default it back to System.__Canon.
                TypeHandle thCanon = TypeHandle(g_pCanonMethodTableClass);
                IfFailThrow(TypeHandleToExpandedTypeInfo(NoValueTypeBoxing,
                                                         (CORDB_ADDRESS)thCanon.AsTAddr(),
                                                         &entry));
            }
            EX_END_CATCH_ALLOW_DATATARGET_MISSING_MEMORY_WITH_HANDLER

            fpCallback(&entry, pUserData);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetClassOrValueTypeHandle
// get a typehandle for a class or valuetype from basic type data (metadata token
// and assembly).
// Arguments:
//     input: pData - contains the metadata token and assembly
// Return value: the type handle for the corresponding type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::GetClassOrValueTypeHandle(DebuggerIPCE_BasicTypeData * pData)
{
    TypeHandle typeHandle;

    // if we already have a type handle, just return it
    if (!pData->vmTypeHandle.IsNull())
    {
        typeHandle = TypeHandle::FromPtr(pData->vmTypeHandle.GetDacPtr());
    }
    // otherwise, have the loader look it up using the metadata token and assembly
    else
    {
        Assembly * pAssembly = pData->vmAssembly.GetDacPtr();
        Module *   pModule   = pAssembly->GetModule();

        typeHandle = ClassLoader::LookupTypeDefOrRefInModule(pModule, pData->metadataToken);
        if (typeHandle.IsNull())
        {
            LOG((LF_CORDB, LL_INFO10000, "D::BTITTH: class isn't loaded.\n"));
            ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
        }

        _ASSERTE(typeHandle.GetNumGenericArgs() == 0);
    }

    return typeHandle;

} // DacDbiInterfaceImpl::GetClassOrValueTypeHandle

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetExactArrayTypeHandle
// get an exact type handle for an array type
// Arguments:
//     input: pTopLevelTypeData - type information for a top-level array type
//            pArgInfo           - contains the following information:
//                 m_genericArgsCount  - number of generic parameters for the element type--this should be 1
//                 m_pGenericArgs      - pointer to the generic parameter for the element type--this is
//                                       effectively a one-element list. These are the actual parameters
// Return Value: the exact type handle for the type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::GetExactArrayTypeHandle(DebuggerIPCE_ExpandedTypeData * pTopLevelTypeData,
                                                        ArgInfoList *                   pArgInfo)
{
    TypeHandle typeArg;

    _ASSERTE(pArgInfo->Count() == 1);

    // get the type handle for the element type
    typeArg = BasicTypeInfoToTypeHandle(&((*pArgInfo)[0]));

    // get the exact type handle for the array type
    return FindLoadedArrayType(pTopLevelTypeData->elementType,
                               typeArg,
                               pTopLevelTypeData->ArrayTypeData.arrayRank);

} // DacDbiInterfaceImpl::GetExactArrayTypeHandle

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetExactPtrOrByRefTypeHandle
// get an exact type handle for a PTR or BYREF type
// Arguments:
//     input: pTopLevelTypeData - type information for the PTR or BYREF type
//            pArgInfo           - contains the following information:
//                 m_genericArgsCount  - number of generic parameters for the element type--this should be 1
//                 m_pGenericArgs      - pointer to the generic parameter for the element type--this is
//                                       effectively a one-element list. These are the actual parameters
// Return Value: the exact type handle for the type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::GetExactPtrOrByRefTypeHandle(DebuggerIPCE_ExpandedTypeData * pTopLevelTypeData,
                                                             ArgInfoList *                   pArgInfo)
{
    TypeHandle typeArg;
    _ASSERTE(pArgInfo->Count() == 1);

    // get the type handle for the referent
    typeArg = BasicTypeInfoToTypeHandle(&((*pArgInfo)[0]));

    // get the exact type handle for the PTR or BYREF type
    return FindLoadedPointerOrByrefType(pTopLevelTypeData->elementType, typeArg);

} // DacDbiInterfaceImpl::GetExactPtrOrByRefTypeHandle

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetExactClassTypeHandle
// get an exact type handle for a CLASS or VALUETYPE type
// Arguments:
//     input: pTopLevelTypeData - type information for the CLASS or VALUETYPE type
//            pArgInfo           - contains the following information:
//                 m_genericArgsCount  - number of generic parameters for the class
//                 m_pGenericArgs      - list of generic parameters for the class--these
//                                       are the actual parameters
// Return Value: the exact type handle for the type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::GetExactClassTypeHandle(DebuggerIPCE_ExpandedTypeData * pTopLevelTypeData,
                                                        ArgInfoList *                   pArgInfo)
{
    Module * pModule = pTopLevelTypeData->ClassTypeData.vmAssembly.GetDacPtr()->GetModule();
    int          argCount = pArgInfo->Count();

    TypeHandle typeConstructor =
        ClassLoader::LookupTypeDefOrRefInModule(pModule, pTopLevelTypeData->ClassTypeData.metadataToken);

    // If we can't find the class, throw the appropriate HR.
    if (typeConstructor.IsNull())
    {
        LOG((LF_CORDB, LL_INFO10000, "D::ETITTH: class isn't loaded.\n"));
        ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
    }

    // if there are no generic parameters, we already have the correct type handle
    if (argCount == 0)
    {
        return typeConstructor;
    }

    // we have generic parameters--first validate we have a number consistent with the list
    // of parameters we received
    if ((unsigned int)argCount != typeConstructor.GetNumGenericArgs())
    {
        LOG((LF_CORDB, LL_INFO10000,
            "D::ETITTH: wrong number of type parameters, %d given, %d expected\n",
            argCount, typeConstructor.GetNumGenericArgs()));
        _ASSERTE((unsigned int)argCount == typeConstructor.GetNumGenericArgs());
        ThrowHR(E_FAIL);
    }

    // now we allocate a list to store the type handles for each parameter
    S_UINT32 allocSize = S_UINT32(argCount) * S_UINT32(sizeof(TypeHandle));
    if (allocSize.IsOverflow())
    {
        ThrowHR(E_OUTOFMEMORY);
    }

    NewArrayHolder<TypeHandle> pInst(new TypeHandle[allocSize.Value()]);

    // convert the type information for each parameter to its corresponding type handle
    // and store it in the list
    for (unsigned int i = 0; i < (unsigned int)argCount; i++)
    {
        pInst[i] = BasicTypeInfoToTypeHandle(&((*pArgInfo)[i]));
    }

    // Finally, we find the type handle corresponding to this particular instantiation
    return FindLoadedInstantiation(typeConstructor.GetModule(),
                                   typeConstructor.GetCl(),
                                   argCount,
                                   pInst);

} // DacDbiInterfaceImpl::GetExactClassTypeHandle

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetExactFnPtrTypeHandle
// get an exact type handle for a FNPTR type
// Arguments:
//     input: pArgInfo - Contains the following information:
//                 m_genericArgsCount  - number of generic parameters for the referent
//                 m_pGenericArgs      - list of generic parameters for the referent--these
//                                       are the actual parameters for the function signature
// Return Value: the exact type handle for the type
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::GetExactFnPtrTypeHandle(ArgInfoList * pArgInfo)
{
    // allocate a list to store the type handles for each parameter
    S_UINT32 allocSize = S_UINT32(pArgInfo->Count()) * S_UINT32(sizeof(TypeHandle));
    if( allocSize.IsOverflow() )
    {
        ThrowHR(E_OUTOFMEMORY);
    }
    NewArrayHolder<TypeHandle> pInst(new TypeHandle[allocSize.Value()]);

    // convert the type information for each parameter to its corresponding type handle
    // and store it in the list
    for (unsigned int i = 0; i < pArgInfo->Count(); i++)
    {
        pInst[i] = BasicTypeInfoToTypeHandle(&((*pArgInfo)[i]));
    }

    // find the type handle corresponding to this particular FNPTR
    return FindLoadedFnptrType(pArgInfo->Count(), pInst);
} // DacDbiInterfaceImpl::GetExactFnPtrTypeHandle

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::BasicTypeInfoToTypeHandle
// Convert basic type info for a type parameter that came from a top-level type to
// the corresponding type handle. If the type parameter is an array or pointer
// type, we simply extract the LS type handle from the VMPTR_TypeHandle that is
// part of the type information. If the type parameter is a class or value type,
// we use the metadata token and assembly in the type info to look up the
// appropriate type handle. If the type parameter is any other types, we get the
// type handle by having the loader look up the type handle for the element type.
// Arguments:
//     input: pArgTypeData - basic type information for the type.
// Return Value: the type handle for the type.
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::BasicTypeInfoToTypeHandle(DebuggerIPCE_BasicTypeData * pArgTypeData)
{
    LOG((LF_CORDB, LL_INFO10000,
        "D::BTITTH: expanding basic right-side type to left-side type, ELEMENT_TYPE: %d.\n",
        pArgTypeData->elementType));
    TypeHandle typeHandle = TypeHandle();

    switch (pArgTypeData->elementType)
    {
        case ELEMENT_TYPE_ARRAY:
        case ELEMENT_TYPE_SZARRAY:
        case ELEMENT_TYPE_PTR:
        case ELEMENT_TYPE_BYREF:
        case ELEMENT_TYPE_FNPTR:
            _ASSERTE(!pArgTypeData->vmTypeHandle.IsNull());
            typeHandle = TypeHandle::FromPtr(pArgTypeData->vmTypeHandle.GetDacPtr());
            break;

        case ELEMENT_TYPE_CLASS:
        case ELEMENT_TYPE_VALUETYPE:
            typeHandle = GetClassOrValueTypeHandle(pArgTypeData);
            break;

        default:
            typeHandle = FindLoadedElementType(pArgTypeData->elementType);
            break;
    }
    if (typeHandle.IsNull())
    {
        ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
    }
    return typeHandle;
} // DacDbiInterfaceImpl::BasicTypeInfoToTypeHandle


//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::ExpandedTypeInfoToTypeHandle
// Convert type information for a top-level type to an exact type handle. This
// information includes information about the element type if the top-level type is
// an array type, the referent if the top-level type is a pointer type, or actual
// parameters if the top-level type is a generic class or value type.
// Arguments:
//     input: pTopLevelTypeData - type information for the top-level type
//            pArgInfo           - contains the following information:
//                 m_genericArtsCount  - number of parameters
//                 m_pGenericArgs      - list of actual parameters
// Return Value: the exact type handle corresponding to the type represented by
//            pTopLevelTypeData
//-----------------------------------------------------------------------------
TypeHandle DacDbiInterfaceImpl::ExpandedTypeInfoToTypeHandle(DebuggerIPCE_ExpandedTypeData * pTopLevelTypeData,
                                                             ArgInfoList *                   pArgInfo)
{
    WRAPPER_NO_CONTRACT;

    LOG((LF_CORDB, LL_INFO10000,
        "D::ETITTH: expanding right-side type to left-side type, ELEMENT_TYPE: %d.\n",
        pData->elementType));

    TypeHandle typeHandle = TypeHandle();
    // depending on the top-level type, get the type handle incorporating information about any type arguments
    switch (pTopLevelTypeData->elementType)
    {
        case ELEMENT_TYPE_ARRAY:
        case ELEMENT_TYPE_SZARRAY:
            typeHandle = GetExactArrayTypeHandle(pTopLevelTypeData, pArgInfo);
            break;

        case ELEMENT_TYPE_PTR:
        case ELEMENT_TYPE_BYREF:
            typeHandle = GetExactPtrOrByRefTypeHandle(pTopLevelTypeData, pArgInfo);
            break;

        case ELEMENT_TYPE_CLASS:
        case ELEMENT_TYPE_VALUETYPE:
            typeHandle = GetExactClassTypeHandle(pTopLevelTypeData, pArgInfo);
            break;
        case ELEMENT_TYPE_FNPTR:
            typeHandle = GetExactFnPtrTypeHandle(pArgInfo);
            break;
        default:
            typeHandle = FindLoadedElementType(pTopLevelTypeData->elementType);
            break;
    } // end switch (pData->elementType)

    if (typeHandle.IsNull())
    {
        // This may fail because there are cases when a type can be used (and so visible to the
        // debugger), but not yet loaded to the point of being available in the EETypeHashTable.
        // For example, generic value types (without explicit constructors) may not need their
        // exact instantiation type to be loaded in order to be used as a field of an object
        // created on the heap
        LOG((LF_CORDB, LL_INFO10000, "D::ETITTH: type isn't loaded.\n"));
        ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
    }
    return typeHandle;
} // DacDbiInterfaceImpl::ExpandedTypeInfoToTypeHandle

// ----------------------------------------------------------------------------
// DacDbi API: GetThreadStaticAddress
// Get the target field address of a thread local static.
//
// Notes:
// The address is constant and could be cached.
//
// This can commonly fail, in which case, it will return NULL.
// ----------------------------------------------------------------------------
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetThreadStaticAddress(VMPTR_FieldDesc vmField, VMPTR_Thread vmRuntimeThread, OUT CORDB_ADDRESS * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pRuntimeThread = vmRuntimeThread.GetDacPtr();
        PTR_FieldDesc pFieldDesc = vmField.GetDacPtr();
        TADDR fieldAddress = (TADDR)NULL;

        _ASSERTE(pRuntimeThread != NULL);

        // Find out whether the field is thread local and get its address.
        if (pFieldDesc->IsThreadStatic())
        {
            fieldAddress = pRuntimeThread->GetStaticFieldAddrNoCreate(pFieldDesc);
        }
        else
        {
            // In case we have more special cases added later, this will allow us to notice the need to
            // update this function.
            ThrowHR(E_NOTIMPL);
        }
        *pRetVal = fieldAddress;

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

    // Get the target field address of a collectible types static.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetCollectibleTypeStaticAddress(VMPTR_FieldDesc vmField, OUT CORDB_ADDRESS * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        PTR_FieldDesc pFieldDesc = vmField.GetDacPtr();

        //
        // Verify this field is of the right type
        //
        if(!pFieldDesc->IsStatic() ||
           pFieldDesc->IsSpecialStatic())
        {
            _ASSERTE(!"BUG: Unsupported static field type for collectible types");
        }

        //
        // Check that the data is available
        //
        /* TODO: Ideally we should be checking if the class is allocated first, however
                 we don't appear to be doing this even for non-collectible statics and
                 we have never seen an issue.
        */

        //
        // Get the address
        //
        PTR_VOID base = pFieldDesc->GetBase();
        if (base == PTR_NULL)
        {
            *pRetVal = PTR_HOST_TO_TADDR(NULL);
        }
        else
        {
            //
            // Store the result and return
            //
            PTR_VOID addr = pFieldDesc->GetStaticAddressHandle(base);
            *pRetVal = PTR_TO_TADDR(addr);
        }

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DacDbi API: EnumerateTypeHandleParams
// - gets the necessary data for a type handle, i.e. its type parameters, e.g. "String" and "List<int>" from the type handle
//   for "Dict<String,List<int>>", and sends it back to the right side via the callback.
// - This should not fail except for OOM
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateTypeHandleParams(VMPTR_TypeHandle vmTypeHandle, FP_TYPEPARAM_CALLBACK fpCallback, CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW

    HRESULT hr = S_OK;
    EX_TRY
    {
        _ASSERTE(fpCallback != NULL);

        TypeHandle typeHandle = TypeHandle::FromPtr(vmTypeHandle.GetDacPtr());
        LOG((LF_CORDB, LL_INFO10000, "D::ETHP: enumerating type parameters for 0x%p.\n", typeHandle.AsPtr()));

        unsigned int count = typeHandle.GetNumGenericArgs();
        Instantiation inst = typeHandle.GetInstantiation();

        for (unsigned int i = 0; i < count; ++i)
        {
            DebuggerIPCE_ExpandedTypeData entry;
            IfFailThrow(TypeHandleToExpandedTypeInfo(NoValueTypeBoxing,
                                                     (CORDB_ADDRESS)inst[i].AsTAddr(),
                                                     &entry));
            fpCallback(&entry, pUserData);
        }

        LOG((LF_CORDB, LL_INFO10000, "D::ETHP: sending result"));
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//-----------------------------------------------------------------------------
// DacDbi API: GetSimpleType
// gets the metadata token and assembly corresponding to a simple type
//-----------------------------------------------------------------------------
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetSimpleType(CorElementType simpleType, OUT mdTypeDef * pMetadataToken, OUT VMPTR_Module * pVmModule)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        // if we fail to get either a valid type handle or module, we will want to send back
        // a NULL module too, so we'll to preinitialize this here.
        _ASSERTE(pVmModule != NULL);
        *pVmModule = VMPTR_Module::NullPtr();
        // FindLoadedElementType will return NULL if the type hasn't been loaded yet.
        TypeHandle typeHandle =  FindLoadedElementType(simpleType);

        if (typeHandle.IsNull())
        {
            ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
        }
        else
        {
            _ASSERTE(pMetadataToken != NULL);
            *pMetadataToken = typeHandle.GetCl();

            Module * pModule = typeHandle.GetModule();
            if (pModule == NULL)
                ThrowHR(CORDBG_E_TARGET_INCONSISTENT);

            pVmModule->SetHostPtr(pModule);
        }

        LOG((LF_CORDB, LL_INFO10000, "D::STI: sending result.\n"));
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsExceptionObject(VMPTR_Object vmObject, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Object* objPtr = vmObject.GetDacPtr();
        MethodTable* pMT = objPtr->GetMethodTable();

        *pResult = IsExceptionObject(pMT);
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

BOOL DacDbiInterfaceImpl::IsExceptionObject(MethodTable* pMT)
{
    PTR_MethodTable pExMT = g_pExceptionClass;

    TADDR targetMT = dac_cast<TADDR>(pMT);
    TADDR exceptionMT = dac_cast<TADDR>(pExMT);

    do
    {
        if (targetMT == exceptionMT)
            return TRUE;

        pMT = pMT->GetParentMethodTable();
        targetMT = dac_cast<TADDR>(pMT);
    } while (pMT);

    return FALSE;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetMethodDescPtrFromIpEx(TADDR funcIp, VMPTR_MethodDesc* ppMD)
{
    DD_ENTER_MAY_THROW;

    // The fast path is check if the code is jitted and the code manager has it available.
    CLRDATA_ADDRESS mdAddr;
    HRESULT hr = g_dacImpl->GetMethodDescPtrFromIP(TO_CDADDR(funcIp), &mdAddr);
    if (S_OK == hr)
    {
        ppMD->SetDacTargetPtr(CLRDATA_ADDRESS_TO_TADDR(mdAddr));
        return hr;
    }

    // Otherwise try to see if a method desc is available for the method that isn't jitted by walking the code stubs.
    MethodDesc* pMD = NonVirtualEntry2MethodDesc(PINSTRToPCODE(funcIp));

    if (pMD == NULL)
        return E_INVALIDARG;

    ppMD->SetDacTargetPtr(PTR_HOST_TO_TADDR(pMD));
    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsDelegate(VMPTR_Object vmObject, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if (vmObject.IsNull())
        {
            *pResult = FALSE;
        }
        else
        {
            Object *pObj = vmObject.GetDacPtr();
            *pResult = pObj->GetGCSafeMethodTable()->IsDelegate();
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//-----------------------------------------------------------------------------
// Given a delegate pointer, compute the type of delegate according to the data held in it.
//-----------------------------------------------------------------------------
DacDbiInterfaceImpl::DelegateType DacDbiInterfaceImpl::GetDelegateType(VMPTR_Object delegateObject)
{
    _ASSERTE(!delegateObject.IsNull());

    DelegateType delegateType = DelegateType::kUnknownDelegateType;
    PTR_DelegateObject pDelObj = dac_cast<PTR_DelegateObject>(delegateObject.GetDacPtr());

    INT_PTR extraData = pDelObj->GetExtraData();
    OBJECTREF helperObject = pDelObj->GetHelperObject();
    if (((helperObject == NULL) || !helperObject->GetMethodTable()->IsArray()) && (extraData != DELEGATE_MARKER_UNMANAGEDFPTR))
    {
        // If this delegate is open, this should be non-null
        TADDR targetMethodPtr = PCODEToPINSTR(pDelObj->GetMethodPtrAux());
        delegateType = targetMethodPtr == (TADDR)NULL ? DelegateType::kClosedDelegate : DelegateType::kOpenDelegate;
    }
    return delegateType;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetDelegateFunctionData(
    VMPTR_Object delegateObject,
    OUT VMPTR_Assembly *ppFunctionAssembly,
    OUT mdMethodDef *pMethodDef)
{
    DD_ENTER_MAY_THROW;
    HRESULT hr = S_OK;

    EX_TRY
    {
        BOOL fIsDelegate = FALSE;
        IsDelegate(delegateObject, &fIsDelegate);
        if (!fIsDelegate)
        {
            ThrowHR(CORDBG_E_UNSUPPORTED_DELEGATE);
        }

        PTR_DelegateObject pDelObj = dac_cast<PTR_DelegateObject>(delegateObject.GetDacPtr());
        TADDR targetMethodPtr = (TADDR)NULL;

        switch (GetDelegateType(delegateObject))
        {
            case kClosedDelegate:
                targetMethodPtr = PCODEToPINSTR(pDelObj->GetMethodPtr());
                break;
            case kOpenDelegate:
                targetMethodPtr = PCODEToPINSTR(pDelObj->GetMethodPtrAux());
                break;
            default:
                ThrowHR(CORDBG_E_UNSUPPORTED_DELEGATE);
        }

        VMPTR_MethodDesc pMD;
        IfFailThrow(GetMethodDescPtrFromIpEx(targetMethodPtr, &pMD));
        ppFunctionAssembly->SetDacTargetPtr(dac_cast<TADDR>(pMD.GetDacPtr()->GetModule()->GetAssembly()));
        *pMethodDef = pMD.GetDacPtr()->GetMemberDef();
    }
    EX_CATCH_HRESULT(hr);

    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetDelegateTargetObject(
    VMPTR_Object delegateObject,
    OUT VMPTR_Object *ppTargetObj)
{
    DD_ENTER_MAY_THROW;
    HRESULT hr = S_OK;
    EX_TRY
    {
        BOOL fIsDelegate = FALSE;
        IsDelegate(delegateObject, &fIsDelegate);
        if (!fIsDelegate)
        {
            ThrowHR(CORDBG_E_UNSUPPORTED_DELEGATE);
        }

        PTR_DelegateObject pDelObj = dac_cast<PTR_DelegateObject>(delegateObject.GetDacPtr());
        switch (GetDelegateType(delegateObject))
        {
            case kClosedDelegate:
            {
                PTR_Object pRemoteTargetObj = OBJECTREFToObject(pDelObj->GetTarget());
                ppTargetObj->SetDacTargetPtr(pRemoteTargetObj.GetAddr());
                break;
            }
            case kOpenDelegate:
                ppTargetObj->SetDacTargetPtr((TADDR)NULL);
                break;
            default:
                ThrowHR(CORDBG_E_UNSUPPORTED_DELEGATE);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateStackFramesFromException(VMPTR_Object vmObject, FP_EXCEPTION_STACK_FRAME_CALLBACK fpCallback, CALLBACK_DATA pUserData)
{
    if (fpCallback == NULL)
        return E_POINTER;

    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        PTR_Object objPtr = vmObject.GetDacPtr();

    #ifdef _DEBUG
        // ensure we have an Exception object
        MethodTable* pMT = objPtr->GetMethodTable();
        _ASSERTE(IsExceptionObject(pMT));
    #endif

        OBJECTREF objRef = ObjectToOBJECTREF(objPtr);

        DebugStackTrace::GetStackFramesData stackFramesData;

        stackFramesData.pDomain = NULL;
        stackFramesData.NumFramesRequested = 0;

        DebugStackTrace::GetStackFramesFromException(&objRef, &stackFramesData);

        INT32 dacStackFramesLength = stackFramesData.cElements;

        AppDomain* pDomain = AppDomain::GetCurrentDomain();
        _ASSERTE(pDomain != NULL);

        VMPTR_AppDomain vmAppDomain = VMPTR_AppDomain::NullPtr();
        vmAppDomain.SetHostPtr(pDomain);

        for (INT32 index = 0; index < dacStackFramesLength; ++index)
        {
            DebugStackTrace::Element const& currentElement = stackFramesData.pElements[index];

            Module* pModule = currentElement.pFunc->GetModule();
            Assembly* pAssembly = pModule->GetAssembly();
            _ASSERTE(pAssembly != NULL);

            VMPTR_Assembly vmAssembly = VMPTR_Assembly::NullPtr();
            vmAssembly.SetHostPtr(pAssembly);

            BOOL isLastForeignExceptionFrame = (currentElement.flags & STEF_LAST_FRAME_FROM_FOREIGN_STACK_TRACE) != 0;
            fpCallback(vmAppDomain, vmAssembly, currentElement.ip, currentElement.pFunc->GetMemberDef(), isLastForeignExceptionFrame, pUserData);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

#ifdef FEATURE_COMINTEROP

PTR_RCW GetRcwFromVmptrObject(VMPTR_Object vmObject)
{
    PTR_RCW pRCW = NULL;

    Object* objPtr = vmObject.GetDacPtr();

    PTR_SyncBlock pSyncBlock = NULL;
    pSyncBlock = objPtr->PassiveGetSyncBlock();
    if (pSyncBlock == NULL)
        return pRCW;

    PTR_InteropSyncBlockInfo pInfo = NULL;
    pInfo = pSyncBlock->GetInteropInfoNoCreate();
    if (pInfo == NULL)
        return pRCW;

    pRCW = dac_cast<PTR_RCW>(pInfo->DacGetRawRCW());

    return pRCW;
}

#endif

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsRcw(VMPTR_Object vmObject, OUT BOOL * pResult)
{
#ifdef FEATURE_COMINTEROP
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        *pResult = GetRcwFromVmptrObject(vmObject) != NULL;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
#else
    *pResult = FALSE;
    return S_OK;
#endif // FEATURE_COMINTEROP
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateRcwCachedInterfacePointers(VMPTR_Object vmObject, FP_RCW_INTERFACE_CALLBACK fpCallback, CALLBACK_DATA pUserData)
{
#ifdef FEATURE_COMINTEROP

    DD_ENTER_MAY_THROW;

    if (fpCallback == NULL)
        return E_POINTER;

    HRESULT hr = S_OK;
    EX_TRY
    {
        PTR_RCW pRCW = GetRcwFromVmptrObject(vmObject);
        if (pRCW != NULL)
        {
            RCW::CachedInterfaceEntryIterator it = pRCW->IterateCachedInterfacePointers();
            while (it.Next())
            {
                PTR_MethodTable pMT = dac_cast<PTR_MethodTable>((TADDR)(it.GetEntry()->m_pMT.Load()));
                if (pMT != NULL)
                {
                    TADDR taUnk = (TADDR)(it.GetEntry()->m_pUnknown.Load());
                    if (taUnk != NULL)
                    {
                        fpCallback((CORDB_ADDRESS)taUnk, pUserData);
                    }
                }
            }
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
#else
    return S_OK;
#endif // FEATURE_COMINTEROP
}

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::FindField
// Finds information for a particular class field
// Arguments:
//     input: thApprox - type handle for the type to which the field belongs
//            fldToken - metadata token for the field
// Return Value: FieldDesc containing information for the field if found or NULL otherwise
//-----------------------------------------------------------------------------
PTR_FieldDesc  DacDbiInterfaceImpl::FindField(TypeHandle thApprox, mdFieldDef fldToken)
{
    EncApproxFieldDescIterator fdIterator(thApprox.GetMethodTable(),
                                          ApproxFieldDescIterator::ALL_FIELDS); // don't fixup EnC (we can't, we're stopped)

    PTR_FieldDesc pCurrentFD;

    while ((pCurrentFD = fdIterator.Next()) != NULL)
    {
        // We're looking for a specific fieldDesc, see if we got it.
        if (pCurrentFD->GetMemberDef() == fldToken)
        {
            return pCurrentFD;
        }
    }

    // we never found it...
    return NULL;
} // DacDbiInterfaceImpl::FindField

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetEnCFieldDesc
// Get the FieldDesc corresponding to a particular EnC field token
// Arguments:
//     input:  pEnCFieldInfo
// Return Value: pointer to the FieldDesc that corresponds to the EnC field
// Note: this function may throw
//-----------------------------------------------------------------------------
FieldDesc * DacDbiInterfaceImpl::GetEnCFieldDesc(const EnCHangingFieldInfo * pEnCFieldInfo)
{
        FieldDesc * pFD = NULL;

        Assembly * pAssembly = pEnCFieldInfo->GetObjectTypeData().vmAssembly.GetDacPtr();
        Module     * pModule     = pAssembly->GetModule();

        // get the type handle for the object
        TypeHandle typeHandle = ClassLoader::LookupTypeDefOrRefInModule(pModule,
                                             pEnCFieldInfo->GetObjectTypeData().metadataToken);
        if (typeHandle == NULL)
        {
            ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
        }
        // and find the field desc
        pFD = FindField(typeHandle, pEnCFieldInfo->GetFieldToken());
        if (pFD == NULL)
        {
            // FieldDesc is not yet available, so can't get EnC field info
            ThrowHR(CORDBG_E_ENC_HANGING_FIELD);
        }
        return pFD;

} // DacDbiInterfaceImpl::GetEnCFieldDesc

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::GetPtrToEnCField
// Get the address of a field added with EnC.
// Arguments:
//     input: pFD           - field desc for the added field
//            pEnCFieldInfo - information about the new field
// Return Value: The field address if the field is available (i.e., it has been accessed)
//               or NULL otherwise
// Note: this function may throw
//-----------------------------------------------------------------------------
PTR_CBYTE DacDbiInterfaceImpl::GetPtrToEnCField(FieldDesc * pFD, const EnCHangingFieldInfo * pEnCFieldInfo)
{
#ifndef FEATURE_METADATA_UPDATER
    _ASSERTE(!"Trying to get the address of an EnC field where EnC is not supported! ");
    return NULL;
#else

    PTR_EditAndContinueModule pEnCModule;
    Assembly * pAssembly = pEnCFieldInfo->GetObjectTypeData().vmAssembly.GetDacPtr();
    Module     * pModule     = pAssembly->GetModule();

    // make sure we actually have an EditAndContinueModule
    _ASSERTE(pModule->IsEditAndContinueCapable());
    pEnCModule = dac_cast<PTR_EditAndContinueModule>(pModule);

    // we should also have an EnCFieldDesc
    _ASSERTE(pFD->IsEnCNew());
    EnCFieldDesc * pEnCFieldDesc;
    pEnCFieldDesc = dac_cast<PTR_EnCFieldDesc>(pFD);

    // If it hasn't been fixed up yet, then we can't return the pointer.
    if (pEnCFieldDesc->NeedsFixup())
    {
        ThrowHR(CORDBG_E_ENC_HANGING_FIELD);
    }
    // Get a pointer to the field
    PTR_CBYTE pORField = NULL;

    PTR_Object pObject = pEnCFieldInfo->GetVmObject().GetDacPtr();
    pORField = pEnCModule->ResolveField(ObjectToOBJECTREF(pObject),
                                        pEnCFieldDesc);

    // The field could be absent because the code hasn't accessed it yet. If so, we're not going to add it
    // since we can't allocate anyway.
    if (pORField == NULL)
    {
        ThrowHR(CORDBG_E_ENC_HANGING_FIELD);
    }
    return pORField;
#endif // FEATURE_METADATA_UPDATER
} // DacDbiInterfaceImpl::GetPtrToEnCField

//-----------------------------------------------------------------------------
// DacDbiInterfaceImpl::InitFieldData
// Initialize information about a field added with EnC
// Arguments :
//     input:
//             pFD           - provides information about whether the field is static,
//                             the metadata token, etc.
//             pORField      - provides the field address or offset
//             pEnCFieldData - provides the offset to the fields of the object
//     output: pFieldData    - initialized in accordance with the input information
//-----------------------------------------------------------------------------
void DacDbiInterfaceImpl::InitFieldData(const FieldDesc *           pFD,
                                        const PTR_CBYTE             pORField,
                                        const EnCHangingFieldInfo * pEnCFieldData,
                                        FieldData *           pFieldData)
{

    pFieldData->ClearFields();

    pFieldData->m_fFldIsStatic = (pFD->IsStatic() != 0);
    pFieldData->m_vmFieldDesc.SetHostPtr(pFD);
    pFieldData->m_fFldIsTLS = (pFD->IsThreadStatic() == TRUE);
    pFieldData->m_fldMetadataToken = pFD->GetMemberDef();
    pFieldData->m_fFldIsRVA = (pFD->IsRVA() == TRUE);
    pFieldData->m_fFldIsCollectibleStatic = FALSE;
    pFieldData->m_fFldStorageAvailable = true;

    if (pFieldData->m_fFldIsStatic)
    {
        //EnC is only supported on regular static fields
        _ASSERTE(!pFieldData->m_fFldIsTLS);
        _ASSERTE(!pFieldData->m_fFldIsRVA);

        // pORField contains the absolute address
        pFieldData->SetStaticAddress(PTR_TO_CORDB_ADDRESS(PTR_TO_TADDR(pORField)));
    }
    else
    {
        // fldInstanceOffset is computed to work correctly with GetFieldValue
        // which computes:
        // addr of pORField = object + pEnCFieldInfo->m_offsetToVars + offsetToFld
        pFieldData->SetInstanceOffset(PTR_TO_TADDR(pORField) -
                                      (PTR_TO_TADDR(pEnCFieldData->GetVmObject().GetDacPtr()) +
                                                   pEnCFieldData->GetOffsetToVars()));
    }
} // DacDbiInterfaceImpl::InitFieldData


// ----------------------------------------------------------------------------
// DacDbi API: GetEnCHangingFieldInfo
// After a class has been loaded, if a field has been added via EnC we'll have to jump through
// some hoops to get at it (it hangs off the sync block or FieldDesc).
//
// GENERICS: TODO: this method will need to be modified if we ever support EnC on
// generic classes.
//-----------------------------------------------------------------------------
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetEnCHangingFieldInfo(const EnCHangingFieldInfo * pEnCFieldInfo, OUT FieldData * pFieldData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        LOG((LF_CORDB, LL_INFO100000, "DDI::IEnCHFI: Obj:0x%x, objType"
            ":0x%x, offset:0x%x\n", pEnCFieldInfo->m_pObject, pEnCFieldInfo->m_objectTypeData.elementType,
            pEnCFieldInfo->m_offsetToVars));

        FieldDesc *  pFD      = NULL;
        PTR_CBYTE    pORField = NULL;

        pFD = GetEnCFieldDesc(pEnCFieldInfo);
        _ASSERTE(pFD->IsEnCNew()); // We shouldn't be here if it wasn't added to an
                                   // already loaded class.

    #ifdef FEATURE_METADATA_UPDATER
        pORField = GetPtrToEnCField(pFD, pEnCFieldInfo);
    #else
        _ASSERTE(!"We shouldn't be here: EnC not supported");
    #endif // FEATURE_METADATA_UPDATER

        InitFieldData(pFD, pORField, pEnCFieldInfo, pFieldData);
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


// Get the full path and file name to the assembly's manifest module.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetAssemblyPath(VMPTR_Assembly vmAssembly, IStringHolder * pStrFilename, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        // Get the manifest module for this assembly
        Assembly * pAssembly = vmAssembly.GetDacPtr();
        Module * pManifestModule = pAssembly->GetModule();

        // Get the path for the manifest module.
        // since we no longer support Win9x, we assume all paths will be in unicode format already
        const WCHAR * szPath = pManifestModule->GetPath().DacGetRawUnicode();
        HRESULT hrStatus = pStrFilename->AssignCopy(szPath);
        IfFailThrow(hrStatus);

        if(szPath == NULL || *szPath=='\0')
        {
            // The asembly has no (and will never have a) file name, but we didn't really fail
            *pResult = FALSE;
        }
        else
        {
            *pResult = TRUE;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DAC/DBI API
// Get a resolved type def from a type ref. The type ref may come from a module other than the
// referencing module.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::ResolveTypeReference(const TypeRefData * pTypeRefInfo, TypeRefData * pTargetRefInfo)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        Assembly * pAssembly          = pTypeRefInfo->vmAssembly.GetDacPtr();
        Module *   pReferencingModule = pAssembly->GetModule();
        BOOL       fSuccess           = FALSE;

        // Resolve the type ref
        // g_pEEInterface->FindLoadedClass is almost what we want, but it isn't guaranteed to work if
        // the typeRef was originally loaded from a different assembly.  Also, we need to ensure that
        // we can resolve even unloaded types in fully loaded assemblies, so APIs such as
        // LoadTypeDefOrRefThrowing aren't acceptable.

        Module * pTargetModule = NULL;
        mdTypeDef targetTypeDef = mdTokenNil;

        // The loader won't need to trigger a GC or throw because we've told it not to load anything
        ENABLE_FORBID_GC_LOADER_USE_IN_THIS_SCOPE();

        fSuccess = ClassLoader::ResolveTokenToTypeDefThrowing(pReferencingModule,
                                                              pTypeRefInfo->typeToken,
                                                              &pTargetModule,
                                                              &targetTypeDef,
                                                              Loader::SafeLookup   //don't load, no locks/allocations
                                                              );
        if (fSuccess)
        {
            _ASSERTE(pTargetModule != NULL);
            _ASSERTE( TypeFromToken(targetTypeDef) == mdtTypeDef );

            pTargetRefInfo->vmAssembly.SetDacTargetPtr(PTR_HOST_TO_TADDR(pTargetModule->GetAssembly()));
            pTargetRefInfo->typeToken = targetTypeDef;
        }
        else
        {
            // failed - presumably because the target assembly isn't loaded
            ThrowHR(CORDBG_E_CLASS_NOT_LOADED);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// Get the full path and file name to the module (if any).
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetModulePath(VMPTR_Module vmModule, IStringHolder * pStrFilename, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Module * pModule = vmModule.GetDacPtr();
        PEAssembly * pPEAssembly = pModule->GetPEAssembly();
        if (pPEAssembly != NULL)
        {
            if( !pPEAssembly->GetPath().IsEmpty() )
            {
                // Module has an on-disk path
                const WCHAR * szPath = pPEAssembly->GetPath().DacGetRawUnicode();
                if (szPath == NULL)
                {
                    szPath = pPEAssembly->GetModuleFileNameHint().DacGetRawUnicode();
                }
                if (szPath != NULL)
                {
                    IfFailThrow(pStrFilename->AssignCopy(szPath));
                    *pResult = TRUE;
                }
                else
                {
                    IfFailThrow(pStrFilename->AssignCopy(W("")));
                    *pResult = FALSE;
                }
            }
            else
            {
                IfFailThrow(pStrFilename->AssignCopy(W("")));
                *pResult = FALSE;
            }
        }
        else
        {
            // no filename
            IfFailThrow(pStrFilename->AssignCopy(W("")));
            *pResult = FALSE;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Implementation of IDacDbiInterface::GetModuleSimpleName
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetModuleSimpleName(VMPTR_Module vmModule, IStringHolder * pStrFilename)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(pStrFilename != NULL);

        Module * pModule = vmModule.GetDacPtr();
        LPCUTF8 szNameUtf8 = pModule->GetSimpleName();

        SString convert(SString::Utf8, szNameUtf8);
        IfFailThrow(pStrFilename->AssignCopy(convert.GetUnicode()));
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsModuleMapped(VMPTR_Module pModule, OUT BOOL *isModuleMapped)
{
    LOG((LF_CORDB, LL_INFO10000, "DDBII::IMM - TADDR 0x%x\n", pModule));
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_FALSE;
    PTR_Module pTargetModule = pModule.GetDacPtr();

    EX_TRY
    {
        PTR_PEAssembly pPEAssembly = pTargetModule->GetPEAssembly();
        _ASSERTE(pPEAssembly != NULL);

        if (pPEAssembly->HasLoadedPEImage())
        {
            *isModuleMapped = pPEAssembly->GetLoadedLayout()->IsMapped();
            hr = S_OK;
        }
    }
    EX_CATCH_HRESULT(hr);

    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::MetadataUpdatesApplied(OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
    #ifdef FEATURE_METADATA_UPDATER
        *pResult = g_metadataUpdatesApplied;
    #else
        *pResult = FALSE;
    #endif
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Helper to initialize a TargetBuffer from a MemoryRange
//
// Arguments:
//    memoryRange - memory range.
//    pTargetBuffer - required out parameter  to be initialized to value of memory range.
//
// Notes:
//    MemoryRange and TargetBuffer both conceptually describe a single contiguous buffer of memory in the
//    target. MemoryRange is a VM structure, which can't bleed across the DacDbi boundary. TargetBuffer is
//    a DacDbi structure, which can cross the DacDbi boundary.
void InitTargetBufferFromMemoryRange(const MemoryRange memoryRange, TargetBuffer * pTargetBuffer)
{
    SUPPORTS_DAC;

    _ASSERTE(pTargetBuffer != NULL);
    PTR_CVOID p = memoryRange.StartAddress();
    CORDB_ADDRESS addr = PTR_TO_CORDB_ADDRESS(PTR_TO_TADDR(p));

    _ASSERTE(memoryRange.Size() <= 0xffffffff);
    pTargetBuffer->Init(addr, (ULONG)memoryRange.Size());
}

// Helper to initialize a TargetBuffer (host representation of target) from an SBuffer  (target)
//
// Arguments:
//   pBuffer - target pointer to a SBuffer structure. If pBuffer is NULL, then target buffer will be empty.
//   pTargetBuffer - required out pointer to hold buffer description.
//
// Notes:
//   PTR_SBuffer and TargetBuffer are both semantically equivalent structures. They both are a pointer and length
//   describing a buffer in the target address space. (SBufer also has ownership semantics, but for DAC's
//   read-only nature, that doesn't matter).
//   Neither of these will actually copy the target buffer into the host without explicit action.
//   The important difference is that TargetBuffer is a host datastructure and so easier to manipulate.
//
void InitTargetBufferFromTargetSBuffer(PTR_SBuffer pBuffer, TargetBuffer * pTargetBuffer)
{
    SUPPORTS_DAC;

    _ASSERTE(pTargetBuffer != NULL);

    SBuffer * pBufferHost = pBuffer;
    if (pBufferHost == NULL)
    {
        pTargetBuffer->Clear();
        return;
    }

    MemoryRange m = pBufferHost->DacGetRawBuffer();
    InitTargetBufferFromMemoryRange(m, pTargetBuffer);
}


// Implementation of IDacDbiInterface::GetMetadata
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetMetadata(VMPTR_Module vmModule, OUT TargetBuffer * pTargetBuffer)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        pTargetBuffer->Clear();

        Module     * pModule = vmModule.GetDacPtr();

        // For dynamic modules, metadata is stored as an eagerly-serialized buffer hanging off the Reflection Module.
        if (pModule->IsReflectionEmit())
        {
            // Here is the fetch.
            ReflectionModule * pReflectionModule = pModule->GetReflectionModule();

            TADDR metadataBuffer = pReflectionModule->GetDynamicMetadataBuffer();
            CORDB_ADDRESS addr = PTR_TO_CORDB_ADDRESS(metadataBuffer + offsetof(DynamicMetadata, Data));
            pTargetBuffer->Init(addr, dac_cast<DPTR(DynamicMetadata)>(metadataBuffer)->Size);
        }
        else
        {
            PEAssembly * pPEAssembly = pModule->GetPEAssembly();

            // For non-dynamic modules, metadata is in the pe-image.
            COUNT_T size;
            CORDB_ADDRESS address = PTR_TO_CORDB_ADDRESS(dac_cast<TADDR>(pPEAssembly->GetLoadedMetadata(&size)));

            pTargetBuffer->Init(address, (ULONG) size);
        }

        if (pTargetBuffer->IsEmpty())
        {
            // We never expect this to happen in a well-behaved scenario. But just in case.
            ThrowHR(CORDBG_E_MISSING_METADATA);
        }

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Implementation of IDacDbiInterface::GetSymbolsBuffer
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetSymbolsBuffer(VMPTR_Module vmModule, OUT TargetBuffer * pTargetBuffer, OUT SymbolFormat * pSymbolFormat)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        pTargetBuffer->Clear();
        *pSymbolFormat = kSymbolFormatNone;

        Module * pModule = vmModule.GetDacPtr();

        PTR_CGrowableStream pStream = pModule->GetInMemorySymbolStream();
        if (pStream == NULL)
        {
            // Common case is to not have PDBs in-memory.
            return hr;
        }

        const MemoryRange m = pStream->GetRawBuffer();
        if (m.Size() == 0)
        {
            // We may be prepared to store symbols (in some particular format) but none are there yet.
            // We treat this the same as not having any symbols above.
            return hr;
        }
        InitTargetBufferFromMemoryRange(m, pTargetBuffer);

        *pSymbolFormat = kSymbolFormatPDB;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}



HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetModuleForAssembly(VMPTR_Assembly vmAssembly, OUT VMPTR_Module * pModule, OUT BOOL * pIsModuleLoaded)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(pModule != NULL);

        // Initialize out params up front so callers don't observe stale/uninitialized
        // values if we throw below.
        *pModule = VMPTR_Module::NullPtr();
        if (pIsModuleLoaded != NULL)
        {
            *pIsModuleLoaded = FALSE;
        }

        Assembly * pAssembly = vmAssembly.GetDacPtr();
        if (pAssembly == NULL)
        {
            ThrowHR(E_INVALIDARG);
        }

        pModule->SetHostPtr(pAssembly->GetModule());

        if (pIsModuleLoaded != NULL)
        {
            *pIsModuleLoaded = pAssembly->IsLoaded() ? TRUE : FALSE;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Implement IDacDbiInterface::GetModuleData
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetModuleData(VMPTR_Module vmModule, OUT ModuleInfo * pData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(pData != NULL);

        ZeroMemory(pData, sizeof(*pData));

        Module     * pModule      = vmModule.GetDacPtr();
        PEAssembly * pPEAssembly        = pModule->GetPEAssembly();

        pData->vmPEAssembly.SetHostPtr(pPEAssembly);
        pData->vmAssembly.SetHostPtr(pModule->GetAssembly());

        // Is it dynamic?
        BOOL fIsDynamic = pModule->IsReflectionEmit();
        pData->fIsDynamic = fIsDynamic;

        // Get PE BaseAddress and Size
        // For dynamic modules, these are 0. Else,
        pData->pPEBaseAddress = (CORDB_ADDRESS)NULL;
        pData->nPESize = 0;

        if (!fIsDynamic)
        {
            COUNT_T size = 0;
            pData->pPEBaseAddress = PTR_TO_TADDR(pPEAssembly->GetDebuggerContents(&size));
            pData->nPESize = (ULONG) size;
        }

        // In-memory is determined by whether the module has a filename.
        pData->fInMemory = FALSE;
        if (pPEAssembly != NULL)
        {
            pData->fInMemory = pPEAssembly->GetPath().IsEmpty();
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// Implementation of IDacDbiInterface::EnumerateAssembliesInAppDomain.
// Enumerate all the assemblies in the appdomain.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateAssembliesInAppDomain(VMPTR_AppDomain vmAppDomain, FP_ASSEMBLY_ENUMERATION_CALLBACK fpCallback, CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(fpCallback != NULL);

        // Iterate through all Assemblies (including shared) in the appdomain.
        AppDomain::AssemblyIterator iterator;

        AppDomain * pAppDomain = vmAppDomain.GetDacPtr();

        if (pAppDomain == nullptr)
        {
            return hr;
        }

        // Pass the magical flags to the loader enumerator to get all Execution-only assemblies.
        iterator = pAppDomain->IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoading | kIncludeLoaded | kIncludeExecution));
        CollectibleAssemblyHolder<Assembly *> pAssembly;

        while (iterator.Next(pAssembly.This()))
        {
            VMPTR_Assembly vmAssembly = VMPTR_Assembly::NullPtr();
            vmAssembly.SetHostPtr(pAssembly);

            fpCallback(vmAssembly, pUserData);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Implementation of IDacDbiInterface::ResolveAssembly
// Returns NULL if not found.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::ResolveAssembly(VMPTR_Assembly vmScope, mdToken tkAssemblyRef, OUT VMPTR_Assembly * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        Assembly * pScopeAssembly = vmScope.GetDacPtr();
        Module *   pModule        = pScopeAssembly->GetModule();

        VMPTR_Assembly vmAssembly = VMPTR_Assembly::NullPtr();

        Assembly * pReferencedAssembly = pModule->LookupAssemblyRef(tkAssemblyRef);
        if (pReferencedAssembly != NULL)
        {
            vmAssembly.SetHostPtr(pReferencedAssembly);
        }
        *pRetVal = vmAssembly;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// When stopped at an event, request a synchronization.
// See DacDbiInterface.h for full comments
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::RequestSyncAtEvent()
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        // To request a sync, we just need to set g_pDebugger->m_RSRequestedSync high.
        if (g_pDebugger != NULL)
        {
            TADDR addr = PTR_HOST_MEMBER_TADDR(Debugger, g_pDebugger, m_RSRequestedSync);

            BOOL fTrue = TRUE;
            SafeWriteStructOrThrow<BOOL>(addr, &fTrue);

        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::SetSendExceptionsOutsideOfJMC(BOOL sendExceptionsOutsideOfJMC)
{
    DD_ENTER_MAY_THROW

    HRESULT hr = S_OK;
    EX_TRY
    {
        if (g_pDebugger != NULL)
        {
            TADDR addr = PTR_HOST_MEMBER_TADDR(Debugger, g_pDebugger, m_sendExceptionsOutsideOfJMC);
            SafeWriteStructOrThrow<BOOL>(addr, &sendExceptionsOutsideOfJMC);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Notify the debuggee that a debugger attach is pending.
// See DacDbiInterface.h for full comments
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::MarkDebuggerAttachPending()
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if (g_pDebugger != NULL)
        {
            DWORD flags = g_CORDebuggerControlFlags;
            flags |= DBCF_PENDING_ATTACH;

            // Uses special DAC writing. PTR_TO_TADDR doesn't fetch for globals.
            // @dbgtodo  dac support - the exact mechanism of writing to the target needs to be flushed out,
            // especially as it relates to DAC cop and enforcing undac-ized writes.
            g_CORDebuggerControlFlags = flags;
        }
        else
        {
            // Caller should have guaranteed that the LS is loaded.
            // If we're detaching, then don't throw because we don't care.
            ThrowHR(CORDBG_E_NOTREADY);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// Notify the debuggee that a debugger is attached.
// See DacDbiInterface.h for full comments
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::MarkDebuggerAttached(BOOL fAttached)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if (g_pDebugger != NULL)
        {
            // To be attached, we need to set the following
            //   g_CORDebuggerControlFlags |= DBCF_ATTACHED;
            // To detach (if !fAttached), we need to do the opposite.

            DWORD flags = g_CORDebuggerControlFlags;
            if (fAttached)
            {
                flags |= DBCF_ATTACHED;
            }
            else
            {
                flags &= ~ (DBCF_ATTACHED | DBCF_PENDING_ATTACH);
            }

            // Uses special DAC writing. PTR_TO_TADDR doesn't fetch for globals.
            // @dbgtodo  dac support - the exact mechanism of writing to the target needs to be flushed out,
            // especially as it relates to DAC cop and enforcing undac-ized writes.
            g_CORDebuggerControlFlags = flags;
        }
        else if (fAttached)
        {
            // Caller should have guaranteed that the LS is loaded.
            // If we're detaching, then don't throw because we don't care.
            ThrowHR(CORDBG_E_NOTREADY);
        }

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}



// Enumerate all threads in the process.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateThreads(FP_THREAD_ENUMERATION_CALLBACK fpCallback, CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if (ThreadStore::s_pThreadStore == NULL)
        {
            return hr;
        }

        Thread *pThread = ThreadStore::GetThreadList(NULL);

        while (pThread != NULL)
        {

            // Don't want to publish threads via enumeration before they're ready to be inspected.
            // Use the same window that we used in whidbey.
            Thread::ThreadState threadState = pThread->GetState();
            if (!((threadState & Thread::TS_Stopped) || (threadState & Thread::TS_Unstarted)))
            {
                VMPTR_Thread vmThread = VMPTR_Thread::NullPtr();
                vmThread.SetHostPtr(pThread);
                fpCallback(vmThread, pUserData);
            }

            pThread = ThreadStore::GetThreadList(pThread);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// public implementation of IsThreadMarkedDead
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsThreadMarkedDead(VMPTR_Thread vmThread, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        Thread * pThread = vmThread.GetDacPtr();
        *pResult = (pThread->GetState() & Thread::TS_Stopped) != 0;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the handle of the specified thread.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetThreadHandle(VMPTR_Thread vmThread, OUT HANDLE * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
#ifdef TARGET_WINDOWS
        Thread * pThread = vmThread.GetDacPtr();
        *pRetVal = pThread->GetThreadHandle();
#else
        *pRetVal = NULL;
#endif // TARGET_WINDOWS
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the object handle for the managed Thread object corresponding to the specified thread.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetThreadObject(VMPTR_Thread vmThread, OUT VMPTR_OBJECTHANDLE * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();
        Thread::ThreadState threadState = pThread->GetState();

        if ( (threadState & Thread::TS_Stopped) ||
             (threadState & Thread::TS_Unstarted) ||
             (threadState & Thread::TS_Detached) ||
             g_fProcessDetach )
        {
            ThrowHR(CORDBG_E_BAD_THREAD_STATE);
        }
        else
        {
            VMPTR_OBJECTHANDLE vmObjHandle = VMPTR_OBJECTHANDLE::NullPtr();
            vmObjHandle.SetDacTargetPtr(pThread->GetExposedObjectHandleForDebugger());
            *pRetVal = vmObjHandle;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetThreadAllocInfo(VMPTR_Thread vmThread, DacThreadAllocInfo* threadAllocInfo)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();
        gc_alloc_context* allocContext = pThread->GetAllocContext();
        if (allocContext != nullptr)
        {
            threadAllocInfo->m_allocBytesSOH = allocContext->alloc_bytes - (allocContext->alloc_limit - allocContext->alloc_ptr);
            threadAllocInfo->m_allocBytesUOH = allocContext->alloc_bytes_uoh;
        }
        else
        {
                threadAllocInfo->m_allocBytesSOH = 0;
                threadAllocInfo->m_allocBytesUOH = 0;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Set and reset the DCTS_UserSuspend bit on the DebuggerControlledThreadState of the specified thread
// according to the CorDebugThreadState.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::SetDebugState(VMPTR_Thread vmThread, CorDebugThreadState debugState)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();

        // update the field on the host copy
        if (debugState == THREAD_SUSPEND)
        {
            pThread->SetDebuggerControlledThreadState(Thread::DCTS_UserSuspend);
        }
        else if (debugState == THREAD_RUN)
        {
            pThread->ResetDebuggerControlledThreadState(Thread::DCTS_UserSuspend);
        }
        else
        {
            ThrowHR(E_INVALIDARG);
        }

        // update the field on the target copy
        TADDR taThreadState = PTR_HOST_MEMBER_TADDR(Thread, pThread, m_DebuggerControlledThreadState);
        Thread::DebuggerControlledThreadState localState = pThread->m_DebuggerControlledThreadState.Load();
        SafeWriteStructOrThrow<Thread::DebuggerControlledThreadState>(taThreadState, &localState);
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Gets the debugger unhandled exception threadstate flag
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::HasUnhandledException(VMPTR_Thread vmThread, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();

        // some managed exceptions don't have any underlying
        // native exception processing going on. They just consist
        // of a managed throwable that we have stashed away followed
        // by a debugger notification and some form of failfast.
        // Everything that comes through EEFatalError is in this category
        if(pThread->IsLastThrownObjectUnhandled())
        {
            *pResult = TRUE;
        }
        else
        {
            // most managed exceptions are just a throwable bound to a
            // native exception. In that case this handle will be non-null
            OBJECTHANDLE ohException = pThread->GetThrowableAsPseudoHandle();
            if (ohException != (OBJECTHANDLE)NULL)
            {
                // during the UEF we set the unhandled bit, if it is set the exception
                // was unhandled
                // however if the exception has intercept info then we consider it handled
                // again
                *pResult = pThread->GetExceptionState()->GetFlags()->IsUnhandled() &&
                    !(pThread->GetExceptionState()->GetFlags()->DebuggerInterceptInfo());
            }
            else
            {
                *pResult = FALSE;
            }
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the user state of the specified thread.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetUserState(VMPTR_Thread vmThread, OUT CorDebugUserState * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        UINT result = 0;
        CorDebugUserState partialState;
        IfFailThrow(GetPartialUserState(vmThread, &partialState));
        result = (UINT)partialState;

        if (!IsThreadAtGCSafePlace(vmThread))
        {
            result |= USER_UNSAFE_POINT;
        }

        *pRetVal = (CorDebugUserState)result;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// Return the connection ID of the specified thread.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetConnectionID(VMPTR_Thread vmThread, OUT CONNID * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        *pRetVal = INVALID_CONNECTION_ID;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the task ID of the specified thread.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetTaskID(VMPTR_Thread vmThread, OUT TASKID * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        *pRetVal = INVALID_TASK_ID;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the OS thread ID of the specified thread
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::TryGetVolatileOSThreadID(VMPTR_Thread vmThread, OUT DWORD * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();
        _ASSERTE(pThread != NULL);

        DWORD dwThreadId = pThread->GetOSThreadIdForDebugger();

        // If the thread ID is a the magical cookie value, then this is really
        // a switched out thread and doesn't have an OS tid. In that case, the
        // DD contract is to return 0 (a much more sane value)
        const DWORD dwSwitchedOutThreadId = SWITCHED_OUT_FIBER_OSID;
        if (dwThreadId == dwSwitchedOutThreadId)
        {
            *pRetVal = 0;
        }
        else
        {
            *pRetVal = dwThreadId;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the unique thread ID of the specified thread.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetUniqueThreadID(VMPTR_Thread vmThread, OUT DWORD * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();
        _ASSERTE(pThread != NULL);

        *pRetVal = pThread->GetOSThreadId();
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the object handle to the managed Exception object of the current exception
// on the specified thread.  The return value could be NULL if there is no current exception.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetCurrentException(VMPTR_Thread vmThread, OUT VMPTR_OBJECTHANDLE * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();

        OBJECTHANDLE ohException = pThread->GetThrowableAsPseudoHandle();

        if (ohException == (OBJECTHANDLE)NULL)
        {
            if (pThread->IsLastThrownObjectUnhandled())
            {
                ohException = pThread->LastThrownObjectHandle();
            }
        }

        VMPTR_OBJECTHANDLE vmObjHandle;
        vmObjHandle.SetDacTargetPtr(ohException);
        *pRetVal = vmObjHandle;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the object handle to the managed object for a given CCW pointer.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetObjectForCCW(CORDB_ADDRESS ccwPtr, OUT VMPTR_OBJECTHANDLE * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        OBJECTHANDLE ohCCW = (OBJECTHANDLE)NULL;

    #ifdef FEATURE_COMWRAPPERS
        if (DACTryGetComWrappersHandleFromCCW(ccwPtr, &ohCCW) != S_OK)
        {
    #endif
    #ifdef FEATURE_COMINTEROP
        ComCallWrapper *pCCW = DACGetCCWFromAddress(ccwPtr);
        if (pCCW)
        {
            ohCCW = pCCW->GetObjectHandle();
        }
    #endif
    #ifdef FEATURE_COMWRAPPERS
        }
    #endif

        VMPTR_OBJECTHANDLE vmObjHandle;
        vmObjHandle.SetDacTargetPtr(ohCCW);
        *pRetVal = vmObjHandle;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the object handle to the managed CustomNotification object of the current notification
// on the specified thread.  The return value could be NULL if there is no current notification.
// Arguments:
//     input: vmThread - the thread on which the notification occurred
// Return value: object handle for the current notification (if any) on the thread. This will return non-null
// if and only if we are currently inside a CustomNotification Callback (or a dump was generated while in this
// callback)
//
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetCurrentCustomDebuggerNotification(VMPTR_Thread vmThread, OUT VMPTR_OBJECTHANDLE * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();

        // OBJECTHANDLEs are really just TADDRs.
        OBJECTHANDLE ohNotification = pThread->GetThreadCurrNotification();        // ohNotification can be NULL

        VMPTR_OBJECTHANDLE vmObjHandle;
        vmObjHandle.SetDacTargetPtr(ohNotification);
        *pRetVal = vmObjHandle;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the current appdomain.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetCurrentAppDomain(OUT VMPTR_AppDomain * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        AppDomain * pAppDomain = AppDomain::GetCurrentDomain();
        VMPTR_AppDomain vmAppDomain = VMPTR_AppDomain::NullPtr();
        vmAppDomain.SetDacTargetPtr(PTR_HOST_TO_TADDR(pAppDomain));
        *pRetVal = vmAppDomain;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// Returns a bitfield reflecting the managed debugging state at the time of
// the jit attach.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetAttachStateFlags(OUT CLR_DEBUGGING_PROCESS_FLAGS * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        CLR_DEBUGGING_PROCESS_FLAGS res = (CLR_DEBUGGING_PROCESS_FLAGS)0;
        if (g_pDebugger != NULL)
        {
            res = g_pDebugger->GetAttachStateFlags();
        }
        else
        {
            // When launching the process under a managed debugger we
            // request these flags when CLR is loaded (before g_pDebugger
            // had a chance to be initialized). In these cases simply
            // return 0
        }
        *pRetVal = res;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//---------------------------------------------------------------------------------------
// Helper to get the address of the 2nd-chance hijack function Or throw
//
// Returns:
//     Non-null Target Address of hijack function.
TADDR DacDbiInterfaceImpl::GetHijackAddress()
{
    TADDR addr = (TADDR)NULL;
    if (g_pDebugger != NULL)
    {
        // Get the start address of the redirect function for unhandled exceptions.
        addr = dac_cast<TADDR>(g_pDebugger->m_rgHijackFunction[Debugger::kUnhandledException].StartAddress());
    }
    if (addr == (TADDR)NULL)
    {
        ThrowHR(CORDBG_E_NOTREADY);
    }
    return addr;
}

//---------------------------------------------------------------------------------------
// Helper to determine whether a control PC is in any native stub which the runtime knows how to unwind.
//
// Arguments:
//    taControlPC - control PC to be checked
//
// Returns:
//    Returns true if the control PC is in a runtime unwindable stub.
//
// Notes:
//    Currently this function only recognizes the ExceptionHijack() stub,
//    which is used for unhandled exceptions.
//

bool DacDbiInterfaceImpl::IsRuntimeUnwindableStub(PCODE targetControlPC)
{

    TADDR controlPC = PCODEToPINSTR(targetControlPC);
    // we call this function a lot while walking the stack and the values here will never change
    // Getting the g_pDebugger and each entry in the m_rgHijackFunction is potentially ~7 DAC
    // accesses per frame. Caching the data into a single local array is much faster. This optimization
    // recovered a few % of DAC stackwalking time
    if(!m_isCachedHijackFunctionValid)
    {
        Debugger* pDebugger = g_pDebugger;
        if ((pDebugger == NULL) || (pDebugger->m_rgHijackFunction == NULL))
        {
            // The in-process debugging infrastructure hasn't been fully initialized, which means that we could
            // NOT have hijacked anything yet.
            return false;
        }

        // PERF NOTE: if needed this array copy could probably be made more efficient
        // hitting the DAC only once for a single memory block, or even better
        // put the array inline in the Debugger object so that we only do 1 DAC
        // access for this entire thing
        for (int i = 0; i < Debugger::kMaxHijackFunctions; i++)
        {
            InitTargetBufferFromMemoryRange(pDebugger->m_rgHijackFunction[i], &m_pCachedHijackFunction[i] );
        }
        m_isCachedHijackFunctionValid = TRUE;
    }

    // Check whether the control PC is in any of the thread redirection functions.
    for (int i = 0; i < Debugger::kMaxHijackFunctions; i++)
    {
        CORDB_ADDRESS start = m_pCachedHijackFunction[i].pAddress;
        CORDB_ADDRESS end = start + m_pCachedHijackFunction[i].cbSize;
        if ((start <= controlPC) && (controlPC < end))
        {
            return true;
        }
    }
    return false;
}

//---------------------------------------------------------------------------------------
// Align a stack pointer for the given architecture
//
// Arguments:
//    pEsp - in/out: pointer to stack pointer.
//
void DacDbiInterfaceImpl::AlignStackPointer(CORDB_ADDRESS * pEsp)
{
    SUPPORTS_DAC;

    // Nop on x86.
#if defined(HOST_64BIT)
    // on 64-bit, stack pointer must be 16-byte aligned.
    // Stacks grown down, so round down to nearest 0xF bits.
    *pEsp &= ~((CORDB_ADDRESS) 0xF);
#endif
}

//---------------------------------------------------------------------------------------
// Emulate pushing something on a thread's stack.
//
// Arguments:
//     pEsp - in/out: pointer to stack pointer to push object at. On output,
//            updated stack pointer.
//     pData  - object to push on the stack.
//     fAlignStack - whether to align the stack pointer before and after the push.
//                   Callers which specify FALSE must be very careful and know exactly
//                   what they are doing.
//
// Return:
//     address of pushed object. Throws on error.
template <class T>
CORDB_ADDRESS DacDbiInterfaceImpl::PushHelper(CORDB_ADDRESS * pEsp,
                                              const T * pData,
                                              BOOL fAlignStack)
{
    SUPPORTS_DAC;

    if (fAlignStack == TRUE)
    {
        AlignStackPointer(pEsp);
    }
    *pEsp -= sizeof(T);
    if (fAlignStack == TRUE)
    {
        AlignStackPointer(pEsp);
    }
    SafeWriteStructOrThrow(*pEsp, pData);
    return *pEsp;
}

//---------------------------------------------------------------------------------------
// Write an EXCEPTION_RECORD structure to the remote target at the specified address while taking
// into account the number of exception parameters.  On 64-bit OS and on the WOW64, the OS always
// pushes the entire EXCEPTION_RECORD onto the stack.  However, on native x86 OS, the OS only pushes
// enough of the EXCEPTION_RECORD to cover the specified number of exception parameters.  Thus we
// need to be extra careful when we overwrite an EXCEPTION_RECORD on the stack.
//
// Arguments:
//    pRemotePtr   - address of the EXCEPTION_RECORD in the remote target
//    pExcepRecord - EXCEPTION_RECORD to be written
//
// Notes:
//    This function is only used by the code which hijacks a therad when there's an unhandled exception.
//    It only works when we are actually debugging a live process, not a dump.
//

void DacDbiInterfaceImpl::WriteExceptionRecordHelper(CORDB_ADDRESS pRemotePtr,
                                                     const EXCEPTION_RECORD * pExcepRecord)
{
    // Calculate the correct size to push onto the stack.
    ULONG32 cbSize = offsetof(EXCEPTION_RECORD, ExceptionInformation);
    cbSize += pExcepRecord->NumberParameters * sizeof(pExcepRecord->ExceptionInformation[0]);

    // Use the data target to write to the remote target.  Here we are assuming that we are debugging a
    // live process, since this function is only called by the hijacking code for unhandled exceptions.
    HRESULT hr = m_pMutableTarget->WriteVirtual(pRemotePtr,
                                                reinterpret_cast<const BYTE *>(pExcepRecord),
                                                cbSize);

    if (FAILED(hr))
    {
        ThrowHR(hr);
    }
}

// Implement IDacDbiInterface::Hijack
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::Hijack(VMPTR_Thread vmThread, ULONG32 dwThreadId, const EXCEPTION_RECORD * pRecord, T_CONTEXT * pOriginalContext, ULONG32 cbSizeContext, EHijackReason::EHijackReason reason, void * pUserData, CORDB_ADDRESS * pRemoteContextAddr)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        //
        // Validate parameters
        //

        // pRecord may be NULL if we're not hijacking at an exception
        // pOriginalContext may be NULL if caller doesn't want a copy of the context.
        // (The hijack function already has the context)
        _ASSERTE((pOriginalContext == NULL) == (cbSizeContext == 0));
        _ASSERTE(EHijackReason::IsValid(reason));
    #ifdef TARGET_UNIX
        _ASSERTE(!"Not supported on this platform");
    #endif

        //
        // If we hijack a thread which might not be managed we can set vmThread = NULL
        // The only side-effect in this case is that we can't reuse CONTEXT and
        // EXCEPTION_RECORD space on the stack by an already underway in-process exception
        // filter. If you depend on those being used and updated you must provide the vmThread
        //
        Thread* pThread = NULL;
        if(!vmThread.IsNull())
        {
            pThread = vmThread.GetDacPtr();
            _ASSERTE(pThread->GetOSThreadIdForDebugger() == dwThreadId);
        }

        TADDR pfnHijackFunction = GetHijackAddress();

        //
        // Setup context for hijack
        //
        T_CONTEXT ctx;
    #if !defined(CROSS_COMPILE) && !defined(TARGET_WINDOWS) && (defined(DTCONTEXT_IS_AMD64) || defined(DTCONTEXT_IS_ARM64))
        // If the host or target is not Windows, then we can assume that the DT_CONTEXT
        // is the same as the T_CONTEXT, except for the XSTATE registers.
        static_assert(sizeof(DT_CONTEXT) == offsetof(T_CONTEXT, XStateFeaturesMask), "DT_CONTEXT does not include the XSTATE registers");
    #else
        // Since Dac + DBI are tightly coupled, context sizes should be the same.
        static_assert(sizeof(DT_CONTEXT) == sizeof(T_CONTEXT), "DT_CONTEXT size must equal the T_CONTEXT size");
    #endif
        HRESULT hr = m_pTarget->GetThreadContext(
            dwThreadId,
            CONTEXT_FULL | CONTEXT_FLOATING_POINT
    #ifdef CONTEXT_EXTENDED_REGISTERS
            | CONTEXT_EXTENDED_REGISTERS
    #endif
            ,
            sizeof(DT_CONTEXT),
            (BYTE*) &ctx);
        IfFailThrow(hr);

        // If caller requested, copy back the original context that we're hijacking from.
        if (pOriginalContext != NULL)
        {
            // Since Dac + DBI are tightly coupled, context sizes should be the same.
            if (cbSizeContext != sizeof(T_CONTEXT))
            {
                ThrowHR(E_INVALIDARG);
            }

            memcpy(pOriginalContext, &ctx, cbSizeContext);
        }

        // Make sure the trace flag isn't on. This can happen if we were single stepping the thread when we faulted. This
        // will ensure that we don't try to single step through the OS's exception logic, which greatly confuses our second
        // chance hijack logic. This also mimics what the OS does for us automaically when single stepping in process, i.e.,
        // when you turn the trace flag on in-process and go, if there is a fault, the fault is reported and the trace flag
        // is automatically turned off.
        //
        // The debugger could always re-enable the single-step flag if it wants to.
    #ifndef FEATURE_EMULATE_SINGLESTEP
        UnsetSSFlag(reinterpret_cast<DT_CONTEXT *>(&ctx));
    #endif

        // Push pointers
        void* espContext = NULL;
        void* espRecord = NULL;
        const void* pData = pUserData;

        // @dbgtodo  cross-plat - this is not cross plat
        CORDB_ADDRESS esp = GetSP(&ctx);

        //
        // Find out where the OS exception dispatcher has pushed the EXCEPTION_RECORD and CONTEXT. The ExInfo
        // has pointers to these data structures, but when we get the unhandled exception notification,
        // the OS exception dispatcher is no longer on the stack, so these pointers are no longer
        // valid.  We need to either update these pointers in the ExInfo/ExcepionTracker, or reuse the stack
        // space used by the OS exception dispatcher.  We are using the latter approach here.
        //

        CORDB_ADDRESS espOSContext = (CORDB_ADDRESS)NULL;
        CORDB_ADDRESS espOSRecord  = (CORDB_ADDRESS)NULL;
        if (pThread != NULL && pThread->IsExceptionInProgress())
        {
            espOSContext = (CORDB_ADDRESS)PTR_TO_TADDR(pThread->GetExceptionState()->GetContextRecord());
            espOSRecord  = (CORDB_ADDRESS)PTR_TO_TADDR(pThread->GetExceptionState()->GetExceptionRecord());

            // The managed exception may not be related to the unhandled exception for which we are trying to
            // hijack.  An example would be when a thread hits a managed exception, VS tries to do func eval on
            // the thread, but the func eval causes an unhandled exception (e.g. AV in mscorwks.dll).  In this
            // case, the pointers stored on the ExInfo are closer to the root than the current SP of the thread.
            // The check below makes sure we don't reuse the pointers in this case.
            if (espOSContext < esp)
            {
                SafeWriteStructOrThrow(espOSContext, &ctx);
                espContext = CORDB_ADDRESS_TO_PTR(espOSContext);

                // We should have an EXCEPTION_RECORD if we are hijacked at an exception.
                // We need to be careful when we overwrite the exception record.  On x86, the OS doesn't
                // always push the full record onto the stack, and so we can't blindly use sizeof(EXCEPTION_RECORD).
                // Instead, we have to look at the number of exception parameters and calculate the size.
                _ASSERTE(pRecord != NULL);
                WriteExceptionRecordHelper(espOSRecord, pRecord);
                espRecord  = CORDB_ADDRESS_TO_PTR(espOSRecord);

                esp = min(espOSContext, espOSRecord);
            }
        }

        // If we haven't reused the pointers, then push everything at the leaf of the stack.
        if (espContext == NULL)
        {
            _ASSERTE(espRecord == NULL);

            // Push on full Context and ExceptionRecord structures. We'll then push pointers to these,
            // and those pointers will serve as the actual args to the function.
            espContext = CORDB_ADDRESS_TO_PTR(PushHelper(&esp, &ctx, TRUE));

            // If caller didn't pass an exception-record, then we're not being hijacked at an exception.
            // We'll just pass NULL for the exception-record to the Hijack function.
            if (pRecord != NULL)
            {
                espRecord  = CORDB_ADDRESS_TO_PTR(PushHelper(&esp, pRecord, TRUE));
            }
        }

        if(pRemoteContextAddr != NULL)
        {
            *pRemoteContextAddr = PTR_TO_CORDB_ADDRESS(espContext);
        }

        //
        // Push args onto the stack to be able to call the hijack function
        //

        // Prototype of hijack is:
        //     void __stdcall ExceptionHijackWorker(CONTEXT * pContext, EXCEPTION_RECORD * pRecord, EHijackReason, void * pData)
        // Set up everything so that the hijack stub can just do a "call" instruction.
        //
        // Regarding stack overflow: We could do an explicit check against the thread's stack base limit.
        // However, we don't need an explicit overflow check because if the stack does overflow,
        // the hijack will just hit a regular stack-overflow exception.
    #if defined(TARGET_X86)  // TARGET
        // X86 calling convention is to push args on the stack in reverse order.
        // If we fail here, the stack is written, but esp hasn't been committed yet so it shouldn't matter.
        PushHelper(&esp, &pData, TRUE);
        PushHelper(&esp, &reason, TRUE);
        PushHelper(&esp, &espRecord, TRUE);
        PushHelper(&esp, &espContext, TRUE);
    #elif defined (TARGET_AMD64) // TARGET
        // AMD64 calling convention is to place first 4 parameters in: rcx, rdx, r8 and r9
        ctx.Rcx = (DWORD64) espContext;
        ctx.Rdx = (DWORD64) espRecord;
        ctx.R8  = (DWORD64) reason;
        ctx.R9  = (DWORD64) pData;

        // Caller must allocate stack space to spill for args.
        // Push the arguments onto the outgoing argument homes.
        // Make sure we push pointer-sized values to keep the stack aligned.
        PushHelper(&esp, reinterpret_cast<SIZE_T *>(&(ctx.R9)), FALSE);
        PushHelper(&esp, reinterpret_cast<SIZE_T *>(&(ctx.R8)), FALSE);
        PushHelper(&esp, reinterpret_cast<SIZE_T *>(&(ctx.Rdx)), FALSE);
        PushHelper(&esp, reinterpret_cast<SIZE_T *>(&(ctx.Rcx)), FALSE);
    #elif defined(TARGET_ARM)
        ctx.R0 = (DWORD)espContext;
        ctx.R1 = (DWORD)espRecord;
        ctx.R2 = (DWORD)reason;
        ctx.R3 = (DWORD)pData;
    #elif defined(TARGET_ARM64)
        ctx.X0 = (DWORD64)espContext;
        ctx.X1 = (DWORD64)espRecord;
        ctx.X2 = (DWORD64)reason;
        ctx.X3 = (DWORD64)pData;
    #elif defined(TARGET_RISCV64)
        ctx.A0 = (DWORD64)espContext;
        ctx.A1 = (DWORD64)espRecord;
        ctx.A2 = (DWORD64)reason;
        ctx.A3 = (DWORD64)pData;
    #elif defined(TARGET_LOONGARCH64)
        ctx.A0 = (DWORD64)espContext;
        ctx.A1 = (DWORD64)espRecord;
        ctx.A2 = (DWORD64)reason;
        ctx.A3 = (DWORD64)pData;
    #else
        PORTABILITY_ASSERT("CordbThread::HijackForUnhandledException is not implemented on this platform.");
    #endif
        SetSP(&ctx, CORDB_ADDRESS_TO_TADDR(esp));

        // @dbgtodo  cross-plat - not cross-platform safe
        SetIP(&ctx, pfnHijackFunction);

        //
        // Commit the context.
        //
        hr = m_pMutableTarget->SetThreadContext(dwThreadId, sizeof(DT_CONTEXT), reinterpret_cast<BYTE*> (&ctx));
        IfFailThrow(hr);
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return the filter CONTEXT on the LS.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetManagedStoppedContext(VMPTR_Thread vmThread, OUT VMPTR_CONTEXT * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        VMPTR_CONTEXT vmContext = VMPTR_CONTEXT::NullPtr();

        Thread * pThread = vmThread.GetDacPtr();
        if (pThread->GetInteropDebuggingHijacked())
        {
            _ASSERTE(!ISREDIRECTEDTHREAD(pThread));
            vmContext = VMPTR_CONTEXT::NullPtr();
        }
        else
        {
            DT_CONTEXT * pLSContext = reinterpret_cast<DT_CONTEXT *>(pThread->GetFilterContext());
            if (pLSContext != NULL)
            {
                _ASSERTE(!ISREDIRECTEDTHREAD(pThread));
                vmContext.SetHostPtr(pLSContext);
            }
            else if (ISREDIRECTEDTHREAD(pThread))
            {
                pLSContext = reinterpret_cast<DT_CONTEXT *>(GETREDIRECTEDCONTEXT(pThread));
                _ASSERTE(pLSContext != NULL);

                if (pLSContext != NULL)
                {
                    vmContext.SetHostPtr(pLSContext);
                }
            }
        }

        *pRetVal = vmContext;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Return a TargetBuffer for the raw vararg signature.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetVarArgSig(CORDB_ADDRESS VASigCookieAddr, OUT CORDB_ADDRESS * pArgBase, OUT TargetBuffer * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(pArgBase != NULL);
        *pArgBase = (CORDB_ADDRESS)NULL;

        // First, read the VASigCookie pointer.
        TADDR taVASigCookie = (TADDR)NULL;
        SafeReadStructOrThrow(VASigCookieAddr, &taVASigCookie);

        // Now create a DAC copy of VASigCookie.
        VASigCookie * pVACookie = PTR_VASigCookie(taVASigCookie);

        // Figure out where the first argument is.
    #if defined(TARGET_X86) // (STACK_GROWS_DOWN_ON_ARGS_WALK)
        *pArgBase = VASigCookieAddr + pVACookie->sizeOfArgs;
    #else  // !TARGET_X86 (STACK_GROWS_UP_ON_ARGS_WALK)
        *pArgBase = VASigCookieAddr + sizeof(VASigCookie *);
    #endif // !TARGET_X86 (STACK_GROWS_UP_ON_ARGS_WALK)

        *pRetVal = TargetBuffer(PTR_TO_CORDB_ADDRESS(pVACookie->signature.GetRawSig()),
                            pVACookie->signature.GetRawSigLen());
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// returns TRUE if the type requires 8-byte alignment
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::RequiresAlign8(VMPTR_TypeHandle thExact, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

    #ifdef FEATURE_64BIT_ALIGNMENT
        TypeHandle th = TypeHandle::FromPtr(thExact.GetDacPtr());
        PTR_MethodTable mt = th.AsMethodTable();

        *pResult = mt->RequiresAlign8();
    #else
        ThrowHR(E_NOTIMPL);
    #endif
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Resolve the raw generics token to the real generics type token.  The resolution is based on the
// given index.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::ResolveExactGenericArgsToken(DWORD dwExactGenericArgsTokenIndex, GENERICS_TYPE_TOKEN rawToken, OUT GENERICS_TYPE_TOKEN * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if (dwExactGenericArgsTokenIndex == 0)
        {
            // In a rare case of VS4Mac debugging VS4Mac ARM64 optimized code we get a null generics argument token. We aren't sure
            // why the token is null, it may be a bug or it may be by design in the runtime. In the interest of time we are working
            // around the issue rather than investigating the root cause. This workaround should only cause us to degrade generic
            // types from exact type parameters to approximate or canonical type parameters. In the future if we discover this issue
            // is happening more frequently than we expect or the workaround is more impactful than we expect we may need to remove
            // this workaround and resolve the underlying issue.
            if (rawToken == 0)
            {
                *pRetVal = rawToken;
            }
            else
            {
                // In this case the real generics type token is the MethodTable of the "this" object.
                // Note that we want the target address here.

                // Incoming rawToken is actually a PTR_Object for the 'this' pointer.
                // Need to do some casting to convert GENERICS_TYPE_TOKEN --> PTR_Object
                TADDR addrObjThis = CORDB_ADDRESS_TO_TADDR(rawToken);
                PTR_Object pObjThis = dac_cast<PTR_Object>(addrObjThis);


                PTR_MethodTable pMT = pObjThis->GetMethodTable();

                // Now package up the PTR_MethodTable back into a GENERICS_TYPE_TOKEN
                TADDR addrMT = dac_cast<TADDR>(pMT);
                GENERICS_TYPE_TOKEN realToken = (GENERICS_TYPE_TOKEN) addrMT;
                *pRetVal = realToken;
            }
        }
        else if (dwExactGenericArgsTokenIndex == (DWORD)ICorDebugInfo::TYPECTXT_ILNUM)
        {
            // rawToken is already initialized correctly.  Nothing to do here.
            *pRetVal = rawToken;
        }
        else
        {
            // The index of the generics type token should not be anything else.
            // This is indeed an error condition, and so we throw here.
            _ASSERTE(!"DDII::REGAT - Unexpected generics type token index.");
            ThrowHR(CORDBG_E_TARGET_INCONSISTENT);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Check if the given method is a DiagnosticHidden or an LCG method.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsDiagnosticsHiddenOrLCGMethod(VMPTR_MethodDesc vmMethodDesc, OUT DynamicMethodType * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        MethodDesc * pMD = vmMethodDesc.GetDacPtr();

        if (pMD->IsDiagnosticsHidden())
        {
            *pRetVal = kDiagnosticHidden;
        }
        else if (pMD->IsLCGMethod())
        {
            *pRetVal = kLCGMethod;
        }
        else
        {
            *pRetVal = kNone;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//---------------------------------------------------------------------------------------
//
// Determine whether the specified thread is at a GC safe place.
//
// Arguments:
//    vmThread - the thread to be examined
//
// Return Value:
//    Return TRUE if the thread is at a GC safe place.
//    and under what conditions
//
// Notes:
//    This function basically does a one-frame stackwalk.
//    The logic is adopted from Debugger::IsThreadAtSafePlace().
//

BOOL DacDbiInterfaceImpl::IsThreadAtGCSafePlace(VMPTR_Thread vmThread)
{
    DD_ENTER_MAY_THROW;

    BOOL fIsGCSafe = FALSE;
    Thread * pThread = vmThread.GetDacPtr();

    T_CONTEXT ctx;
    REGDISPLAY rd;
    SetUpRegdisplayForStackWalk(pThread, &ctx, &rd);

    ULONG32 flags = (QUICKUNWIND | HANDLESKIPPEDFRAMES | DISABLE_MISSING_FRAME_DETECTION);

    StackFrameIterator iter;
    iter.Init(pThread, NULL, &rd, flags);

    CrawlFrame * pCF = &(iter.m_crawl);
    if (pCF->IsFrameless() && pCF->IsActiveFunc())
    {
        if (pCF->IsGcSafe())
        {
            fIsGCSafe = TRUE;
        }
    }

    return fIsGCSafe;
}

//---------------------------------------------------------------------------------------
//
// Return a partial user state of the specified thread.  The returned user state doesn't contain
// information about USER_UNSAFE_POINT.  The caller needs to call IsThreadAtGCSafePlace() to get
// the full user state.
//
// Arguments:
//    vmThread - the specified thread
//
// Return Value:
//    Return the partial user state except for USER_UNSAFE_POINT
//

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetPartialUserState(VMPTR_Thread vmThread, OUT CorDebugUserState * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        Thread * pThread = vmThread.GetDacPtr();
        Thread::ThreadState ts = pThread->GetState();

        UINT result = 0;
        if (ts & Thread::TS_Background)
        {
            result |= USER_BACKGROUND;
        }

        if (ts & Thread::TS_Unstarted)
        {
            result |= USER_UNSTARTED;
        }

        // Don't report a StopRequested if the thread has actually stopped.
        if (ts & Thread::TS_Stopped)
        {
            result |= USER_STOPPED;
        }

        if (ts & Thread::TS_WaitSleepJoin)
        {
            result |= USER_WAIT_SLEEP_JOIN;
        }

        if (pThread->IsThreadPoolThread())
        {
            result |= USER_THREADPOOL;
        }

        *pRetVal = (CorDebugUserState)result;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

//---------------------------------------------------------------------------------------
//
// Look up the EnC version number of a particular jitted instance of a managed method.
//
// Arguments:
//    pModule             - the module containing the managed method
//    vmMethodDesc        - the MethodDesc of the managed method
//    mdMethod            - the MethodDef metadata token of the managed method
//    pNativeStartAddress - the native start address of the jitted code
//    pJittedInstanceEnCVersion - out parameter; the version number of the version
//                                corresponding to the specified native start address
//    pLatestEnCVersion         - out parameter; the version number of the latest version
//
// Assumptions:
//    vmMethodDesc and mdMethod must match (see below).
//
// Notes:
//    mdMethod is not strictly necessary, since we can always get that from vmMethodDesc.
//    It is just a perf optimization since the caller has the metadata token around already.
//
//    Today, there is no way to retrieve the EnC version number from the RS data structures.
//    This primitive uses DAC to retrieve it from the LS data structures.  This function may
//    very well be ripped out in the future if we DACize this information, but the current
//    thinking is that some of the RS data structures will remain, most likely in a reduced form.
//

void DacDbiInterfaceImpl::LookupEnCVersions(Module*          pModule,
                                            VMPTR_MethodDesc vmMethodDesc,
                                            mdMethodDef      mdMethod,
                                            CORDB_ADDRESS    pNativeStartAddress,
                                            SIZE_T *         pLatestEnCVersion,
                                            SIZE_T *         pJittedInstanceEnCVersion /* = NULL */)
{
    MethodDesc * pMD     = vmMethodDesc.GetDacPtr();

    // make sure the vmMethodDesc and mdMethod match
    _ASSERTE(pMD->GetMemberDef() == mdMethod);

    _ASSERTE(pLatestEnCVersion != NULL);

#ifdef FEATURE_CODE_VERSIONING
    CodeVersionManager * pCodeVersionManager = pModule->GetCodeVersionManager();

    // Latest EnC version: the active IL code version for this method.
    ILCodeVersion activeILVersion = pCodeVersionManager->GetActiveILCodeVersion(dac_cast<PTR_Module>(pModule), mdMethod);
    *pLatestEnCVersion = activeILVersion.IsNull()
        ? (SIZE_T)CorDB_DEFAULT_ENC_FUNCTION_VERSION
        : activeILVersion.GetEnCVersion();

    // Jitted-instance EnC version: the version the native code at pNativeStartAddress was built from.
    if (pJittedInstanceEnCVersion != NULL)
    {
        *pJittedInstanceEnCVersion = CorDB_DEFAULT_ENC_FUNCTION_VERSION;
        if (pNativeStartAddress != (CORDB_ADDRESS)NULL)
        {
            NativeCodeVersion nativeCodeVersion = pCodeVersionManager->GetNativeCodeVersion(
                dac_cast<PTR_MethodDesc>(pMD),
                PINSTRToPCODE(CORDB_ADDRESS_TO_TADDR(pNativeStartAddress)));
            if (!nativeCodeVersion.IsNull())
            {
                *pJittedInstanceEnCVersion = nativeCodeVersion.GetILCodeVersion().GetEnCVersion();
            }
        }
    }
#else // !FEATURE_CODE_VERSIONING
    *pLatestEnCVersion = CorDB_DEFAULT_ENC_FUNCTION_VERSION;
    if (pJittedInstanceEnCVersion != NULL)
    {
        *pJittedInstanceEnCVersion = CorDB_DEFAULT_ENC_FUNCTION_VERSION;
    }
#endif // FEATURE_CODE_VERSIONING
}

// Get the address of the Debugger control block on the helper thread
// Arguments: none
// Return Value: The remote address of the Debugger control block allocated on the helper thread
//               if it has been successfully allocated or NULL otherwise.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetDebuggerControlBlockAddress(OUT CORDB_ADDRESS * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        if ((g_pDebugger != NULL) &&
            (g_pDebugger->m_pRCThread != NULL))
        {
            *pRetVal = CORDB_ADDRESS(dac_cast<TADDR>(g_pDebugger->m_pRCThread->GetDCB()));
        }
        else
        {
            *pRetVal = (CORDB_ADDRESS)NULL;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DacDbi API: Get the context for a particular thread of the target process
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetContext(VMPTR_Thread vmThread, DT_CONTEXT * pContextBuffer)
{
    DD_ENTER_MAY_THROW

    HRESULT hr = S_OK;
    EX_TRY
    {

        _ASSERTE(pContextBuffer != NULL);

        Thread *  pThread  = vmThread.GetDacPtr();

        // @dbgtodo  Once the filter context is removed, then we should always
        // start with the leaf CONTEXT.
        DT_CONTEXT * pFilterContext = reinterpret_cast<DT_CONTEXT *>(pThread->GetFilterContext());

        if (pFilterContext == NULL)
        {
            // If the filter context is NULL, then we use the true context of the thread.
            pContextBuffer->ContextFlags = DT_CONTEXT_ALL;
            HRESULT hrContext = m_pTarget->GetThreadContext(pThread->GetOSThreadId(),
                                                    pContextBuffer->ContextFlags,
                                                    sizeof(DT_CONTEXT),
                                                    reinterpret_cast<BYTE *>(pContextBuffer));
            if (hrContext == E_NOTIMPL)
            {
                // GetThreadContext is not implemented on this data target (e.g. Linux).
                // That's why we have to make do with context we can obtain from Frames explicitly stored in Thread object.
                // It suffices for managed debugging stackwalk.
                REGDISPLAY tmpRd = {};
                T_CONTEXT tmpContext = {};
                FillRegDisplay(&tmpRd, &tmpContext);

                // Going through thread Frames and looking for first (deepest one) one that
                // that has context available for stackwalking (SP and PC)
                // For example: RedirectedThreadFrame, InlinedCallFrame, DynamicHelperFrame
                Frame *frame = pThread->GetFrame();

                while (frame != NULL && frame != FRAME_TOP)
                {
#ifdef FEATURE_INTERPRETER
                    if (frame->GetFrameIdentifier() == FrameIdentifier::InterpreterFrame)
                    {
                        PTR_InterpreterFrame pInterpreterFrame = dac_cast<PTR_InterpreterFrame>(frame);
                        pInterpreterFrame->SetContextToInterpMethodContextFrame(&tmpContext);
                        CopyMemory(pContextBuffer, &tmpContext, sizeof(*pContextBuffer));
                        return S_OK;
                    }
#endif // FEATURE_INTERPRETER
                    frame->UpdateRegDisplay(&tmpRd);
                    if (GetRegdisplaySP(&tmpRd) != 0 && GetControlPC(&tmpRd) != 0)
                    {
                        UpdateContextFromRegDisp(&tmpRd, &tmpContext);
                        CopyMemory(pContextBuffer, &tmpContext, sizeof(*pContextBuffer));
                        pContextBuffer->ContextFlags = DT_CONTEXT_CONTROL
    #if defined(TARGET_AMD64) || defined(TARGET_ARM)
                                                    | DT_CONTEXT_INTEGER
    #endif
                        ;
#ifdef FEATURE_INTERPRETER
                        EECodeInfo codeInfo(GetIP(&tmpContext));
                        if (codeInfo.IsInterpretedCode())
                        {
                            pContextBuffer->ContextFlags |= DT_CONTEXT_INTEGER;
                        }
#endif // FEATURE_INTERPRETER
                        return S_OK;
                    }
                    frame = frame->Next();
                }

                // It looks like this thread is not running managed code.
                ZeroMemory(pContextBuffer, sizeof(*pContextBuffer));
            }
            else
            {
                IfFailThrow(hrContext);
            }
        }
        else
        {
            *pContextBuffer = *pFilterContext;
        }

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Create a VMPTR_Object from a target object address
// @dbgtodo validate the VMPTR_Object is in fact a object, possibly by DACizing
//          Object::Validate
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetObject(CORDB_ADDRESS ptr, OUT VMPTR_Object * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        VMPTR_Object vmObj = VMPTR_Object::NullPtr();
        vmObj.SetDacTargetPtr(CORDB_ADDRESS_TO_TADDR(ptr));
        *pRetVal = vmObj;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

typedef DPTR(OBJECTREF) PTR_ObjectRef;

// Create a VMPTR_Object from an address which points to a reference to an object
// @dbgtodo validate the VMPTR_Object is in fact a object, possibly by DACizing
//          Object::Validate
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetObjectFromRefPtr(CORDB_ADDRESS ptr, OUT VMPTR_Object * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        VMPTR_Object vmObj = VMPTR_Object::NullPtr();
        PTR_ObjectRef objRef = PTR_ObjectRef(CORDB_ADDRESS_TO_TADDR(ptr));
        vmObj.SetDacTargetPtr(PTR_TO_TADDR(*objRef));

        *pRetVal = vmObj;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Create a VMPTR_OBJECTHANDLE from a handle
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetVmObjectHandle(CORDB_ADDRESS handleAddress, OUT VMPTR_OBJECTHANDLE * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        VMPTR_OBJECTHANDLE vmObjHandle = VMPTR_OBJECTHANDLE::NullPtr();
        vmObjHandle.SetDacTargetPtr(CORDB_ADDRESS_TO_TADDR(handleAddress));

        *pRetVal = vmObjHandle;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// Validate that the VMPTR_OBJECTHANDLE refers to a legitimate managed object
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsVmObjectHandleValid(VMPTR_OBJECTHANDLE vmHandle, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        BOOL ret = FALSE;
        // this may cause unallocated debuggee memory to be read
        // SEH exceptions will be caught
        EX_TRY
        {
            OBJECTREF objRef = ObjectFromHandle((OBJECTHANDLE)vmHandle.GetDacPtr());

            // NULL is certainly valid...
            if (objRef != NULL)
            {
                if (objRef->ValidateObjectWithPossibleAV())
                {
                    ret = TRUE;
                }
            }
        }
        EX_CATCH
        {
        }
        EX_END_CATCH

        *pResult = ret;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Get the target address from a VMPTR_OBJECTHANDLE, i.e., the handle address
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetHandleAddressFromVmHandle(VMPTR_OBJECTHANDLE vmHandle, OUT CORDB_ADDRESS * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        CORDB_ADDRESS handle = vmHandle.GetDacPtr();

        *pRetVal = handle;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// ============================================================================
// functions to get information about objects referenced via an instance of CordbReferenceValue or
// CordbHandleValue
// ============================================================================

// DacDbiInterfaceImpl::FastSanityCheckObject
// Helper function for CheckRef. Sanity check an object.
// We use a fast and easy check to improve confidence that objPtr points to a valid object.
// We can't tell cheaply if this is really a valid object (that would require walking the GC heap), but at
// least we can check if we get an EEClass from the supposed method table and then get the method table from
// the class. If we can, we have improved the probability that the object is valid.
// Arguments:
//     input: objPtr - address of the object we are checking
// Return Value: E_INVALIDARG or S_OK.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::FastSanityCheckObject(PTR_Object objPtr)
{
    CONTRACTL
    {
        NOTHROW;
        GC_NOTRIGGER;
    }
    CONTRACTL_END;

    HRESULT hr = S_OK;

    EX_TRY
    {
        // NULL is certainly valid...
        if (objPtr != NULL)
        {
            if (!objPtr->ValidateObjectWithPossibleAV())
            {
                LOG((LF_CORDB, LL_INFO10000, "GOI: object methodtable-class invariant doesn't hold.\n"));
                hr = E_INVALIDARG;
            }
        }
    }
    EX_CATCH
    {
        LOG((LF_CORDB, LL_INFO10000, "GOI: exception indicated ref is bad.\n"));
        hr = E_INVALIDARG;
    }
    EX_END_CATCH

    return hr;
}   // DacDbiInterfaceImpl::FastSanityCheckObject

// Perform a sanity check on an object address to determine if this _could be_ a valid object.
// We can't tell this for certain without walking the GC heap, but we do some fast tests to rule
// out clearly invalid object addresses. See code:DacDbiInterfaceImpl::FastSanityCheckObject for more
// details.
// Arguments:
//     input:  objPtr    - address of the object we are checking
// Return Value:
//             objRefBad - true iff we have determined the address cannot be pointing to a valid object.
//                         Note that a value of false doesn't necessarily guarantee the object is really
//                         valid
bool DacDbiInterfaceImpl::CheckRef(PTR_Object objPtr)
{
    bool objRefBad = false;

    // Shortcut null references now...
    if (objPtr == NULL)
    {
        LOG((LF_CORDB, LL_INFO10000, "D::GOI: ref is NULL.\n"));

        objRefBad = true;
    }
    else
    {
        // Try to verify the integrity of the object. This is not fool proof.
        // @todo - this whole idea of expecting AVs is broken, but it does rule
        // out a fair bit of rubbish. Find another
        // way to test if the object is valid?
        if (FAILED(FastSanityCheckObject(objPtr)))
        {
            LOG((LF_CORDB, LL_INFO10000, "D::GOI: address is not a valid object.\n"));

            objRefBad = true;
        }
    }

    return objRefBad;
} // DacDbiInterfaceImpl::CheckRef

// DAC/DBI API

// Get object information for a TypedByRef object (System.TypedReference).

// These are objects that contain a managed pointer to a location and the type of the value at that location.
// They are most commonly used for varargs but also may be used for parameters and locals. They are
// stack-allocated. They provide a means for adding dynamic type information to a value type, whereas boxing
// provides only static type information. This means they can be passed as reference parameters to
// polymorphic methods that don't statically restrict the type of arguments they can receive.

// Although they are represented simply as an address, unlike other object references, they don't point
// directly to the object. Instead, there is an extra level of indirection. The reference points to a struct
// that contains the address of the object, so we need to treat them differently. They have their own
// CorElementType (ELEMENT_TYPE_TYPEDBYREF) which makes it possible to identify this special case.

// Example:
// static int AddABunchOfInts (__arglist)
// {
//     int result = 0;
//
//     System.ArgIterator iter = new System.ArgIterator (__arglist);
//     int argCount = iter.GetRemainingCount();
//
//     for (int i = 0; i < argCount; i++)
//     {
//         System.TypedReference typedRef = iter.GetNextArg();
//         result += (int)TypedReference.ToObject(typedRef);
//     }
//
//     return result;
// }
//
// static int Main (string[] args)
// {
//     int result = AddABunchOfInts (__arglist (2, 3, 4));
//     Console.WriteLine ("Answer: {0}", result);
//
//     if (result != 9)
//         return 1;
//
//     return 0;
// }

// Initializes the objRef and typedByRefType fields of pObjectData (type info for the referent).
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetTypedByRefInfo(CORDB_ADDRESS pTypedByRef, CORDB_ADDRESS * pObjRef, DebuggerIPCE_BasicTypeData * pTypedByRefType)
{
     DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        // pTypedByRef is really the address of a TypedByRef struct rather than of a normal object.
        // The data field of the TypedByRef struct is the actual object ref.
        PTR_TypedByRef refAddr = PTR_TypedByRef(TADDR(pTypedByRef));

        _ASSERTE(refAddr != NULL);
        _ASSERTE(pObjRef != NULL);
        _ASSERTE(pTypedByRefType != NULL);

        // The type of the referent is in the type field of the TypedByRef. We need to initialize the object
        // data type information.
        TypeHandleToBasicTypeInfo(refAddr->type, pTypedByRefType);

        // The reference to the object is in the data field of the TypedByRef.
        *pObjRef = dac_cast<TADDR>(refAddr->data);

        LOG((LF_CORDB, LL_INFO10000, "D::GASOI: sending REFANY result: "
             "ref=0x%08x, cls=0x%08x, mod=0x%p\n",
             *pObjRef,
             pTypedByRefType->metadataToken,
             pTypedByRefType->vmAssembly.GetDacPtr()));
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// Get the string data associated with obj and put it into the pointers
// DAC/DBI API
// Get the string length and offset to string base for a string object
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetStringData(CORDB_ADDRESS objectAddress, UINT * pLength, UINT * pOffsetToStringBase)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        PTR_Object objPtr = PTR_Object(TADDR(objectAddress));
        LOG((LF_CORDB, LL_INFO10000, "D::GOI: The referent is a string.\n"));

        if (objPtr->GetGCSafeMethodTable() != g_pStringClass)
        {
            ThrowHR(CORDBG_E_TARGET_INCONSISTENT);
        }

        PTR_StringObject pStrObj = dac_cast<PTR_StringObject>(objPtr);

        _ASSERTE(pStrObj != NULL);
        *pLength = pStrObj->GetStringLength();
        *pOffsetToStringBase = (UINT_PTR) pStrObj->GetBufferOffset();

    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


// DAC/DBI API
// Get information for an array type referent of an objRef, including rank, upper and lower
// bounds, element size and type, and the number of elements.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetArrayData(CORDB_ADDRESS objectAddress, BOOL * pIsValidArray, DacDbiArrayInfo * pArrayInfo)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        PTR_Object objPtr = PTR_Object(TADDR(objectAddress));
        PTR_MethodTable pMT = objPtr->GetGCSafeMethodTable();

        if (!objPtr->GetGCSafeTypeHandle().IsArray())
        {
            LOG((LF_CORDB, LL_INFO10000,
                 "D::GASOI: object should be an array.\n"));

            *pIsValidArray = FALSE;
        }
        else
        {
            *pIsValidArray = TRUE;
            PTR_ArrayBase arrPtr = dac_cast<PTR_ArrayBase>(objPtr);

            // this is also returned in the type information for the array - we return both for sanity checking...
            pArrayInfo->rank = arrPtr->GetRank();
            pArrayInfo->componentCount = arrPtr->GetNumComponents();
            pArrayInfo->offsetToArrayBase = arrPtr->GetDataPtrOffset(pMT);

            if (arrPtr->IsMultiDimArray())
            {
                pArrayInfo->offsetToUpperBounds = SIZE_T(arrPtr->GetBoundsOffset(pMT));

                pArrayInfo->offsetToLowerBounds = SIZE_T(arrPtr->GetLowerBoundsOffset(pMT));
            }
            else
            {
                pArrayInfo->offsetToUpperBounds = 0;
                pArrayInfo->offsetToLowerBounds = 0;
            }

            pArrayInfo->elementSize = (UINT)arrPtr->GetComponentSize();

            LOG((LF_CORDB, LL_INFO10000, "D::GOI: array info: "
                "baseOff=%u, lowerOff=%u, upperOff=%u, cnt=%u, rank=%u, "
                 "eleSize=%u\n",
                 pArrayInfo->offsetToArrayBase,
                 pArrayInfo->offsetToLowerBounds,
                 pArrayInfo->offsetToUpperBounds,
                 pArrayInfo->componentCount,
                 pArrayInfo->rank,
                 pArrayInfo->elementSize));
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DAC/DBI API: Get information about an object for which we have a reference, including the object size and
// type information.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetBasicObjectInfo(CORDB_ADDRESS objectAddress, BOOL * pIsValidRef, UINT * pObjSize, UINT * pObjOffsetToVars, DebuggerIPCE_ExpandedTypeData * pObjTypeData)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        PTR_Object objPtr = PTR_Object(TADDR(objectAddress));
        BOOL objRefBad = CheckRef(objPtr);
        *pIsValidRef = !objRefBad;
        if (!objRefBad)
        {
            // initialize object type, size, offset information. Note: We may have a different element type
            // after this. For example, we may start with E_T_CLASS but return with something more specific.
            *pObjSize = (UINT)objPtr->GetSize();
            *pObjOffsetToVars = (UINT)(dac_cast<TADDR>((objPtr)->GetData()) - dac_cast<TADDR>(objPtr));

            IfFailThrow(TypeHandleToExpandedTypeInfo(AllBoxed, (CORDB_ADDRESS)objPtr->GetGCSafeTypeHandle().AsTAddr(), pObjTypeData));

            // If this is a string object, set the type to ELEMENT_TYPE_STRING.
            if (objPtr->GetGCSafeMethodTable() == g_pStringClass)
            {
                pObjTypeData->elementType = ELEMENT_TYPE_STRING;
            }
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DAC/DBI API:
// Returns the thread which owns the monitor lock on an object and the acquisition count
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetThreadOwningMonitorLock(VMPTR_Object vmObject, OUT MonitorLockInfo * pRetVal)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {
        MonitorLockInfo info;
        info.lockOwner = VMPTR_Thread::NullPtr();
        info.acquisitionCount = 0;

        Object* pObj = vmObject.GetDacPtr();

        DWORD threadId = 0;
        DWORD recursionCount = 0;
        SyncBlock* psb = pObj->GetHeader()->PassiveGetSyncBlock();
        BOOL isLockHeld = psb != NULL && psb->TryGetLockInfo(&threadId, &recursionCount);

        if (!isLockHeld)
        {
            *pRetVal = info;
        }
        else
        {
            Thread *pThread = ThreadStore::GetThreadList(NULL);
            while (pThread != NULL)
            {
                if(pThread->GetThreadId() == threadId)
                {
                    info.lockOwner.SetDacTargetPtr(PTR_HOST_TO_TADDR(pThread));
                    info.acquisitionCount = recursionCount + 1; // The runtime tracks recursion count starting at 0, but diagnostics users expect it to start at 1.
                    break;
                }
                pThread = ThreadStore::GetThreadList(pThread);
            }
            if (pThread == NULL)
            {
                _ASSERTE(!"A thread should have been found");
            }
            *pRetVal = info;
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

// DAC/DBI API:
// Enumerate all threads waiting on the monitor event for an object.
// Not implemented as this API is not believed to be called by any current consumers.
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateMonitorEventWaitList(VMPTR_Object vmObject, FP_THREAD_ENUMERATION_CALLBACK fpCallback, CALLBACK_DATA pUserData)
{
    return E_NOTIMPL;
}


HeapData::HeapData()
    : YoungestGenPtr(0), YoungestGenLimit(0), Gen0Start(0), Gen0End(0), SegmentCount(0), Segments(0)
{
}

HeapData::~HeapData()
{
    if (Segments)
        delete [] Segments;
}

LinearReadCache::LinearReadCache()
    : mCurrPageStart(0), mPageSize(0), mCurrPageSize(0), mPage(0)
{
    SYSTEM_INFO si;
	GetSystemInfo(&si);

    mPageSize = si.dwPageSize;
    mPage = new (nothrow) BYTE[mPageSize];
}

LinearReadCache::~LinearReadCache()
{
    if (mPage)
        delete [] mPage;
}

bool LinearReadCache::MoveToPage(CORDB_ADDRESS addr)
{
    mCurrPageStart = addr - (addr % mPageSize);
    HRESULT hr = g_dacImpl->m_pTarget->ReadVirtual(mCurrPageStart, mPage, mPageSize, &mCurrPageSize);

    if (hr != S_OK)
    {
        mCurrPageStart = 0;
        mCurrPageSize = 0;
        return false;
    }

    return true;
}


CORDB_ADDRESS DacHeapWalker::HeapStart = 0;
CORDB_ADDRESS DacHeapWalker::HeapEnd = ~0;

DacHeapWalker::DacHeapWalker()
    : mAllocContextCount(0), mAllocInfo(0), mHeapCount(0), mHeaps(0),
        mCurrObj(0), mCurrSize(0), mCurrMT(0),
        mCurrHeap(0), mCurrSeg(0), mStart((TADDR)HeapStart), mEnd((TADDR)HeapEnd)
{
}

DacHeapWalker::~DacHeapWalker()
{
    if (mAllocInfo)
        delete [] mAllocInfo;

    if (mHeaps)
        delete [] mHeaps;
}

SegmentData *DacHeapWalker::FindSegment(CORDB_ADDRESS obj)
{
    for (size_t i = 0; i < mHeapCount; ++i)
        for (size_t j = 0; j < mHeaps[i].SegmentCount; ++j)
            if (mHeaps[i].Segments[j].Start <= obj && obj <= mHeaps[i].Segments[j].End)
                return &mHeaps[i].Segments[j];

    return NULL;
}

HRESULT DacHeapWalker::Next(CORDB_ADDRESS *pValue, CORDB_ADDRESS *pMT, ULONG64 *pSize)
{
    if (!HasMoreObjects())
        return E_FAIL;

    if (pValue)
        *pValue = mCurrObj;

    if (pMT)
        *pMT = (CORDB_ADDRESS)mCurrMT;

    if (pSize)
        *pSize = (ULONG64)mCurrSize;

    mCurrObj += mCurrSize;

    bool isGen0 = IsRegionGCEnabled() ? (mHeaps[mCurrHeap].Segments[mCurrSeg].Generation == 0) :
                                   (mHeaps[mCurrHeap].Gen0Start <= mCurrObj && mHeaps[mCurrHeap].Gen0End > mCurrObj);
    if (isGen0)
        CheckAllocAndSegmentRange();

    if (mCurrObj >= mHeaps[mCurrHeap].Segments[mCurrSeg].End || mCurrObj > mEnd)
    {
        return AdvanceToNextValidSegment();
    }

    if (!mCache.ReadMT(mCurrObj, &mCurrMT) || !GetSize(mCurrMT, mCurrSize))
    {
        (void)AdvanceToNextValidSegment();
        return E_FAIL;
    }

    return S_OK;
}

bool DacHeapWalker::GetSize(TADDR tMT, size_t &size)
{
    // With heap corruption, it's entirely possible that the MethodTable
    // we get is bad.  This could cause exceptions, which we will catch
    // and return false.  This causes the heapwalker to move to the next
    // segment.
    bool ret = true;
    EX_TRY
    {
        MethodTable *mt = PTR_MethodTable(tMT);
        size_t cs = mt->GetComponentSize();

        if (cs)
        {
            DWORD tmp = 0;
            if (mCache.Read(mCurrObj + sizeof(TADDR), &tmp))
                cs *= tmp;
            else
                ret = false;
        }

        size = mt->GetBaseSize() + cs;

        // The size is not guaranteed to be aligned, we have to
        // do that ourself.
        if (mHeaps[mCurrHeap].Segments[mCurrSeg].Generation == 3
            || mHeaps[mCurrHeap].Segments[mCurrSeg].Generation == 4)
            size = AlignLarge(size);
        else
            size = Align(size);

        // If size == 0, it means we have a heap corruption and
        // we will stuck in an infinite loop, so better fail the call now.
        ret &= (0 < size);
        // Also guard for cases where the size reported is too large and exceeds the high allocation mark.
        ret &= ((mCurrObj + size) <= mHeaps[mCurrHeap].Segments[mCurrSeg].End);
    }
    EX_CATCH
    {
        ret = false;
    }
    EX_END_CATCH

    return ret;
}


HRESULT DacHeapWalker::AdvanceToNextValidSegment()
{
    HRESULT hr = S_OK;
    mCurrObj = 0;
    mCurrMT = 0;
    mCurrSize = 0;

    bool gotValidStart = false;
    do
    {
        // If we run out of segments entirely, we're done.
        do
        {
            mCurrSeg++;
            while (mCurrSeg >= mHeaps[mCurrHeap].SegmentCount)
            {
                mCurrSeg = 0;
                mCurrHeap++;

                if (mCurrHeap >= mHeapCount)
                {
                    // If we accumulated an E_FAIL while trying
                    // to skip a corrupt segment, propagate it so the caller
                    // knows the walk didn't end cleanly.
                    return (hr == S_OK) ? S_FALSE : hr;
                }
            }
        } while (mHeaps[mCurrHeap].Segments[mCurrSeg].Start >= mHeaps[mCurrHeap].Segments[mCurrSeg].End);

        if ((mHeaps[mCurrHeap].Segments[mCurrSeg].Start > mEnd)
            || (mHeaps[mCurrHeap].Segments[mCurrSeg].End < mStart))
        {
            continue;
        }

        mCurrObj = mHeaps[mCurrHeap].Segments[mCurrSeg].Start;

        bool isGen0 = IsRegionGCEnabled() ? (mHeaps[mCurrHeap].Segments[mCurrSeg].Generation == 0) :
                                   (mHeaps[mCurrHeap].Gen0Start <= mCurrObj && mHeaps[mCurrHeap].Gen0End > mCurrObj);

        if (isGen0)
            CheckAllocAndSegmentRange();

        gotValidStart = mCache.ReadMT(mCurrObj, &mCurrMT) && GetSize(mCurrMT, mCurrSize);
        if (!gotValidStart)
        {
            mCurrObj = 0;
            mCurrMT = 0;
            mCurrSize = 0;
            // Remember that we skipped over corruption so callers can distinguish
            // "advanced cleanly" (S_OK) from "advanced past a target-read failure.
            hr = E_FAIL;
        }
    } while (!gotValidStart);

    return hr;
}

void DacHeapWalker::CheckAllocAndSegmentRange()
{
    const size_t MinObjSize = sizeof(TADDR)*3;

    for (int i = 0; i < mAllocContextCount; ++i)
        if (mCurrObj == mAllocInfo[i].Ptr)
        {
            mCurrObj = mAllocInfo[i].Limit + Align(MinObjSize);
            break;
        }

    if (mCurrObj == mHeaps[mCurrHeap].YoungestGenPtr)
    {
        mCurrObj = mHeaps[mCurrHeap].YoungestGenLimit + Align(MinObjSize);
    }
}

HRESULT DacHeapWalker::Init(CORDB_ADDRESS start, CORDB_ADDRESS end)
{
    // Collect information about the allocation contexts in the process.
    ThreadStore* threadStore = ThreadStore::s_pThreadStore;
    if (threadStore != NULL)
    {
        int count = (int)threadStore->ThreadCountInEE();
        mAllocInfo = new (nothrow) AllocInfo[count + 1];
        if (mAllocInfo == NULL)
            return E_OUTOFMEMORY;

        Thread *thread = NULL;
        int j = 0;
        for (int i = 0; i < count; ++i)
        {
            // The thread or allocation context being null is troubling, but not fatal.
            // We may have stopped the process where the thread list or thread's alloc
            // context was in an inconsistent state.  We will simply skip over affected
            // segments during the heap walk if we encounter problems due to this.
            thread = ThreadStore::GetThreadList(thread);
            if (thread == NULL)
                continue;

            gc_alloc_context *ctx = thread->GetAllocContext();
            if (ctx == NULL)
                continue;

            if ((CORDB_ADDRESS)ctx->alloc_ptr != (CORDB_ADDRESS)NULL)
            {
                mAllocInfo[j].Ptr = (CORDB_ADDRESS)ctx->alloc_ptr;
                mAllocInfo[j].Limit = (CORDB_ADDRESS)ctx->alloc_limit;
                j++;
            }
        }
        gc_alloc_context globalCtx = ((ee_alloc_context)g_global_alloc_context).m_GCAllocContext;
        if (globalCtx.alloc_ptr != nullptr)
        {
            mAllocInfo[j].Ptr = (CORDB_ADDRESS)globalCtx.alloc_ptr;
            mAllocInfo[j].Limit = (CORDB_ADDRESS)globalCtx.alloc_limit;
            j++;
        }

        mAllocContextCount = j;
    }

#ifdef FEATURE_SVR_GC
    HRESULT hr = GCHeapUtilities::IsServerHeap() ? InitHeapDataSvr(mHeaps, mHeapCount) : InitHeapDataWks(mHeaps, mHeapCount);
#else
    HRESULT hr = InitHeapDataWks(mHeaps, mHeapCount);
#endif

    // Set up mCurrObj/mCurrMT.
    if (SUCCEEDED(hr))
        hr = Reset(start, end);

    // Collect information about GC heaps
    return hr;
}

HRESULT DacHeapWalker::Reset(CORDB_ADDRESS start, CORDB_ADDRESS end)
{
    _ASSERTE(mHeaps);
    _ASSERTE(mHeapCount > 0);
    _ASSERTE(mHeaps[0].Segments);
    _ASSERTE(mHeaps[0].SegmentCount > 0);

    mStart = start;
    mEnd = end;

    // Set up first object
    mCurrObj = mHeaps[0].Segments[0].Start;
    mCurrMT = 0;
    mCurrSize = 0;
    mCurrHeap = 0;
    mCurrSeg = 0;

    HRESULT hr = S_OK;

    // it's possible the first segment is empty
    if (mCurrObj >= mHeaps[0].Segments[0].End)
        hr = AdvanceToNextValidSegment();

    if (!mCache.ReadMT(mCurrObj, &mCurrMT))
        return E_FAIL;

    if (!GetSize(mCurrMT, mCurrSize))
        return E_FAIL;

    if (mCurrObj < mStart || mCurrObj > mEnd)
        hr = AdvanceToNextValidSegment();

    return hr;
}

HRESULT DacHeapWalker::ListNearObjects(CORDB_ADDRESS obj, CORDB_ADDRESS *pPrev, CORDB_ADDRESS *pContaining, CORDB_ADDRESS *pNext)
{
    SegmentData *seg = FindSegment(obj);

    if (seg == NULL)
        return E_FAIL;

    HRESULT hr = Reset(seg->Start, seg->End);
    if (SUCCEEDED(hr))
    {
        CORDB_ADDRESS prev = 0;
        CORDB_ADDRESS curr = 0;
        ULONG64 size = 0;
        bool found = false;

        while (!found && HasMoreObjects())
        {
            prev = curr;
            hr = Next(&curr, NULL, &size);
            if (FAILED(hr))
                break;

            if (obj >= curr && obj < curr + size)
                found = true;
        }

        if (found)
        {
            if (pPrev)
                *pPrev = prev;

            if (pContaining)
                *pContaining = curr;

            if (pNext)
            {
                if (HasMoreObjects())
                {
                    hr = Next(&curr, NULL, NULL);
                    if (SUCCEEDED(hr))
                        *pNext = curr;
                }
                else
                {
                    *pNext = 0;
                }
            }

            hr = S_OK;
        }
        else if (SUCCEEDED(hr))
        {
            hr = E_FAIL;
        }
    }

    return hr;
}

HRESULT DacHeapWalker::InitHeapDataWks(HeapData *&pHeaps, size_t &pCount)
{
    bool regions = IsRegionGCEnabled();

    // Scrape basic heap details
    pCount = 1;
    pHeaps = new (nothrow) HeapData[1];
    if (pHeaps == NULL)
        return E_OUTOFMEMORY;

    dac_generation gen0 = GenerationTableIndex(g_gcDacGlobals->generation_table, 0);
    dac_generation gen1 = GenerationTableIndex(g_gcDacGlobals->generation_table, 1);
    dac_generation gen2 = GenerationTableIndex(g_gcDacGlobals->generation_table, 2);
    dac_generation loh  = GenerationTableIndex(g_gcDacGlobals->generation_table, 3);
    dac_generation poh  = GenerationTableIndex(g_gcDacGlobals->generation_table, 4);

    pHeaps[0].YoungestGenPtr = (CORDB_ADDRESS)gen0.allocation_context.alloc_ptr;
    pHeaps[0].YoungestGenLimit = (CORDB_ADDRESS)gen0.allocation_context.alloc_limit;

    if (!regions)
    {
        pHeaps[0].Gen0Start = (CORDB_ADDRESS)gen0.allocation_start;
        pHeaps[0].Gen0End = (CORDB_ADDRESS)*g_gcDacGlobals->alloc_allocated;
        pHeaps[0].Gen1Start = (CORDB_ADDRESS)gen1.allocation_start;
    }

    // Segments
    int count = GetSegmentCount(loh.start_segment);
    count += GetSegmentCount(poh.start_segment);
    count += GetSegmentCount(gen2.start_segment);
    if (regions)
    {
        count += GetSegmentCount(gen1.start_segment);
        count += GetSegmentCount(gen0.start_segment);
    }

    pHeaps[0].SegmentCount = count;
    pHeaps[0].Segments = new (nothrow) SegmentData[count];
    if (pHeaps[0].Segments == NULL)
        return E_OUTOFMEMORY;

    DPTR(dac_heap_segment) seg;
    int i = 0;

    // Small object heap segments
    if (regions)
    {
        seg = gen2.start_segment;
        for (; seg && (i < count); ++i)
        {
            pHeaps[0].Segments[i].Generation = seg->flags & HEAP_SEGMENT_FLAGS_READONLY ? CorDebug_NonGC : CorDebug_Gen2;
            pHeaps[0].Segments[i].Start = (CORDB_ADDRESS)seg->mem;
            pHeaps[0].Segments[i].End = (CORDB_ADDRESS)seg->allocated;

            seg = seg->next;
        }
        seg = gen1.start_segment;
        for (; seg && (i < count); ++i)
        {
            pHeaps[0].Segments[i].Generation = CorDebug_Gen1;
            pHeaps[0].Segments[i].Start = (CORDB_ADDRESS)seg->mem;
            pHeaps[0].Segments[i].End = (CORDB_ADDRESS)seg->allocated;

            seg = seg->next;
        }
        seg = gen0.start_segment;
        for (; seg && (i < count); ++i)
        {
            pHeaps[0].Segments[i].Start = (CORDB_ADDRESS)seg->mem;
            if (seg.GetAddr() == (TADDR)*g_gcDacGlobals->ephemeral_heap_segment)
            {
                pHeaps[0].Segments[i].End = (CORDB_ADDRESS)*g_gcDacGlobals->alloc_allocated;
                pHeaps[0].EphemeralSegment = i;
            }
            else
            {
                pHeaps[0].Segments[i].End = (CORDB_ADDRESS)seg->allocated;
            }
            pHeaps[0].Segments[i].Generation = CorDebug_Gen0;

            seg = seg->next;
        }
    }
    else
    {
        DPTR(dac_heap_segment) seg = gen2.start_segment;
        for (; seg && (i < count); ++i)
        {
            pHeaps[0].Segments[i].Start = (CORDB_ADDRESS)seg->mem;
            if (seg.GetAddr() == (TADDR)*g_gcDacGlobals->ephemeral_heap_segment)
            {
                pHeaps[0].Segments[i].End = (CORDB_ADDRESS)*g_gcDacGlobals->alloc_allocated;
                pHeaps[0].Segments[i].Generation = CorDebug_Gen1;
                pHeaps[0].EphemeralSegment = i;
            }
            else
            {
                pHeaps[0].Segments[i].End = (CORDB_ADDRESS)seg->allocated;
                pHeaps[0].Segments[i].Generation = seg->flags & HEAP_SEGMENT_FLAGS_READONLY ? CorDebug_NonGC : CorDebug_Gen2;
            }

            seg = seg->next;
        }
    }

    // Large object heap segments
    seg = loh.start_segment;
    for (; seg && (i < count); ++i)
    {
        pHeaps[0].Segments[i].Generation = CorDebug_LOH;
        pHeaps[0].Segments[i].Start = (CORDB_ADDRESS)seg->mem;
        pHeaps[0].Segments[i].End = (CORDB_ADDRESS)seg->allocated;

        seg = seg->next;
    }

    // Pinned object heap segments
    seg = poh.start_segment;
    for (; seg && (i < count); ++i)
    {
        pHeaps[0].Segments[i].Generation = CorDebug_POH;
        pHeaps[0].Segments[i].Start = (CORDB_ADDRESS)seg->mem;
        pHeaps[0].Segments[i].End = (CORDB_ADDRESS)seg->allocated;

        seg = seg->next;
    }

    _ASSERTE(count == i);

    return S_OK;
}

 HRESULT DacDbiInterfaceImpl::CreateHeapWalk(IDacDbiInterface::HeapWalkHandle *pHandle)
{
    DD_ENTER_MAY_THROW;

    DacHeapWalker *data = new (nothrow) DacHeapWalker;
    if (data == NULL)
        return E_OUTOFMEMORY;

    HRESULT hr = data->Init();
    if (SUCCEEDED(hr))
        *pHandle = reinterpret_cast<HeapWalkHandle>(data);
    else
        delete data;

    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::DeleteHeapWalk(HeapWalkHandle handle)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        DacHeapWalker *data = reinterpret_cast<DacHeapWalker*>(handle);
        if (data)
            delete data;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::WalkHeap(HeapWalkHandle handle,
                    ULONG count,
                    OUT COR_HEAPOBJECT * objects,
                    OUT ULONG *fetched)
{
    DD_ENTER_MAY_THROW;
    if (fetched == NULL)
        return E_INVALIDARG;

    DacHeapWalker *walk = reinterpret_cast<DacHeapWalker*>(handle);
    *fetched = 0;

    if (!walk->HasMoreObjects())
        return S_FALSE;

    CORDB_ADDRESS freeMT = (CORDB_ADDRESS)g_pFreeObjectMethodTable.GetAddr();

    HRESULT hr = S_OK;
    CORDB_ADDRESS addr, mt;
    ULONG64 size;

    ULONG i = 0;
    while (i < count && walk->HasMoreObjects())
    {
        hr = walk->Next(&addr, &mt, &size);

        // On a FAILED return Next() still has a valid prior object.
        if (mt != freeMT)
        {
            objects[i].address = addr;
            objects[i].type.token1 = mt;
            objects[i].type.token2 = 0;
            objects[i].size = size;
            i++;
        }

        if (FAILED(hr))
            break;
    }

    if (SUCCEEDED(hr))
        hr = (i < count) ? S_FALSE : S_OK;

    *fetched = i;
    return hr;
}



HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateHeapSegments(
    FP_HEAPSEGMENT_CALLBACK fpCallback,
    CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW;

    if (fpCallback == NULL)
        return E_POINTER;

    size_t heapCount = 0;
    HeapData *heaps = 0;

    bool region = IsRegionGCEnabled();

#ifdef FEATURE_SVR_GC
    HRESULT hr = GCHeapUtilities::IsServerHeap() ? DacHeapWalker::InitHeapDataSvr(heaps, heapCount) : DacHeapWalker::InitHeapDataWks(heaps, heapCount);
#else
    HRESULT hr = DacHeapWalker::InitHeapDataWks(heaps, heapCount);
#endif

    NewArrayHolder<HeapData> _heapHolder = heaps;

    if (FAILED(hr))
        return hr;

    // Now walk all segments and emit them through the callback.
    for (size_t i = 0; i < heapCount; ++i)
    {
        if (!region)
        {
            // Generation 0 is not in the segment list.
            fpCallback(heaps[i].Gen0Start, heaps[i].Gen0End, (int)CorDebug_Gen0, (ULONG)i, pUserData);
        }

        for (size_t j = 0; j < heaps[i].SegmentCount; ++j)
        {
            if (region)
            {
                fpCallback(
                    heaps[i].Segments[j].Start,
                    heaps[i].Segments[j].End,
                    (int)heaps[i].Segments[j].Generation,
                    (ULONG)i,
                    pUserData);
            }
            else if (heaps[i].Segments[j].Generation == 1)
            {
                // This is the ephemeral segment.  We have already written Gen0,
                // now write Gen1.
                _ASSERTE(heaps[i].Segments[j].Start <= heaps[i].Gen1Start);
                _ASSERTE(heaps[i].Segments[j].End > heaps[i].Gen1Start);

                fpCallback(heaps[i].Gen1Start, heaps[i].Gen0Start, (int)CorDebug_Gen1, (ULONG)i, pUserData);

                // It's possible for Gen2 to take up a portion of the ephemeral segment.
                // We test for that here.
                if (heaps[i].Segments[j].Start != heaps[i].Gen1Start)
                {
                    fpCallback(heaps[i].Segments[j].Start, heaps[i].Gen1Start, (int)CorDebug_Gen2, (ULONG)i, pUserData);
                }
            }
            else
            {
                // Otherwise, we have a gen2, POH, LOH or NonGC
                _ASSERTE(heaps[i].Segments[j].Generation <= CorDebug_NonGC);
                fpCallback(
                    heaps[i].Segments[j].Start,
                    heaps[i].Segments[j].End,
                    (int)heaps[i].Segments[j].Generation,
                    (ULONG)i,
                    pUserData);
            }
        }
    }

    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::IsValidObject(CORDB_ADDRESS obj, OUT BOOL * pResult)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        BOOL isValid = FALSE;

        if (obj != 0 && obj != (CORDB_ADDRESS)-1)
        {
            EX_TRY
            {
                PTR_Object pObj(TO_TADDR(obj));

                PTR_MethodTable mt = pObj->GetMethodTable();
                PTR_EEClass cls = mt->GetClass();

                if (mt == cls->GetMethodTable())
                    isValid = TRUE;
                else if (!mt->IsCanonicalMethodTable() || mt->IsContinuationWithoutMetadata())
                    isValid = cls->GetMethodTable()->GetClass() == cls;
            }
            EX_CATCH
            {
                isValid = FALSE;
            }
            EX_END_CATCH
        }

        *pResult = isValid;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::CreateRefWalk(OUT RefWalkHandle * pHandle, BOOL walkStacks, UINT32 handleWalkMask)
{
    DD_ENTER_MAY_THROW;

    DacRefWalker *walker = new (nothrow) DacRefWalker(this, walkStacks, handleWalkMask, TRUE);

    if (walker == NULL)
        return E_OUTOFMEMORY;

    HRESULT hr = walker->Init();
    if (FAILED(hr))
    {
        delete walker;
    }
    else
    {
        *pHandle = reinterpret_cast<RefWalkHandle>(walker);
    }

    return hr;
}


HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::DeleteRefWalk(RefWalkHandle handle)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        DacRefWalker *walker = reinterpret_cast<DacRefWalker*>(handle);

        if (walker)
            delete walker;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::WalkRefs(RefWalkHandle handle, ULONG count, OUT DacGcReference * objects, OUT ULONG *pFetched)
{
    if (objects == NULL || pFetched == NULL)
        return E_POINTER;

    DD_ENTER_MAY_THROW;

    DacRefWalker *walker = reinterpret_cast<DacRefWalker*>(handle);
    if (!walker)
        return E_INVALIDARG;

   return walker->Next(count, objects, pFetched);
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetTypeID(CORDB_ADDRESS dbgObj, COR_TYPEID *pID)
{
    DD_ENTER_MAY_THROW;

    TADDR obj[3];
    ULONG32 read = 0;
    HRESULT hr = g_dacImpl->m_pTarget->ReadVirtual(dbgObj, (BYTE*)obj, sizeof(obj), &read);
    if (FAILED(hr))
        return hr;

    pID->token1 = (UINT64)(obj[0] & ~1);
    pID->token2 = 0;

    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetTypeIDForType(VMPTR_TypeHandle vmTypeHandle, COR_TYPEID *pID)
{
    DD_ENTER_MAY_THROW;

    _ASSERTE(pID != NULL);
    _ASSERTE(!vmTypeHandle.IsNull());

    TypeHandle th = TypeHandle::FromPtr(vmTypeHandle.GetDacPtr());
    PTR_MethodTable pMT = th.GetMethodTable();
    pID->token1 = pMT.GetAddr();
    _ASSERTE(pID->token1 != 0);
    pID->token2 = 0;
    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetObjectFields(UINT64 id, ULONG32 celt, COR_FIELD *layout, ULONG32 *pceltFetched)
{
    if (pceltFetched == NULL)
        return E_POINTER;

    if (id == 0)
        return CORDBG_E_CLASS_NOT_LOADED;

    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;

    TypeHandle typeHandle = TypeHandle::FromPtr(TO_TADDR(id));

    if (typeHandle.IsTypeDesc())
        return E_INVALIDARG;

    typeHandle = typeHandle.UpCastTypeIfNeeded();

    ApproxFieldDescIterator fieldDescIterator(typeHandle.AsMethodTable(), ApproxFieldDescIterator::INSTANCE_FIELDS);

    ULONG32 cFields = fieldDescIterator.Count();

    // Handle case where user only wanted to know the number of fields.
    if (layout == NULL)
    {
        *pceltFetched = cFields;
        return S_FALSE;
    }

    if (celt < cFields)
    {
        cFields = celt;

        // we are returning less than the total
        hr = S_FALSE;
    }

    // This must be non-null due to check at beginning of function.
    *pceltFetched = celt;

    CorElementType componentType = typeHandle.AsMethodTable()->GetInternalCorElementType();
    BOOL fReferenceType = CorTypeInfo::IsObjRef_NoThrow(componentType);
    for (ULONG32 i = 0; i < cFields; ++i)
    {
        FieldDesc *pField = fieldDescIterator.Next();

        COR_FIELD* corField = layout + i;
        corField->token = pField->GetMemberDef();
        corField->offset = (ULONG32)pField->GetOffset() + (fReferenceType ? Object::GetOffsetOfFirstField() : 0);

        TypeHandle fieldHandle = pField->LookupFieldTypeHandle();

        if (fieldHandle.IsNull())
        {
            corField->id = {};
            corField->fieldType = (CorElementType)0;
        }
        else if (fieldHandle.IsByRef())
        {
            corField->fieldType = ELEMENT_TYPE_BYREF;
            // All ByRefs intentionally return IntPtr's MethodTable.
            corField->id.token1 = CoreLibBinder::GetElementType(ELEMENT_TYPE_I).GetAddr();
            corField->id.token2 = 0;
        }
        else
        {
            // Note that pointer types are handled in this path.
            // UIntPtr's MethodTable is set for all pointer types and is expected.
            PTR_MethodTable mt = fieldHandle.GetMethodTable();
            corField->fieldType = mt->GetInternalCorElementType();
            corField->id.token1 = (ULONG64)mt.GetAddr();
            corField->id.token2 = 0;
        }
    }

    return hr;
}


HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetTypeLayout(CORDB_ADDRESS id, COR_TYPE_LAYOUT *pLayout)
{
    if (pLayout == NULL)
        return E_POINTER;

    if (id == 0)
        return CORDBG_E_CLASS_NOT_LOADED;

    DD_ENTER_MAY_THROW;

    PTR_MethodTable mt = PTR_MethodTable(TO_TADDR(id));
    PTR_MethodTable parentMT = mt->GetParentMethodTable();

    COR_TYPEID parent = {parentMT.GetAddr(), 0};
    pLayout->parentID = parent;

    DWORD size = mt->GetBaseSize();
    ApproxFieldDescIterator fieldDescIterator(mt, ApproxFieldDescIterator::INSTANCE_FIELDS);

    pLayout->objectSize = size;
    pLayout->numFields = fieldDescIterator.Count();

    // Get type
    CorElementType componentType = mt->IsString() ? ELEMENT_TYPE_STRING : mt->GetInternalCorElementType();
    pLayout->type = componentType;
    pLayout->boxOffset = CorTypeInfo::IsObjRef_NoThrow(componentType) ? 0 : sizeof(TADDR);

    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetArrayLayout(CORDB_ADDRESS id, COR_ARRAY_LAYOUT *pLayout)
{
    if (pLayout == NULL)
        return E_POINTER;

    if (id == 0)
        return CORDBG_E_CLASS_NOT_LOADED;

    DD_ENTER_MAY_THROW;

    PTR_MethodTable mt = PTR_MethodTable(TO_TADDR(id));

    if (!mt->IsStringOrArray())
        return E_INVALIDARG;

    if (mt->IsString())
    {
        COR_TYPEID token;
        token.token1 = CoreLibBinder::GetElementType(ELEMENT_TYPE_CHAR).GetAddr();
        token.token2 = 0;

        pLayout->componentID = token;

        pLayout->rankSize = 4;
        pLayout->numRanks = 1;
        pLayout->rankOffset = sizeof(TADDR);
        pLayout->firstElementOffset = sizeof(TADDR) + 4;
        pLayout->countOffset = sizeof(TADDR);
        pLayout->componentType = ELEMENT_TYPE_CHAR;
        pLayout->elementSize = 2;
    }
    else
    {
        DWORD ranks = mt->GetRank();
        pLayout->rankSize = 4;
        pLayout->numRanks = ranks;
        bool multiDim = (ranks > 1);

        pLayout->rankOffset = multiDim ? sizeof(TADDR)*2 : sizeof(TADDR);
        pLayout->countOffset = sizeof(TADDR);
        pLayout->firstElementOffset = ArrayBase::GetDataPtrOffset(mt);


        TypeHandle hnd = mt->GetArrayElementTypeHandle();
        PTR_MethodTable cmt = hnd.GetMethodTable();

        CorElementType componentType = cmt->GetInternalCorElementType();
        if ((UINT64)cmt.GetAddr() == (UINT64)g_pStringClass.GetAddr())
            componentType = ELEMENT_TYPE_STRING;

        COR_TYPEID token;
        token.token1 = cmt.GetAddr();  // This could be type handle
        token.token2 = 0;
        pLayout->componentID = token;
        pLayout->componentType = componentType;

        if (CorTypeInfo::IsObjRef_NoThrow(componentType))
            pLayout->elementSize = sizeof(TADDR);
        else if (CorIsPrimitiveType(componentType))
            pLayout->elementSize = gElementTypeInfo[componentType].m_cbSize;
        else
            pLayout->elementSize = cmt->GetNumInstanceFieldBytes();
    }

    return S_OK;
}


HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetGCHeapInformation(OUT COR_HEAPINFO * pHeapInfo)
{
    DD_ENTER_MAY_THROW;

    HRESULT hr = S_OK;
    EX_TRY
    {

        size_t heapCount = 0;
        pHeapInfo->areGCStructuresValid = *g_gcDacGlobals->gc_structures_invalid_cnt == 0;

    #ifdef FEATURE_SVR_GC
        if (GCHeapUtilities::IsServerHeap())
        {
            pHeapInfo->gcType = CorDebugServerGC;
            pHeapInfo->numHeaps = DacGetNumHeaps();
        }
        else
    #endif
        {
            pHeapInfo->gcType = CorDebugWorkstationGC;
            pHeapInfo->numHeaps = 1;
        }

        pHeapInfo->pointerSize = sizeof(TADDR);
        pHeapInfo->concurrent = g_pConfig->GetGCconcurrent() ? TRUE : FALSE;
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}


HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetPEFileMDInternalRW(VMPTR_PEAssembly vmPEAssembly, OUT TADDR* pAddrMDInternalRW)
{
    DD_ENTER_MAY_THROW;
    if (pAddrMDInternalRW == NULL)
        return E_INVALIDARG;
    PEAssembly * pPEAssembly = vmPEAssembly.GetDacPtr();
    *pAddrMDInternalRW = pPEAssembly->GetMDInternalRWAddress();
    return S_OK;
}

#ifdef FEATURE_CODE_VERSIONING
HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetActiveRejitILCodeVersionNode(VMPTR_Module vmModule, mdMethodDef methodTk, OUT VMPTR_ILCodeVersionNode* pVmILCodeVersionNode)
{
    DD_ENTER_MAY_THROW;
    if (pVmILCodeVersionNode == NULL)
        return E_INVALIDARG;
#ifdef FEATURE_REJIT
    PTR_Module pModule = vmModule.GetDacPtr();
    CodeVersionManager * pCodeVersionManager = pModule->GetCodeVersionManager();
    // Be careful, there are two different definitions of 'active' being used here
    // For the CodeVersionManager, the active IL version is whatever one should be used in the next invocation of the method
    // 'rejit active' narrows that to only include rejit IL bodies where the profiler has already provided the definition
    // for the new IL (ilCodeVersion.GetRejitState()==RejitFlags::kStateActive). It is possible that the code version
    // manager's active IL version hasn't yet asked the profiler for the IL body to use, in which case we want to filter it
    //  out from the return in this method.
    ILCodeVersion activeILVersion = pCodeVersionManager->GetActiveILCodeVersion(pModule, methodTk);
    if (activeILVersion.IsNull() || activeILVersion.IsDefaultVersion() || activeILVersion.GetRejitState() != RejitFlags::kStateActive || activeILVersion.GetSource() != CodeVersionSource::kReJIT)
    {
        pVmILCodeVersionNode->SetDacTargetPtr(0);
    }
    else
    {
        pVmILCodeVersionNode->SetDacTargetPtr(PTR_TO_TADDR(activeILVersion.AsNode()));
    }
#else
    _ASSERTE(!"You shouldn't be calling this - rejit is not supported in this build");
    pVmILCodeVersionNode->SetDacTargetPtr(0);
#endif
    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetNativeCodeVersionNode(VMPTR_MethodDesc vmMethod, CORDB_ADDRESS codeStartAddress, OUT VMPTR_NativeCodeVersionNode* pVmNativeCodeVersionNode)
{
    DD_ENTER_MAY_THROW;
    if (pVmNativeCodeVersionNode == NULL)
        return E_INVALIDARG;
#ifdef FEATURE_REJIT
    PTR_MethodDesc pMD = vmMethod.GetDacPtr();
    CodeVersionManager * pCodeVersionManager = pMD->GetCodeVersionManager();
    NativeCodeVersion codeVersion = pCodeVersionManager->GetNativeCodeVersion(pMD, (PCODE)codeStartAddress);
    pVmNativeCodeVersionNode->SetDacTargetPtr(PTR_TO_TADDR(codeVersion.AsNode()));
#else
    pVmNativeCodeVersionNode->SetDacTargetPtr(0);
#endif
    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetILCodeVersionNode(VMPTR_NativeCodeVersionNode vmNativeCodeVersionNode, VMPTR_ILCodeVersionNode* pVmILCodeVersionNode)
{
    DD_ENTER_MAY_THROW;
    if (pVmILCodeVersionNode == NULL)
        return E_INVALIDARG;
#ifdef FEATURE_REJIT
    NativeCodeVersionNode* pNativeCodeVersionNode = vmNativeCodeVersionNode.GetDacPtr();
    ILCodeVersion ilCodeVersion = pNativeCodeVersionNode->GetILCodeVersion();
    if (ilCodeVersion.IsDefaultVersion() || ilCodeVersion.GetSource() != CodeVersionSource::kReJIT)
    {
        pVmILCodeVersionNode->SetDacTargetPtr(0);
    }
    else
    {
        pVmILCodeVersionNode->SetDacTargetPtr(PTR_TO_TADDR(ilCodeVersion.AsNode()));
    }

#else
    _ASSERTE(!"You shouldn't be calling this - rejit is not supported in this build");
    pVmILCodeVersionNode->SetDacTargetPtr(0);
#endif
    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetEnCILCodeAndSig(VMPTR_Module vmModule, mdMethodDef methodTk, SIZE_T enCVersion, TargetBuffer * pCodeInfo, mdSignature * pLocalSigToken)
{
    DD_ENTER_MAY_THROW;
    if (pCodeInfo == NULL || pLocalSigToken == NULL)
        return E_INVALIDARG;

    pCodeInfo->Clear();
    *pLocalSigToken = mdSignatureNil;

    PTR_Module pModule = vmModule.GetDacPtr();
    CodeVersionManager * pCodeVersionManager = pModule->GetCodeVersionManager();

    TADDR pTargetIL = 0; // target address of start of IL blob for the requested EnC version
    {
        CodeVersionManager::LockHolder codeVersioningLockHolder;

        // Find the explicit EnC IL code version stamped with the requested EnC version. The default
        // version has no explicit node (it represents the original, unedited IL), so it is skipped.
        ILCodeVersionCollection ilCodeVersions = pCodeVersionManager->GetILCodeVersions(pModule, methodTk);
        for (ILCodeVersionIterator cur = ilCodeVersions.Begin(), end = ilCodeVersions.End(); cur != end; cur++)
        {
            ILCodeVersion ilCodeVersion = *cur;
            if (!ilCodeVersion.IsDefaultVersion() &&
                ilCodeVersion.GetSource() == CodeVersionSource::kEnC &&
                ilCodeVersion.GetEnCVersion() == enCVersion)
            {
                pTargetIL = dac_cast<TADDR>(ilCodeVersion.GetIL());
                break;
            }
        }
    }

    if (pTargetIL != 0)
    {
        // Bring the IL blob over to the host and extract the code buffer and local var sig token.
        // We need the target address of the IL itself (beyond the header), so we add the offset from
        // the beginning of the host IL blob (the header) to the beginning of the IL to the target
        // address of the blob.
        COR_ILMETHOD * pHostIL = DacGetIlMethod(pTargetIL);
        COR_ILMETHOD_DECODER header(pHostIL);

        pCodeInfo->pAddress = pTargetIL + ((SIZE_T)(header.Code) - (SIZE_T)pHostIL);
        pCodeInfo->cbSize = header.GetCodeSize();

        if (header.LocalVarSigTok != mdTokenNil)
        {
            *pLocalSigToken = header.GetLocalVarSigTok();
        }
    }

    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetILCodeVersionNodeData(VMPTR_ILCodeVersionNode vmILCodeVersionNode, DacSharedReJitInfo* pData)
{
    DD_ENTER_MAY_THROW;
#ifdef FEATURE_REJIT
    ILCodeVersion ilCode(vmILCodeVersionNode.GetDacPtr());
    pData->m_pbIL = PTR_TO_CORDB_ADDRESS(dac_cast<TADDR>(ilCode.GetIL()));
    const InstrumentedILOffsetMapping* pMapping = ilCode.GetInstrumentedILMap();
    if (pMapping)
    {
        pData->m_cInstrumentedMapEntries = (ULONG)pMapping->GetCount();
        pData->m_rgInstrumentedMapEntries = PTR_TO_CORDB_ADDRESS(dac_cast<TADDR>(pMapping->GetOffsets()));
    }
    else
    {
        pData->m_cInstrumentedMapEntries = 0;
        pData->m_rgInstrumentedMapEntries = 0;
    }
#else
    _ASSERTE(!"You shouldn't be calling this - rejit isn't supported in this build");
#endif
    return S_OK;
}
#endif // FEATURE_CODE_VERSIONING

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::AreOptimizationsDisabled(VMPTR_Module vmModule, mdMethodDef methodTk, OUT BOOL* pOptimizationsDisabled)
{
    DD_ENTER_MAY_THROW;
    PTR_Module pModule = vmModule.GetDacPtr();
    if (pModule == NULL || pOptimizationsDisabled == NULL || TypeFromToken(methodTk) != mdtMethodDef)
    {
        return E_INVALIDARG;
    }
#ifdef FEATURE_REJIT
    {
        CodeVersionManager * pCodeVersionManager = pModule->GetCodeVersionManager();
        ILCodeVersion activeILVersion = pCodeVersionManager->GetActiveILCodeVersion(pModule, methodTk);
        *pOptimizationsDisabled = activeILVersion.IsDeoptimized();
    }
#else
    *pOptimizationsDisabled = FALSE;
#endif

    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetDefinesBitField(ULONG32 *pDefines)
{
    DD_ENTER_MAY_THROW;
    if (pDefines == NULL)
        return E_INVALIDARG;

    if (g_pDebugger == NULL)
        return CORDBG_E_NOTREADY;

    *pDefines = g_pDebugger->m_defines;
    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetMDStructuresVersion(ULONG32* pMDStructuresVersion)
{
    DD_ENTER_MAY_THROW;
    if (pMDStructuresVersion == NULL)
        return E_INVALIDARG;

    if (g_pDebugger == NULL)
        return CORDBG_E_NOTREADY;

    *pMDStructuresVersion = g_pDebugger->m_mdDataStructureVersion;
    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnableGCNotificationEvents(BOOL fEnable)
{
    DD_ENTER_MAY_THROW

    HRESULT hr = S_OK;
    EX_TRY
    {
        if (g_pDebugger != NULL)
        {
            TADDR addr = PTR_HOST_MEMBER_TADDR(Debugger, g_pDebugger, m_isGarbageCollectionEventsEnabled);
            SafeWriteStructOrThrow<BOOL>(addr, &fEnable);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetAssemblyFromModule(VMPTR_Module vmModule, OUT VMPTR_Assembly *pvmAssembly)
{
    DD_ENTER_MAY_THROW;

    if (vmModule.IsNull() || pvmAssembly == NULL)
        return E_INVALIDARG;

    Module *pModule = vmModule.GetDacPtr();
    if (pModule == NULL)
        return E_INVALIDARG;

    *pvmAssembly = VMPTR_Assembly::NullPtr();
    pvmAssembly->SetHostPtr(pModule->GetAssembly());

    return S_OK;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::ParseContinuation(
    CORDB_ADDRESS continuationAddress,
    OUT CORDB_ADDRESS* pDiagnosticIP,
    OUT CORDB_ADDRESS* pNextContinuation,
    OUT UINT32* pState)
{
    DD_ENTER_MAY_THROW

    PTR_Object continuationObjectPtr = PTR_Object(CORDB_ADDRESS_TO_TADDR(continuationAddress));
    OBJECTREF continuation = ObjectToOBJECTREF(continuationObjectPtr);

    PTR_MethodTable pDerivedMT = continuationObjectPtr->GetMethodTable();
    PTR_MethodTable pContinuationMT = pDerivedMT->GetParentMethodTable();

    struct ResumeInfo
    {
        PCODE pResume;
        PCODE pDiagnosticIP;
    };
    typedef DPTR(ResumeInfo) PTR_ResumeInfo;


    OBJECTREF pNext = nullptr;
    PTR_ResumeInfo pResumeInfo = nullptr;
    UINT32 state = 0;
    int numFound = 0;

    *pDiagnosticIP = 0;
    *pNextContinuation = 0;
    *pState = 0;

    ApproxFieldDescIterator continuationFieldIter(pContinuationMT, ApproxFieldDescIterator::INSTANCE_FIELDS);
    for (FieldDesc *continuationField = continuationFieldIter.Next(); continuationField != NULL && numFound < 3; continuationField = continuationFieldIter.Next())
    {
        LPCUTF8 fieldName = continuationField->GetName();
        if (!strcmp(fieldName, "Next"))
        {
            pNext = (OBJECTREF)dac_cast<PTR_Object>((TADDR)continuation->GetPtrOffset(continuationField->GetOffset()));
            numFound++;
        }
        else if (!strcmp(fieldName, "ResumeInfo"))
        {
            pResumeInfo = dac_cast<PTR_ResumeInfo>((TADDR)continuation->GetPtrOffset(continuationField->GetOffset()));
            numFound++;
        }
        else if (!strcmp(fieldName, "State"))
        {
            state = continuation->GetOffset32(continuationField->GetOffset());
            numFound++;
        }
    }

    if (numFound < 3)
    {
        return E_FAIL;
    }

    *pDiagnosticIP = static_cast<CORDB_ADDRESS>(pResumeInfo->pDiagnosticIP);
    *pNextContinuation = static_cast<CORDB_ADDRESS>(dac_cast<TADDR>(OBJECTREFToObject(pNext)));
    *pState = state;

    return S_OK;
}

// Allocator to pass to the debug-info-stores...
static BYTE* DebugInfoStoreNew(void * pData, size_t cBytes)
{
    return new (nothrow) BYTE[cBytes];
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::EnumerateAsyncLocals(VMPTR_MethodDesc vmMethod, CORDB_ADDRESS codeAddr, UINT32 state, FP_ASYNC_LOCAL_CALLBACK fpCallback, CALLBACK_DATA pUserData)
{
    DD_ENTER_MAY_THROW;

    _ASSERTE(fpCallback != NULL);

    HRESULT hr = S_OK;
    EX_TRY
    {

        MethodDesc* pMethodDesc = vmMethod.GetDacPtr();
        if (pMethodDesc->IsAsyncThunkMethod())
        {
            return hr;
        }
        TADDR nativeCodeStartAddr;
        if (codeAddr != (TADDR)NULL)
        {
            NativeCodeVersion requestedNativeCodeVersion = ExecutionManager::GetNativeCodeVersion(static_cast<PCODE>(codeAddr));
            if (requestedNativeCodeVersion.IsNull() || requestedNativeCodeVersion.GetNativeCode() == (PCODE)NULL)
            {
                return hr;
            }
            nativeCodeStartAddr = PCODEToPINSTR(requestedNativeCodeVersion.GetNativeCode());
        }
        else
        {
            nativeCodeStartAddr = PCODEToPINSTR(pMethodDesc->GetNativeCode());
        }

        DebugInfoRequest request;
        request.InitFromStartingAddr(pMethodDesc, nativeCodeStartAddr);

        ICorDebugInfo::AsyncInfo asyncInfo = {};
        NewArrayHolder<ICorDebugInfo::AsyncSuspensionPoint> asyncSuspensionPoints(NULL);
        NewArrayHolder<ICorDebugInfo::AsyncContinuationVarInfo> asyncVars(NULL);
        ULONG32 cAsyncVars = 0;

        BOOL success = DebugInfoManager::GetAsyncDebugInfo(
            request,
            DebugInfoStoreNew,
            nullptr,
            &asyncInfo,
            &asyncSuspensionPoints,
            &asyncVars,
            &cAsyncVars);

        if (!success) return hr;
        if (state >= asyncInfo.NumSuspensionPoints) return hr;

        UINT32 varBeginIndex = 0;
        for (UINT32 i = 0; i < state; i++)
        {
            varBeginIndex += asyncSuspensionPoints[i].NumContinuationVars;
        }

        UINT32 varCount = asyncSuspensionPoints[state].NumContinuationVars;

        _ASSERTE(varBeginIndex + varCount <= cAsyncVars);
        for (UINT32 i = 0; i < varCount; i++)
        {
            AsyncLocalData local;
            local.offset   = asyncVars[varBeginIndex + i].Offset;
            local.ilVarNum = asyncVars[varBeginIndex + i].VarNumber;
            fpCallback(&local, pUserData);
        }
    }
    EX_CATCH_HRESULT(hr);
    return hr;
}

HRESULT STDMETHODCALLTYPE DacDbiInterfaceImpl::GetGenericArgTokenIndex(VMPTR_MethodDesc vmMethod, OUT UINT32* pIndex)
{
    DD_ENTER_MAY_THROW;

    if (vmMethod.IsNull() || pIndex == NULL)
        return E_INVALIDARG;

    PTR_MethodDesc pMethod = vmMethod.GetDacPtr();

    if (!pMethod->IsSharedByGenericInstantiations())
    {
        // Not a shared generic method, so there is no generic token
        return S_FALSE;
    }

    if (pMethod->AcquiresInstMethodTableFromThis())
    {
        *pIndex = 0;
    }
    else
    {
        *pIndex = ICorDebugInfo::TYPECTXT_ILNUM;
    }

    return S_OK;
}

DacRefWalker::DacRefWalker(ClrDataAccess *dac, BOOL walkStacks, UINT32 handleMask, BOOL resolvePointers)
    : mDac(dac), mWalkStacks(walkStacks), mHandleMask(handleMask), mStackWalker(NULL),
      mResolvePointers(resolvePointers), mHandleWalker(NULL)
{
}

DacRefWalker::~DacRefWalker()
{
    Clear();
}

HRESULT DacRefWalker::Init()
{
    HRESULT hr = S_OK;
    if (mHandleMask)
    {
        // Will throw on OOM, which is fine.
        mHandleWalker = new DacHandleWalker();

        hr = mHandleWalker->Init(GetHandleWalkerMask());
    }

    if (mWalkStacks && SUCCEEDED(hr))
    {
        hr = NextThread();
    }

    return hr;
}

void DacRefWalker::Clear()
{
    if (mHandleWalker)
    {
        delete mHandleWalker;
        mHandleWalker = NULL;
    }

    if (mStackWalker)
    {
        delete mStackWalker;
        mStackWalker = NULL;
    }
}



UINT32 DacRefWalker::GetHandleWalkerMask()
{
    UINT32 result = 0;
    if (mHandleMask & CorHandleStrong)
        result |= (1 << HNDTYPE_STRONG);

    if (mHandleMask & CorHandleStrongPinning)
        result |= (1 << HNDTYPE_PINNED);

    if (mHandleMask & CorHandleWeakShort)
        result |= (1 << HNDTYPE_WEAK_SHORT);

    if (mHandleMask & CorHandleWeakLong)
        result |= (1 << HNDTYPE_WEAK_LONG);

#if defined(FEATURE_COMINTEROP) || defined(FEATURE_COMWRAPPERS) || defined(FEATURE_OBJCMARSHAL)
    if ((mHandleMask & CorHandleWeakRefCount) || (mHandleMask & CorHandleStrongRefCount))
        result |= (1 << HNDTYPE_REFCOUNTED);
#endif // FEATURE_COMINTEROP || FEATURE_COMWRAPPERS || FEATURE_OBJCMARSHAL

    if (mHandleMask & CorHandleStrongDependent)
        result |= (1 << HNDTYPE_DEPENDENT);

    return result;
}



HRESULT DacRefWalker::Next(ULONG celt, DacGcReference roots[], ULONG *pceltFetched)
{
    if (roots == NULL || pceltFetched == NULL)
        return E_POINTER;

    ULONG total = 0;
    HRESULT hr = S_OK;

    if (mHandleWalker)
    {
        hr = mHandleWalker->Next(celt, roots, &total);

        if (total == 0 || FAILED(hr))
        {
            delete mHandleWalker;
            mHandleWalker = NULL;

            if (FAILED(hr))
                return hr;
        }
    }

    while (total < celt && mStackWalker)
    {
        ULONG fetched = 0;
        hr = mStackWalker->Next(celt-total, roots+total, &fetched);

        if (FAILED(hr))
            return hr;

        if (fetched == 0)
        {
            hr = NextThread();

            if (FAILED(hr))
                return hr;
        }

        total += fetched;
    }

    *pceltFetched = total;

    return total < celt ? S_FALSE : S_OK;
}

HRESULT DacRefWalker::NextThread()
{
    Thread *pThread = NULL;
    if (mStackWalker)
    {
        pThread = mStackWalker->GetThread();
        delete mStackWalker;
        mStackWalker = NULL;
    }

    pThread = ThreadStore::GetThreadList(pThread);

    if (!pThread)
        return S_FALSE;

    mStackWalker = new DacStackReferenceWalker(mDac, pThread->GetOSThreadId(), mResolvePointers == TRUE);
    return mStackWalker->Init();
}

HRESULT DacHandleWalker::Next(ULONG count, DacGcReference roots[], ULONG *pFetched)
{
    SUPPORTS_DAC;

    if (roots == NULL || pFetched == NULL)
        return E_POINTER;

    if (!mEnumerated)
        WalkHandles();

    unsigned int i;
    for (i = 0; i < count && mIteratorIndex < mList.GetCount(); mIteratorIndex++, i++)
    {
        const SOSHandleData &handle = mList.Get(mIteratorIndex);

        roots[i].objHnd.SetDacTargetPtr(TO_TADDR(handle.Handle));
        roots[i].vmDomain.SetDacTargetPtr(TO_TADDR(handle.AppDomain));
        roots[i].i64ExtraData = 0;

        unsigned int refCnt = 0;
        switch (handle.Type)
        {
            case HNDTYPE_STRONG:
                roots[i].dwType = (DWORD)CorHandleStrong;
                break;

            case HNDTYPE_PINNED:
                roots[i].dwType = (DWORD)CorHandleStrongPinning;
                break;

            case HNDTYPE_WEAK_SHORT:
                roots[i].dwType = (DWORD)CorHandleWeakShort;
                break;

            case HNDTYPE_WEAK_LONG:
                roots[i].dwType = (DWORD)CorHandleWeakLong;
                break;

        #if defined(FEATURE_COMINTEROP) || defined(FEATURE_COMWRAPPERS) || defined(FEATURE_OBJCMARSHAL)
            case HNDTYPE_REFCOUNTED:
                GetRefCountedHandleInfo((OBJECTREF)CLRDATA_ADDRESS_TO_TADDR(handle.Handle), handle.Type, &refCnt, NULL, NULL, NULL);
                roots[i].i64ExtraData = refCnt;
                roots[i].dwType = (DWORD)(roots[i].i64ExtraData ? CorHandleStrongRefCount : CorHandleWeakRefCount);
                break;
        #endif // FEATURE_COMINTEROP || FEATURE_COMWRAPPERS || FEATURE_OBJCMARSHAL

            case HNDTYPE_DEPENDENT:
                roots[i].dwType = (DWORD)CorHandleStrongDependent;
                roots[i].i64ExtraData = GetDependentHandleSecondary(CLRDATA_ADDRESS_TO_TADDR(handle.Handle)).GetAddr();
                break;
        }
    }

    *pFetched = i;

    return (unsigned)mIteratorIndex < mList.GetCount() ? S_FALSE : S_OK;
}


HRESULT DacStackReferenceWalker::Next(ULONG count, DacGcReference stackRefs[], ULONG *pFetched)
{
    if (stackRefs == NULL || pFetched == NULL)
        return E_POINTER;

    if (!mEnumerated)
        WalkStack();

    TADDR domain = AppDomain::GetCurrentDomain().GetAddr();

    unsigned int i;
    for (i = 0; i < count && mIteratorIndex < mList.GetCount(); mIteratorIndex++, i++)
    {
        stackRefs[i].dwType = CorReferenceStack;
        stackRefs[i].vmDomain.SetDacTargetPtr(domain);
        stackRefs[i].i64ExtraData = 0;

        const SOSStackRefData &sosStackRef = mList.Get(i);
        if (sosStackRef.Flags & GC_CALL_INTERIOR || sosStackRef.Address == 0)
        {
            // Direct pointer case - interior pointer, Frame ref, or enregistered var.
            stackRefs[i].pObject = CLRDATA_ADDRESS_TO_TADDR(sosStackRef.Object) | 1;
        }
        else
        {
            stackRefs[i].objHnd.SetDacTargetPtr(CLRDATA_ADDRESS_TO_TADDR(sosStackRef.Address));
        }
    }

    *pFetched = i;

    return S_OK;
}