Rename overloaded "table" to "store" for VM side concept.

adityamandaleeka · adityamandaleeka · commit ab43a5fbeccc · 2017-04-11T20:33:26.000-07:00
diff --git a/src/gc/gchandletable.cpp b/src/gc/gchandletable.cpp
@@ -23,45 +23,50 @@ void GCHandleTable::Shutdown()
     Ref_Shutdown();
 }
 
-void* GCHandleTable::GetGlobalHandleTable()
+void* GCHandleTable::GetGlobalHandleStore()
 {
     return (void*)g_HandleTableMap.pBuckets[0];
 }
 
-void* GCHandleTable::GetNewHandleTable(void* context)
+void* GCHandleTable::CreateHandleStore(void* context)
 {
-    return (void*)::Ref_CreateHandleTableBucket(ADIndex((uintptr_t)context));
+#ifndef FEATURE_REDHAWK
+    return (void*)::Ref_CreateHandleTableBucket(ADIndex((DWORD)(uintptr_t)context));
+#else
+    assert("CreateHandleStore is not implemented when FEATURE_REDHAWK is defined!");
+    return nullptr;
+#endif
 }
 
 void* GCHandleTable::GetHandleContext(OBJECTHANDLE handle)
 {
     return (void*)((uintptr_t)::HndGetHandleTableADIndex(::HndGetHandleTable(handle)).m_dwIndex);
 }
 
-void GCHandleTable::DestroyHandleTable(void* table)
+void GCHandleTable::DestroyHandleStore(void* store)
 {
-    Ref_DestroyHandleTableBucket((HandleTableBucket*) table);
+    Ref_DestroyHandleTableBucket((HandleTableBucket*) store);
 }
 
-void GCHandleTable::UprootHandleTable(void* table)
+void GCHandleTable::UprootHandleStore(void* store)
 {
-    Ref_RemoveHandleTableBucket((HandleTableBucket*) table);
+    Ref_RemoveHandleTableBucket((HandleTableBucket*) store);
 }
 
-bool GCHandleTable::ContainsHandle(void* table, OBJECTHANDLE handle)
+bool GCHandleTable::ContainsHandle(void* store, OBJECTHANDLE handle)
 {
-    return ((HandleTableBucket*)table)->Contains(handle);
+    return ((HandleTableBucket*)store)->Contains(handle);
 }
 
-OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* table, Object* object, int type)
+OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* store, Object* object, int type)
 {
-    HHANDLETABLE handletable = ((HandleTableBucket*)table)->pTable[GetCurrentThreadHomeHeapNumber()];
+    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
     return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
 }
 
-OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* table, Object* object, int type, int heapToAffinitizeTo)
+OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo)
 {
-    HHANDLETABLE handletable = ((HandleTableBucket*)table)->pTable[heapToAffinitizeTo];
+    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[heapToAffinitizeTo];
     return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
 }
 
@@ -70,15 +75,15 @@ OBJECTHANDLE GCHandleTable::CreateGlobalHandleOfType(Object* object, int type)
     return ::HndCreateHandle(g_HandleTableMap.pBuckets[0]->pTable[GetCurrentThreadHomeHeapNumber()], type, ObjectToOBJECTREF(object)); 
 }
 
-OBJECTHANDLE GCHandleTable::CreateHandleWithExtraInfo(void* table, Object* object, int type, void* pExtraInfo)
+OBJECTHANDLE GCHandleTable::CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo)
 {
-    HHANDLETABLE handletable = ((HandleTableBucket*)table)->pTable[GetCurrentThreadHomeHeapNumber()];
+    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
     return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object), reinterpret_cast<uintptr_t>(pExtraInfo));
 }
 
-OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* table, Object* primary, Object* secondary)
+OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* store, Object* primary, Object* secondary)
 {
-    HHANDLETABLE handletable = ((HandleTableBucket*)table)->pTable[GetCurrentThreadHomeHeapNumber()];
+    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
     OBJECTHANDLE handle = ::HndCreateHandle(handletable, HNDTYPE_DEPENDENT, ObjectToOBJECTREF(primary));
     ::SetDependentHandleSecondary(handle, ObjectToOBJECTREF(secondary));
 
@@ -87,7 +92,7 @@ OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* table, Object* primary,
 
 OBJECTHANDLE GCHandleTable::CreateDuplicateHandle(OBJECTHANDLE handle)
 {
-    return ::HndCreateHandle(HndGetHandleTable(handle), HNDTYPE_DEFAULT, ObjectFromHandle(handle));
+    return ::HndCreateHandle(HndGetHandleTable(handle), HNDTYPE_DEFAULT, ::HndFetchHandle(handle));
 }
 
 void GCHandleTable::DestroyHandleOfType(OBJECTHANDLE handle, int type)
diff --git a/src/gc/gchandletableimpl.h b/src/gc/gchandletableimpl.h
@@ -14,25 +14,25 @@ class GCHandleTable : public IGCHandleTable
 
     virtual void Shutdown();
 
-    virtual void* GetGlobalHandleTable();
+    virtual void* GetGlobalHandleStore();
 
-    virtual void* GetNewHandleTable(void* context);
+    virtual void* CreateHandleStore(void* context);
 
     virtual void* GetHandleContext(OBJECTHANDLE handle);
 
-    virtual void DestroyHandleTable(void* table);
+    virtual void DestroyHandleStore(void* store);
 
-    virtual void UprootHandleTable(void* table);
+    virtual void UprootHandleStore(void* store);
 
-    virtual bool ContainsHandle(void* table, OBJECTHANDLE handle);
+    virtual bool ContainsHandle(void* store, OBJECTHANDLE handle);
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* table, Object* object, int type);
+    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type);
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* table, Object* object, int type, int heapToAffinitizeTo);
+    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo);
 
-    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* table, Object* object, int type, void* pExtraInfo);
+    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo);
 
-    virtual OBJECTHANDLE CreateDependentHandle(void* table, Object* primary, Object* secondary);
+    virtual OBJECTHANDLE CreateDependentHandle(void* store, Object* primary, Object* secondary);
 
     virtual OBJECTHANDLE CreateGlobalHandleOfType(Object* object, int type);
 
diff --git a/src/gc/gcinterface.h b/src/gc/gcinterface.h
@@ -411,23 +411,23 @@ class IGCHandleTable {
 
     virtual void* GetHandleContext(OBJECTHANDLE handle) = 0;
 
-    virtual void* GetGlobalHandleTable() = 0;
+    virtual void* GetGlobalHandleStore() = 0;
 
-    virtual void* GetNewHandleTable(void* context) = 0;
+    virtual void* CreateHandleStore(void* context) = 0;
 
-    virtual void DestroyHandleTable(void* table) = 0;
+    virtual void DestroyHandleStore(void* store) = 0;
 
-    virtual void UprootHandleTable(void* table) = 0;
+    virtual void UprootHandleStore(void* store) = 0;
 
-    virtual bool ContainsHandle(void* table, OBJECTHANDLE handle) = 0;
+    virtual bool ContainsHandle(void* store, OBJECTHANDLE handle) = 0;
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* table, Object* object, int type) = 0;
+    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type) = 0;
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* table, Object* object, int type, int heapToAffinitizeTo) = 0;
+    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo) = 0;
 
-    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* table, Object* object, int type, void* pExtraInfo) = 0;
+    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo) = 0;
 
-    virtual OBJECTHANDLE CreateDependentHandle(void* table, Object* primary, Object* secondary) = 0;
+    virtual OBJECTHANDLE CreateDependentHandle(void* store, Object* primary, Object* secondary) = 0;
 
     virtual OBJECTHANDLE CreateGlobalHandleOfType(Object* object, int type) = 0;
 
diff --git a/src/vm/appdomain.cpp b/src/vm/appdomain.cpp
@@ -740,10 +740,10 @@ BaseDomain::BaseDomain()
     m_pLargeHeapHandleTable = NULL;
 
 #ifndef CROSSGEN_COMPILE
-    // Note that m_gcHandleTable is overridden by app domains
-    m_gcHandleTable = GCHandleTableUtilities::GetGCHandleTable()->GetGlobalHandleTable();
+    // Note that m_handleStore is overridden by app domains
+    m_handleStore = GCHandleTableUtilities::GetGCHandleTable()->GetGlobalHandleStore();
 #else
-    m_gcHandleTable = NULL;
+    m_handleStore = NULL;
 #endif
 
     m_pMarshalingData = NULL;
@@ -4042,7 +4042,7 @@ AppDomain::AppDomain()
     m_pUMEntryThunkCache = NULL;
 
     m_pAsyncPool = NULL;
-    m_gcHandleTable = NULL;
+    m_handleStore = NULL;
 
     m_ExposedObject = NULL;
     m_pComIPForExposedObject = NULL;
