Add a fourth parameter to the DEFINE_DACVAR macro that is the actual fully qualified name of the static/global.

First pass at the global DAC table support for Linux. Explicitly build the table in the coreclr module instead of extract it from the pdb and put it in a resource.

Fixed the SVR gc globals in the DAC table. They had to be seperated and initialized in gceesvr.cpp.

Start on global pointer table.

PAL functions to write and read the DAC table address between processes.

The dac table is now copied from the coreclr process to the DAC/debugger process.  The tables were not being built with exactly the same defines so they weren't the same size. Fixed a bug in the read memory implementation. Still assumes pid = 0.

Changed the dacTable entries to be RVAs and renabled getting the corclr module base addres (m_globalBase). Added dac table address file cleanup on coreclr shutdown.

Filled in the vtable entries in the global dac table.  Changed some of the VPTR_* macros to be defined on the coreclr side (RS) to defined a constructor that is used to get the vtable in dactable.cpp. These changes required default constructors to be added to some of the classes.

Changed getting the vtable address to not invoke the destructors since the constructor used didn't do anything (like initialize variables, etc.).

Added a TODO comment about the debuggee pid not being available in the dac table address file name.

Fixed Windows build. Created a couple of new VPTR_* macros that add a default constructor only if building coreclr (not DAC) on Linux.

Comment on how these DAC table functions are temporary.

40 files changed, 599 insertions, 204 deletions

diff --git a/dac.cmake b/dac.cmake
index 90608c68ed..1b27ac00dc 100644
--- a/dac.cmake
+++ b/dac.cmake
@@ -1,7 +1,6 @@
 # Contains the dac build specific definitions. Included by the leaf dac cmake files.
 
 remove_definitions(-DPROFILING_SUPPORTED)
-add_definitions(-DPROFILING_SUPPORTED_DATA)
 add_definitions(-DDACCESS_COMPILE)
 if(WIN32)
     add_definitions(-MT)
diff --git a/src/ToolBox/SOS/Strike/strike.cpp b/src/ToolBox/SOS/Strike/strike.cpp
index c41e6568a9..641953493f 100644
--- a/src/ToolBox/SOS/Strike/strike.cpp
+++ b/src/ToolBox/SOS/Strike/strike.cpp
@@ -279,11 +279,6 @@ DECLARE_API(IP2MD)
     {
         return Status;
     }
-#ifdef FEATURE_PAL 
-    // TODO - mikem 2/20/14 - temporary until the rest of the DAC is working.
-    ExtOut("Test output for IP2MD %16x\n", IP);
-    return Status;
-#endif 
     EnableDMLHolder dmlHolder(dml);
 
     if (IP == 0)
