Adds Console Log Formatting APIs

docs/project/list-of-obsoletions.md

@@ -15,3 +15,4 @@ Currently the identifiers `MSLIB0001` through `MSLIB0999` are carved out for obs
 | :--------------- | :---------- |
 |  __`MSLIB0001`__ | The UTF-7 encoding is insecure and should not be used. Consider using UTF-8 instead. |
 |  __`MSLIB0002`__ | `PrincipalPermissionAttribute` is not honored by the runtime and must not be used. |
+|  __`MSLIB0003`__ | `BinaryFormatter` serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for recommended alternatives. |

eng/Version.Details.xml

@@ -118,9 +118,9 @@
       <Uri>https://github.com/dotnet/runtime-assets</Uri>
       <Sha>b34a70799faa67f13c2e72852e4f3af463ff4d6c</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NETCore.Runtime.ICU.Transport" Version="5.0.0-preview.8.20359.7">
+    <Dependency Name="Microsoft.NETCore.Runtime.ICU.Transport" Version="5.0.0-preview.8.20364.1">
       <Uri>https://github.com/dotnet/icu</Uri>
-      <Sha>88c2807979f8762a121f8e4b217191672d334822</Sha>
+      <Sha>bf5a3a643815a8a46693d618d08dbc96f353ca9e</Sha>
     </Dependency>
     <Dependency Name="runtime.linux-arm64.Microsoft.NETCore.Runtime.Mono.LLVM.Sdk" Version="9.0.1-alpha.1.20356.1">
       <Uri>https://github.com/dotnet/llvm-project</Uri>
@@ -182,9 +182,9 @@
       <Uri>https://github.com/dotnet/runtime</Uri>
       <Sha>0375524a91a47ca4db3ee1be548f74bab7e26e76</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.NET.ILLink.Tasks" Version="5.0.0-preview.3.20361.1">
+    <Dependency Name="Microsoft.NET.ILLink.Tasks" Version="5.0.0-preview.3.20363.5">
       <Uri>https://github.com/mono/linker</Uri>
-      <Sha>3b524e4aa109ce5c8d9db5d6447386a0714d0d2d</Sha>
+      <Sha>e76321851c05c5016df3d1243885c02e875b9912</Sha>
     </Dependency>
     <Dependency Name="Microsoft.DotNet.XHarness.TestRunners.Xunit" Version="1.0.0-prerelease.20352.3">
       <Uri>https://github.com/dotnet/xharness</Uri>

eng/Versions.props

@@ -116,9 +116,9 @@
     <!-- Docs -->
     <MicrosoftPrivateIntellisenseVersion>3.0.0-preview-20200602.3</MicrosoftPrivateIntellisenseVersion>
     <!-- ILLink -->
-    <MicrosoftNETILLinkTasksVersion>5.0.0-preview.3.20361.1</MicrosoftNETILLinkTasksVersion>
+    <MicrosoftNETILLinkTasksVersion>5.0.0-preview.3.20363.5</MicrosoftNETILLinkTasksVersion>
     <!-- ICU -->
-    <MicrosoftNETCoreRuntimeICUTransportVersion>5.0.0-preview.8.20359.7</MicrosoftNETCoreRuntimeICUTransportVersion>
+    <MicrosoftNETCoreRuntimeICUTransportVersion>5.0.0-preview.8.20364.1</MicrosoftNETCoreRuntimeICUTransportVersion>
     <!-- Mono LLVM -->
     <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>9.0.1-alpha.1.20356.1</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMSdkVersion>
     <runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>9.0.1-alpha.1.20356.1</runtimelinuxarm64MicrosoftNETCoreRuntimeMonoLLVMToolsVersion>

src/coreclr/src/debug/daccess/dacdbiimpl.cpp

@@ -22,6 +22,7 @@
 #include "switches.h"
 #include "generics.h"
 #include "stackwalk.h"
+#include "virtualcallstub.h"
 
 #include "dacdbiimpl.h"
 