@@ -4273,11 +4273,11 @@ void AppDomain::Init()
     // default domain cannot be unloaded.
     if (GetId().m_dwId == DefaultADID)
     {
-        m_gcHandleTable = GCHandleTableUtilities::GetGCHandleTable()->GetGlobalHandleTable();
+        m_handleStore = GCHandleTableUtilities::GetGCHandleTable()->GetGlobalHandleStore();
     }
     else
     {
-        m_gcHandleTable = GCHandleTableUtilities::GetGCHandleTable()->GetNewHandleTable((void*)(uintptr_t)m_dwIndex.m_dwIndex);
+        m_handleStore = GCHandleTableUtilities::GetGCHandleTable()->CreateHandleStore((void*)(uintptr_t)m_dwIndex.m_dwIndex);
     }
 
 #endif // CROSSGEN_COMPILE
@@ -4578,10 +4578,10 @@ void AppDomain::Terminate()
 
     BaseDomain::Terminate();
 
-    if (m_gcHandleTable) 
+    if (m_handleStore) 
     {
-        GCHandleTableUtilities::GetGCHandleTable()->DestroyHandleTable(m_gcHandleTable);
-        m_gcHandleTable = NULL;
+        GCHandleTableUtilities::GetGCHandleTable()->DestroyHandleStore(m_handleStore);
+        m_handleStore = NULL;
     }
 
 #ifdef FEATURE_APPDOMAIN_RESOURCE_MONITORING
@@ -9198,7 +9198,7 @@ void AppDomain::ClearGCHandles()
     HandleAsyncPinHandles();
 
     // Remove our handle table as a source of GC roots
-    GCHandleTableUtilities::GetGCHandleTable()->UprootHandleTable(m_gcHandleTable);
+    GCHandleTableUtilities::GetGCHandleTable()->UprootHandleStore(m_handleStore);
 }
 
 // When an AD is unloaded, we will release all objects in this AD.
@@ -9215,14 +9215,14 @@ void AppDomain::HandleAsyncPinHandles()
     CONTRACTL_END;
 
     // TODO: Temporarily casting stuff here until Ref_RelocateAsyncPinHandles is moved to the interface.
-    HandleTableBucket *pBucket = (HandleTableBucket*)m_gcHandleTable;
+    HandleTableBucket *pBucket = (HandleTableBucket*)m_handleStore;
 
     // IO completion port picks IO job using FIFO.  Here is how we know which AsyncPinHandle can be freed.
     // 1. We mark all non-pending AsyncPinHandle with READYTOCLEAN.
     // 2. We queue a dump Overlapped to the IO completion as a marker.
     // 3. When the Overlapped is picked up by completion port, we wait until all previous IO jobs are processed.
     // 4. Then we can delete all AsyncPinHandle marked with READYTOCLEAN.
-    HandleTableBucket *pBucketInDefault = (HandleTableBucket*)SystemDomain::System()->DefaultDomain()->m_gcHandleTable;
+    HandleTableBucket *pBucketInDefault = (HandleTableBucket*)SystemDomain::System()->DefaultDomain()->m_handleStore;
 
     // TODO: When this function is moved to the interface it will take void*s
     Ref_RelocateAsyncPinHandles(pBucket, pBucketInDefault);
@@ -9255,7 +9255,7 @@ void AppDomain::ClearGCRoots()
         pThread->DeleteThreadStaticData(this);
 
         // <TODO>@TODO: A pre-allocated AppDomainUnloaded exception might be better.</TODO>
-        if (pHandleTable->ContainsHandle(m_gcHandleTable, pThread->m_LastThrownObjectHandle))
+        if (pHandleTable->ContainsHandle(m_handleStore, pThread->m_LastThrownObjectHandle))
         {
             // Never delete a handle to a preallocated exception object.
             if (!CLRException::IsPreallocatedExceptionHandle(pThread->m_LastThrownObjectHandle))
@@ -9267,7 +9267,7 @@ void AppDomain::ClearGCRoots()
         }
 
         // Clear out the exceptions objects held by a thread.
-        pThread->GetExceptionState()->ClearThrowablesForUnload(m_gcHandleTable);
+        pThread->GetExceptionState()->ClearThrowablesForUnload(m_handleStore);
     }
 
     //delete them while we still have the runtime suspended