diff --git a/src/ToolBox/SOS/lldbplugin/debugclient.cpp b/src/ToolBox/SOS/lldbplugin/debugclient.cpp
index 5f506fed08..e973670f1e 100644
--- a/src/ToolBox/SOS/lldbplugin/debugclient.cpp
+++ b/src/ToolBox/SOS/lldbplugin/debugclient.cpp
@@ -176,7 +176,7 @@ DebugClient::ReadVirtual(
     ULONG bufferSize,
     PULONG bytesRead)
 {
-    bytesRead = 0;
+    *bytesRead = 0;
 
     lldb::SBTarget target = m_debugger.GetSelectedTarget();
     if (!target.IsValid())
diff --git a/src/debug/daccess/daccess.cpp b/src/debug/daccess/daccess.cpp
index 7e10e2a445..24f18bdb48 100644
--- a/src/debug/daccess/daccess.cpp
+++ b/src/debug/daccess/daccess.cpp
@@ -7180,6 +7180,25 @@ HRESULT
 ClrDataAccess::GetDacGlobals()
 {
 #ifdef FEATURE_PAL
+    // TODO - 3/5/15 - the DAC side needs the debuggee pid
+    DWORD pid = 0;
+    PVOID dacTableAddress = nullptr;
+    ULONG dacTableSize = 0;
+    DWORD err = PAL_GetDacTableAddress(pid, &dacTableAddress, &dacTableSize);
+    if (err != ERROR_SUCCESS)
+    {
+        return CORDBG_E_MISSING_DEBUGGER_EXPORTS;
+    }
+
+    if (dacTableSize != sizeof(g_dacGlobals))
+    {
+        return E_INVALIDARG;
+    }
+
+    if (FAILED(ReadFromDataTarget(m_pTarget, (ULONG64)dacTableAddress, (BYTE*)&g_dacGlobals, dacTableSize)))
+    {
+        return CORDBG_E_MISSING_DEBUGGER_EXPORTS;
+    }
     return S_OK;
 #else
     HRESULT status = E_FAIL;
diff --git a/src/debug/daccess/enummem.cpp b/src/debug/daccess/enummem.cpp
index ce7786e989..0d50ec6767 100644
--- a/src/debug/daccess/enummem.cpp
+++ b/src/debug/daccess/enummem.cpp
@@ -216,7 +216,10 @@ HRESULT ClrDataAccess::EnumMemCLRStatic(IN CLRDataEnumMemoryFlags flags)
     // global variables. But it won't report the structures that are pointed by 
     // global pointers.
     //
-#define DEFINE_DACVAR(id_type, size_type, id)   \
+#define DEFINE_DACVAR(id_type, size_type, id, var) \
+    ReportMem(m_globalBase + g_dacGlobals.id, sizeof(size_type));
+
+#define DEFINE_DACVAR_SVR(id_type, size_type, id, var) \
     ReportMem(m_globalBase + g_dacGlobals.id, sizeof(size_type));
 
     // Cannot use CATCH_ALL_EXCEPT_RETHROW_COR_E_OPERATIONCANCELLED
diff --git a/src/debug/ee/CMakeLists.txt b/src/debug/ee/CMakeLists.txt
index 5200072353..bd4849e316 100644
--- a/src/debug/ee/CMakeLists.txt
+++ b/src/debug/ee/CMakeLists.txt
@@ -43,6 +43,10 @@ if(WIN32)
     dbgtransportproxy.cpp
     ddunpack.cpp
   )
+else()
+  list(APPEND CORDBEE_SOURCES_WKS 
+    dactable.cpp
+  )
 endif(WIN32)
 
 if (IS_64BIT_BUILD EQUAL 1)
diff --git a/src/debug/ee/dactable.cpp b/src/debug/ee/dactable.cpp
new file mode 100644
index 0000000000..43b27996d6
--- /dev/null
+++ b/src/debug/ee/dactable.cpp
@@ -0,0 +1,89 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+//*****************************************************************************
+// File: dacglobals.cpp
+//
+
+//
+// The DAC global pointer table
+//
+//*****************************************************************************
+
+#include "stdafx.h"
+#include <daccess.h>
+#include "../../vm/virtualcallstub.h"
+#include "../../vm/win32threadpool.h"
+#include "../../vm/hillclimbing.h"
+#include "../../vm/codeman.h"
+#include "../../vm/eedbginterfaceimpl.h"
+#include "../../vm/common.h"
+#include "../../vm/gcenv.h"
+#include "../../vm/ecall.h"
+#include "../../vm/rcwwalker.h"
+#include "../../gc/gc.h"
+#include "../../gc/gcscan.h"
+
+#undef SERVER_GC
+namespace WKS {
+#include "../../gc/gcimpl.h"
+#include "../../gc/gcpriv.h"
+}
+
+#ifdef DEBUGGING_SUPPORTED
+
+extern PTR_ECHash gFCallMethods;
+extern TADDR gLowestFCall;
+extern TADDR gHighestFCall;
+extern PCODE g_FCDynamicallyAssignedImplementations;
+extern DWORD gThreadTLSIndex;
+extern DWORD gAppDomainTLSIndex;
+
+#ifdef FEATURE_APPX
+#if defined(FEATURE_CORECLR)
+extern BOOL g_fAppX;
+#else
+extern PTR_AppXRTInfo g_pAppXRTInfo;
+#endif
+#endif // FEATURE_APPX
+
+DacGlobals g_dacTable;
+
+// DAC global pointer table initialization
+void DacGlobals::Initialize()
+{
+    TADDR baseAddress = PTR_TO_TADDR(PAL_GetCoreClrModuleBase());
+    g_dacTable.InitializeEntries(baseAddress);
+#ifdef FEATURE_SVR_GC
+    g_dacTable.InitializeSVREntries(baseAddress);
+#endif
+    PAL_PublishDacTableAddress(&g_dacTable, sizeof(g_dacTable));
+}
+
+// Initializes the non-SVR table entries
+void DacGlobals::InitializeEntries(TADDR baseAddress)
+{
+#define DEFINE_DACVAR(id_type, size, id, var)                   id = PTR_TO_TADDR(&var) - baseAddress;
+#define DEFINE_DACVAR_SVR(id_type, size, id, var) 
+#define DEFINE_DACVAR_NO_DUMP(id_type, size, id, var)           id = PTR_TO_TADDR(&var) - baseAddress;
+#include "dacvars.h"
+
+#define VPTR_CLASS(name) \
+    { \
+        void *pBuf = _alloca(sizeof(name)); \
+        name *dummy = new (pBuf) name(0); \
+        name##__vtAddr = PTR_TO_TADDR(*((PVOID*)dummy)) - baseAddress; \
+    }
+#define VPTR_MULTI_CLASS(name, keyBase) \
+    { \
+        void *pBuf = _alloca(sizeof(name)); \
+        name *dummy = new (pBuf) name(0); \
+        name##__##keyBase##__mvtAddr = PTR_TO_TADDR(*((PVOID*)dummy)) - baseAddress; \
+    }
+#include <vptr_list.h>
+#undef VPTR_CLASS
+#undef VPTR_MULTI_CLASS
+}
+
+#endif // DEBUGGER_SUPPORTED
diff --git a/src/dlls/mscoree/mscoree.cpp b/src/dlls/mscoree/mscoree.cpp
index 89d91b6f94..4d935d2c73 100644
--- a/src/dlls/mscoree/mscoree.cpp
+++ b/src/dlls/mscoree/mscoree.cpp
@@ -180,7 +180,9 @@ BOOL WINAPI DllMain(HANDLE hInstance, DWORD dwReason, LPVOID lpReserved)
             // If buffer is overrun, it is possible the saved callback has been trashed.
             // The callback is unsafe.
             //SetBufferOverrunHandler();
-
+#ifdef FEATURE_PAL
+            DacGlobals::Initialize();
+#endif
             if (!EEDllMain((HINSTANCE)hInstance, dwReason, lpReserved))
             {
                 return FALSE;
@@ -194,6 +196,9 @@ BOOL WINAPI DllMain(HANDLE hInstance, DWORD dwReason, LPVOID lpReserved)
 
     case DLL_PROCESS_DETACH:
         {
+#ifdef FEATURE_PAL
+            PAL_CleanupDacTableAddress();
+#endif
             EEDllMain((HINSTANCE)hInstance, dwReason, lpReserved);
 
 #ifdef FEATURE_MERGE_JIT_AND_ENGINE
diff --git a/src/gc/gc.h b/src/gc/gc.h
index 455b6dbd6e..60e3dfda5d 100644
--- a/src/gc/gc.h
+++ b/src/gc/gc.h
@@ -356,6 +356,7 @@ void record_changed_seg (BYTE* start, BYTE* end,
 #define GC_ALLOC_ALIGN8_BIAS 0x4
 
 class GCHeap {
+    friend struct ::_DacGlobals;
 #ifdef DACCESS_COMPILE
     friend class ClrDataAccess;
 #endif
diff --git a/src/gc/gceesvr.cpp b/src/gc/gceesvr.cpp
index 6778e4a34e..6aa6c063b3 100644
--- a/src/gc/gceesvr.cpp
+++ b/src/gc/gceesvr.cpp
@@ -21,4 +21,15 @@ namespace SVR {
 #include "gcee.cpp"
 }
 
-#endif // defined(FEATURE_SVR_GC)
+#if defined(FEATURE_PAL) && !defined(DACCESS_COMPILE)
+ 
+// Initializes the SVR DAC table entries
+void DacGlobals::InitializeSVREntries(TADDR baseAddress)
+{
+#define DEFINE_DACVAR_SVR(id_type, size, id, var)   id = PTR_TO_TADDR(&var) - baseAddress;
+#include "dacvars.h"
+}
+
+#endif // FEATURE_PAL && !DACCESS_COMPILE
+
+#endif // FEATURE_SVR_GC
diff --git a/src/gc/gcpriv.h b/src/gc/gcpriv.h
index c99fd86125..d16f4ba9b1 100644
--- a/src/gc/gcpriv.h
+++ b/src/gc/gcpriv.h
@@ -1112,6 +1112,7 @@ extern void GCProfileWalkHeapWorker(BOOL fProfilerPinned, BOOL fShouldWalkHeapRo
 #endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
 class gc_heap
 {
+    friend struct ::_DacGlobals;
 #ifdef DACCESS_COMPILE
     friend class ::ClrDataAccess;
     friend class ::DacHeapWalker;
diff --git a/src/gc/gcscan.h b/src/gc/gcscan.h
index 3b2fa70e26..9b198b0782 100644
--- a/src/gc/gcscan.h
+++ b/src/gc/gcscan.h
@@ -43,8 +43,10 @@ typedef void enum_alloc_context_func(alloc_context*);
 
 class CNameSpace
 {
+    friend struct ::_DacGlobals;
+
   public:
-    
+
     // Called on gc start
     static void GcStartDoWork();
 
diff --git a/src/inc/corhost.h b/src/inc/corhost.h
index d77db20117..133fb9c340 100644
--- a/src/inc/corhost.h
+++ b/src/inc/corhost.h
@@ -631,6 +631,7 @@ class CCLRErrorReportingManager :
 #endif // FEATURE_WINDOWSPHONE
 {
     friend class ClrDataAccess;
+    friend struct _DacGlobals;
 
     SVAL_DECL(ECustomDumpFlavor, g_ECustomDumpFlavor);
     
@@ -748,6 +749,8 @@ class CorHost2 :
 #endif
     , public CorExecutionManager
 {
+    friend struct _DacGlobals;
+
 public:
     CorHost2();
 
diff --git a/src/inc/daccess.h b/src/inc/daccess.h
index fbd7919f93..e4f011b3ef 100644
--- a/src/inc/daccess.h
+++ b/src/inc/daccess.h
@@ -566,8 +566,6 @@ struct DacTableHeader
     DacTableInfo info;
 };
 
-#ifdef DACCESS_COMPILE
-
 //
 // This version of things wraps pointer access in
 // templates which understand how to retrieve data
@@ -587,7 +585,6 @@ typedef ULONG_PTR TADDR;
 // which reflects the host pointer size.
 typedef SIZE_T TSIZE_T;
 
-extern DacTableInfo g_dacTableInfo;
 
 //
 // The following table contains all the global information that data access needs to begin 
@@ -597,9 +594,18 @@ extern DacTableInfo g_dacTableInfo;
 
 typedef struct _DacGlobals
 {
+#ifdef FEATURE_PAL
+    static void Initialize();
+    void InitializeEntries(TADDR baseAddress);
+#ifdef FEATURE_SVR_GC
+    void InitializeSVREntries(TADDR baseAddress);
+#endif // FEATURE_SVR_GC
+#endif // FEATURE_PAL
+
 // These will define all of the dac related mscorwks static and global variables    
-#define DEFINE_DACVAR(id_type, size, id)                 id_type id;
-#define DEFINE_DACVAR_NO_DUMP(id_type, size, id)        id_type id;
+#define DEFINE_DACVAR(id_type, size, id, var)                 id_type id;
+#define DEFINE_DACVAR_SVR(id_type, size, id, var)             id_type id;
+#define DEFINE_DACVAR_NO_DUMP(id_type, size, id, var)         id_type id;
 #include "dacvars.h"
 
     // Global functions.
@@ -625,6 +631,9 @@ typedef struct _DacGlobals
 #undef VPTR_MULTI_CLASS
 } DacGlobals;
 
+#ifdef DACCESS_COMPILE
+
+extern DacTableInfo g_dacTableInfo;
 extern DacGlobals g_dacGlobals;
 
 #ifdef __cplusplus
@@ -1821,6 +1830,9 @@ typedef __VoidPtr PTR_CVOID;
 public: name(TADDR addr, TADDR vtAddr) : base(addr, vtAddr) {}  \
         VPTR_CLASS_METHODS(name)
 
+#define VPTR_VTABLE_CLASS_AND_CTOR(name, base)                  \
+        VPTR_VTABLE_CLASS(name, base)
+
 #define VPTR_MULTI_VTABLE_CLASS(name, base)                     \
 public: name(TADDR addr, TADDR vtAddr) : base(addr, vtAddr) {}  \
         VPTR_MULTI_CLASS_METHODS(name, base)
@@ -1842,6 +1854,9 @@ public: name(TADDR addr, TADDR vtAddr);                         \
 public: name(TADDR addr, TADDR vtAddr) {}                       \
         virtual ULONG32 VPtrSize(void) = 0;
 
+#define VPTR_BASE_VTABLE_CLASS_AND_CTOR(name)                   \
+        VPTR_BASE_VTABLE_CLASS(name)
+
 #define VPTR_BASE_VTABLE_CLASS_NO_CTOR_BODY(name)               \
 public: name(TADDR addr, TADDR vtAddr);                         \
         virtual ULONG32 VPtrSize(void) = 0;
@@ -2085,12 +2100,49 @@ typedef const void* PTR_CVOID;
 #define S8PTRMAX(type, maxChars) type*
 #define S16PTR(type) type*
 #define S16PTRMAX(type, maxChars) type*
+
+#if defined(FEATURE_PAL)
+
+#define VPTR_VTABLE_CLASS(name, base) \
+        friend struct _DacGlobals; \
+public: name(int dummy) : base(dummy) {}
+
+#define VPTR_VTABLE_CLASS_AND_CTOR(name, base) \
+        VPTR_VTABLE_CLASS(name, base) \
+        name() : base() {}
+
+#define VPTR_MULTI_VTABLE_CLASS(name, base) \
+        friend struct _DacGlobals; \
+public: name(int dummy) : base(dummy) {}
+
+#define VPTR_BASE_CONCRETE_VTABLE_CLASS(name) \
+        friend struct _DacGlobals; \
+public: name(int dummy) {}
+
+#define VPTR_BASE_VTABLE_CLASS(name) \
+        friend struct _DacGlobals; \
+public: name(int dummy) {}
+
+#define VPTR_BASE_VTABLE_CLASS_AND_CTOR(name) \
+        VPTR_BASE_VTABLE_CLASS(name) \
+        name() {}
+
+#define VPTR_ABSTRACT_VTABLE_CLASS(name, base) \
+        friend struct _DacGlobals; \
+public: name(int dummy) : base(dummy) {}
+
+#else // FEATURE_PAL
+
 #define VPTR_VTABLE_CLASS(name, base)
+#define VPTR_VTABLE_CLASS_AND_CTOR(name, base)
 #define VPTR_MULTI_VTABLE_CLASS(name, base)
 #define VPTR_BASE_CONCRETE_VTABLE_CLASS(name)
 #define VPTR_BASE_VTABLE_CLASS(name)
+#define VPTR_BASE_VTABLE_CLASS_AND_CTOR(name)
 #define VPTR_ABSTRACT_VTABLE_CLASS(name, base)
 
+#endif // FEATURE_PAL
+
 // helper macro to make the vtables unique for DAC
 #define VPTR_UNIQUE(unique) virtual int MakeVTableUniqueForDAC() {    STATIC_CONTRACT_SO_TOLERANT; return unique; }
 #define VPTR_UNIQUE_BaseDomain                          (100000)
diff --git a/src/inc/dacvars.h b/src/inc/dacvars.h
index 4cf0c4b12b..35006f1aa5 100644
--- a/src/inc/dacvars.h
+++ b/src/inc/dacvars.h
@@ -13,8 +13,8 @@
 // DEFINE_DACVAR macro & include dacvars.h like so (see enummem.cpp and/or 
 // daccess.h for examples):
 //
-// #define DEFINE_DACVAR(type, size, id)  type id;	//this defn. discards
-//													//the size
+// #define DEFINE_DACVAR(type, size, id, var)  type id;     //this defn. discards
+//                                                          //the size
 // #include "dacvars.h"
 //
 // @dbgtodo: 
@@ -47,6 +47,10 @@
 // member, the name should be <class_name>__<member_name>. If the variable is a 
 // global, the name should be <dac>__<global_name>.
 //					*				*				*
+// The FOURTH ARGUMENT should be the actual name of the static/global variable. If 
+// static data the should be [<namespace>::]<class_name>::<member_name>. If global,
+// it should look like <global_name>.
+//					*				*				*
 // If you need to add an entry to this file, your type may not be visible when  
 // this file is compiled. In that case, you need to do one of two things:
 // - If the type is a pointer type, you can simply use UNKNOWN_POINTER_TYPE as the 
@@ -58,258 +62,264 @@
 // nothing will be dumped. 
 
 #ifndef DEFINE_DACVAR
-#define DEFINE_DACVAR(type, true_type, id)
+#define DEFINE_DACVAR(type, true_type, id, var)
 #endif
 
-#define UNKNOWN_POINTER_TYPE SIZE_T
+// Use this macro for any server (namespace SVR) variables
+#ifndef DEFINE_DACVAR_SVR
+#define DEFINE_DACVAR_SVR(type, true_type, id, var)
+#endif
 
 // Use this macro to define a static var that is known to DAC, but not captured in a dump.                         
 #ifndef DEFINE_DACVAR_NO_DUMP
-#define DEFINE_DACVAR_NO_DUMP(type, true_type, id)
+#define DEFINE_DACVAR_NO_DUMP(type, true_type, id, var)
 #endif
 
-DEFINE_DACVAR(ULONG, PTR_RangeSection, ExecutionManager__m_CodeRangeList)
-DEFINE_DACVAR(ULONG, PTR_EECodeManager, ExecutionManager__m_pDefaultCodeMan)
-DEFINE_DACVAR(ULONG, LONG, ExecutionManager__m_dwReaderCount)
-DEFINE_DACVAR(ULONG, LONG, ExecutionManager__m_dwWriterLock)
+#define UNKNOWN_POINTER_TYPE SIZE_T
+
+DEFINE_DACVAR(ULONG, PTR_RangeSection, ExecutionManager__m_CodeRangeList, ExecutionManager::m_CodeRangeList)
+DEFINE_DACVAR(ULONG, PTR_EECodeManager, ExecutionManager__m_pDefaultCodeMan, ExecutionManager::m_pDefaultCodeMan)
+DEFINE_DACVAR(ULONG, LONG, ExecutionManager__m_dwReaderCount, ExecutionManager::m_dwReaderCount)
+DEFINE_DACVAR(ULONG, LONG, ExecutionManager__m_dwWriterLock, ExecutionManager::m_dwWriterLock)
 
-DEFINE_DACVAR(ULONG, PTR_EEJitManager, ExecutionManager__m_pEEJitManager)
+DEFINE_DACVAR(ULONG, PTR_EEJitManager, ExecutionManager__m_pEEJitManager, ExecutionManager::m_pEEJitManager)
 #ifdef FEATURE_PREJIT
-DEFINE_DACVAR(ULONG, PTR_NativeImageJitManager, ExecutionManager__m_pNativeImageJitManager)
+DEFINE_DACVAR(ULONG, PTR_NativeImageJitManager, ExecutionManager__m_pNativeImageJitManager, ExecutionManager::m_pNativeImageJitManager)
 #endif
 #ifdef FEATURE_READYTORUN
-DEFINE_DACVAR(ULONG, PTR_ReadyToRunJitManager, ExecutionManager__m_pReadyToRunJitManager)
+DEFINE_DACVAR(ULONG, PTR_ReadyToRunJitManager, ExecutionManager__m_pReadyToRunJitManager, ExecutionManager::m_pReadyToRunJitManager)
 #endif
 
-DEFINE_DACVAR_NO_DUMP(ULONG, VMHELPDEF *, dac__hlpFuncTable)
-DEFINE_DACVAR(ULONG, VMHELPDEF *, dac__hlpDynamicFuncTable)
+DEFINE_DACVAR_NO_DUMP(ULONG, VMHELPDEF *, dac__hlpFuncTable, ::hlpFuncTable)
+DEFINE_DACVAR(ULONG, VMHELPDEF *, dac__hlpDynamicFuncTable, ::hlpDynamicFuncTable)
 
 #ifdef FEATURE_INCLUDE_ALL_INTERFACES
-DEFINE_DACVAR(ULONG, PTR_ConnectionNameTable, CCLRDebugManager__m_pConnectionNameHash)
+DEFINE_DACVAR(ULONG, PTR_ConnectionNameTable, CCLRDebugManager__m_pConnectionNameHash, CCLRDebugManager::m_pConnectionNameHash)
 #endif // FEATURE_INCLUDE_ALL_INTERFACES
-DEFINE_DACVAR(ULONG, PTR_StubManager, StubManager__g_pFirstManager)
-DEFINE_DACVAR(ULONG, PTR_PrecodeStubManager, PrecodeStubManager__g_pManager)
-DEFINE_DACVAR(ULONG, PTR_StubLinkStubManager, StubLinkStubManager__g_pManager)
-DEFINE_DACVAR(ULONG, PTR_ThunkHeapStubManager, ThunkHeapStubManager__g_pManager)
-DEFINE_DACVAR(ULONG, PTR_JumpStubStubManager, JumpStubStubManager__g_pManager)
-DEFINE_DACVAR(ULONG, PTR_RangeSectionStubManager, RangeSectionStubManager__g_pManager)
-DEFINE_DACVAR(ULONG, PTR_DelegateInvokeStubManager, DelegateInvokeStubManager__g_pManager)
-DEFINE_DACVAR(ULONG, PTR_VirtualCallStubManagerManager, VirtualCallStubManagerManager__g_pManager)
-
-DEFINE_DACVAR(ULONG, PTR_ThreadStore, ThreadStore__s_pThreadStore)
-
-DEFINE_DACVAR(ULONG, int, ThreadpoolMgr__cpuUtilization)
-DEFINE_DACVAR(ULONG, ThreadpoolMgr::ThreadCounter, ThreadpoolMgr__WorkerCounter)
-DEFINE_DACVAR(ULONG, int, ThreadpoolMgr__MinLimitTotalWorkerThreads)
-DEFINE_DACVAR(ULONG, DWORD, ThreadpoolMgr__MaxLimitTotalWorkerThreads)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*PTR_WorkRequest*/, ThreadpoolMgr__WorkRequestHead) // PTR_WorkRequest is not defined. So use a pointer type
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE  /*PTR_WorkRequest*/, ThreadpoolMgr__WorkRequestTail) // 
-DEFINE_DACVAR(ULONG, ThreadpoolMgr::ThreadCounter, ThreadpoolMgr__CPThreadCounter)
-DEFINE_DACVAR(ULONG, LONG, ThreadpoolMgr__MaxFreeCPThreads)
-DEFINE_DACVAR(ULONG, LONG, ThreadpoolMgr__MaxLimitTotalCPThreads)
-DEFINE_DACVAR(ULONG, LONG, ThreadpoolMgr__MinLimitTotalCPThreads)        
-DEFINE_DACVAR(ULONG, LIST_ENTRY, ThreadpoolMgr__TimerQueue)        
-DEFINE_DACVAR_NO_DUMP(ULONG, SIZE_T, dac__HillClimbingLog)
-DEFINE_DACVAR(ULONG, int, dac__HillClimbingLogFirstIndex)        
-DEFINE_DACVAR(ULONG, int, dac__HillClimbingLogSize)        
-
-DEFINE_DACVAR(ULONG, PTR_Thread, dac__g_pFinalizerThread)
-DEFINE_DACVAR(ULONG, PTR_Thread, dac__g_pSuspensionThread)
+DEFINE_DACVAR(ULONG, PTR_StubManager, StubManager__g_pFirstManager, StubManager::g_pFirstManager)
+DEFINE_DACVAR(ULONG, PTR_PrecodeStubManager, PrecodeStubManager__g_pManager, PrecodeStubManager::g_pManager)
+DEFINE_DACVAR(ULONG, PTR_StubLinkStubManager, StubLinkStubManager__g_pManager, StubLinkStubManager::g_pManager)
+DEFINE_DACVAR(ULONG, PTR_ThunkHeapStubManager, ThunkHeapStubManager__g_pManager, ThunkHeapStubManager::g_pManager)
+DEFINE_DACVAR(ULONG, PTR_JumpStubStubManager, JumpStubStubManager__g_pManager, JumpStubStubManager::g_pManager)
+DEFINE_DACVAR(ULONG, PTR_RangeSectionStubManager, RangeSectionStubManager__g_pManager, RangeSectionStubManager::g_pManager)
+DEFINE_DACVAR(ULONG, PTR_DelegateInvokeStubManager, DelegateInvokeStubManager__g_pManager, DelegateInvokeStubManager::g_pManager)
+DEFINE_DACVAR(ULONG, PTR_VirtualCallStubManagerManager, VirtualCallStubManagerManager__g_pManager, VirtualCallStubManagerManager::g_pManager)
+
+DEFINE_DACVAR(ULONG, PTR_ThreadStore, ThreadStore__s_pThreadStore, ThreadStore::s_pThreadStore)
+
+DEFINE_DACVAR(ULONG, int, ThreadpoolMgr__cpuUtilization, ThreadpoolMgr::cpuUtilization)
+DEFINE_DACVAR(ULONG, ThreadpoolMgr::ThreadCounter, ThreadpoolMgr__WorkerCounter, ThreadpoolMgr::WorkerCounter)
+DEFINE_DACVAR(ULONG, int, ThreadpoolMgr__MinLimitTotalWorkerThreads, ThreadpoolMgr::MinLimitTotalWorkerThreads)
+DEFINE_DACVAR(ULONG, DWORD, ThreadpoolMgr__MaxLimitTotalWorkerThreads, ThreadpoolMgr::MaxLimitTotalWorkerThreads)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*PTR_WorkRequest*/, ThreadpoolMgr__WorkRequestHead, ThreadpoolMgr::WorkRequestHead)  // PTR_WorkRequest is not defined. So use a pointer type
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE  /*PTR_WorkRequest*/, ThreadpoolMgr__WorkRequestTail, ThreadpoolMgr::WorkRequestTail) // 
+DEFINE_DACVAR(ULONG, ThreadpoolMgr::ThreadCounter, ThreadpoolMgr__CPThreadCounter, ThreadpoolMgr::CPThreadCounter)
+DEFINE_DACVAR(ULONG, LONG, ThreadpoolMgr__MaxFreeCPThreads, ThreadpoolMgr::MaxFreeCPThreads)
+DEFINE_DACVAR(ULONG, LONG, ThreadpoolMgr__MaxLimitTotalCPThreads, ThreadpoolMgr::MaxLimitTotalCPThreads)
+DEFINE_DACVAR(ULONG, LONG, ThreadpoolMgr__MinLimitTotalCPThreads, ThreadpoolMgr::MinLimitTotalCPThreads)
+DEFINE_DACVAR(ULONG, LIST_ENTRY, ThreadpoolMgr__TimerQueue, ThreadpoolMgr::TimerQueue)
+DEFINE_DACVAR_NO_DUMP(ULONG, SIZE_T, dac__HillClimbingLog, ::HillClimbingLog)
+DEFINE_DACVAR(ULONG, int, dac__HillClimbingLogFirstIndex, ::HillClimbingLogFirstIndex)
+DEFINE_DACVAR(ULONG, int, dac__HillClimbingLogSize, ::HillClimbingLogSize)
+
+DEFINE_DACVAR(ULONG, PTR_Thread, dac__g_pFinalizerThread, ::g_pFinalizerThread)
+DEFINE_DACVAR(ULONG, PTR_Thread, dac__g_pSuspensionThread, ::g_pSuspensionThread)
 
 #ifdef FEATURE_SVR_GC
-DEFINE_DACVAR(ULONG, DWORD, GCHeap__gcHeapType)
+DEFINE_DACVAR(ULONG, DWORD, GCHeap__gcHeapType, GCHeap::gcHeapType)
 #endif // FEATURE_SVR_GC
 
-DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__alloc_allocated)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*PTR_heap_segment*/, WKS__gc_heap__ephemeral_heap_segment)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*PTR_CFinalize*/, WKS__gc_heap__finalize_queue)
+DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__alloc_allocated, WKS::gc_heap::alloc_allocated)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*PTR_heap_segment*/, WKS__gc_heap__ephemeral_heap_segment, WKS::gc_heap::ephemeral_heap_segment)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*PTR_CFinalize*/, WKS__gc_heap__finalize_queue, WKS::gc_heap::finalize_queue)
 
 // Can not use MULTIPLE_HEAPS here because desktop build contains it is not defined for workstation GC
 // but we include workstation GC in mscorwks.dll.
 #ifdef FEATURE_SVR_GC