@@ -3570,6 +3571,139 @@ HRESULT DacDbiInterfaceImpl::GetDelegateTargetObject(
     return hr;
 }
 
+static bool TrackMemoryRangeHelper(PTR_VOID pvArgs, PTR_VOID pvAllocationBase, SIZE_T cbReserved)
+{
+    // The pvArgs is really pointing to a debugger-side container. Sadly the callback only takes a PTR_VOID.
+    CQuickArrayList<COR_MEMORY_RANGE> *rangeCollection =
+                                        (CQuickArrayList<COR_MEMORY_RANGE>*)(dac_cast<TADDR>(pvArgs));
+    TADDR rangeStart = dac_cast<TADDR>(pvAllocationBase);
+    TADDR rangeEnd = rangeStart + cbReserved;
+    rangeCollection->Push({rangeStart, rangeEnd});
+
+    // This is a tracking function, not a search callback. Pretend we never found what we were looking for
+    // to get all possible ranges.
+    return false;
+}
+
+void DacDbiInterfaceImpl::EnumerateMemRangesForLoaderAllocator(PTR_LoaderAllocator pLoaderAllocator, CQuickArrayList<COR_MEMORY_RANGE> *rangeAcummulator)
+{
+    CQuickArrayList<PTR_LoaderHeap> heapsToEnumerate;
+
+    // We always expect to see these three heaps
+    _ASSERTE(pLoaderAllocator->GetLowFrequencyHeap() != NULL);
+    heapsToEnumerate.Push(pLoaderAllocator->GetLowFrequencyHeap());
+
+    _ASSERTE(pLoaderAllocator->GetHighFrequencyHeap() != NULL);
+    heapsToEnumerate.Push(pLoaderAllocator->GetHighFrequencyHeap());
+
+    _ASSERTE(pLoaderAllocator->GetStubHeap() != NULL);
+    heapsToEnumerate.Push(pLoaderAllocator->GetStubHeap());
+
+    // GetVirtualCallStubManager returns VirtualCallStubManager*, but it's really an address to target as
+    // pLoaderAllocator is DACized. Cast it so we don't try to to a Host to Target translation.
+    VirtualCallStubManager *pVcsMgr = PTR_VirtualCallStubManager(TO_TADDR(pLoaderAllocator->GetVirtualCallStubManager()));
+    LOG((LF_CORDB, LL_INFO10000, "DDBII::EMRFLA: VirtualCallStubManager 0x%x\n", PTR_HOST_TO_TADDR(pVcsMgr)));
+    if (pVcsMgr)
+    {
+        if (pVcsMgr->indcell_heap != NULL) heapsToEnumerate.Push(pVcsMgr->indcell_heap);
+        if (pVcsMgr->lookup_heap != NULL) heapsToEnumerate.Push(pVcsMgr->lookup_heap);
+        if (pVcsMgr->resolve_heap != NULL) heapsToEnumerate.Push(pVcsMgr->resolve_heap);
+        if (pVcsMgr->dispatch_heap != NULL) heapsToEnumerate.Push(pVcsMgr->dispatch_heap);
+        if (pVcsMgr->cache_entry_heap != NULL) heapsToEnumerate.Push(pVcsMgr->cache_entry_heap);
+    }
+
+    TADDR rangeAccumAsTaddr = TO_TADDR(rangeAcummulator);
+    for (uint32_t i = 0; i < (uint32_t)heapsToEnumerate.Size(); i++)
+    {
+        LOG((LF_CORDB, LL_INFO10000, "DDBII::EMRFLA: LoaderHeap 0x%x\n", heapsToEnumerate[i].GetAddr()));
+        heapsToEnumerate[i]->EnumPageRegions(TrackMemoryRangeHelper, rangeAccumAsTaddr);
+    }
+}
+
+void DacDbiInterfaceImpl::EnumerateMemRangesForJitCodeHeaps(CQuickArrayList<COR_MEMORY_RANGE> *rangeAcummulator)
+{
+    // We should always have a valid EEJitManager with at least one code heap.
+    EEJitManager *pEM = ExecutionManager::GetEEJitManager();
+    _ASSERTE(pEM != NULL && pEM->m_pCodeHeap.IsValid());
+
+    PTR_HeapList pHeapList = pEM->m_pCodeHeap;
+    while (pHeapList != NULL)
+    {
+        CodeHeap *pHeap = pHeapList->pHeap;
+        DacpJitCodeHeapInfo jitCodeHeapInfo = DACGetHeapInfoForCodeHeap(pHeap);
+
+        switch (jitCodeHeapInfo.codeHeapType)
+        {
+            case CODEHEAP_LOADER:
+            {
+                TADDR targetLoaderHeap = CLRDATA_ADDRESS_TO_TADDR(jitCodeHeapInfo.LoaderHeap);
+                LOG((LF_CORDB, LL_INFO10000,
+                    "DDBII::EMRFJCH: LoaderCodeHeap 0x%x with LoaderHeap at 0x%x\n",
+                    PTR_HOST_TO_TADDR(pHeap), targetLoaderHeap));
+                PTR_ExplicitControlLoaderHeap pLoaderHeap = PTR_ExplicitControlLoaderHeap(targetLoaderHeap);
+                pLoaderHeap->EnumPageRegions(TrackMemoryRangeHelper, TO_TADDR(rangeAcummulator));
+                break;
+            }
+
+            case CODEHEAP_HOST:
+            {
+                LOG((LF_CORDB, LL_INFO10000,
+                    "DDBII::EMRFJCH: HostCodeHeap 0x%x\n",
+                    PTR_HOST_TO_TADDR(pHeap)));
+                rangeAcummulator->Push({
+                    CLRDATA_ADDRESS_TO_TADDR(jitCodeHeapInfo.HostData.baseAddr),
+                    CLRDATA_ADDRESS_TO_TADDR(jitCodeHeapInfo.HostData.currentAddr)
+                });
+                break;
+            }
+
+            default:
+            {
+                LOG((LF_CORDB, LL_INFO10000, "DDBII::EMRFJCH: unknown heap type at 0x%x\n\n", pHeap));
+                _ASSERTE("Unknown heap type enumerating code ranges.");
+                break;
+            }
+        }
+
+        pHeapList = pHeapList->GetNext();
+    }
+}
+
+HRESULT DacDbiInterfaceImpl::GetLoaderHeapMemoryRanges(DacDbiArrayList<COR_MEMORY_RANGE> *pRanges)
+{
+    LOG((LF_CORDB, LL_INFO10000, "DDBII::GLHMR\n"));
+    DD_ENTER_MAY_THROW;
+
+    HRESULT hr = S_OK;
+
+    EX_TRY
+    {
+        CQuickArrayList<COR_MEMORY_RANGE> memoryRanges;
+
+        // Anything that's loaded in the SystemDomain or into the main AppDomain's default context in .NET Core
+        // and after uses only one global allocator. Enumerating that one is enough for most purposes.
+        // This doesn't consider any uses of AssemblyLoadingContexts (Unloadable or not). Each context has
+        // it's own LoaderAllocator, but there's no easy way of getting a hand at them other than going through
+        // the heap, getting a managed LoaderAllocators, from there getting a Scout, and from there getting a native
+        // pointer to the LoaderAllocator tos enumerate.
+        PTR_LoaderAllocator pGlobalAllocator = SystemDomain::System()->GetLoaderAllocator();
+        _ASSERTE(pGlobalAllocator);
+        EnumerateMemRangesForLoaderAllocator(pGlobalAllocator, &memoryRanges);
+
+        EnumerateMemRangesForJitCodeHeaps(&memoryRanges);
+
+        // This code doesn't enumerate module thunk heaps to support IJW.
+        // It's a fairly rare scenario and requires to enumerate all modules.
+        // The return for such added time is minimal.
+
+        _ASSERTE(memoryRanges.Size() < INT_MAX);
+        pRanges->Init(memoryRanges.Ptr(), (UINT) memoryRanges.Size());
+    }
+    EX_CATCH_HRESULT(hr);
+
+    return hr;
+}
+
 void DacDbiInterfaceImpl::GetStackFramesFromException(VMPTR_Object vmObject, DacDbiArrayList<DacExceptionCallStackData>& dacStackFrames)
 {
     DD_ENTER_MAY_THROW;

src/coreclr/src/debug/daccess/dacdbiimpl.h

@@ -361,6 +361,8 @@ class DacDbiInterfaceImpl :
         OUT VMPTR_Object *ppTargetObj,
         OUT VMPTR_AppDomain *ppTargetAppDomain);
 