diff --git a/src/vm/appdomain.hpp b/src/vm/appdomain.hpp
@@ -1246,39 +1246,39 @@ class BaseDomain
         WRAPPER_NO_CONTRACT;
 
         IGCHandleTable *pHandleTable = GCHandleTableUtilities::GetGCHandleTable();
-        return pHandleTable->CreateHandleOfType(m_gcHandleTable, OBJECTREFToObject(object), type);
+        return pHandleTable->CreateHandleOfType(m_handleStore, OBJECTREFToObject(object), type);
     }
 
     OBJECTHANDLE CreateHandle(OBJECTREF object)
     {
         WRAPPER_NO_CONTRACT;
         CONDITIONAL_CONTRACT_VIOLATION(ModeViolation, object == NULL)
-        return ::CreateHandle(m_gcHandleTable, object);
+        return ::CreateHandle(m_handleStore, object);
     }
 
     OBJECTHANDLE CreateWeakHandle(OBJECTREF object)
     {
         WRAPPER_NO_CONTRACT;
-        return ::CreateWeakHandle(m_gcHandleTable, object);
+        return ::CreateWeakHandle(m_handleStore, object);
     }
 
     OBJECTHANDLE CreateShortWeakHandle(OBJECTREF object)
     {
         WRAPPER_NO_CONTRACT;
-        return ::CreateShortWeakHandle(m_gcHandleTable, object);
+        return ::CreateShortWeakHandle(m_handleStore, object);
     }
 
     OBJECTHANDLE CreateLongWeakHandle(OBJECTREF object)
     {
         WRAPPER_NO_CONTRACT;
         CONDITIONAL_CONTRACT_VIOLATION(ModeViolation, object == NULL)
-        return ::CreateLongWeakHandle(m_gcHandleTable, object);
+        return ::CreateLongWeakHandle(m_handleStore, object);
     }
 
     OBJECTHANDLE CreateStrongHandle(OBJECTREF object)
     {
         WRAPPER_NO_CONTRACT;
-        return ::CreateStrongHandle(m_gcHandleTable, object);
+        return ::CreateStrongHandle(m_handleStore, object);
     }
 
     OBJECTHANDLE CreatePinningHandle(OBJECTREF object)
@@ -1288,7 +1288,7 @@ class BaseDomain
         if(IsAppDomain())
             object->TryAssignAppDomain((AppDomain*)this,TRUE);
 #endif
-        return ::CreatePinningHandle(m_gcHandleTable, object);
+        return ::CreatePinningHandle(m_handleStore, object);
     }
 
     OBJECTHANDLE CreateSizedRefHandle(OBJECTREF object)
@@ -1297,11 +1297,11 @@ class BaseDomain
         OBJECTHANDLE h;
         if (GCHeapUtilities::IsServerHeap())
         {
-            h = ::CreateSizedRefHandle(m_gcHandleTable, object, m_dwSizedRefHandles % m_iNumberOfProcessors);
+            h = ::CreateSizedRefHandle(m_handleStore, object, m_dwSizedRefHandles % m_iNumberOfProcessors);
         }
         else
         {
-            h = ::CreateSizedRefHandle(m_gcHandleTable, object);
+            h = ::CreateSizedRefHandle(m_handleStore, object);
         }
 
         InterlockedIncrement((LONG*)&m_dwSizedRefHandles);
@@ -1312,7 +1312,7 @@ class BaseDomain
     OBJECTHANDLE CreateRefcountedHandle(OBJECTREF object)
     {
         WRAPPER_NO_CONTRACT;
-        return ::CreateRefcountedHandle(m_gcHandleTable, object);
+        return ::CreateRefcountedHandle(m_handleStore, object);
     }
 
     OBJECTHANDLE CreateWinRTWeakHandle(OBJECTREF object, IWeakReference* pWinRTWeakReference)
@@ -1325,14 +1325,14 @@ class BaseDomain
         }
         CONTRACTL_END;
 
-        return ::CreateWinRTWeakHandle(m_gcHandleTable, object, pWinRTWeakReference);
+        return ::CreateWinRTWeakHandle(m_handleStore, object, pWinRTWeakReference);
     }
 #endif // FEATURE_COMINTEROP
 
     OBJECTHANDLE CreateVariableHandle(OBJECTREF object, UINT type)
     {
         WRAPPER_NO_CONTRACT;
-        return ::CreateVariableHandle(m_gcHandleTable, object, type);
+        return ::CreateVariableHandle(m_handleStore, object, type);
     }
 
     OBJECTHANDLE CreateDependentHandle(OBJECTREF primary, OBJECTREF secondary)