-DEFINE_DACVAR(ULONG, int, SVR__gc_heap__n_heaps)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*(PTR_gc_heap*)*/, SVR__gc_heap__g_heaps)
+DEFINE_DACVAR_SVR(ULONG, int, SVR__gc_heap__n_heaps, SVR::gc_heap::n_heaps)
+DEFINE_DACVAR_SVR(ULONG, UNKNOWN_POINTER_TYPE /*(PTR_gc_heap*)*/, SVR__gc_heap__g_heaps, SVR::gc_heap::g_heaps)
 #endif // FEATURE_SVR_GC
-DEFINE_DACVAR(ULONG, oom_history, WKS__gc_heap__oom_info)
+DEFINE_DACVAR(ULONG, oom_history, WKS__gc_heap__oom_info, WKS::gc_heap::oom_info)
 
-DEFINE_DACVAR(ULONG, PTR_SystemDomain, SystemDomain__m_pSystemDomain)
-DEFINE_DACVAR(ULONG, ArrayListStatic, SystemDomain__m_appDomainIndexList)
-DEFINE_DACVAR(ULONG, BOOL, SystemDomain__s_fForceDebug)
-DEFINE_DACVAR(ULONG, BOOL, SystemDomain__s_fForceProfiling)
-DEFINE_DACVAR(ULONG, BOOL, SystemDomain__s_fForceInstrument)
-DEFINE_DACVAR(ULONG, PTR_SharedDomain, SharedDomain__m_pSharedDomain)
+DEFINE_DACVAR(ULONG, PTR_SystemDomain, SystemDomain__m_pSystemDomain, SystemDomain::m_pSystemDomain)
+DEFINE_DACVAR(ULONG, ArrayListStatic, SystemDomain__m_appDomainIndexList, SystemDomain::m_appDomainIndexList)
+DEFINE_DACVAR(ULONG, BOOL, SystemDomain__s_fForceDebug, SystemDomain::s_fForceDebug)
+DEFINE_DACVAR(ULONG, BOOL, SystemDomain__s_fForceProfiling, SystemDomain::s_fForceProfiling)
+DEFINE_DACVAR(ULONG, BOOL, SystemDomain__s_fForceInstrument, SystemDomain::s_fForceInstrument)
+DEFINE_DACVAR(ULONG, PTR_SharedDomain, SharedDomain__m_pSharedDomain, SharedDomain::m_pSharedDomain)
 
 
-DEFINE_DACVAR(ULONG, DWORD, CExecutionEngine__TlsIndex)
+DEFINE_DACVAR(ULONG, DWORD, CExecutionEngine__TlsIndex, CExecutionEngine::TlsIndex)
 