+    HRESULT GetLoaderHeapMemoryRanges(OUT DacDbiArrayList<COR_MEMORY_RANGE> * pRanges);
+
     // retrieves the list of COM interfaces implemented by vmObject, as it is known at
     // the time of the call (the list may change as new interface types become available
     // in the runtime)
@@ -394,6 +396,14 @@ class DacDbiInterfaceImpl :
                         OUT DacDbiArrayList<DebuggerIPCE_ExpandedTypeData> * pTypes);
 
 private:
+    // Helper to enumerate all possible memory ranges help by a loader allocator.
+    void EnumerateMemRangesForLoaderAllocator(
+        PTR_LoaderAllocator pLoaderAllocator,
+        CQuickArrayList<COR_MEMORY_RANGE> *rangeAcummulator);
+
+    void EnumerateMemRangesForJitCodeHeaps(
+        CQuickArrayList<COR_MEMORY_RANGE> *rangeAcummulator);
+
     // Given a pointer to a managed function, obtain the method desc for it.
     // Equivalent to GetMethodDescPtrFromIp, except if the method isn't jitted
     // it will look for it in code stubs.

src/coreclr/src/debug/daccess/dacfn.cpp

@@ -268,7 +268,7 @@ DacVirtualUnwind(ULONG32 threadId, PT_CONTEXT context, PT_KNONVOLATILE_CONTEXT_P
         memset(contextPointers, 0, sizeof(T_KNONVOLATILE_CONTEXT_POINTERS));
     }
 