@@ -1346,7 +1346,7 @@ class BaseDomain
         CONTRACTL_END;
 
         IGCHandleTable *pHandleTable = GCHandleTableUtilities::GetGCHandleTable();
-        return pHandleTable->CreateDependentHandle(m_gcHandleTable, OBJECTREFToObject(primary), OBJECTREFToObject(secondary));
+        return pHandleTable->CreateDependentHandle(m_handleStore, OBJECTREFToObject(primary), OBJECTREFToObject(secondary));
     }
 #endif // DACCESS_COMPILE && !CROSSGEN_COMPILE
 
@@ -1402,7 +1402,7 @@ class BaseDomain
 
     CLRPrivBinderCoreCLR *m_pTPABinderContext; // Reference to the binding context that holds TPA list details
 
-    void* m_gcHandleTable;
+    void* m_handleStore;
 
     // The large heap handle table.
     LargeHeapHandleTable        *m_pLargeHeapHandleTable;
diff --git a/src/vm/exstate.cpp b/src/vm/exstate.cpp
@@ -102,7 +102,7 @@ void ThreadExceptionState::FreeAllStackTraces()
     }
 }
 
-void ThreadExceptionState::ClearThrowablesForUnload(void* handleTable)
+void ThreadExceptionState::ClearThrowablesForUnload(void* handleStore)
 {
     WRAPPER_NO_CONTRACT;
 
@@ -118,7 +118,7 @@ void ThreadExceptionState::ClearThrowablesForUnload(void* handleTable)
           pNode != NULL;
           pNode = pNode->m_pPrevNestedInfo)
     {
-        if (pHandleTable->ContainsHandle(handleTable, pNode->m_hThrowable))
+        if (pHandleTable->ContainsHandle(handleStore, pNode->m_hThrowable))
         {
             pNode->DestroyExceptionHandle();
         }
diff --git a/src/vm/exstate.h b/src/vm/exstate.h
@@ -56,7 +56,7 @@ class ThreadExceptionState
 public:
     
     void FreeAllStackTraces();
-    void ClearThrowablesForUnload(void* handleTable);
+    void ClearThrowablesForUnload(void* handleStore);
 
 #ifdef _DEBUG
     typedef enum 

Original file line number	Diff line number	Diff line change
`@@ -23,45 +23,50 @@ void GCHandleTable::Shutdown()`
`23`	`23`	`Ref_Shutdown();`
`24`	`24`	`}`
`25`	`25`
`26`		`-void* GCHandleTable::GetGlobalHandleTable()`
	`26`	`+void* GCHandleTable::GetGlobalHandleStore()`
`27`	`27`	`{`
`28`	`28`	`return (void*)g_HandleTableMap.pBuckets[0];`
`29`	`29`	`}`
`30`	`30`
`31`		`-void* GCHandleTable::GetNewHandleTable(void* context)`
	`31`	`+void* GCHandleTable::CreateHandleStore(void* context)`
`32`	`32`	`{`
`33`		`- return (void*)::Ref_CreateHandleTableBucket(ADIndex((uintptr_t)context));`
	`33`	`+#ifndef FEATURE_REDHAWK`
	`34`	`+ return (void*)::Ref_CreateHandleTableBucket(ADIndex((DWORD)(uintptr_t)context));`
	`35`	`+#else`
	`36`	`+ assert("CreateHandleStore is not implemented when FEATURE_REDHAWK is defined!");`
	`37`	`+ return nullptr;`
	`38`	`+#endif`
`34`	`39`	`}`
`35`	`40`
`36`	`41`	`void* GCHandleTable::GetHandleContext(OBJECTHANDLE handle)`
`37`	`42`	`{`
`38`	`43`	`return (void*)((uintptr_t)::HndGetHandleTableADIndex(::HndGetHandleTable(handle)).m_dwIndex);`
`39`	`44`	`}`
`40`	`45`
`41`		`-void GCHandleTable::DestroyHandleTable(void* table)`
	`46`	`+void GCHandleTable::DestroyHandleStore(void* store)`
`42`	`47`	`{`
`43`		`- Ref_DestroyHandleTableBucket((HandleTableBucket*) table);`
	`48`	`+ Ref_DestroyHandleTableBucket((HandleTableBucket*) store);`
`44`	`49`	`}`
`45`	`50`
`46`		`-void GCHandleTable::UprootHandleTable(void* table)`
	`51`	`+void GCHandleTable::UprootHandleStore(void* store)`
`47`	`52`	`{`
`48`		`- Ref_RemoveHandleTableBucket((HandleTableBucket*) table);`
	`53`	`+ Ref_RemoveHandleTableBucket((HandleTableBucket*) store);`
`49`	`54`	`}`
`50`	`55`
`51`		`-bool GCHandleTable::ContainsHandle(void* table, OBJECTHANDLE handle)`
	`56`	`+bool GCHandleTable::ContainsHandle(void* store, OBJECTHANDLE handle)`
`52`	`57`	`{`
`53`		`- return ((HandleTableBucket*)table)->Contains(handle);`
	`58`	`+ return ((HandleTableBucket*)store)->Contains(handle);`
`54`	`59`	`}`
`55`	`60`
`56`		`-OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* table, Object* object, int type)`
	`61`	`+OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* store, Object* object, int type)`
`57`	`62`	`{`
`58`		`- HHANDLETABLE handletable = ((HandleTableBucket*)table)->pTable[GetCurrentThreadHomeHeapNumber()];`
	`63`	`+ HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];`
`59`	`64`	`return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));`
`60`	`65`	`}`
`61`	`66`
`62`		`-OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* table, Object* object, int type, int heapToAffinitizeTo)`
	`67`	`+OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo)`
`63`	`68`	`{`
`64`		`- HHANDLETABLE handletable = ((HandleTableBucket*)table)->pTable[heapToAffinitizeTo];`
	`69`	`+ HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[heapToAffinitizeTo];`
`65`	`70`	`return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));`
`66`	`71`	`}`
`67`	`72`
`@@ -70,15 +75,15 @@ OBJECTHANDLE GCHandleTable::CreateGlobalHandleOfType(Object* object, int type)`
`70`	`75`	`return ::HndCreateHandle(g_HandleTableMap.pBuckets[0]->pTable[GetCurrentThreadHomeHeapNumber()], type, ObjectToOBJECTREF(object));`
`71`	`76`	`}`
`72`	`77`
`73`		`-OBJECTHANDLE GCHandleTable::CreateHandleWithExtraInfo(void* table, Object* object, int type, void* pExtraInfo)`
	`78`	`+OBJECTHANDLE GCHandleTable::CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo)`
`74`	`79`	`{`
`75`		`- HHANDLETABLE handletable = ((HandleTableBucket*)table)->pTable[GetCurrentThreadHomeHeapNumber()];`
	`80`	`+ HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];`
`76`	`81`	`return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object), reinterpret_cast<uintptr_t>(pExtraInfo));`
`77`	`82`	`}`
`78`	`83`
`79`		`-OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* table, Object* primary, Object* secondary)`
	`84`	`+OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* store, Object* primary, Object* secondary)`
`80`	`85`	`{`
`81`		`- HHANDLETABLE handletable = ((HandleTableBucket*)table)->pTable[GetCurrentThreadHomeHeapNumber()];`
	`86`	`+ HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];`
`82`	`87`	`OBJECTHANDLE handle = ::HndCreateHandle(handletable, HNDTYPE_DEPENDENT, ObjectToOBJECTREF(primary));`
`83`	`88`	`::SetDependentHandleSecondary(handle, ObjectToOBJECTREF(secondary));`
`84`	`89`
`@@ -87,7 +92,7 @@ OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* table, Object* primary,`
`87`	`92`
`88`	`93`	`OBJECTHANDLE GCHandleTable::CreateDuplicateHandle(OBJECTHANDLE handle)`
`89`	`94`	`{`
`90`		`- return ::HndCreateHandle(HndGetHandleTable(handle), HNDTYPE_DEFAULT, ObjectFromHandle(handle));`
	`95`	`+ return ::HndCreateHandle(HndGetHandleTable(handle), HNDTYPE_DEFAULT, ::HndFetchHandle(handle));`
`91`	`96`	`}`
`92`	`97`
`93`	`98`	`void GCHandleTable::DestroyHandleOfType(OBJECTHANDLE handle, int type)`
Original file line number	Diff line number	Diff line change
`@@ -1246,39 +1246,39 @@ class BaseDomain`
`1246`	`1246`	`WRAPPER_NO_CONTRACT;`
`1247`	`1247`
`1248`	`1248`	`IGCHandleTable *pHandleTable = GCHandleTableUtilities::GetGCHandleTable();`
`1249`		`- return pHandleTable->CreateHandleOfType(m_gcHandleTable, OBJECTREFToObject(object), type);`
	`1249`	`+ return pHandleTable->CreateHandleOfType(m_handleStore, OBJECTREFToObject(object), type);`
`1250`	`1250`	`}`
`1251`	`1251`
`1252`	`1252`	`OBJECTHANDLE CreateHandle(OBJECTREF object)`
`1253`	`1253`	`{`
`1254`	`1254`	`WRAPPER_NO_CONTRACT;`
`1255`	`1255`	`CONDITIONAL_CONTRACT_VIOLATION(ModeViolation, object == NULL)`
`1256`		`- return ::CreateHandle(m_gcHandleTable, object);`
	`1256`	`+ return ::CreateHandle(m_handleStore, object);`
`1257`	`1257`	`}`
`1258`	`1258`
`1259`	`1259`	`OBJECTHANDLE CreateWeakHandle(OBJECTREF object)`
`1260`	`1260`	`{`
`1261`	`1261`	`WRAPPER_NO_CONTRACT;`
`1262`		`- return ::CreateWeakHandle(m_gcHandleTable, object);`
	`1262`	`+ return ::CreateWeakHandle(m_handleStore, object);`
`1263`	`1263`	`}`
`1264`	`1264`
`1265`	`1265`	`OBJECTHANDLE CreateShortWeakHandle(OBJECTREF object)`
`1266`	`1266`	`{`
`1267`	`1267`	`WRAPPER_NO_CONTRACT;`
`1268`		`- return ::CreateShortWeakHandle(m_gcHandleTable, object);`
	`1268`	`+ return ::CreateShortWeakHandle(m_handleStore, object);`
`1269`	`1269`	`}`
`1270`	`1270`
`1271`	`1271`	`OBJECTHANDLE CreateLongWeakHandle(OBJECTREF object)`
`1272`	`1272`	`{`
`1273`	`1273`	`WRAPPER_NO_CONTRACT;`
`1274`	`1274`	`CONDITIONAL_CONTRACT_VIOLATION(ModeViolation, object == NULL)`
`1275`		`- return ::CreateLongWeakHandle(m_gcHandleTable, object);`
	`1275`	`+ return ::CreateLongWeakHandle(m_handleStore, object);`
`1276`	`1276`	`}`
`1277`	`1277`
`1278`	`1278`	`OBJECTHANDLE CreateStrongHandle(OBJECTREF object)`
`1279`	`1279`	`{`
`1280`	`1280`	`WRAPPER_NO_CONTRACT;`
`1281`		`- return ::CreateStrongHandle(m_gcHandleTable, object);`
	`1281`	`+ return ::CreateStrongHandle(m_handleStore, object);`
`1282`	`1282`	`}`
`1283`	`1283`
`1284`	`1284`	`OBJECTHANDLE CreatePinningHandle(OBJECTREF object)`
`@@ -1288,7 +1288,7 @@ class BaseDomain`
`1288`	`1288`	`if(IsAppDomain())`
`1289`	`1289`	`object->TryAssignAppDomain((AppDomain*)this,TRUE);`
`1290`	`1290`	`#endif`
`1291`		`- return ::CreatePinningHandle(m_gcHandleTable, object);`
	`1291`	`+ return ::CreatePinningHandle(m_handleStore, object);`
`1292`	`1292`	`}`
`1293`	`1293`
`1294`	`1294`	`OBJECTHANDLE CreateSizedRefHandle(OBJECTREF object)`
`@@ -1297,11 +1297,11 @@ class BaseDomain`
`1297`	`1297`	`OBJECTHANDLE h;`
`1298`	`1298`	`if (GCHeapUtilities::IsServerHeap())`
`1299`	`1299`	`{`
`1300`		`- h = ::CreateSizedRefHandle(m_gcHandleTable, object, m_dwSizedRefHandles % m_iNumberOfProcessors);`
	`1300`	`+ h = ::CreateSizedRefHandle(m_handleStore, object, m_dwSizedRefHandles % m_iNumberOfProcessors);`
`1301`	`1301`	`}`
`1302`	`1302`	`else`
`1303`	`1303`	`{`
`1304`		`- h = ::CreateSizedRefHandle(m_gcHandleTable, object);`
	`1304`	`+ h = ::CreateSizedRefHandle(m_handleStore, object);`
`1305`	`1305`	`}`
`1306`	`1306`
`1307`	`1307`	`InterlockedIncrement((LONG*)&m_dwSizedRefHandles);`
`@@ -1312,7 +1312,7 @@ class BaseDomain`
`1312`	`1312`	`OBJECTHANDLE CreateRefcountedHandle(OBJECTREF object)`
`1313`	`1313`	`{`
`1314`	`1314`	`WRAPPER_NO_CONTRACT;`
`1315`		`- return ::CreateRefcountedHandle(m_gcHandleTable, object);`
	`1315`	`+ return ::CreateRefcountedHandle(m_handleStore, object);`
`1316`	`1316`	`}`
`1317`	`1317`
`1318`	`1318`	`OBJECTHANDLE CreateWinRTWeakHandle(OBJECTREF object, IWeakReference* pWinRTWeakReference)`
`@@ -1325,14 +1325,14 @@ class BaseDomain`
`1325`	`1325`	`}`
`1326`	`1326`	`CONTRACTL_END;`
`1327`	`1327`
`1328`		`- return ::CreateWinRTWeakHandle(m_gcHandleTable, object, pWinRTWeakReference);`
	`1328`	`+ return ::CreateWinRTWeakHandle(m_handleStore, object, pWinRTWeakReference);`
`1329`	`1329`	`}`
`1330`	`1330`	`#endif // FEATURE_COMINTEROP`
`1331`	`1331`
`1332`	`1332`	`OBJECTHANDLE CreateVariableHandle(OBJECTREF object, UINT type)`
`1333`	`1333`	`{`
`1334`	`1334`	`WRAPPER_NO_CONTRACT;`
`1335`		`- return ::CreateVariableHandle(m_gcHandleTable, object, type);`
	`1335`	`+ return ::CreateVariableHandle(m_handleStore, object, type);`
`1336`	`1336`	`}`
`1337`	`1337`
`1338`	`1338`	`OBJECTHANDLE CreateDependentHandle(OBJECTREF primary, OBJECTREF secondary)`
`@@ -1346,7 +1346,7 @@ class BaseDomain`
`1346`	`1346`	`CONTRACTL_END;`
`1347`	`1347`
`1348`	`1348`	`IGCHandleTable *pHandleTable = GCHandleTableUtilities::GetGCHandleTable();`
`1349`		`- return pHandleTable->CreateDependentHandle(m_gcHandleTable, OBJECTREFToObject(primary), OBJECTREFToObject(secondary));`
	`1349`	`+ return pHandleTable->CreateDependentHandle(m_handleStore, OBJECTREFToObject(primary), OBJECTREFToObject(secondary));`
`1350`	`1350`	`}`
`1351`	`1351`	`#endif // DACCESS_COMPILE && !CROSSGEN_COMPILE`
`1352`	`1352`
`@@ -1402,7 +1402,7 @@ class BaseDomain`
`1402`	`1402`
`1403`	`1403`	`CLRPrivBinderCoreCLR *m_pTPABinderContext; // Reference to the binding context that holds TPA list details`
`1404`	`1404`
`1405`		`- void* m_gcHandleTable;`
	`1405`	`+ void* m_handleStore;`
`1406`	`1406`
`1407`	`1407`	`// The large heap handle table.`
`1408`	`1408`	`LargeHeapHandleTable *m_pLargeHeapHandleTable;`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ void ThreadExceptionState::FreeAllStackTraces()`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
`105`		`-void ThreadExceptionState::ClearThrowablesForUnload(void* handleTable)`
	`105`	`+void ThreadExceptionState::ClearThrowablesForUnload(void* handleStore)`
`106`	`106`	`{`
`107`	`107`	`WRAPPER_NO_CONTRACT;`
`108`	`108`
`@@ -118,7 +118,7 @@ void ThreadExceptionState::ClearThrowablesForUnload(void* handleTable)`
`118`	`118`	`pNode != NULL;`
`119`	`119`	`pNode = pNode->m_pPrevNestedInfo)`
`120`	`120`	`{`
`121`		`- if (pHandleTable->ContainsHandle(handleTable, pNode->m_hThrowable))`
	`121`	`+ if (pHandleTable->ContainsHandle(handleStore, pNode->m_hThrowable))`
`122`	`122`	`{`
`123`	`123`	`pNode->DestroyExceptionHandle();`
`124`	`124`	`}`