-DEFINE_DACVAR(ULONG, LONG, CNameSpace__m_GcStructuresInvalidCnt)
+DEFINE_DACVAR(ULONG, LONG, CNameSpace__m_GcStructuresInvalidCnt, CNameSpace::m_GcStructuresInvalidCnt)
 
 #if defined(FEATURE_INCLUDE_ALL_INTERFACES) || defined(FEATURE_WINDOWSPHONE)
-DEFINE_DACVAR(ULONG, int, CCLRErrorReportingManager__g_ECustomDumpFlavor)
+DEFINE_DACVAR(ULONG, int, CCLRErrorReportingManager__g_ECustomDumpFlavor, CCLRErrorReportingManager::g_ECustomDumpFlavor)
 #endif
 
-DEFINE_DACVAR(ULONG, PTR_SString, SString__s_Empty)
+DEFINE_DACVAR(ULONG, PTR_SString, SString__s_Empty, SString::s_Empty)
 
 #ifdef FEATURE_APPX
 #if defined(FEATURE_CORECLR)
-DEFINE_DACVAR(ULONG, BOOL, dac__g_fAppX)
+DEFINE_DACVAR(ULONG, BOOL, dac__g_fAppX, ::g_fAppX)
 #else
-DEFINE_DACVAR(ULONG, PTR_AppXRTInfo, dac__g_pAppXRTInfo)
+DEFINE_DACVAR(ULONG, PTR_AppXRTInfo, dac__g_pAppXRTInfo, ::g_pAppXRTInfo)
 #endif
 #endif // FEATURE_APPX
 
-DEFINE_DACVAR(ULONG, BOOL, SString__s_IsANSIMultibyte)
+DEFINE_DACVAR(ULONG, BOOL, SString__s_IsANSIMultibyte, SString::s_IsANSIMultibyte)
 
 #ifdef FEATURE_REMOTING
-DEFINE_DACVAR_NO_DUMP(ULONG, MethodTable, CTPMethodTable__s_pThunkTable)
+DEFINE_DACVAR_NO_DUMP(ULONG, MethodTable, CTPMethodTable__s_pThunkTable, CTPMethodTable::s_pThunkTable)
 #endif // FEATURE_REMOTING
 
-DEFINE_DACVAR(ULONG, INT32, ArrayBase__s_arrayBoundsZero)
+DEFINE_DACVAR(ULONG, INT32, ArrayBase__s_arrayBoundsZero, ArrayBase::s_arrayBoundsZero)
 
-DEFINE_DACVAR(ULONG, BOOL, StackwalkCache__s_Enabled)
+DEFINE_DACVAR(ULONG, BOOL, StackwalkCache__s_Enabled, StackwalkCache::s_Enabled)
 
-DEFINE_DACVAR(ULONG, PTR_JITNotification, dac__g_pNotificationTable)
-DEFINE_DACVAR(ULONG, ULONG32, dac__g_dacNotificationFlags)
-DEFINE_DACVAR(ULONG, PTR_GcNotification, dac__g_pGcNotificationTable)
+DEFINE_DACVAR(ULONG, PTR_JITNotification, dac__g_pNotificationTable, ::g_pNotificationTable)
+DEFINE_DACVAR(ULONG, ULONG32, dac__g_dacNotificationFlags, ::g_dacNotificationFlags)
+DEFINE_DACVAR(ULONG, PTR_GcNotification, dac__g_pGcNotificationTable, ::g_pGcNotificationTable)
 
 #ifndef FEATURE_IMPLICIT_TLS
-DEFINE_DACVAR(ULONG, DWORD, dac__gThreadTLSIndex)
-DEFINE_DACVAR(ULONG, DWORD, dac__gAppDomainTLSIndex)
+DEFINE_DACVAR(ULONG, DWORD, dac__gThreadTLSIndex, ::gThreadTLSIndex)
+DEFINE_DACVAR(ULONG, DWORD, dac__gAppDomainTLSIndex, ::gAppDomainTLSIndex)
 #endif
 