-    HRESULT hr = S_OK;
+    HRESULT hr = E_NOINTERFACE;
 
 #ifdef FEATURE_DATATARGET4
     ReleaseHolder<ICorDebugDataTarget4> dt;
@@ -277,9 +277,12 @@ DacVirtualUnwind(ULONG32 threadId, PT_CONTEXT context, PT_KNONVOLATILE_CONTEXT_P
     {
         hr = dt->VirtualUnwind(threadId, sizeof(CONTEXT), (BYTE*)context);
     }
-    else
 #endif
+
+    if (hr == E_NOINTERFACE || hr == E_NOTIMPL)
     {
+        hr = S_OK;
+
         SIZE_T baseAddress = DacGlobalBase();
         if (baseAddress == 0 || !PAL_VirtualUnwindOutOfProc(context, contextPointers, baseAddress, DacReadAllAdapter))
         {

src/coreclr/src/debug/daccess/dacimpl.h

@@ -1455,8 +1455,12 @@ class ClrDataAccess
 private:
 #endif
 
-#ifdef FEATURE_COMINTEROP
 protected:
+    // Populates a DacpJitCodeHeapInfo with proper information about the
+    // code heap type and the information needed to locate it.
+    DacpJitCodeHeapInfo DACGetHeapInfoForCodeHeap(CodeHeap *heapAddr);
+
+#ifdef FEATURE_COMINTEROP
     // Returns CCW pointer based on a target address.
     PTR_ComCallWrapper DACGetCCWFromAddress(CLRDATA_ADDRESS addr);
 

src/coreclr/src/debug/daccess/request.cpp

@@ -499,27 +499,8 @@ ClrDataAccess::GetCodeHeapList(CLRDATA_ADDRESS jitManager, unsigned int count, s
         unsigned int i = 0;
         while ((heapList != NULL) && (i < count))
         {
-            // What type of CodeHeap pointer do we have?
             CodeHeap *codeHeap = heapList->pHeap;
-            TADDR ourVTablePtr = VPTR_HOST_VTABLE_TO_TADDR(*(LPVOID*)codeHeap);
-            if (ourVTablePtr == LoaderCodeHeap::VPtrTargetVTable())
-            {
-                LoaderCodeHeap *loaderCodeHeap = PTR_LoaderCodeHeap(PTR_HOST_TO_TADDR(codeHeap));
-                codeHeaps[i].codeHeapType = CODEHEAP_LOADER;
-                codeHeaps[i].LoaderHeap =
-                    TO_CDADDR(PTR_HOST_MEMBER_TADDR(LoaderCodeHeap, loaderCodeHeap, m_LoaderHeap));
-            }
-            else if (ourVTablePtr == HostCodeHeap::VPtrTargetVTable())
-            {
-                HostCodeHeap *hostCodeHeap = PTR_HostCodeHeap(PTR_HOST_TO_TADDR(codeHeap));
-                codeHeaps[i].codeHeapType = CODEHEAP_HOST;
-                codeHeaps[i].HostData.baseAddr = PTR_CDADDR(hostCodeHeap->m_pBaseAddr);
-                codeHeaps[i].HostData.currentAddr = PTR_CDADDR(hostCodeHeap->m_pLastAvailableCommittedAddr);
-            }
-            else
-            {
-                codeHeaps[i].codeHeapType = CODEHEAP_UNKNOWN;
-            }
+            codeHeaps[i] = DACGetHeapInfoForCodeHeap(codeHeap);
             heapList = heapList->hpNext;
             i++;
         }
@@ -547,6 +528,33 @@ ClrDataAccess::GetCodeHeapList(CLRDATA_ADDRESS jitManager, unsigned int count, s
     return hr;
 }
 
+DacpJitCodeHeapInfo ClrDataAccess::DACGetHeapInfoForCodeHeap(CodeHeap *heapAddr)
+{
+    DacpJitCodeHeapInfo jitCodeHeapInfo;
+
+    TADDR targetVtblPtrForHeapType = VPTR_HOST_VTABLE_TO_TADDR(*(LPVOID*)heapAddr);
+    if (targetVtblPtrForHeapType == LoaderCodeHeap::VPtrTargetVTable())
+    {
+        LoaderCodeHeap *loaderCodeHeap = PTR_LoaderCodeHeap(PTR_HOST_TO_TADDR(heapAddr));
+        jitCodeHeapInfo.codeHeapType = CODEHEAP_LOADER;
+        jitCodeHeapInfo.LoaderHeap =
+            TO_CDADDR(PTR_HOST_MEMBER_TADDR(LoaderCodeHeap, loaderCodeHeap, m_LoaderHeap));
+    }
+    else if (targetVtblPtrForHeapType == HostCodeHeap::VPtrTargetVTable())
+    {
+        HostCodeHeap *hostCodeHeap = PTR_HostCodeHeap(PTR_HOST_TO_TADDR(heapAddr));
+        jitCodeHeapInfo.codeHeapType = CODEHEAP_HOST;
+        jitCodeHeapInfo.HostData.baseAddr = PTR_CDADDR(hostCodeHeap->m_pBaseAddr);
+        jitCodeHeapInfo.HostData.currentAddr = PTR_CDADDR(hostCodeHeap->m_pLastAvailableCommittedAddr);
+    }
+    else
+    {
+        jitCodeHeapInfo.codeHeapType = CODEHEAP_UNKNOWN;
+    }
+
+    return jitCodeHeapInfo;
+}
+
 HRESULT
 ClrDataAccess::GetStackLimits(CLRDATA_ADDRESS threadPtr, CLRDATA_ADDRESS *lower,
                               CLRDATA_ADDRESS *upper, CLRDATA_ADDRESS *fp)

src/coreclr/src/debug/di/process.cpp

@@ -2173,6 +2173,10 @@ HRESULT CordbProcess::QueryInterface(REFIID id, void **pInterface)
     {
         *pInterface = static_cast<ICorDebugProcess10*>(this);
     }
+    else if (id == IID_ICorDebugProcess11)
+    {
+        *pInterface = static_cast<ICorDebugProcess11*>(this);
+    }
     else if (id == IID_IUnknown)
     {
         *pInterface = static_cast<IUnknown*>(static_cast<ICorDebugProcess*>(this));
@@ -2531,6 +2535,35 @@ COM_METHOD CordbProcess::EnableGCNotificationEvents(BOOL fEnable)
     return hr;
 }
 
+//-----------------------------------------------------------
+// ICorDebugProcess11
+//-----------------------------------------------------------
+COM_METHOD CordbProcess::EnumerateLoaderHeapMemoryRegions(ICorDebugMemoryRangeEnum **ppRanges)
+{
+    VALIDATE_POINTER_TO_OBJECT(ppRanges, ICorDebugMemoryRangeEnum **);
+    FAIL_IF_NEUTERED(this);
+
+    HRESULT hr = S_OK;
+
+    PUBLIC_API_BEGIN(this);
+    {
+        DacDbiArrayList<COR_MEMORY_RANGE> heapRanges;
+
+        hr = GetDAC()->GetLoaderHeapMemoryRanges(&heapRanges);
+
+        if (SUCCEEDED(hr))
+        {
+            RSInitHolder<CordbMemoryRangeEnumerator> heapSegmentEnumerator(
+                new CordbMemoryRangeEnumerator(this, &heapRanges[0], (DWORD)heapRanges.Count()));
+
+            GetContinueNeuterList()->Add(this, heapSegmentEnumerator);
+            heapSegmentEnumerator.TransferOwnershipExternal(ppRanges);
+        }
+    }
+    PUBLIC_API_END(hr);
+    return hr;
+}
+
 HRESULT CordbProcess::GetTypeForObject(CORDB_ADDRESS addr, CordbAppDomain* pAppDomainOverride, CordbType **ppType, CordbAppDomain **pAppDomain)
 {
     VMPTR_AppDomain appDomain;

src/coreclr/src/debug/di/rspriv.h

@@ -1668,6 +1668,11 @@ typedef CordbEnumerator<COR_SEGMENT,
                         ICorDebugHeapSegmentEnum, IID_ICorDebugHeapSegmentEnum,
                         IdentityConvert<COR_SEGMENT> > CordbHeapSegmentEnumerator;
 
+typedef CordbEnumerator<COR_MEMORY_RANGE,
+                        COR_MEMORY_RANGE,
+                        ICorDebugMemoryRangeEnum, IID_ICorDebugMemoryRangeEnum,
+                        IdentityConvert<COR_MEMORY_RANGE> > CordbMemoryRangeEnumerator;
+
 typedef CordbEnumerator<CorDebugExceptionObjectStackFrame,
                         CorDebugExceptionObjectStackFrame,
                         ICorDebugExceptionObjectCallStackEnum, IID_ICorDebugExceptionObjectCallStackEnum,
@@ -2931,6 +2936,7 @@ class CordbProcess :
     public ICorDebugProcess7,
     public ICorDebugProcess8,
     public ICorDebugProcess10,
+    public ICorDebugProcess11,
     public IDacDbiInterface::IAllocator,
     public IDacDbiInterface::IMetaDataLookup,
     public IProcessShimHooks
@@ -3144,6 +3150,11 @@ class CordbProcess :
     //-----------------------------------------------------------
     COM_METHOD EnableGCNotificationEvents(BOOL fEnable);
 
+    //-----------------------------------------------------------
+    // ICorDebugProcess11
+    //-----------------------------------------------------------
+    COM_METHOD EnumerateLoaderHeapMemoryRegions(ICorDebugMemoryRangeEnum **ppRanges);
+
     //-----------------------------------------------------------
     // Methods not exposed via a COM interface.
     //-----------------------------------------------------------
@@ -11822,5 +11833,3 @@ struct RSDebuggingInfo
 #include "rspriv.inl"
 
 #endif // #if RSPRIV_H
-
-