-DEFINE_DACVAR(ULONG, PTR_EEConfig, dac__g_pConfig)
+DEFINE_DACVAR(ULONG, PTR_EEConfig, dac__g_pConfig, ::g_pConfig)
 
-DEFINE_DACVAR(ULONG, MscorlibBinder, dac__g_Mscorlib)
+DEFINE_DACVAR(ULONG, MscorlibBinder, dac__g_Mscorlib, ::g_Mscorlib)
 
 #if defined(PROFILING_SUPPORTED) || defined(PROFILING_SUPPORTED_DATA)
-DEFINE_DACVAR(ULONG, ProfControlBlock, dac__g_profControlBlock)
+DEFINE_DACVAR(ULONG, ProfControlBlock, dac__g_profControlBlock, ::g_profControlBlock)
 #endif // defined(PROFILING_SUPPORTED) || defined(PROFILING_SUPPORTED_DATA)
 
-DEFINE_DACVAR_NO_DUMP(ULONG, SIZE_T, dac__generation_table)
-DEFINE_DACVAR(ULONG, PTR_DWORD, dac__g_card_table)
-DEFINE_DACVAR(ULONG, PTR_BYTE, dac__g_lowest_address)
-DEFINE_DACVAR(ULONG, PTR_BYTE, dac__g_highest_address)
-
-DEFINE_DACVAR(ULONG, GCHeap, dac__g_pGCHeap)
-
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThinLockThreadIdDispenser)    
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pModuleIndexDispenser)    
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pObjectClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pRuntimeTypeClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pCanonMethodTableClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pStringClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pArrayClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pSZArrayHelperClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pNullableClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pExceptionClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThreadAbortExceptionClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pOutOfMemoryExceptionClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pStackOverflowExceptionClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pExecutionEngineExceptionClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pDelegateClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pMulticastDelegateClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pFreeObjectMethodTable)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pOverlappedDataClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pValueTypeClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pEnumClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThreadClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pCriticalFinalizerObjectClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pAsyncFileStream_AsyncResultClass)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pPredefinedArrayTypes)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_ArgumentHandleMT)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_ArgIteratorMT)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_TypedReferenceMT)
+DEFINE_DACVAR_NO_DUMP(ULONG, SIZE_T, dac__generation_table, WKS::generation_table)
+DEFINE_DACVAR(ULONG, PTR_DWORD, dac__g_card_table, ::g_card_table)
+DEFINE_DACVAR(ULONG, PTR_BYTE, dac__g_lowest_address, ::g_lowest_address)
+DEFINE_DACVAR(ULONG, PTR_BYTE, dac__g_highest_address, ::g_highest_address)
+
+DEFINE_DACVAR(ULONG, GCHeap, dac__g_pGCHeap, ::g_pGCHeap)
+
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThinLockThreadIdDispenser, ::g_pThinLockThreadIdDispenser)    
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pModuleIndexDispenser, ::g_pModuleIndexDispenser)    
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pObjectClass, ::g_pObjectClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pRuntimeTypeClass, ::g_pRuntimeTypeClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pCanonMethodTableClass, ::g_pCanonMethodTableClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pStringClass, ::g_pStringClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pArrayClass, ::g_pArrayClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pSZArrayHelperClass, ::g_pSZArrayHelperClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pNullableClass, ::g_pNullableClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pExceptionClass, ::g_pExceptionClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThreadAbortExceptionClass, ::g_pThreadAbortExceptionClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pOutOfMemoryExceptionClass, ::g_pOutOfMemoryExceptionClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pStackOverflowExceptionClass, ::g_pStackOverflowExceptionClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pExecutionEngineExceptionClass, ::g_pExecutionEngineExceptionClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pDelegateClass, ::g_pDelegateClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pMulticastDelegateClass, ::g_pMulticastDelegateClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pFreeObjectMethodTable, ::g_pFreeObjectMethodTable)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pOverlappedDataClass, ::g_pOverlappedDataClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pValueTypeClass, ::g_pValueTypeClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pEnumClass, ::g_pEnumClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pThreadClass, ::g_pThreadClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pCriticalFinalizerObjectClass, ::g_pCriticalFinalizerObjectClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pAsyncFileStream_AsyncResultClass, ::g_pAsyncFileStream_AsyncResultClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pPredefinedArrayTypes, ::g_pPredefinedArrayTypes)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_ArgumentHandleMT, ::g_ArgumentHandleMT)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_ArgIteratorMT, ::g_ArgIteratorMT)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_TypedReferenceMT, ::g_TypedReferenceMT)
 
 #ifdef FEATURE_COMINTEROP
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pBaseCOMObject)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pBaseRuntimeClass)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pBaseCOMObject, ::g_pBaseCOMObject)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pBaseRuntimeClass, ::g_pBaseRuntimeClass)
 #endif
 
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pPrepareConstrainedRegionsMethod)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pExecuteBackoutCodeHelperMethod)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pPrepareConstrainedRegionsMethod, ::g_pPrepareConstrainedRegionsMethod)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pExecuteBackoutCodeHelperMethod, ::g_pExecuteBackoutCodeHelperMethod)
 
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pObjectCtorMD)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pObjectFinalizerMD)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pObjectCtorMD, ::g_pObjectCtorMD)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pObjectFinalizerMD, ::g_pObjectFinalizerMD)
 
-DEFINE_DACVAR(ULONG, bool, dac__g_fProcessDetach)
-DEFINE_DACVAR(ULONG, DWORD, dac__g_fEEShutDown)
-DEFINE_DACVAR(ULONG, DWORD, dac__g_fHostConfig)
+DEFINE_DACVAR(ULONG, bool, dac__g_fProcessDetach, ::g_fProcessDetach)
+DEFINE_DACVAR(ULONG, DWORD, dac__g_fEEShutDown, ::g_fEEShutDown)
+DEFINE_DACVAR(ULONG, DWORD, dac__g_fHostConfig, ::g_fHostConfig)
 
-DEFINE_DACVAR(ULONG, ULONG, dac__g_CORDebuggerControlFlags)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pDebugger)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pDebugInterface)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pEEDbgInterfaceImpl)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pEEInterface)
+DEFINE_DACVAR(ULONG, ULONG, dac__g_CORDebuggerControlFlags, ::g_CORDebuggerControlFlags)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pDebugger, ::g_pDebugger)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pDebugInterface, ::g_pDebugInterface)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pEEDbgInterfaceImpl, ::g_pEEDbgInterfaceImpl)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pEEInterface, ::g_pEEInterface)
 
-DEFINE_DACVAR(ULONG, BOOL, Debugger__s_fCanChangeNgenFlags)
+DEFINE_DACVAR(ULONG, BOOL, Debugger__s_fCanChangeNgenFlags, Debugger::s_fCanChangeNgenFlags)
 
-DEFINE_DACVAR(ULONG, PTR_DebuggerPatchTable, DebuggerController__g_patches)
-DEFINE_DACVAR(ULONG, BOOL, DebuggerController__g_patchTableValid)
+DEFINE_DACVAR(ULONG, PTR_DebuggerPatchTable, DebuggerController__g_patches, DebuggerController::g_patches)
+DEFINE_DACVAR(ULONG, BOOL, DebuggerController__g_patchTableValid, DebuggerController::g_patchTableValid)
 
 
-DEFINE_DACVAR(ULONG, SIZE_T, dac__gLowestFCall)
-DEFINE_DACVAR(ULONG, SIZE_T, dac__gHighestFCall)
-DEFINE_DACVAR(ULONG, SIZE_T, dac__gFCallMethods)
+DEFINE_DACVAR(ULONG, SIZE_T, dac__gLowestFCall, ::gLowestFCall)
+DEFINE_DACVAR(ULONG, SIZE_T, dac__gHighestFCall, ::gHighestFCall)
+DEFINE_DACVAR(ULONG, SIZE_T, dac__gFCallMethods, ::gFCallMethods)
 
-DEFINE_DACVAR(ULONG, PTR_SyncTableEntry, dac__g_pSyncTable)
+DEFINE_DACVAR(ULONG, PTR_SyncTableEntry, dac__g_pSyncTable, ::g_pSyncTable)
 #ifdef FEATURE_COMINTEROP
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pRCWCleanupList)
-DEFINE_DACVAR(ULONG, BOOL, RCWWalker__s_bIsGlobalPeggingOn);
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pRCWCleanupList, ::g_pRCWCleanupList)
+DEFINE_DACVAR(ULONG, BOOL, RCWWalker__s_bIsGlobalPeggingOn, RCWWalker::s_bIsGlobalPeggingOn)
 #endif // FEATURE_COMINTEROP
 
 #ifndef FEATURE_PAL
-DEFINE_DACVAR(ULONG, SIZE_T, dac__g_runtimeLoadedBaseAddress)
-DEFINE_DACVAR(ULONG, SIZE_T, dac__g_runtimeVirtualSize)
+DEFINE_DACVAR(ULONG, SIZE_T, dac__g_runtimeLoadedBaseAddress, ::g_runtimeLoadedBaseAddress)
+DEFINE_DACVAR(ULONG, SIZE_T, dac__g_runtimeVirtualSize, ::g_runtimeVirtualSize)
 #endif // !FEATURE_PAL
 
-DEFINE_DACVAR(ULONG, SyncBlockCache *, SyncBlockCache__s_pSyncBlockCache)
+DEFINE_DACVAR(ULONG, SyncBlockCache *, SyncBlockCache__s_pSyncBlockCache, SyncBlockCache::s_pSyncBlockCache)
 
-DEFINE_DACVAR(ULONG, HandleTableMap, dac__g_HandleTableMap)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pStressLog)
+DEFINE_DACVAR(ULONG, HandleTableMap, dac__g_HandleTableMap, ::g_HandleTableMap)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pStressLog, ::g_pStressLog)
 
-DEFINE_DACVAR(ULONG, SIZE_T, dac__s_gsCookie)
+DEFINE_DACVAR(ULONG, SIZE_T, dac__s_gsCookie, ::s_gsCookie)
 
 #ifdef FEATURE_IPCMAN
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pIPCManagerInterface)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE, dac__g_pIPCManagerInterface, ::g_pIPCManagerInterface)
 #endif // FEATURE_IPCMAN
 
-DEFINE_DACVAR_NO_DUMP(ULONG, SIZE_T, dac__g_FCDynamicallyAssignedImplementations)
+DEFINE_DACVAR_NO_DUMP(ULONG, SIZE_T, dac__g_FCDynamicallyAssignedImplementations, ::g_FCDynamicallyAssignedImplementations)
 
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*BYTE**/, WKS__gc_heap__internal_root_array)
-DEFINE_DACVAR(ULONG, size_t, WKS__gc_heap__internal_root_array_index)
-DEFINE_DACVAR(ULONG, ULONG, WKS__gc_heap__heap_analyze_success)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /*BYTE**/, WKS__gc_heap__internal_root_array, WKS::gc_heap::internal_root_array)
+DEFINE_DACVAR(ULONG, size_t, WKS__gc_heap__internal_root_array_index, WKS::gc_heap::internal_root_array_index)
+DEFINE_DACVAR(ULONG, ULONG, WKS__gc_heap__heap_analyze_success, WKS::gc_heap::heap_analyze_success)
 
-DEFINE_DACVAR(ULONG, SIZE_T, WKS__gc_heap__mark_array)
-DEFINE_DACVAR(ULONG, SIZE_T, WKS__gc_heap__current_c_gc_state)
-DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__next_sweep_obj)
-DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /* PTR_heap_segment */, WKS__gc_heap__saved_sweep_ephemeral_seg)
-DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__saved_sweep_ephemeral_start)
-DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__background_saved_lowest_address)
-DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__background_saved_highest_address)
+DEFINE_DACVAR(ULONG, SIZE_T, WKS__gc_heap__mark_array, WKS::gc_heap::mark_array)
+DEFINE_DACVAR(ULONG, SIZE_T, WKS__gc_heap__current_c_gc_state, WKS::gc_heap::current_c_gc_state)
+DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__next_sweep_obj, WKS::gc_heap::next_sweep_obj)
+DEFINE_DACVAR(ULONG, UNKNOWN_POINTER_TYPE /* PTR_heap_segment */, WKS__gc_heap__saved_sweep_ephemeral_seg, WKS::gc_heap::saved_sweep_ephemeral_seg)
+DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__saved_sweep_ephemeral_start, WKS::gc_heap::saved_sweep_ephemeral_start)
+DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__background_saved_lowest_address, WKS::gc_heap::background_saved_lowest_address)
+DEFINE_DACVAR(ULONG, PTR_BYTE, WKS__gc_heap__background_saved_highest_address, WKS::gc_heap::background_saved_highest_address)
 
 #ifdef FEATURE_CORECLR
-DEFINE_DACVAR(ULONG, HANDLE, dac__g_hContinueStartupEvent)
-DEFINE_DACVAR(ULONG, DWORD, CorHost2__m_dwStartupFlags)
+DEFINE_DACVAR(ULONG, HANDLE, dac__g_hContinueStartupEvent, ::g_hContinueStartupEvent)
+DEFINE_DACVAR(ULONG, DWORD, CorHost2__m_dwStartupFlags, CorHost2::m_dwStartupFlags)
 #endif // FEATURE_CORECLR
 
-DEFINE_DACVAR(ULONG, HRESULT, dac__g_hrFatalError)
+DEFINE_DACVAR(ULONG, HRESULT, dac__g_hrFatalError, ::g_hrFatalError)
 
 #if defined(DEBUGGING_SUPPORTED) && defined (FEATURE_PREJIT)
-    DEFINE_DACVAR(ULONG, DWORD, PEFile__s_NGENDebugFlags)
+    DEFINE_DACVAR(ULONG, DWORD, PEFile__s_NGENDebugFlags, PEFile::s_NGENDebugFlags)
 #endif //defined(DEBUGGING_SUPPORTED) && defined (FEATURE_PREJIT)
 
 #ifndef FEATURE_CORECLR
-DEFINE_DACVAR(ULONG, DWORD, AssemblyUsageLogManager__s_UsageLogFlags)
+DEFINE_DACVAR(ULONG, DWORD, AssemblyUsageLogManager__s_UsageLogFlags, AssemblyUsageLogManager::s_UsageLogFlags)
 #endif // FEATURE_CORECLR
 
 #if defined(FEATURE_HOSTED_BINDER) && defined(FEATURE_APPX_BINDER)
-DEFINE_DACVAR(ULONG, PTR_CLRPrivBinderAppX, CLRPrivBinderAppX__s_pSingleton)
+DEFINE_DACVAR(ULONG, PTR_CLRPrivBinderAppX, CLRPrivBinderAppX__s_pSingleton, CLRPrivBinderAppX::s_pSingleton)
 #endif //defined(FEATURE_HOSTED_BINDER) && defined(FEATURE_APPX)
 
 #ifdef FEATURE_MINIMETADATA_IN_TRIAGEDUMPS
-DEFINE_DACVAR(ULONG, DWORD, dac__g_MiniMetaDataBuffMaxSize)
-DEFINE_DACVAR(ULONG, TADDR, dac__g_MiniMetaDataBuffAddress)
+DEFINE_DACVAR(ULONG, DWORD, dac__g_MiniMetaDataBuffMaxSize, ::g_MiniMetaDataBuffMaxSize)
+DEFINE_DACVAR(ULONG, TADDR, dac__g_MiniMetaDataBuffAddress, ::g_MiniMetaDataBuffAddress)
 #endif // FEATURE_MINIMETADATA_IN_TRIAGEDUMPS
 
 #undef DEFINE_DACVAR
+#undef DEFINE_DACVAR_SVR
 #undef DEFINE_DACVAR_NO_DUMP
diff --git a/src/inc/eetwain.h b/src/inc/eetwain.h
index b88af6fba2..9143729906 100644
--- a/src/inc/eetwain.h
+++ b/src/inc/eetwain.h
@@ -133,7 +133,7 @@ enum GenericParamContextType
 
 class ICodeManager
 {
-    VPTR_BASE_VTABLE_CLASS(ICodeManager)
+    VPTR_BASE_VTABLE_CLASS_AND_CTOR(ICodeManager)
 
 public:
 
@@ -353,7 +353,7 @@ struct hdrInfo;
 
 class EECodeManager : public ICodeManager {
 
-    VPTR_VTABLE_CLASS(EECodeManager, ICodeManager)
+    VPTR_VTABLE_CLASS_AND_CTOR(EECodeManager, ICodeManager)
 
 public:
 
diff --git a/src/inc/sstring.h b/src/inc/sstring.h
index 31329e2856..a42d71155e 100644
--- a/src/inc/sstring.h
+++ b/src/inc/sstring.h
@@ -73,6 +73,8 @@ typedef const UTF8 *LPCUTF8;
 typedef DPTR(class SString) PTR_SString;
 class SString : private SBuffer
 {
+    friend struct _DacGlobals;
+
 private:
     enum Representation
     {
@@ -757,7 +759,6 @@ private:
     SString(void *buffer, COUNT_T size);
 
  private:
- 
     static int CaseCompareHelperA(const CHAR *buffer1, const CHAR *buffer2, COUNT_T count, LocaleID lcid, BOOL stopOnNull, BOOL stopOnCount);
     static int CaseCompareHelper(const WCHAR *buffer1, const WCHAR *buffer2, COUNT_T count, LocaleID lcid, BOOL stopOnNull, BOOL stopOnCount);
     
diff --git a/src/inc/vptr_list.h b/src/inc/vptr_list.h
index a5198bb89f..352f6f83a0 100644
--- a/src/inc/vptr_list.h
+++ b/src/inc/vptr_list.h
@@ -153,5 +153,7 @@ VPTR_CLASS(GlobalLoaderAllocator)
 VPTR_CLASS(AppDomainLoaderAllocator)
 VPTR_CLASS(AssemblyLoaderAllocator)
 
+#ifndef FEATURE_PAL
 VPTR_CLASS(AssemblySecurityDescriptor)
 VPTR_CLASS(ApplicationSecurityDescriptor)
+#endif // FEATURE_PAL
diff --git a/src/pal/inc/pal.h b/src/pal/inc/pal.h
index de924fc424..8516ce95c9 100644
--- a/src/pal/inc/pal.h
+++ b/src/pal/inc/pal.h
@@ -566,6 +566,30 @@ PAL_DeleteExecWatchpoint(
 
 
 PALIMPORT
+DWORD
+PALAPI
+PAL_PublishDacTableAddress(
+    IN PVOID address,
+    IN ULONG size
+    );
+
+PALIMPORT
+DWORD
+PALAPI
+PAL_GetDacTableAddress(
+    IN DWORD pid,
+    OUT PVOID *pAddress,
+    OUT PULONG pSize
+    );
+
+PALIMPORT
+VOID
+PALAPI
+PAL_CleanupDacTableAddress(
+    );
+
+
+PALIMPORT
 BOOL
 PALAPI
 PAL_RegisterMacEHPort();
diff --git a/src/pal/src/CMakeLists.txt b/src/pal/src/CMakeLists.txt
index 721bbba4a9..d65233ed17 100644
--- a/src/pal/src/CMakeLists.txt
+++ b/src/pal/src/CMakeLists.txt
@@ -89,6 +89,7 @@ set(SOURCES
   misc/fmtmessage.cpp
   misc/interlock.cpp
   misc/miscpalapi.cpp
+  misc/dactableaddress.cpp
   misc/strutil.cpp
   misc/sysinfo.cpp
   misc/time.cpp
diff --git a/src/pal/src/misc/dactableaddress.cpp b/src/pal/src/misc/dactableaddress.cpp
new file mode 100644
index 0000000000..43ef7d68ed
--- /dev/null
+++ b/src/pal/src/misc/dactableaddress.cpp
@@ -0,0 +1,163 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information. 
+//
+
+/*++
+
+
+
+Module Name:
+
+    dactableaddress.cpp
+
+Abstract:
+
+    Functions to write and read DAC global pointer table address between the coreclr
+    and DAC/debugger processes.
+
+NOTE:
+
+   These functions are temporary until a better way to plumb the DAC table
+   address from the debuggee to debugger processes is implemented.
+
+Revision History:
+
+
+--*/
+
+#include "pal/palinternal.h"
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+
+/*++
+Function
+    PAL_PublishDacTableAddress
+
+Parameters
+
+    address
+       [in] address of dac table
+    size
+       [in] size of dac table
+
+Return Values
+   pal errors
+
+--*/
+PALIMPORT
+DWORD
+PALAPI
+PAL_PublishDacTableAddress(
+    IN PVOID address,
+    IN ULONG size)
+{
+    DWORD ret = NO_ERROR;
+
+    // TODO - 3/5/15 - the DAC side needs the debuggee pid
+    // pid_t pid = getpid();
+    pid_t pid = 0;
+    char fileName[100]; 
+    snprintf(fileName, sizeof(fileName), "/tmp/%d_dacTable", pid);
+
+    FILE *file = fopen(fileName, "w+");
+    if (file != nullptr) 
+    {
+        char dacTableAddress[100]; 
+        snprintf(dacTableAddress, sizeof(dacTableAddress), "%p %d\n", address, size);
+
+        if (fputs(dacTableAddress, file) < 0)
+        {
+            ret = ERROR_INVALID_DATA;
+        }
+
+        fclose(file);
+    }
+    else
+    {
+        ret = ERROR_FILE_NOT_FOUND;
+    }
+
+    return ret;
+}
+
+
+/*++
+Function
+    PAL_GetDacTableAddress
+
+Parameters
+
+    pid
+       [in] process id to get the data
+    pAddress
+       [out] pointer to put DAC table address
+    pSize
+       [out] pointer to put DAC table size
+
+Return Values
+   pal errors
+
+--*/
+PALIMPORT
+DWORD
+PALAPI
+PAL_GetDacTableAddress(
+    IN DWORD pid,
+    OUT PVOID *pAddress,
+    OUT PULONG pSize)
+{
+    DWORD ret = NO_ERROR;
+
+    char fileName[100]; 
+    snprintf(fileName, sizeof(fileName), "/tmp/%d_dacTable", pid);
+
+    FILE *file = fopen(fileName, "r");
+    if (file != nullptr) 
+    {
+        char data[100]; 
+        if (fgets(data, sizeof(data), file) != nullptr)
+        {
+            if (sscanf(data, "%p %d\n", pAddress, pSize) != 2)
+            {
+                ret = ERROR_INVALID_DATA;
+            }
+        }
+        else
+        {
+            ret = ERROR_INVALID_DATA;
+        }
+
+        fclose(file);
+    }
+    else
+    {
+        ret = ERROR_FILE_NOT_FOUND;
+    }
+    return ret;
+}
+
+/*++
+Function
+    PAL_CleanupDacTableAddress
+
+Parameters
+    None
+
+Return Values
+   None
+
+--*/
+PALIMPORT
+VOID
+PALAPI
+PAL_CleanupDacTableAddress()
+{
+    //pid_t pid = getpid();
+    pid_t pid = 0;
+    char fileName[100]; 
+    snprintf(fileName, sizeof(fileName), "/tmp/%d_dacTable", pid);
+
+    remove(fileName);
+}
diff --git a/src/unwinder/dac/hostwinamd64/CMakeLists.txt b/src/unwinder/dac/hostwinamd64/CMakeLists.txt
index 66a595f033..757fde3909 100644
--- a/src/unwinder/dac/hostwinamd64/CMakeLists.txt
+++ b/src/unwinder/dac/hostwinamd64/CMakeLists.txt
@@ -1,5 +1,3 @@
-remove_definitions(-DPROFILING_SUPPORTED)
-add_definitions(-DPROFILING_SUPPORTED_DATA)
-add_definitions(-DDACCESS_COMPILE)
+include(${CLR_DIR}/dac.cmake)
 
 add_library(unwinder_dac_amd64 ${UNWINDER_SOURCES})
diff --git a/src/vm/appdomain.hpp b/src/vm/appdomain.hpp
index 24c86e9ae4..0e966659bb 100644
--- a/src/vm/appdomain.hpp
+++ b/src/vm/appdomain.hpp
@@ -5162,8 +5162,7 @@ typedef VPTR(class SharedDomain) PTR_SharedDomain;
 
 class SharedDomain : public BaseDomain
 {
-
-    VPTR_VTABLE_CLASS(SharedDomain, BaseDomain)
+    VPTR_VTABLE_CLASS_AND_CTOR(SharedDomain, BaseDomain)
 
 public:
 
diff --git a/src/vm/ceemain.h b/src/vm/ceemain.h
index e4f70057b9..9a6a54fbb3 100644
--- a/src/vm/ceemain.h
+++ b/src/vm/ceemain.h
@@ -57,6 +57,8 @@ void InnerCoEEShutDownCOM();
 //        how the g_pCEE and related variables are initialized.
 class CExecutionEngine : public IExecutionEngine, public IEEMemoryManager
 {
+    friend struct _DacGlobals;
+
     //***************************************************************************
     // public API:
     //***************************************************************************
diff --git a/src/vm/codeman.h b/src/vm/codeman.h
index e7ba84b862..a28c556dfd 100644
--- a/src/vm/codeman.h
+++ b/src/vm/codeman.h
@@ -390,10 +390,7 @@ class CodeHeap
     VPTR_BASE_VTABLE_CLASS(CodeHeap)
 
 public:
-
-#ifdef DACCESS_COMPILE
     CodeHeap() {}
-#endif
 
     // virtual dtor. Clean up heap
     virtual ~CodeHeap() {}
@@ -1143,6 +1140,7 @@ public:
 class ExecutionManager
 {
     friend class CorExternalDataAccess;
+    friend struct _DacGlobals;
 
 #ifdef DACCESS_COMPILE
     friend class ClrDataAccess;
@@ -1282,7 +1280,7 @@ public:
                           LoaderAllocator *pLoaderAllocator = NULL);
 #endif
 
-private :
+private:
     static RangeSection * FindCodeRangeWithLock(PCODE currentPC);
 
     static BOOL IsManagedCodeWithLock(PCODE currentPC);
diff --git a/src/vm/crst.h b/src/vm/crst.h
index da50066ccc..010cb5f8fb 100644
--- a/src/vm/crst.h
+++ b/src/vm/crst.h
@@ -473,11 +473,12 @@ public:
         LIMITED_METHOD_CONTRACT;
     };
 
+#endif
+
     Crst() {
         LIMITED_METHOD_CONTRACT;
     }
 
-#endif
 #endif // CLR_STANDALONE_BINDER
 };
 
diff --git a/src/vm/dbginterface.h b/src/vm/dbginterface.h
index fb3e167374..4d55f74e02 100644
--- a/src/vm/dbginterface.h
+++ b/src/vm/dbginterface.h
@@ -28,7 +28,7 @@ typedef void (*FAVORCALLBACK)(void *);
 
 class DebugInterface
 {
-    VPTR_BASE_VTABLE_CLASS(DebugInterface);
+    VPTR_BASE_VTABLE_CLASS_AND_CTOR(DebugInterface);
 
 public:
 
diff --git a/src/vm/eedbginterface.h b/src/vm/eedbginterface.h
index f300a0f665..e6678a8861 100644
--- a/src/vm/eedbginterface.h
+++ b/src/vm/eedbginterface.h
@@ -63,7 +63,7 @@ struct DebugOffsetToHandlerInfo
 
 class EEDebugInterface
 {
-    VPTR_BASE_VTABLE_CLASS(EEDebugInterface);
+    VPTR_BASE_VTABLE_CLASS_AND_CTOR(EEDebugInterface);
 
 public:
 
diff --git a/src/vm/eedbginterfaceimpl.h b/src/vm/eedbginterfaceimpl.h
index 5b59f897d0..f743dd02c1 100644
--- a/src/vm/eedbginterfaceimpl.h
+++ b/src/vm/eedbginterfaceimpl.h
@@ -36,7 +36,7 @@
 
 class EEDbgInterfaceImpl : public EEDebugInterface
 {
-    VPTR_VTABLE_CLASS(EEDbgInterfaceImpl, EEDebugInterface);
+    VPTR_VTABLE_CLASS_AND_CTOR(EEDbgInterfaceImpl, EEDebugInterface);
 
 public:
 
@@ -48,7 +48,7 @@ public:
     static FORCEINLINE void Init(void)
     {
         g_pEEDbgInterfaceImpl = new EEDbgInterfaceImpl(); // new throws on failure
-        }
+    }
 
     //
     // Cleanup any global data used by this interface.
diff --git a/src/vm/object.h b/src/vm/object.h
index 4930944c96..2669a54b2a 100644
--- a/src/vm/object.h
+++ b/src/vm/object.h
@@ -747,6 +747,7 @@ class ArrayBase : public Object
     friend OBJECTREF FastAllocatePrimitiveArray(MethodTable* arrayType, DWORD cElements, BOOL bAllocateInLargeHeap);
     friend class JIT_TrialAlloc;
     friend class CheckAsmOffsets;
+    friend struct _DacGlobals;
 
 private:
     // This MUST be the first field, so that it directly follows Object.  This is because
diff --git a/src/vm/pefile.h b/src/vm/pefile.h
index a62ba774c8..8f8a5f3588 100644
--- a/src/vm/pefile.h
+++ b/src/vm/pefile.h
@@ -108,7 +108,6 @@ class PEFile
     // ------------------------------------------------------------
     // SOS support
     // ------------------------------------------------------------
-
     VPTR_BASE_CONCRETE_VTABLE_CLASS(PEFile)
 
 public:
diff --git a/src/vm/rcwwalker.h b/src/vm/rcwwalker.h
index a2272eafbb..2497b8c2f8 100644
--- a/src/vm/rcwwalker.h
+++ b/src/vm/rcwwalker.h
@@ -32,6 +32,8 @@
 //
 class RCWWalker
 {
+    friend struct _DacGlobals;
+
 private :
     static VolatilePtr<IJupiterGCManager>  s_pGCManager;            // The one and only GCManager instance
     static BOOL                     s_bGCStarted;                   // Has GC started?    
diff --git a/src/vm/security.h b/src/vm/security.h
index 2b9e63c06d..9331a6820a 100644
--- a/src/vm/security.h
+++ b/src/vm/security.h
@@ -246,7 +246,9 @@ namespace Security
 class ISecurityDescriptor
 {
 public:
+#ifndef FEATURE_PAL
     VPTR_BASE_VTABLE_CLASS(ISecurityDescriptor)
+#endif
     virtual ~ISecurityDescriptor() { LIMITED_METHOD_CONTRACT; }
 
     virtual BOOL IsFullyTrusted() = 0;
@@ -274,7 +276,9 @@ public:
 class IApplicationSecurityDescriptor : public ISecurityDescriptor
 {
 public:
+#ifndef FEATURE_PAL
     VPTR_ABSTRACT_VTABLE_CLASS(IApplicationSecurityDescriptor, ISecurityDescriptor)
+#endif
 
 #ifndef DACCESS_COMPILE
 public:
@@ -318,7 +322,9 @@ public:
 class IAssemblySecurityDescriptor : public ISecurityDescriptor
 {
 public:
+#ifndef FEATURE_PAL
     VPTR_ABSTRACT_VTABLE_CLASS(IAssemblySecurityDescriptor, ISecurityDescriptor)
+#endif
 
 #ifndef DACCESS_COMPILE
     virtual SharedSecurityDescriptor *GetSharedSecDesc() = 0;
diff --git a/src/vm/securitydescriptor.h b/src/vm/securitydescriptor.h
index 22aecf5dd8..5d52f0494b 100644
--- a/src/vm/securitydescriptor.h
+++ b/src/vm/securitydescriptor.h
@@ -139,7 +139,9 @@ template<typename IT>
 class SecurityDescriptorBase : public IT, public SecurityDescriptor
 {
 public:
+#ifndef FEATURE_PAL
     VPTR_ABSTRACT_VTABLE_CLASS(SecurityDescriptorBase, IT) // needed for the DAC
+#endif
 
     inline SecurityDescriptorBase(AppDomain *pAppDomain, DomainAssembly *pAssembly, PEFile* pPEFile, LoaderAllocator *pLoaderAllocator);
 
diff --git a/src/vm/securitydescriptorappdomain.h b/src/vm/securitydescriptorappdomain.h
index d39cf0e3a9..6deab32c2d 100644
--- a/src/vm/securitydescriptorappdomain.h
+++ b/src/vm/securitydescriptorappdomain.h
@@ -36,7 +36,9 @@
 class ApplicationSecurityDescriptor : public SecurityDescriptorBase<IApplicationSecurityDescriptor>
 {
 public:
+#ifndef FEATURE_PAL
     VPTR_VTABLE_CLASS(ApplicationSecurityDescriptor, SecurityDescriptorBase<IApplicationSecurityDescriptor>)
+#endif
 
 private:
     // Dependency in managed : System.Security.HostSecurityManager.cs
diff --git a/src/vm/securitydescriptorassembly.h b/src/vm/securitydescriptorassembly.h
index 306ac24517..3687538a06 100644
--- a/src/vm/securitydescriptorassembly.h
+++ b/src/vm/securitydescriptorassembly.h
@@ -57,7 +57,9 @@ void StoreObjectInLazyHandle(LOADERHANDLE& handle, OBJECTREF ref, LoaderAllocato
 class AssemblySecurityDescriptor : public SecurityDescriptorBase<IAssemblySecurityDescriptor>
 {
 public:
+#ifndef FEATURE_PAL
     VPTR_VTABLE_CLASS(AssemblySecurityDescriptor, SecurityDescriptorBase<IAssemblySecurityDescriptor>)
+#endif
 
 private:
     PsetCacheEntry*   m_arrPassedLinktimeDemands[MAX_PASSED_DEMANDS];
diff --git a/src/vm/simplerwlock.hpp b/src/vm/simplerwlock.hpp
index 4566bcd4d1..6363d60884 100644
--- a/src/vm/simplerwlock.hpp
+++ b/src/vm/simplerwlock.hpp
@@ -163,7 +163,6 @@ public:
 #endif
     }
 
-#ifdef DACCESS_COMPILE
     // Special empty CTOR for DAC. We still need to assign to const fields, but they won't actually be used.
     SimpleRWLock()  
         : m_gcMode(COOPERATIVE_OR_PREEMPTIVE)
@@ -174,7 +173,6 @@ public:
         m_countNoTriggerGC = 0;
 #endif //_DEBUG
     }
-#endif
     
 #ifndef DACCESS_COMPILE
     // Acquire the reader lock.
diff --git a/src/vm/stackwalktypes.h b/src/vm/stackwalktypes.h
index f2be145c81..89829a85dc 100644
--- a/src/vm/stackwalktypes.h
+++ b/src/vm/stackwalktypes.h
@@ -199,6 +199,8 @@ static_assert_no_msg(sizeof(StackwalkCacheEntry) == 2 * sizeof(UINT_PTR));
 
 class StackwalkCache 
 {
+    friend struct _DacGlobals;
+
     public:
         BOOL Lookup(UINT_PTR IP);
         void Insert(StackwalkCacheEntry *pCacheEntry);
diff --git a/src/vm/stubmgr.h b/src/vm/stubmgr.h
index 70405ddf50..00743e2b14 100644
--- a/src/vm/stubmgr.h
+++ b/src/vm/stubmgr.h
@@ -194,6 +194,7 @@ typedef VPTR(class StubManager) PTR_StubManager;
 class StubManager
 {
     friend class StubManagerIterator;
+
     VPTR_BASE_VTABLE_CLASS(StubManager)
     
   public:
@@ -319,7 +320,7 @@ public:
     // This is used by DAC to provide more information on who owns a stub.
     virtual LPCWSTR GetStubManagerName(PCODE addr) = 0;
 #endif
-
+ 
 private:
     SPTR_DECL(StubManager, g_pFirstManager);
     PTR_StubManager m_pNextManager;
diff --git a/src/vm/win32threadpool.h b/src/vm/win32threadpool.h
index 20d2412c18..22fd6e05b4 100644
--- a/src/vm/win32threadpool.h
+++ b/src/vm/win32threadpool.h
@@ -104,7 +104,7 @@ class ThreadpoolMgr
     friend class ManagedPerAppDomainTPCount;
     friend class PerAppDomainTPCountList;
     friend class HillClimbing;
-
+    friend struct _DacGlobals;
 
     //
     // UnfairSemaphore is a more scalable semaphore than CLRSemaphore.  It prefers to release threads that have more recently begun waiting,
@@ -1291,8 +1291,8 @@ private:
 
     static LONG Initialization;                         // indicator of whether the threadpool is initialized.
 
-    SVAL_DECL(LONG,MinLimitTotalWorkerThreads);          // same as MinLimitTotalCPThreads
-    SVAL_DECL(LONG,MaxLimitTotalWorkerThreads);        // same as MaxLimitTotalCPThreads
+    SVAL_DECL(LONG,MinLimitTotalWorkerThreads);         // same as MinLimitTotalCPThreads
+    SVAL_DECL(LONG,MaxLimitTotalWorkerThreads);         // same as MaxLimitTotalCPThreads
         
     static Volatile<unsigned int> LastDequeueTime;      // used to determine if work items are getting thread starved 
     
@@ -1306,12 +1306,10 @@ private:
 
     static int ThreadAdjustmentInterval;
 
-    private:
-
     SPTR_DECL(WorkRequest,WorkRequestHead);             // Head of work request queue
     SPTR_DECL(WorkRequest,WorkRequestTail);             // Head of work request queue
 
-    static unsigned int LastCPThreadCreation;		    // last time a completion port thread was created
+    static unsigned int LastCPThreadCreation;		// last time a completion port thread was created
     static unsigned int NumberOfProcessors;             // = NumberOfWorkerThreads - no. of blocked threads
 
     static BOOL IsApcPendingOnWaitThread;               // Indicates if an APC is pending on the wait thread
@@ -1323,9 +1321,8 @@ public:
     static CrstStatic WorkerCriticalSection;
 
 private:
-
     static const DWORD WorkerTimeout = 20 * 1000;
-    static const DWORD WorkerTimeoutAppX = 5 * 1000; // shorter timeout to allow threads to exit prior to app suspension
+    static const DWORD WorkerTimeoutAppX = 5 * 1000;    // shorter timeout to allow threads to exit prior to app suspension
 
     SVAL_DECL(ThreadCounter,WorkerCounter);
 
@@ -1361,10 +1358,10 @@ private:
     static BOOL InitCompletionPortThreadpool;           // flag indicating whether completion port threadpool has been initialized
     static HANDLE GlobalCompletionPort;                 // used for binding io completions on file handles
 
-    public:
+public:
     SVAL_DECL(ThreadCounter,CPThreadCounter);
 
-    private:
+private:
     SVAL_DECL(LONG,MaxLimitTotalCPThreads);             // = MaxLimitCPThreadsPerCPU * number of CPUS
     SVAL_DECL(LONG,MinLimitTotalCPThreads);             
     SVAL_DECL(LONG,MaxFreeCPThreads);                   // = MaxFreeCPThreadsPerCPU * Number of CPUS