Introduce an interface separating the GC and the VM,

modifying the VM to utilize this interface.

Introduce an interface separating the GC and the rest of the VM

Remove static members of both IGCHeap and IGCHeapInternal and move the management of the singular GC heap to the VM.

Rename uses of IGCHeap in the VM to GCHeapHolder, as well as other misc. renames throughout the VM and GC.

Split each interface function into categories, document them, use consistent formatting across the interface

Undo some accidental find/replace collateral damage

Remove all ifdefs from the GC interface

Deduplicate function declarations between IGCHeap and IGCHeapInternal, expose AllocAlign8 through the interface and the reference to alloc_context to repair the ARM build

Paper cut: false -> nullptr

Repair the ARM and x86 builds

Rename GCHeapHolder -> GCHeapUtilities and address documentation feedback

Rebase against master

Rename gcholder.h/cpp -> gcheaputilities.h/cpp

Fix an uninitialized field on alloc_context causing test failures on clang

Rename the include guard for gcheaputilities.h

Un-breaks SOS by making the following changes:
  1) Instructs the DAC to look for IGCHeap::gcHeapType by name,
     instead of assuming that it exists near g_pGCHeap,
  2) Eliminate all virtual calls on IGCHeap in the DAC, since we cannot
     dispatch on an object in another process,
  3) Because of 2, expose the number of generations past the GC interface
     using a static variable on IGCHeap that the DAC can read directly.

repair the Windows build

16 files changed, 795 insertions, 607 deletions

diff --git a/src/gc/env/gcenv.ee.h b/src/gc/env/gcenv.ee.h
index 0c1fd4988a..f71380e1a1 100644
--- a/src/gc/env/gcenv.ee.h
+++ b/src/gc/env/gcenv.ee.h
@@ -9,10 +9,11 @@
 
 struct ScanContext;
 class CrawlFrame;
+struct gc_alloc_context;
 
 typedef void promote_func(PTR_PTR_Object, ScanContext*, uint32_t);
 
-typedef void enum_alloc_context_func(alloc_context*, void*);
+typedef void enum_alloc_context_func(gc_alloc_context*, void*);
 
 typedef struct
 {
@@ -74,7 +75,7 @@ public:
     static void EnablePreemptiveGC(Thread * pThread);
     static void DisablePreemptiveGC(Thread * pThread);
 
-    static alloc_context * GetAllocContext(Thread * pThread);
+    static gc_alloc_context * GetAllocContext(Thread * pThread);
     static bool CatchAtSafePoint(Thread * pThread);
 
     static void GcEnumAllocContexts(enum_alloc_context_func* fn, void* param);
diff --git a/src/gc/gc.cpp b/src/gc/gc.cpp
index dad71331cd..198fd32a88 100644
--- a/src/gc/gc.cpp
+++ b/src/gc/gc.cpp
@@ -1544,7 +1544,7 @@ void WaitLongerNoInstru (int i)
     }
     else if (g_TrapReturningThreads)
     {
-        GCHeap::GetGCHeap()->WaitUntilGCComplete();
+        g_theGcHeap->WaitUntilGCComplete();
     }
 }
 
@@ -1573,7 +1573,7 @@ retry:
         unsigned int i = 0;
         while (VolatileLoad(lock) >= 0)
         {
-            if ((++i & 7) && !GCHeap::IsGCInProgress())
+            if ((++i & 7) && !IsGCInProgress())
             {
                 if  (g_SystemInfo.dwNumberOfProcessors > 1)
                 {
@@ -1584,11 +1584,11 @@ retry:
 #endif //!MULTIPLE_HEAPS
                     for (int j = 0; j < spin_count; j++)
                     {
-                        if  (VolatileLoad(lock) < 0 || GCHeap::IsGCInProgress())
+                        if  (VolatileLoad(lock) < 0 || IsGCInProgress())
                             break;
                         YieldProcessor();           // indicate to the processor that we are spining
                     }
-                    if  (VolatileLoad(lock) >= 0 && !GCHeap::IsGCInProgress())
+                    if  (VolatileLoad(lock) >= 0 && !IsGCInProgress())
                     {
                         safe_switch_to_thread();
                     }
@@ -3743,9 +3743,9 @@ public:
         BOOL fSmallObjectHeapPtr = FALSE, fLargeObjectHeapPtr = FALSE;
         if (!noRangeChecks)
         {
-            fSmallObjectHeapPtr = GCHeap::GetGCHeap()->IsHeapPointer(this, TRUE);
+            fSmallObjectHeapPtr = g_theGcHeap->IsHeapPointer(this, TRUE);
             if (!fSmallObjectHeapPtr)
-                fLargeObjectHeapPtr = GCHeap::GetGCHeap()->IsHeapPointer(this);
+                fLargeObjectHeapPtr = g_theGcHeap->IsHeapPointer(this);
 
             _ASSERTE(fSmallObjectHeapPtr || fLargeObjectHeapPtr);
         }
@@ -3763,14 +3763,14 @@ public:
 
 #ifdef VERIFY_HEAP
         if (bDeep && (g_pConfig->GetHeapVerifyLevel() & EEConfig::HEAPVERIFY_GC))
-            GCHeap::GetGCHeap()->ValidateObjectMember(this);
+            g_theGcHeap->ValidateObjectMember(this);
 #endif
         if (fSmallObjectHeapPtr)
         {
 #ifdef FEATURE_BASICFREEZE
-            _ASSERTE(!GCHeap::GetGCHeap()->IsLargeObject(pMT) || GCHeap::GetGCHeap()->IsInFrozenSegment(this));
+            _ASSERTE(!g_theGcHeap->IsLargeObject(pMT) || g_theGcHeap->IsInFrozenSegment(this));
 #else
-            _ASSERTE(!GCHeap::GetGCHeap()->IsLargeObject(pMT));
+            _ASSERTE(!g_theGcHeap->IsLargeObject(pMT));
 #endif
         }
     }
@@ -4361,7 +4361,7 @@ static size_t get_valid_segment_size (BOOL large_seg=FALSE)
 
     // if seg_size is small but not 0 (0 is default if config not set)
     // then set the segment to the minimum size
-    if (!GCHeap::IsValidSegmentSize(seg_size))
+    if (!g_theGcHeap->IsValidSegmentSize(seg_size))
     {
         // if requested size is between 1 byte and 4MB, use min
         if ((seg_size >> 1) && !(seg_size >> 22))
@@ -5775,7 +5775,7 @@ void gc_heap::fix_allocation_context (alloc_context* acontext, BOOL for_gc_p,
 
 //used by the heap verification for concurrent gc.
 //it nulls out the words set by fix_allocation_context for heap_verification
-void repair_allocation (alloc_context* acontext, void*)
+void repair_allocation (gc_alloc_context* acontext, void*)
 {
     uint8_t*  point = acontext->alloc_ptr;
 
@@ -5788,7 +5788,7 @@ void repair_allocation (alloc_context* acontext, void*)
     }
 }
 
-void void_allocation (alloc_context* acontext, void*)
+void void_allocation (gc_alloc_context* acontext, void*)
 {
     uint8_t*  point = acontext->alloc_ptr;
 
@@ -5818,10 +5818,10 @@ struct fix_alloc_context_args
     void* heap;
 };
 
-void fix_alloc_context(alloc_context* acontext, void* param)
+void fix_alloc_context(gc_alloc_context* acontext, void* param)
 {
     fix_alloc_context_args* args = (fix_alloc_context_args*)param;
-    GCHeap::GetGCHeap()->FixAllocContext(acontext, FALSE, (void*)(size_t)(args->for_gc_p), args->heap);
+    g_theGcHeap->FixAllocContext(acontext, FALSE, (void*)(size_t)(args->for_gc_p), args->heap);
 }
 
 void gc_heap::fix_allocation_contexts(BOOL for_gc_p)
@@ -10384,10 +10384,10 @@ gc_heap::init_gc_heap (int  h_number)
     heap_segment_heap (lseg) = this;
 
     //initialize the alloc context heap
-    generation_alloc_context (generation_of (0))->alloc_heap = vm_heap;
+    generation_alloc_context (generation_of (0))->set_alloc_heap(vm_heap);
 
     //initialize the alloc context heap
-    generation_alloc_context (generation_of (max_generation+1))->alloc_heap = vm_heap;
+    generation_alloc_context (generation_of (max_generation+1))->set_alloc_heap(vm_heap);
 
 #endif //MULTIPLE_HEAPS
 
@@ -13080,10 +13080,10 @@ void gc_heap::balance_heaps (alloc_context* acontext)
     {
         if (acontext->alloc_count == 0)
         {
-            acontext->home_heap = GCHeap::GetHeap( heap_select::select_heap(acontext, 0) );
-            gc_heap* hp = acontext->home_heap->pGenGCHeap;
+            acontext->set_home_heap(GCHeap::GetHeap( heap_select::select_heap(acontext, 0) ));
+            gc_heap* hp = acontext->get_home_heap()->pGenGCHeap;
             dprintf (3, ("First allocation for context %Ix on heap %d\n", (size_t)acontext, (size_t)hp->heap_number));
-            acontext->alloc_heap = acontext->home_heap;
+            acontext->set_alloc_heap(acontext->get_home_heap());
             hp->alloc_context_count++;
         }
     }
@@ -13094,9 +13094,9 @@ void gc_heap::balance_heaps (alloc_context* acontext)
 
         if (heap_select::can_find_heap_fast())
         {
-            if (acontext->home_heap != NULL)
-                hint = acontext->home_heap->pGenGCHeap->heap_number;
-            if (acontext->home_heap != GCHeap::GetHeap(hint = heap_select::select_heap(acontext, hint)) || ((acontext->alloc_count & 15) == 0))
+            if (acontext->get_home_heap() != NULL)
+                hint = acontext->get_home_heap()->pGenGCHeap->heap_number;
+            if (acontext->get_home_heap() != GCHeap::GetHeap(hint = heap_select::select_heap(acontext, hint)) || ((acontext->alloc_count & 15) == 0))
             {
                 set_home_heap = TRUE;
             }
@@ -13122,7 +13122,7 @@ void gc_heap::balance_heaps (alloc_context* acontext)
             else
 */
             {
-                gc_heap* org_hp = acontext->alloc_heap->pGenGCHeap;
+                gc_heap* org_hp = acontext->get_alloc_heap()->pGenGCHeap;
 
                 dynamic_data* dd = org_hp->dynamic_data_of (0);
                 ptrdiff_t org_size = dd_new_allocation (dd);
@@ -13141,9 +13141,9 @@ try_again:
                 {
                     max_hp = org_hp;
                     max_size = org_size + delta;
-                    acontext->home_heap = GCHeap::GetHeap( heap_select::select_heap(acontext, hint) );
+                    acontext->set_home_heap(GCHeap::GetHeap( heap_select::select_heap(acontext, hint) ));
 
-                    if (org_hp == acontext->home_heap->pGenGCHeap)
+                    if (org_hp == acontext->get_home_heap()->pGenGCHeap)
                         max_size = max_size + delta;
 
                     org_alloc_context_count = org_hp->alloc_context_count;
@@ -13156,7 +13156,7 @@ try_again:
                         gc_heap* hp = GCHeap::GetHeap(i%n_heaps)->pGenGCHeap;
                         dd = hp->dynamic_data_of (0);
                         ptrdiff_t size = dd_new_allocation (dd);
-                        if (hp == acontext->home_heap->pGenGCHeap)
+                        if (hp == acontext->get_home_heap()->pGenGCHeap)
                             size = size + delta;
                         int hp_alloc_context_count = hp->alloc_context_count;
                         if (hp_alloc_context_count > 0)
@@ -13183,7 +13183,7 @@ try_again:
                 {
                     org_hp->alloc_context_count--;
                     max_hp->alloc_context_count++;
-                    acontext->alloc_heap = GCHeap::GetHeap(max_hp->heap_number);
+                    acontext->set_alloc_heap(GCHeap::GetHeap(max_hp->heap_number));
 #if !defined(FEATURE_PAL)
                     if (CPUGroupInfo::CanEnableGCCPUGroups())
                     {   //only set ideal processor when max_hp and org_hp are in the same cpu
@@ -13221,7 +13221,7 @@ try_again:
 #endif // !FEATURE_PAL
                     dprintf (3, ("Switching context %p (home heap %d) ", 
                                  acontext,
-                        acontext->home_heap->pGenGCHeap->heap_number));
+                        acontext->get_home_heap()->pGenGCHeap->heap_number));
                     dprintf (3, (" from heap %d (%Id free bytes, %d contexts) ", 
                                  org_hp->heap_number,
                                  org_size,
@@ -13239,7 +13239,7 @@ try_again:
 
 gc_heap* gc_heap::balance_heaps_loh (alloc_context* acontext, size_t /*size*/)
 {
-    gc_heap* org_hp = acontext->alloc_heap->pGenGCHeap;
+    gc_heap* org_hp = acontext->get_alloc_heap()->pGenGCHeap;
     //dprintf (1, ("LA: %Id", size));
 
     //if (size > 128*1024)
@@ -13316,7 +13316,7 @@ BOOL gc_heap::allocate_more_space(alloc_context* acontext, size_t size,
         if (alloc_generation_number == 0)
         {
             balance_heaps (acontext);
-            status = acontext->alloc_heap->pGenGCHeap->try_allocate_more_space (acontext, size, alloc_generation_number);
+            status = acontext->get_alloc_heap()->pGenGCHeap->try_allocate_more_space (acontext, size, alloc_generation_number);
         }
         else
         {
@@ -22250,7 +22250,7 @@ void gc_heap::plan_phase (int condemned_gen_number)
 #endif //TIME_GC
 
     // We may update write barrier code.  We assume here EE has been suspended if we are on a GC thread.
-    assert(GCHeap::IsGCInProgress());
+    assert(IsGCInProgress());
 
     BOOL should_expand = FALSE;
     BOOL should_compact= FALSE;
@@ -30469,7 +30469,7 @@ CObjectHeader* gc_heap::allocate_large_object (size_t jsize, int64_t& alloc_byte
     acontext.alloc_limit = 0;
     acontext.alloc_bytes = 0;
 #ifdef MULTIPLE_HEAPS
-    acontext.alloc_heap = vm_heap;
+    acontext.set_alloc_heap(vm_heap);
 #endif //MULTIPLE_HEAPS
 
 #ifdef MARK_ARRAY
@@ -31946,11 +31946,11 @@ void gc_heap::descr_card_table ()
 #endif //TRACE_GC
 }
 
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
 void gc_heap::descr_generations_to_profiler (gen_walk_fn fn, void *context)
 {
+#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
 #ifdef MULTIPLE_HEAPS
-    int n_heaps = GCHeap::GetGCHeap()->GetNumberOfHeaps ();
+    int n_heaps = g_theGcHeap->GetNumberOfHeaps ();
     for (int i = 0; i < n_heaps; i++)
     {
         gc_heap* hp = GCHeap::GetHeap(i)->pGenGCHeap;
@@ -32026,8 +32026,8 @@ void gc_heap::descr_generations_to_profiler (gen_walk_fn fn, void *context)
             curr_gen_number0--;
         }
     }
-}
 #endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
+}
 
 #ifdef TRACE_GC
 // Note that when logging is on it can take a long time to go through the free items.
@@ -33306,8 +33306,12 @@ gc_heap::verify_heap (BOOL begin_gc_p)
 #endif //BACKGROUND_GC 
 }
 
+#endif  //VERIFY_HEAP
+
+
 void GCHeap::ValidateObjectMember (Object* obj)
 {
+#ifdef VERIFY_HEAP
     size_t s = size (obj);
     uint8_t* o = (uint8_t*)obj;
 
@@ -33325,9 +33329,8 @@ void GCHeap::ValidateObjectMember (Object* obj)
                                         }
                                     }
                                 } );
-
+#endif // VERIFY_HEAP
 }
-#endif  //VERIFY_HEAP
 
 void DestructObject (CObjectHeader* hdr)
 {
@@ -33640,12 +33643,12 @@ BOOL    GCHeap::IsEphemeral (Object* object)
     return hp->ephemeral_pointer_p (o);
 }
 
-#ifdef VERIFY_HEAP
 // Return NULL if can't find next object. When EE is not suspended,
 // the result is not accurate: if the input arg is in gen0, the function could 
 // return zeroed out memory as next object
 Object * GCHeap::NextObj (Object * object)
 {
+#ifdef VERIFY_HEAP
     uint8_t* o = (uint8_t*)object;
 
 #ifndef FEATURE_BASICFREEZE
@@ -33687,8 +33690,13 @@ Object * GCHeap::NextObj (Object * object)
     }
 
     return (Object *)nextobj;
+#else
+    return nullptr;
+#endif // VERIFY_HEAP
 }
 
+#ifdef VERIFY_HEAP
+
 #ifdef FEATURE_BASICFREEZE
 BOOL GCHeap::IsInFrozenSegment (Object * object)
 {
@@ -33918,11 +33926,16 @@ int StressRNG(int iMaxValue)
     int randValue = (((lHoldrand = lHoldrand * 214013L + 2531011L) >> 16) & 0x7fff);
     return randValue % iMaxValue;
 }
+#endif // STRESS_HEAP
+#endif // !FEATURE_REDHAWK
 
 // free up object so that things will move and then do a GC
 //return TRUE if GC actually happens, otherwise FALSE
-BOOL GCHeap::StressHeap(alloc_context * acontext)
+BOOL GCHeap::StressHeap(gc_alloc_context * context)
 {
+#if defined(STRESS_HEAP) && !defined(FEATURE_REDHAWK)
+    alloc_context* acontext = static_cast<alloc_context*>(context);
+
     // if GC stress was dynamically disabled during this run we return FALSE
     if (!GCStressPolicy::IsEnabled())
         return FALSE;
@@ -34102,11 +34115,11 @@ BOOL GCHeap::StressHeap(alloc_context * acontext)
     }
 
     return TRUE;
+#else
+    return FALSE;
+#endif // defined(STRESS_HEAP) && !defined(FEATURE_REDHAWK)
 }
 
-#endif // STRESS_HEAP
-#endif // FEATURE_REDHAWK
-
 
 #ifdef FEATURE_PREMORTEM_FINALIZATION
 #define REGISTER_FOR_FINALIZATION(_object, _size) \
@@ -34164,8 +34177,6 @@ GCHeap::Alloc( size_t size, uint32_t flags REQD_ALIGN_DCL)
 
     TRIGGERSGC();
 
-    assert (!GCHeap::UseAllocationContexts());
-
     Object* newAlloc = NULL;
 
 #ifdef TRACE_GC
@@ -34237,11 +34248,11 @@ GCHeap::Alloc( size_t size, uint32_t flags REQD_ALIGN_DCL)
     return newAlloc;
 }
 
-#ifdef FEATURE_64BIT_ALIGNMENT
 // Allocate small object with an alignment requirement of 8-bytes. Non allocation context version.
 Object *
 GCHeap::AllocAlign8( size_t size, uint32_t flags)
 {
+#ifdef FEATURE_64BIT_ALIGNMENT
     CONTRACTL {
 #ifdef FEATURE_REDHAWK
         // Under Redhawk NULL is returned on failure.
@@ -34252,8 +34263,6 @@ GCHeap::AllocAlign8( size_t size, uint32_t flags)
         GC_TRIGGERS;
     } CONTRACTL_END;
 
-    assert (!GCHeap::UseAllocationContexts());
-
     Object* newAlloc = NULL;
 
     {
@@ -34270,12 +34279,17 @@ GCHeap::AllocAlign8( size_t size, uint32_t flags)
     }
 
     return newAlloc;
+#else
+    assert(!"should not call GCHeap::AllocAlign8 without FEATURE_64BIT_ALIGNMENT defined!");
+    return nullptr;
+#endif  //FEATURE_64BIT_ALIGNMENT
 }
 
 // Allocate small object with an alignment requirement of 8-bytes. Allocation context version.
 Object*
-GCHeap::AllocAlign8(alloc_context* acontext, size_t size, uint32_t flags )
+GCHeap::AllocAlign8(gc_alloc_context* ctx, size_t size, uint32_t flags )
 {
+#ifdef FEATURE_64BIT_ALIGNMENT
     CONTRACTL {
 #ifdef FEATURE_REDHAWK
         // Under Redhawk NULL is returned on failure.
@@ -34286,25 +34300,32 @@ GCHeap::AllocAlign8(alloc_context* acontext, size_t size, uint32_t flags )
         GC_TRIGGERS;
     } CONTRACTL_END;
 
+    alloc_context* acontext = static_cast<alloc_context*>(ctx);
+
 #ifdef MULTIPLE_HEAPS
-    if (acontext->alloc_heap == 0)
+    if (acontext->get_alloc_heap() == 0)
     {
         AssignHeap (acontext);
-        assert (acontext->alloc_heap);
+        assert (acontext->get_alloc_heap());
     }
 
-    gc_heap* hp = acontext->alloc_heap->pGenGCHeap;
+    gc_heap* hp = acontext->get_alloc_heap()->pGenGCHeap;
 #else
     gc_heap* hp = pGenGCHeap;
 #endif //MULTIPLE_HEAPS
 
     return AllocAlign8Common(hp, acontext, size, flags);
+#else
+    assert(!"should not call GCHeap::AllocAlign8 without FEATURE_64BIT_ALIGNMENT defined!");
+    return nullptr;
+#endif  //FEATURE_64BIT_ALIGNMENT
 }
 
 // Common code used by both variants of AllocAlign8 above.
 Object*
 GCHeap::AllocAlign8Common(void* _hp, alloc_context* acontext, size_t size, uint32_t flags)
 {
+#ifdef FEATURE_64BIT_ALIGNMENT
     CONTRACTL {
 #ifdef FEATURE_REDHAWK
         // Under Redhawk NULL is returned on failure.
@@ -34424,8 +34445,11 @@ GCHeap::AllocAlign8Common(void* _hp, alloc_context* acontext, size_t size, uint3
     AllocCount++;
 #endif //TRACE_GC
     return newAlloc;
-}
+#else
+    assert(!"Should not call GCHeap::AllocAlign8Common without FEATURE_64BIT_ALIGNMENT defined!");
+    return nullptr;
 #endif // FEATURE_64BIT_ALIGNMENT
+}
 
 Object *
 GCHeap::AllocLHeap( size_t size, uint32_t flags REQD_ALIGN_DCL)
@@ -34499,7 +34523,7 @@ GCHeap::AllocLHeap( size_t size, uint32_t flags REQD_ALIGN_DCL)
 }
 
 Object*
-GCHeap::Alloc(alloc_context* acontext, size_t size, uint32_t flags REQD_ALIGN_DCL)
+GCHeap::Alloc(gc_alloc_context* context, size_t size, uint32_t flags REQD_ALIGN_DCL)
 {
     CONTRACTL {
 #ifdef FEATURE_REDHAWK
@@ -34522,6 +34546,7 @@ GCHeap::Alloc(alloc_context* acontext, size_t size, uint32_t flags REQD_ALIGN_DC
     TRIGGERSGC();
 
     Object* newAlloc = NULL;
+    alloc_context* acontext = static_cast<alloc_context*>(context);
 
 #ifdef TRACE_GC
 #ifdef COUNT_CYCLES
@@ -34534,10 +34559,10 @@ GCHeap::Alloc(alloc_context* acontext, size_t size, uint32_t flags REQD_ALIGN_DC
 #endif //TRACE_GC
 
 #ifdef MULTIPLE_HEAPS
-    if (acontext->alloc_heap == 0)
+    if (acontext->get_alloc_heap() == 0)
     {
         AssignHeap (acontext);
-        assert (acontext->alloc_heap);
+        assert (acontext->get_alloc_heap());
     }
 #endif //MULTIPLE_HEAPS
 
@@ -34546,7 +34571,7 @@ GCHeap::Alloc(alloc_context* acontext, size_t size, uint32_t flags REQD_ALIGN_DC
 #endif // FEATURE_REDHAWK
 
 #ifdef MULTIPLE_HEAPS
-    gc_heap* hp = acontext->alloc_heap->pGenGCHeap;
+    gc_heap* hp = acontext->get_alloc_heap()->pGenGCHeap;
 #else
     gc_heap* hp = pGenGCHeap;
 #ifdef _PREFAST_
@@ -34591,8 +34616,9 @@ GCHeap::Alloc(alloc_context* acontext, size_t size, uint32_t flags REQD_ALIGN_DC
 }
 
 void
-GCHeap::FixAllocContext (alloc_context* acontext, BOOL lockp, void* arg, void *heap)
+GCHeap::FixAllocContext (gc_alloc_context* context, BOOL lockp, void* arg, void *heap)
 {
+    alloc_context* acontext = static_cast<alloc_context*>(context);
 #ifdef MULTIPLE_HEAPS
 
     if (arg != 0)
@@ -35383,8 +35409,8 @@ size_t GCHeap::ApproxTotalBytesInUse(BOOL small_heap_only)
 void GCHeap::AssignHeap (alloc_context* acontext)
 {
     // Assign heap based on processor
-    acontext->alloc_heap = GetHeap(heap_select::select_heap(acontext, 0));
-    acontext->home_heap = acontext->alloc_heap;
+    acontext->set_alloc_heap(GetHeap(heap_select::select_heap(acontext, 0)));
+    acontext->set_home_heap(acontext->get_alloc_heap());
 }
 GCHeap* GCHeap::GetHeap (int n)
 {
@@ -35393,11 +35419,12 @@ GCHeap* GCHeap::GetHeap (int n)
 }
 #endif //MULTIPLE_HEAPS
 
-bool GCHeap::IsThreadUsingAllocationContextHeap(alloc_context* acontext, int thread_number)
+bool GCHeap::IsThreadUsingAllocationContextHeap(gc_alloc_context* context, int thread_number)
 {
+    alloc_context* acontext = static_cast<alloc_context*>(context);
 #ifdef MULTIPLE_HEAPS
-    return ((acontext->home_heap == GetHeap(thread_number)) ||
-            ((acontext->home_heap == 0) && (thread_number == 0)));
+    return ((acontext->get_home_heap() == GetHeap(thread_number)) ||
+            ((acontext->get_home_heap() == 0) && (thread_number == 0)));
 #else
     UNREFERENCED_PARAMETER(acontext);
     UNREFERENCED_PARAMETER(thread_number);
@@ -35427,7 +35454,8 @@ int GCHeap::GetHomeHeapNumber ()
     {
         if (pThread)
         {
-            GCHeap *hp = GCToEEInterface::GetAllocContext(pThread)->home_heap;
+            gc_alloc_context* ctx = GCToEEInterface::GetAllocContext(pThread);
+            GCHeap *hp = static_cast<alloc_context*>(ctx)->get_home_heap();
             if (hp == gc_heap::g_heaps[i]->vm_heap) return i;
         }
     }
@@ -35639,7 +35667,7 @@ size_t GCHeap::GetValidGen0MaxSize(size_t seg_size)
 {
     size_t gen0size = g_pConfig->GetGCgen0size();
 
-    if ((gen0size == 0) || !GCHeap::IsValidGen0MaxSize(gen0size))
+    if ((gen0size == 0) || !g_theGcHeap->IsValidGen0MaxSize(gen0size))
     {
 #ifdef SERVER_GC
         // performance data seems to indicate halving the size results
@@ -35869,7 +35897,7 @@ GCHeap::SetCardsAfterBulkCopy( Object **StartPoint, size_t len )
 #ifdef BACKGROUND_GC
         (!gc_heap::settings.concurrent) &&
 #endif //BACKGROUND_GC
-        (GCHeap::GetGCHeap()->WhichGeneration( (Object*) StartPoint ) == 0))
+        (g_theGcHeap->WhichGeneration( (Object*) StartPoint ) == 0))
         return;
 
     rover = StartPoint;
@@ -36374,7 +36402,7 @@ CFinalize::ScanForFinalization (promote_func* pfn, int gen, BOOL mark_only_p,
             {
                 CObjectHeader* obj = (CObjectHeader*)*i;
                 dprintf (3, ("scanning: %Ix", (size_t)obj));
-                if (!GCHeap::GetGCHeap()->IsPromoted (obj))
+                if (!g_theGcHeap->IsPromoted (obj))
                 {
                     dprintf (3, ("freacheable: %Ix", (size_t)obj));
 
@@ -36507,7 +36535,7 @@ CFinalize::UpdatePromotedGenerations (int gen, BOOL gen_0_empty_p)
             for (Object** po = startIndex;
                  po < SegQueueLimit (gen_segment(i)); po++)
             {
-                int new_gen = GCHeap::GetGCHeap()->WhichGeneration (*po);
+                int new_gen = g_theGcHeap->WhichGeneration (*po);
                 if (new_gen != i)
                 {
                     if (new_gen > i)
@@ -36567,7 +36595,7 @@ void CFinalize::CheckFinalizerObjects()
 
         for (Object **po = startIndex; po < stopIndex; po++)
         {
-            if ((int)GCHeap::GetGCHeap()->WhichGeneration (*po) < i)
+            if ((int)g_theGcHeap->WhichGeneration (*po) < i)
                 FATAL_GC_ERROR ();
             ((CObjectHeader*)*po)->Validate();
         }
@@ -36640,9 +36668,9 @@ void gc_heap::walk_heap (walk_fn fn, void* context, int gen_number, BOOL walk_la
     }
 }
 
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
 void GCHeap::WalkObject (Object* obj, walk_fn fn, void* context)
 {
+#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
     uint8_t* o = (uint8_t*)obj;
     if (o)
     {
@@ -36657,8 +36685,8 @@ void GCHeap::WalkObject (Object* obj, walk_fn fn, void* context)
                                     }
             );
     }
-}
 #endif //defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
+}
 
 // Go through and touch (read) each page straddled by a memory block.
 void TouchPages(void * pStart, size_t cb)
diff --git a/src/gc/gc.h b/src/gc/gc.h
index 14c6baee83..7f6e956515 100644
--- a/src/gc/gc.h
+++ b/src/gc/gc.h
@@ -14,9 +14,8 @@ Module Name:
 #ifndef __GC_H
 #define __GC_H
 
-#ifdef PROFILING_SUPPORTED
-#define GC_PROFILING       //Turn on profiling
-#endif // PROFILING_SUPPORTED
+#include "gcinterface.h"
+
 
 /*
  * Promotion Function Prototypes
@@ -80,6 +79,24 @@ enum oom_reason
     oom_unproductive_full_gc = 6
 };
 
+// TODO : it would be easier to make this an ORed value
+enum gc_reason
+{
+    reason_alloc_soh = 0,
+    reason_induced = 1,
+    reason_lowmemory = 2,
+    reason_empty = 3,
+    reason_alloc_loh = 4,
+    reason_oos_soh = 5,
+    reason_oos_loh = 6,
+    reason_induced_noforce = 7, // it's an induced GC and doesn't have to be blocking.
+    reason_gcstress = 8,        // this turns into reason_induced & gc_mechanisms.stress_induced = true
+    reason_lowmemory_blocking = 9,
+    reason_induced_compacting = 10,
+    reason_lowmemory_host = 11,
+    reason_max
+};
+
 struct oom_history
 {
     oom_reason reason;
@@ -97,28 +114,16 @@ struct oom_history
 class CObjectHeader;
 class Object;
 
-class GCHeap;
+class IGCHeapInternal;
 
 /* misc defines */
 #define LARGE_OBJECT_SIZE ((size_t)(85000))
 
-GPTR_DECL(GCHeap, g_pGCHeap);
-
 #ifdef GC_CONFIG_DRIVEN
 #define MAX_GLOBAL_GC_MECHANISMS_COUNT 6
 GARY_DECL(size_t, gc_global_mechanisms, MAX_GLOBAL_GC_MECHANISMS_COUNT);
 #endif //GC_CONFIG_DRIVEN
 
-#ifndef DACCESS_COMPILE
-extern "C" {
-#endif
-GPTR_DECL(uint8_t,g_lowest_address);
-GPTR_DECL(uint8_t,g_highest_address);
-GPTR_DECL(uint32_t,g_card_table);
-#ifndef DACCESS_COMPILE
-}
-#endif
-
 #ifdef DACCESS_COMPILE
 class DacHeapWalker;
 #endif
@@ -127,137 +132,22 @@ class DacHeapWalker;
 #define  _LOGALLOC
 #endif
 
-#ifdef WRITE_BARRIER_CHECK
-//always defined, but should be 0 in Server GC
-extern uint8_t* g_GCShadow;
-extern uint8_t* g_GCShadowEnd;
-// saves the g_lowest_address in between GCs to verify the consistency of the shadow segment
-extern uint8_t* g_shadow_lowest_address;
-#endif
-
 #define MP_LOCKS
 
-extern "C" uint8_t* g_ephemeral_low;
-extern "C" uint8_t* g_ephemeral_high;
-
 namespace WKS {
-    ::GCHeap* CreateGCHeap();
+    ::IGCHeapInternal* CreateGCHeap();
     class GCHeap;
     class gc_heap;
     }
 
 #if defined(FEATURE_SVR_GC)
 namespace SVR {
-    ::GCHeap* CreateGCHeap();
+    ::IGCHeapInternal* CreateGCHeap();
     class GCHeap;
     class gc_heap;
 }
 #endif // defined(FEATURE_SVR_GC)
 
-/*
- * Ephemeral Garbage Collected Heap Interface
- */
-
-
-struct alloc_context 
-{
-    friend class WKS::gc_heap;
-#if defined(FEATURE_SVR_GC)
-    friend class SVR::gc_heap;
-    friend class SVR::GCHeap;
-#endif // defined(FEATURE_SVR_GC)
-    friend struct ClassDumpInfo;
-
-    uint8_t*       alloc_ptr;
-    uint8_t*       alloc_limit;
-    int64_t        alloc_bytes; //Number of bytes allocated on SOH by this context
-    int64_t        alloc_bytes_loh; //Number of bytes allocated on LOH by this context
-#if defined(FEATURE_SVR_GC)
-    SVR::GCHeap*   alloc_heap;
-    SVR::GCHeap*   home_heap;
-#endif // defined(FEATURE_SVR_GC)
-    int            alloc_count;
-public:
-
-    void init()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        alloc_ptr = 0;
-        alloc_limit = 0;
-        alloc_bytes = 0;
-        alloc_bytes_loh = 0;
-#if defined(FEATURE_SVR_GC)
-        alloc_heap = 0;
-        home_heap = 0;
-#endif // defined(FEATURE_SVR_GC)
-        alloc_count = 0;
-    }
-};
-
-struct ScanContext
-{
-    Thread* thread_under_crawl;
-    int thread_number;
-    uintptr_t stack_limit; // Lowest point on the thread stack that the scanning logic is permitted to read
-    BOOL promotion; //TRUE: Promotion, FALSE: Relocation.
-    BOOL concurrent; //TRUE: concurrent scanning 
-#if CHECK_APP_DOMAIN_LEAKS || defined (FEATURE_APPDOMAIN_RESOURCE_MONITORING) || defined (DACCESS_COMPILE)
-    AppDomain *pCurrentDomain;
-#endif //CHECK_APP_DOMAIN_LEAKS || FEATURE_APPDOMAIN_RESOURCE_MONITORING || DACCESS_COMPILE
-
-#ifndef FEATURE_REDHAWK
-#if defined(GC_PROFILING) || defined (DACCESS_COMPILE)
-    MethodDesc *pMD;
-#endif //GC_PROFILING || DACCESS_COMPILE
-#endif // FEATURE_REDHAWK
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-    EtwGCRootKind dwEtwRootKind;
-#endif // GC_PROFILING || FEATURE_EVENT_TRACE
-    
-    ScanContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        thread_under_crawl = 0;
-        thread_number = -1;
-        stack_limit = 0;
-        promotion = FALSE;
-        concurrent = FALSE;
-#ifdef GC_PROFILING
-        pMD = NULL;
-#endif //GC_PROFILING
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-        dwEtwRootKind = kEtwGCRootKindOther;
-#endif // GC_PROFILING || FEATURE_EVENT_TRACE
-    }
-};
-
-typedef BOOL (* walk_fn)(Object*, void*);
-typedef void (* gen_walk_fn)(void *context, int generation, uint8_t *range_start, uint8_t * range_end, uint8_t *range_reserved);
-
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-struct ProfilingScanContext : ScanContext
-{
-    BOOL fProfilerPinned;
-    void * pvEtwContext;
-    void *pHeapId;
-    
-    ProfilingScanContext(BOOL fProfilerPinnedParam) : ScanContext()
-    {
-        LIMITED_METHOD_CONTRACT;
-
-        pHeapId = NULL;
-        fProfilerPinned = fProfilerPinnedParam;
-        pvEtwContext = NULL;
-#ifdef FEATURE_CONSERVATIVE_GC
-        // To not confuse GCScan::GcScanRoots
-        promotion = g_pConfig->GetGCConservative();
-#endif
-    }
-};
-#endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-
 #ifdef STRESS_HEAP
 #define IN_STRESS_HEAP(x) x
 #define STRESS_HEAP_ARG(x) ,x
@@ -266,7 +156,6 @@ struct ProfilingScanContext : ScanContext
 #define STRESS_HEAP_ARG(x)
 #endif // STRESS_HEAP
 
-
 //dynamic data interface
 struct gc_counters
 {
@@ -275,51 +164,6 @@ struct gc_counters
     size_t collection_count;
 };
 
-// !!!!!!!!!!!!!!!!!!!!!!!
-// make sure you change the def in bcl\system\gc.cs 
-// if you change this!
-enum collection_mode
-{
-    collection_non_blocking = 0x00000001,
-    collection_blocking = 0x00000002,
-    collection_optimized = 0x00000004,
-    collection_compacting = 0x00000008
-#ifdef STRESS_HEAP
-    , collection_gcstress = 0x80000000
-#endif // STRESS_HEAP
-};
-
-// !!!!!!!!!!!!!!!!!!!!!!!
-// make sure you change the def in bcl\system\gc.cs 
-// if you change this!
-enum wait_full_gc_status
-{
-    wait_full_gc_success = 0,
-    wait_full_gc_failed = 1,
-    wait_full_gc_cancelled = 2,
-    wait_full_gc_timeout = 3,
-    wait_full_gc_na = 4
-};
-
-// !!!!!!!!!!!!!!!!!!!!!!!
-// make sure you change the def in bcl\system\gc.cs 
-// if you change this!
-enum start_no_gc_region_status
-{
-    start_no_gc_success = 0,
-    start_no_gc_no_memory = 1,
-    start_no_gc_too_large = 2,
-    start_no_gc_in_progress = 3
-};
-
-enum end_no_gc_region_status
-{
-    end_no_gc_success = 0,
-    end_no_gc_not_in_progress = 1,
-    end_no_gc_induced = 2,
-    end_no_gc_alloc_exceeded = 3
-};
-
 enum bgc_state
 {
     bgc_not_in_process = 0,
@@ -352,276 +196,72 @@ void record_changed_seg (uint8_t* start, uint8_t* end,
 void record_global_mechanism (int mech_index);
 #endif //GC_CONFIG_DRIVEN
 
-//constants for the flags parameter to the gc call back
-
-#define GC_CALL_INTERIOR            0x1
-#define GC_CALL_PINNED              0x2
-#define GC_CALL_CHECK_APP_DOMAIN    0x4
-
-//flags for GCHeap::Alloc(...)
-#define GC_ALLOC_FINALIZE 0x1
-#define GC_ALLOC_CONTAINS_REF 0x2
-#define GC_ALLOC_ALIGN8_BIAS 0x4
-#define GC_ALLOC_ALIGN8 0x8
-
-class GCHeap {
-    friend struct ::_DacGlobals;
-#ifdef DACCESS_COMPILE
-    friend class ClrDataAccess;
-#endif
-    
-public:
-
-    virtual ~GCHeap() {}
-
-    static GCHeap *GetGCHeap()
+struct alloc_context : gc_alloc_context 
+{
+#ifdef FEATURE_SVR_GC
+    inline SVR::GCHeap* get_alloc_heap()
     {
-        LIMITED_METHOD_CONTRACT;
-
-        _ASSERTE(g_pGCHeap != NULL);
-        return g_pGCHeap;
+        return static_cast<SVR::GCHeap*>(gc_reserved_1);
     }
 
-#ifndef DACCESS_COMPILE
-    static BOOL IsGCInProgress(BOOL bConsiderGCStart = FALSE)
-    {
-        WRAPPER_NO_CONTRACT;
-
-        return (IsGCHeapInitialized() ? GetGCHeap()->IsGCInProgressHelper(bConsiderGCStart) : false);
-    }   
-#endif
-    
-    static BOOL IsGCHeapInitialized()
+    inline void set_alloc_heap(SVR::GCHeap* heap)
     {
-        LIMITED_METHOD_CONTRACT;
-
-        return (g_pGCHeap != NULL);
+        gc_reserved_1 = heap;
     }
 
-    static void WaitForGCCompletion(BOOL bConsiderGCStart = FALSE)
-    {
-        WRAPPER_NO_CONTRACT;
-
-        if (IsGCHeapInitialized())
-            GetGCHeap()->WaitUntilGCComplete(bConsiderGCStart);
-    }   
-
-    // The runtime needs to know whether we're using workstation or server GC 
-    // long before the GCHeap is created.  So IsServerHeap cannot be a virtual 
-    // method on GCHeap.  Instead we make it a static method and initialize 
-    // gcHeapType before any of the calls to IsServerHeap.  Note that this also 
-    // has the advantage of getting the answer without an indirection
-    // (virtual call), which is important for perf critical codepaths.
-
-    #ifndef DACCESS_COMPILE
-    static void InitializeHeapType(bool bServerHeap)
-    {
-        LIMITED_METHOD_CONTRACT;
-#ifdef FEATURE_SVR_GC
-        gcHeapType = bServerHeap ? GC_HEAP_SVR : GC_HEAP_WKS;
-#ifdef WRITE_BARRIER_CHECK
-        if (gcHeapType == GC_HEAP_SVR)
-        {
-            g_GCShadow = 0;
-            g_GCShadowEnd = 0;
-        }
-#endif
-#else // FEATURE_SVR_GC
-        UNREFERENCED_PARAMETER(bServerHeap);
-        CONSISTENCY_CHECK(bServerHeap == false);
-#endif // FEATURE_SVR_GC
-    }
-    #endif
-    
-    static BOOL IsValidSegmentSize(size_t cbSize)
+    inline SVR::GCHeap* get_home_heap()
     {
-        //Must be aligned on a Mb and greater than 4Mb
-        return (((cbSize & (1024*1024-1)) ==0) && (cbSize >> 22));
+        return static_cast<SVR::GCHeap*>(gc_reserved_2);
     }
 
-    static BOOL IsValidGen0MaxSize(size_t cbSize)
+    inline void set_home_heap(SVR::GCHeap* heap)
     {
-        return (cbSize >= 64*1024);
+        gc_reserved_2 = heap;
     }
-
-    inline static bool IsServerHeap()
-    {
-        LIMITED_METHOD_CONTRACT;
-#ifdef FEATURE_SVR_GC
-        _ASSERTE(gcHeapType != GC_HEAP_INVALID);
-        return (gcHeapType == GC_HEAP_SVR);
-#else // FEATURE_SVR_GC
-        return false;
 #endif // FEATURE_SVR_GC
-    }
+};
 
-    inline static bool UseAllocationContexts()
-    {
-        WRAPPER_NO_CONTRACT;
-#ifdef FEATURE_REDHAWK
-        // SIMPLIFY:  only use allocation contexts
-        return true;
-#else
-#if defined(_TARGET_ARM_) || defined(FEATURE_PAL)
-        return true;
-#else
-        return ((IsServerHeap() ? true : (g_SystemInfo.dwNumberOfProcessors >= 2)));
+class IGCHeapInternal : public IGCHeap {
+    friend struct ::_DacGlobals;
+#ifdef DACCESS_COMPILE
+    friend class ClrDataAccess;
 #endif
-#endif 
-    }
-
-   inline static bool MarkShouldCompeteForStatics()
-    {
-        WRAPPER_NO_CONTRACT;
-
-        return IsServerHeap() && g_SystemInfo.dwNumberOfProcessors >= 2;
-    }
     
-#ifndef DACCESS_COMPILE
-    static GCHeap * CreateGCHeap()
-    {
-        WRAPPER_NO_CONTRACT;
-
-        GCHeap * pGCHeap;
-
-#if defined(FEATURE_SVR_GC)
-        pGCHeap = (IsServerHeap() ? SVR::CreateGCHeap() : WKS::CreateGCHeap());
-#else
-        pGCHeap = WKS::CreateGCHeap();
-#endif // defined(FEATURE_SVR_GC)
+public:
 
-        g_pGCHeap = pGCHeap;
-        return pGCHeap;
-    }
-#endif // DACCESS_COMPILE
+    virtual ~IGCHeapInternal() {}
 
 private:
-    typedef enum
-    {
-        GC_HEAP_INVALID = 0,
-        GC_HEAP_WKS     = 1,
-        GC_HEAP_SVR     = 2
-    } GC_HEAP_TYPE;
-    
-#ifdef FEATURE_SVR_GC
-    SVAL_DECL(uint32_t,gcHeapType);
-#endif // FEATURE_SVR_GC
-
+    virtual Object* AllocAlign8Common (void* hp, alloc_context* acontext, size_t size, uint32_t flags) = 0;
 public:
-        // TODO Synchronization, should be moved out
-    virtual BOOL    IsGCInProgressHelper (BOOL bConsiderGCStart = FALSE) = 0;
-    virtual uint32_t    WaitUntilGCComplete (BOOL bConsiderGCStart = FALSE) = 0;
-    virtual void SetGCInProgress(BOOL fInProgress) = 0;
-    virtual CLREventStatic * GetWaitForGCEvent() = 0;
-
-    virtual void    SetFinalizationRun (Object* obj) = 0;
-    virtual Object* GetNextFinalizable() = 0;
-    virtual size_t GetNumberOfFinalizable() = 0;
-
-    virtual void SetFinalizeQueueForShutdown(BOOL fHasLock) = 0;
-    virtual BOOL FinalizeAppDomain(AppDomain *pDomain, BOOL fRunFinalizers) = 0;
-    virtual BOOL ShouldRestartFinalizerWatchDog() = 0;
-
-    //wait for concurrent GC to finish
-    virtual void WaitUntilConcurrentGCComplete () = 0;                                  // Use in managed threads
-#ifndef DACCESS_COMPILE    
-    virtual HRESULT WaitUntilConcurrentGCCompleteAsync(int millisecondsTimeout) = 0;    // Use in native threads. TRUE if succeed. FALSE if failed or timeout
-#endif    
-    virtual BOOL IsConcurrentGCInProgress() = 0;
-
-    // Enable/disable concurrent GC    
-    virtual void TemporaryEnableConcurrentGC() = 0;
-    virtual void TemporaryDisableConcurrentGC() = 0;
-    virtual BOOL IsConcurrentGCEnabled() = 0;
-
-    virtual void FixAllocContext (alloc_context* acontext, BOOL lockp, void* arg, void *heap) = 0;
-    virtual Object* Alloc (alloc_context* acontext, size_t size, uint32_t flags) = 0;
-
-    // This is safe to call only when EE is suspended.
-    virtual Object* GetContainingObject(void *pInteriorPtr) = 0;
-
-        // TODO Should be folded into constructor
-    virtual HRESULT Initialize () = 0;
-
-    virtual HRESULT GarbageCollect (int generation = -1, BOOL low_memory_p=FALSE, int mode = collection_blocking) = 0;
-    virtual Object*  Alloc (size_t size, uint32_t flags) = 0;
-#ifdef FEATURE_64BIT_ALIGNMENT
-    virtual Object*  AllocAlign8 (size_t size, uint32_t flags) = 0;
-    virtual Object*  AllocAlign8 (alloc_context* acontext, size_t size, uint32_t flags) = 0;
-private:
-    virtual Object*  AllocAlign8Common (void* hp, alloc_context* acontext, size_t size, uint32_t flags) = 0;
-public:
-#endif // FEATURE_64BIT_ALIGNMENT
-    virtual Object*  AllocLHeap (size_t size, uint32_t flags) = 0;
-    virtual void     SetReservedVMLimit (size_t vmlimit) = 0;
-    virtual void SetCardsAfterBulkCopy( Object**, size_t ) = 0;
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-    virtual void WalkObject (Object* obj, walk_fn fn, void* context) = 0;
-#endif //defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-
-    virtual bool IsThreadUsingAllocationContextHeap(alloc_context* acontext, int thread_number) = 0;
+    virtual void SetReservedVMLimit (size_t vmlimit) = 0;
     virtual int GetNumberOfHeaps () = 0; 
     virtual int GetHomeHeapNumber () = 0;
-    
-    virtual int CollectionCount (int generation, int get_bgc_fgc_count = 0) = 0;
-
-        // Finalizer queue stuff (should stay)
-    virtual bool    RegisterForFinalization (int gen, Object* obj) = 0;
-
-        // General queries to the GC
-    virtual BOOL    IsPromoted (Object *object) = 0;
-    virtual unsigned WhichGeneration (Object* object) = 0;
-    virtual BOOL    IsEphemeral (Object* object) = 0;
-    virtual BOOL    IsHeapPointer (void* object, BOOL small_heap_only = FALSE) = 0;
-
-    virtual unsigned GetCondemnedGeneration() = 0;
-    virtual int GetGcLatencyMode() = 0;
-    virtual int SetGcLatencyMode(int newLatencyMode) = 0;
-
-    virtual int GetLOHCompactionMode() = 0;
-    virtual void SetLOHCompactionMode(int newLOHCompactionyMode) = 0;
-
-    virtual BOOL RegisterForFullGCNotification(uint32_t gen2Percentage,
-                                               uint32_t lohPercentage) = 0;
-    virtual BOOL CancelFullGCNotification() = 0;
-    virtual int WaitForFullGCApproach(int millisecondsTimeout) = 0;
-    virtual int WaitForFullGCComplete(int millisecondsTimeout) = 0;
-
-    virtual int StartNoGCRegion(uint64_t totalSize, BOOL lohSizeKnown, uint64_t lohSize, BOOL disallowFullBlockingGC) = 0;
-    virtual int EndNoGCRegion() = 0;
+    virtual size_t GetPromotedBytes(int heap_index) = 0;
 
-    virtual BOOL IsObjectInFixedHeap(Object *pObj) = 0;
-    virtual size_t  GetTotalBytesInUse () = 0;
-    virtual size_t  GetCurrentObjSize() = 0;
-    virtual size_t  GetLastGCStartTime(int generation) = 0;
-    virtual size_t  GetLastGCDuration(int generation) = 0;
-    virtual size_t  GetNow() = 0;
-    virtual unsigned GetGcCount() = 0;
-    virtual void TraceGCSegments() = 0;
+    unsigned GetMaxGeneration()
+    {
+        return IGCHeap::maxGeneration;
+    }
 
-    virtual void PublishObject(uint8_t* obj) = 0;
+    BOOL IsValidSegmentSize(size_t cbSize)
+    {
+        //Must be aligned on a Mb and greater than 4Mb
+        return (((cbSize & (1024*1024-1)) ==0) && (cbSize >> 22));
+    }
 
-    // static if since restricting for all heaps is fine
-    virtual size_t GetValidSegmentSize(BOOL large_seg = FALSE) = 0;
+    BOOL IsValidGen0MaxSize(size_t cbSize)
+    {
+        return (cbSize >= 64*1024);
+    }
 
-    static BOOL IsLargeObject(MethodTable *mt) {
+    BOOL IsLargeObject(MethodTable *mt)
+    {
         WRAPPER_NO_CONTRACT;
 
         return mt->GetBaseSize() >= LARGE_OBJECT_SIZE;
     }
 
-    static unsigned GetMaxGeneration() {
-        LIMITED_METHOD_DAC_CONTRACT;  
-        return max_generation;
-    }
-
-    virtual size_t GetPromotedBytes(int heap_index) = 0;
-
-private:
-    enum {
-        max_generation  = 2,
-    };
-    
 public:
 
 #ifdef FEATURE_BASICFREEZE
@@ -630,43 +270,17 @@ public:
     virtual void UnregisterFrozenSegment(segment_handle seg) = 0;
 #endif //FEATURE_BASICFREEZE
 
-        // debug support 
-#ifndef FEATURE_REDHAWK // Redhawk forces relocation a different way
-#ifdef STRESS_HEAP
-    //return TRUE if GC actually happens, otherwise FALSE
-    virtual BOOL    StressHeap(alloc_context * acontext = 0) = 0;
-#endif
-#endif // FEATURE_REDHAWK
-#ifdef VERIFY_HEAP
-    virtual void    ValidateObjectMember (Object *obj) = 0;
-#endif
-
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-    virtual void DescrGenerationsToProfiler (gen_walk_fn fn, void *context) = 0;
-#endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-
 protected: 
-#ifdef VERIFY_HEAP
 public:
-    // Return NULL if can't find next object. When EE is not suspended,
-    // the result is not accurate: if the input arg is in gen0, the function could 
-    // return zeroed out memory as next object
-    virtual Object * NextObj (Object * object) = 0;
-#ifdef FEATURE_BASICFREEZE
+#if defined(FEATURE_BASICFREEZE) && defined(VERIFY_HEAP)
     // Return TRUE if object lives in frozen segment
     virtual BOOL IsInFrozenSegment (Object * object) = 0;
-#endif //FEATURE_BASICFREEZE
-#endif //VERIFY_HEAP    
+#endif // defined(FEATURE_BASICFREEZE) && defined(VERIFY_HEAP)
 };
 
-extern VOLATILE(int32_t) m_GCLock;
-
 // Go through and touch (read) each page straddled by a memory block.
 void TouchPages(void * pStart, size_t cb);
 
-// For low memory notification from host
-extern int32_t g_bLowMemoryFromHost;
-
 #ifdef WRITE_BARRIER_CHECK
 void updateGCShadow(Object** ptr, Object* val);
 #endif
@@ -677,4 +291,27 @@ extern MethodTable  *pWeakReferenceMT;
 extern MethodTable  *pWeakReferenceOfTCanonMT;
 extern void FinalizeWeakReference(Object * obj);
 
+// The single GC heap instance, shared with the VM.
+extern IGCHeapInternal* g_theGcHeap;
+
+#ifndef DACCESS_COMPILE
+inline BOOL IsGCInProgress(bool bConsiderGCStart = FALSE)
+{
+    WRAPPER_NO_CONTRACT;
+
+    return g_theGcHeap != nullptr ? g_theGcHeap->IsGCInProgressHelper(bConsiderGCStart) : false;
+}
+#endif // DACCESS_COMPILE
+
+inline BOOL IsServerHeap()
+{
+    LIMITED_METHOD_CONTRACT;
+#ifdef FEATURE_SVR_GC
+    _ASSERTE(IGCHeap::gcHeapType != IGCHeap::GC_HEAP_INVALID);
+    return (IGCHeap::gcHeapType == IGCHeap::GC_HEAP_SVR);
+#else // FEATURE_SVR_GC
+    return false;
+#endif // FEATURE_SVR_GC
+}
+
 #endif // __GC_H
diff --git a/src/gc/gccommon.cpp b/src/gc/gccommon.cpp
index 779aac7296..6bcdf3957b 100644
--- a/src/gc/gccommon.cpp
+++ b/src/gc/gccommon.cpp
@@ -15,10 +15,12 @@
 #include "gc.h"
 
 #ifdef FEATURE_SVR_GC
-SVAL_IMPL_INIT(uint32_t,GCHeap,gcHeapType,GCHeap::GC_HEAP_INVALID);
+SVAL_IMPL_INIT(uint32_t,IGCHeap,gcHeapType,IGCHeap::GC_HEAP_INVALID);
 #endif // FEATURE_SVR_GC
 
-GPTR_IMPL(GCHeap,g_pGCHeap);
+SVAL_IMPL_INIT(uint32_t,IGCHeap,maxGeneration,2);
+
+IGCHeapInternal* g_theGcHeap;
 
 /* global versions of the card table and brick table */ 
 GPTR_IMPL(uint32_t,g_card_table);
@@ -112,4 +114,41 @@ void record_changed_seg (uint8_t* start, uint8_t* end,
     }
 }
 
+// The runtime needs to know whether we're using workstation or server GC 
+// long before the GCHeap is created.
+void InitializeHeapType(bool bServerHeap)
+{
+    LIMITED_METHOD_CONTRACT;
+#ifdef FEATURE_SVR_GC
+    IGCHeap::gcHeapType = bServerHeap ? IGCHeap::GC_HEAP_SVR : IGCHeap::GC_HEAP_WKS;
+#ifdef WRITE_BARRIER_CHECK
+    if (IGCHeap::gcHeapType == IGCHeap::GC_HEAP_SVR)
+    {
+        g_GCShadow = 0;
+        g_GCShadowEnd = 0;
+    }
+#endif // WRITE_BARRIER_CHECK
+#else // FEATURE_SVR_GC
+    UNREFERENCED_PARAMETER(bServerHeap);
+    CONSISTENCY_CHECK(bServerHeap == false);
+#endif // FEATURE_SVR_GC
+}
+
+IGCHeap* InitializeGarbageCollector(IGCToCLR* clrToGC)
+{
+    LIMITED_METHOD_CONTRACT;
+    UNREFERENCED_PARAMETER(clrToGC);
+
+    IGCHeapInternal* heap;
+#ifdef FEATURE_SVR_GC
+    assert(IGCHeap::gcHeapType != IGCHeap::GC_HEAP_INVALID);
+    heap = IGCHeap::gcHeapType == IGCHeap::GC_HEAP_SVR ? SVR::CreateGCHeap() : WKS::CreateGCHeap();
+#else
+    heap = WKS::CreateGCHeap();
+#endif
+
+    g_theGcHeap = heap;
+    return heap;
+}
+
 #endif // !DACCESS_COMPILE
diff --git a/src/gc/gcee.cpp b/src/gc/gcee.cpp
index d37eaf4de9..e2015eef0c 100644
--- a/src/gc/gcee.cpp
+++ b/src/gc/gcee.cpp
@@ -148,7 +148,7 @@ void GCHeap::UpdatePostGCCounters()
     // if a max gen garbage collection was performed, resync the GC Handle counter; 
     // if threads are currently suspended, we do not need to obtain a lock on each handle table
     if (condemned_gen == max_generation)
-        total_num_gc_handles = HndCountAllHandles(!GCHeap::IsGCInProgress());
+        total_num_gc_handles = HndCountAllHandles(!IsGCInProgress());
 #endif //FEATURE_REDHAWK
 
     // per generation calculation.
@@ -782,7 +782,7 @@ void gc_heap::background_gc_wait_lh (alloc_wait_reason awr)
 
 
 /******************************************************************************/
-::GCHeap* CreateGCHeap() {
+IGCHeapInternal* CreateGCHeap() {
     return new(nothrow) GCHeap();   // we return wks or svr 
 }
 
@@ -823,12 +823,12 @@ void GCHeap::TraceGCSegments()
 #endif // FEATURE_EVENT_TRACE
 }
 
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
 void GCHeap::DescrGenerationsToProfiler (gen_walk_fn fn, void *context)
 {
+#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
     pGenGCHeap->descr_generations_to_profiler(fn, context);
-}
 #endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
+}
 
 #ifdef FEATURE_BASICFREEZE
 segment_handle GCHeap::RegisterFrozenSegment(segment_info *pseginfo)
diff --git a/src/gc/gcimpl.h b/src/gc/gcimpl.h
index 6a4ee86cd8..38392b8229 100644
--- a/src/gc/gcimpl.h
+++ b/src/gc/gcimpl.h
@@ -36,29 +36,10 @@ inline void checkGCWriteBarrier() {}
 
 void GCProfileWalkHeap();
 
-class GCHeap;
 class gc_heap;
 class CFinalize;
 
-// TODO : it would be easier to make this an ORed value
-enum gc_reason
-{
-    reason_alloc_soh = 0,
-    reason_induced = 1,
-    reason_lowmemory = 2,
-    reason_empty = 3,
-    reason_alloc_loh = 4,
-    reason_oos_soh = 5,
-    reason_oos_loh = 6,
-    reason_induced_noforce = 7, // it's an induced GC and doesn't have to be blocking.
-    reason_gcstress = 8,        // this turns into reason_induced & gc_mechanisms.stress_induced = true
-    reason_lowmemory_blocking = 9,
-    reason_induced_compacting = 10,
-    reason_lowmemory_host = 11,
-    reason_max
-};
-
-class GCHeap : public ::GCHeap
+class GCHeap : public IGCHeapInternal
 {
 protected:
 
@@ -111,17 +92,15 @@ public:
 
     //flags can be GC_ALLOC_CONTAINS_REF GC_ALLOC_FINALIZE
     Object*  Alloc (size_t size, uint32_t flags);
-#ifdef FEATURE_64BIT_ALIGNMENT
     Object*  AllocAlign8 (size_t size, uint32_t flags);
-    Object*  AllocAlign8 (alloc_context* acontext, size_t size, uint32_t flags);
+    Object*  AllocAlign8 (gc_alloc_context* acontext, size_t size, uint32_t flags);
 private:
     Object*  AllocAlign8Common (void* hp, alloc_context* acontext, size_t size, uint32_t flags);
 public:
-#endif // FEATURE_64BIT_ALIGNMENT
     Object*  AllocLHeap (size_t size, uint32_t flags);
-    Object* Alloc (alloc_context* acontext, size_t size, uint32_t flags);
+    Object* Alloc (gc_alloc_context* acontext, size_t size, uint32_t flags);
 
-    void FixAllocContext (alloc_context* acontext,
+    void FixAllocContext (gc_alloc_context* acontext,
                                             BOOL lockp, void* arg, void *heap);
 
     Object* GetContainingObject(void *pInteriorPtr);
@@ -132,7 +111,7 @@ public:
 #endif //MULTIPLE_HEAPS
 
     int GetHomeHeapNumber ();
-    bool IsThreadUsingAllocationContextHeap(alloc_context* acontext, int thread_number);
+    bool IsThreadUsingAllocationContextHeap(gc_alloc_context* acontext, int thread_number);
     int GetNumberOfHeaps ();
     void HideAllocContext(alloc_context*);
     void RevealAllocContext(alloc_context*);
@@ -176,9 +155,7 @@ public:
     BOOL    IsEphemeral (Object* object);
     BOOL    IsHeapPointer (void* object, BOOL small_heap_only = FALSE);
     
-#ifdef VERIFY_HEAP
     void    ValidateObjectMember (Object *obj);
-#endif //_DEBUG
 
     PER_HEAP    size_t  ApproxTotalBytesInUse(BOOL small_heap_only = FALSE);
     PER_HEAP    size_t  ApproxFreeBytes();
@@ -199,8 +176,6 @@ public:
 
     int StartNoGCRegion(uint64_t totalSize, BOOL lohSizeKnown, uint64_t lohSize, BOOL disallowFullBlockingGC);
     int EndNoGCRegion();
-
-    PER_HEAP_ISOLATED     unsigned GetMaxGeneration();
  
     unsigned GetGcCount();
 
@@ -224,9 +199,7 @@ public:
     BOOL ShouldRestartFinalizerWatchDog();
 
     void SetCardsAfterBulkCopy( Object**, size_t);
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
     void WalkObject (Object* obj, walk_fn fn, void* context);
-#endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
 
 public:	// FIX 
 
@@ -281,11 +254,12 @@ private:
         // the condition here may have to change as well.
         return g_TrapReturningThreads == 0;
     }
-#ifndef FEATURE_REDHAWK // Redhawk forces relocation a different way
-#ifdef STRESS_HEAP 
 public:
     //return TRUE if GC actually happens, otherwise FALSE
-    BOOL    StressHeap(alloc_context * acontext = 0);
+    BOOL    StressHeap(gc_alloc_context * acontext = 0);
+
+#ifndef FEATURE_REDHAWK // Redhawk forces relocation a different way
+#ifdef STRESS_HEAP 
 protected:
 
     // only used in BACKGROUND_GC, but the symbol is not defined yet...
@@ -300,17 +274,13 @@ protected:
 #endif  // STRESS_HEAP 
 #endif // FEATURE_REDHAWK
 
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
     virtual void DescrGenerationsToProfiler (gen_walk_fn fn, void *context);
-#endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
 
-#ifdef VERIFY_HEAP
 public:
     Object * NextObj (Object * object);
-#ifdef FEATURE_BASICFREEZE
+#if defined (FEATURE_BASICFREEZE) && defined (VERIFY_HEAP)
     BOOL IsInFrozenSegment (Object * object);
-#endif //FEATURE_BASICFREEZE
-#endif //VERIFY_HEAP     
+#endif // defined (FEATURE_BASICFREEZE) && defined (VERIFY_HEAP)
 };
 
 #endif  // GCIMPL_H_
diff --git a/src/gc/gcinterface.h b/src/gc/gcinterface.h
new file mode 100644
index 0000000000..a12031bc61
--- /dev/null
+++ b/src/gc/gcinterface.h
@@ -0,0 +1,509 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#ifndef _GC_INTERFACE_H_
+#define _GC_INTERFACE_H_
+
+// The allocation context must be known to the VM for use in the allocation
+// fast path and known to the GC for performing the allocation. Every Thread
+// has its own allocation context that it hands to the GC when allocating.
+struct gc_alloc_context
+{
+    uint8_t*       alloc_ptr;
+    uint8_t*       alloc_limit;
+    int64_t        alloc_bytes; //Number of bytes allocated on SOH by this context
+    int64_t        alloc_bytes_loh; //Number of bytes allocated on LOH by this context
+    // These two fields are deliberately not exposed past the EE-GC interface.
+    void*          gc_reserved_1;
+    void*          gc_reserved_2;
+    int            alloc_count;
+public:
+
+    void init()
+    {
+        LIMITED_METHOD_CONTRACT;
+
+        alloc_ptr = 0;
+        alloc_limit = 0;
+        alloc_bytes = 0;
+        alloc_bytes_loh = 0;
+        gc_reserved_1 = 0;
+        gc_reserved_2 = 0;
+        alloc_count = 0;
+    }
+};
+
+#ifdef PROFILING_SUPPORTED
+#define GC_PROFILING       //Turn on profiling
+#endif // PROFILING_SUPPORTED
+
+#define LARGE_OBJECT_SIZE ((size_t)(85000))
+
+class Object;
+class IGCHeap;
+class IGCToCLR;
+
+// Initializes the garbage collector. Should only be called
+// once, during EE startup.
+IGCHeap* InitializeGarbageCollector(IGCToCLR* clrToGC);
+
+// The runtime needs to know whether we're using workstation or server GC 
+// long before the GCHeap is created. This function sets the type of
+// heap that will be created, before InitializeGarbageCollector is called
+// and the heap is actually recated.
+void InitializeHeapType(bool bServerHeap);
+
+#ifndef DACCESS_COMPILE
+extern "C" {
+#endif // !DACCESS_COMPILE
+GPTR_DECL(uint8_t,g_lowest_address);
+GPTR_DECL(uint8_t,g_highest_address);
+GPTR_DECL(uint32_t,g_card_table);
+#ifndef DACCESS_COMPILE
+} 
+#endif // !DACCESS_COMPILE
+
+extern "C" uint8_t* g_ephemeral_low;
+extern "C" uint8_t* g_ephemeral_high;
+
+#ifdef WRITE_BARRIER_CHECK
+//always defined, but should be 0 in Server GC
+extern uint8_t* g_GCShadow;
+extern uint8_t* g_GCShadowEnd;
+// saves the g_lowest_address in between GCs to verify the consistency of the shadow segment
+extern uint8_t* g_shadow_lowest_address;
+#endif
+
+// For low memory notification from host
+extern int32_t g_bLowMemoryFromHost;
+
+extern VOLATILE(int32_t) m_GCLock;
+
+// !!!!!!!!!!!!!!!!!!!!!!!
+// make sure you change the def in bcl\system\gc.cs 
+// if you change this!
+enum collection_mode
+{
+    collection_non_blocking = 0x00000001,
+    collection_blocking = 0x00000002,
+    collection_optimized = 0x00000004,
+    collection_compacting = 0x00000008
+#ifdef STRESS_HEAP
+    , collection_gcstress = 0x80000000
+#endif // STRESS_HEAP
+};
+
+// !!!!!!!!!!!!!!!!!!!!!!!
+// make sure you change the def in bcl\system\gc.cs 
+// if you change this!
+enum wait_full_gc_status
+{
+    wait_full_gc_success = 0,
+    wait_full_gc_failed = 1,
+    wait_full_gc_cancelled = 2,
+    wait_full_gc_timeout = 3,
+    wait_full_gc_na = 4
+};
+
+// !!!!!!!!!!!!!!!!!!!!!!!
+// make sure you change the def in bcl\system\gc.cs 
+// if you change this!
+enum start_no_gc_region_status
+{
+    start_no_gc_success = 0,
+    start_no_gc_no_memory = 1,
+    start_no_gc_too_large = 2,
+    start_no_gc_in_progress = 3
+};
+
+enum end_no_gc_region_status
+{
+    end_no_gc_success = 0,
+    end_no_gc_not_in_progress = 1,
+    end_no_gc_induced = 2,
+    end_no_gc_alloc_exceeded = 3
+};
+
+typedef BOOL (* walk_fn)(Object*, void*);
+typedef void (* gen_walk_fn)(void* context, int generation, uint8_t* range_start, uint8_t* range_end, uint8_t* range_reserved);
+
+// IGCHeap is the interface that the VM will use when interacting with the GC.
+class IGCHeap {
+public:
+    /*
+    ===========================================================================
+    Hosting APIs. These are used by GC hosting. The code that
+    calls these methods may possibly be moved behind the interface -
+    today, the VM handles the setting of segment size and max gen 0 size.
+    (See src/vm/corehost.cpp)
+    ===========================================================================
+    */
+
+    // Returns whether or not the given size is a valid segment size.
+    virtual BOOL IsValidSegmentSize(size_t size) = 0;
+
+    // Returns whether or not the given size is a valid gen 0 max size.
+    virtual BOOL IsValidGen0MaxSize(size_t size) = 0;
+
+    // Gets a valid segment size.
+    virtual size_t GetValidSegmentSize(BOOL large_seg = FALSE) = 0;
+
+    /*
+    ===========================================================================
+    Concurrent GC routines. These are used in various places in the VM
+    to synchronize with the GC, when the VM wants to update something that
+    the GC is potentially using, if it's doing a background GC.
+
+    Concrete examples of this are moving async pinned handles across appdomains
+    and profiling/ETW scenarios.
+    ===========================================================================
+    */
+
+    // Blocks until any running concurrent GCs complete.
+    virtual void WaitUntilConcurrentGCComplete() = 0;
+
+    // Returns true if a concurrent GC is in progress, false otherwise.
+    virtual BOOL IsConcurrentGCInProgress() = 0;
+
+    // Temporarily enables concurrent GC, used during profiling.
+    virtual void TemporaryEnableConcurrentGC() = 0;
+
+    // Temporarily disables concurrent GC, used during profiling.
+    virtual void TemporaryDisableConcurrentGC() = 0;
+
+    // Returns whether or not Concurrent GC is enabled.
+    virtual BOOL IsConcurrentGCEnabled() = 0;
+
+    // Wait for a concurrent GC to complete if one is in progress, with the given timeout.
+    virtual HRESULT WaitUntilConcurrentGCCompleteAsync(int millisecondsTimeout) = 0;    // Use in native threads. TRUE if succeed. FALSE if failed or timeout
+
+
+    /*
+    ===========================================================================
+    Finalization routines. These are used by the finalizer thread to communicate
+    with the GC.
+    ===========================================================================
+    */
+
+    // Finalizes an app domain by finalizing objects within that app domain.
+    virtual BOOL FinalizeAppDomain(AppDomain* pDomain, BOOL fRunFinalizers) = 0;
+
+    // Finalizes all registered objects for shutdown, even if they are still reachable.
+    virtual void SetFinalizeQueueForShutdown(BOOL fHasLock) = 0;
+
+    // Gets the number of finalizable objects.
+    virtual size_t GetNumberOfFinalizable() = 0;
+
+    // Traditionally used by the finalizer thread on shutdown to determine
+    // whether or not to time out. Returns true if the GC lock has not been taken.
+    virtual BOOL ShouldRestartFinalizerWatchDog() = 0;
+
+    // Gets the next finalizable object.
+    virtual Object* GetNextFinalizable() = 0;
+
+    /*
+    ===========================================================================
+    BCL routines. These are routines that are directly exposed by mscorlib
+    as a part of the `System.GC` class. These routines behave in the same
+    manner as the functions on `System.GC`.
+    ===========================================================================
+    */
+
+    // Gets the current GC latency mode.
+    virtual int GetGcLatencyMode() = 0;
+
+    // Sets the current GC latency mode. newLatencyMode has already been
+    // verified by mscorlib to be valid.
+    virtual int SetGcLatencyMode(int newLatencyMode) = 0;
+
+    // Gets the current LOH compaction mode.
+    virtual int GetLOHCompactionMode() = 0;
+
+    // Sets the current LOH compaction mode. newLOHCompactionMode has
+    // already been verified by mscorlib to be valid.
+    virtual void SetLOHCompactionMode(int newLOHCompactionMode) = 0;
+
+    // Registers for a full GC notification, raising a notification if the gen 2 or
+    // LOH object heap thresholds are exceeded.
+    virtual BOOL RegisterForFullGCNotification(uint32_t gen2Percentage, uint32_t lohPercentage) = 0;
+
+    // Cancels a full GC notification that was requested by `RegisterForFullGCNotification`.
+    virtual BOOL CancelFullGCNotification() = 0;
+
+    // Returns the status of a registered notification for determining whether a blocking
+    // Gen 2 collection is about to be initiated, with the given timeout.
+    virtual int WaitForFullGCApproach(int millisecondsTimeout) = 0;
+
+    // Returns the status of a registered notification for determining whether a blocking
+    // Gen 2 collection has completed, with the given timeout.
+    virtual int WaitForFullGCComplete(int millisecondsTimeout) = 0;
+
+    // Returns the generation in which obj is found. Also used by the VM
+    // in some places, in particular syncblk code.
+    virtual unsigned WhichGeneration(Object* obj) = 0;
+
+    // Returns the number of GCs that have transpired in the given generation
+    // since the beginning of the life of the process. Also used by the VM
+    // for debug code and app domains.
+    virtual int CollectionCount(int generation, int get_bgc_fgc_coutn = 0) = 0;
+
+    // Begins a no-GC region, returning a code indicating whether entering the no-GC
+    // region was successful.
+    virtual int StartNoGCRegion(uint64_t totalSize, BOOL lohSizeKnown, uint64_t lohSize, BOOL disallowFullBlockingGC) = 0;
+
+    // Exits a no-GC region.
+    virtual int EndNoGCRegion() = 0;
+
+    // Gets the total number of bytes in use.
+    virtual size_t GetTotalBytesInUse() = 0;
+
+    // Forces a garbage collection of the given generation. Also used extensively
+    // throughout the VM.
+    virtual HRESULT GarbageCollect(int generation = -1, BOOL low_memory_p = FALSE, int mode = collection_blocking) = 0;
+
+    // Gets the largest GC generation. Also used extensively throughout the VM.
+    virtual unsigned GetMaxGeneration() = 0;
+
+    // Indicates that an object's finalizer should not be run upon the object's collection.
+    virtual void SetFinalizationRun(Object* obj) = 0;
+
+    // Indicates that an object's finalizer should be run upon the object's collection.
+    virtual bool RegisterForFinalization(int gen, Object* obj) = 0;
+
+    /*
+    ===========================================================================
+    Miscellaneous routines used by the VM.
+    ===========================================================================
+    */
+
+    // Initializes the GC heap, returning whether or not the initialization
+    // was successful.
+    virtual HRESULT Initialize() = 0;
+
+    // Returns whether nor this GC was promoted by the last GC.
+    virtual BOOL IsPromoted(Object* object) = 0;
+
+    // Returns true if this pointer points into a GC heap, false otherwise.
+    virtual BOOL IsHeapPointer(void* object, BOOL small_heap_only = FALSE) = 0;
+
+    // Return the generation that has been condemned by the current GC.
+    virtual unsigned GetCondemnedGeneration() = 0;
+
+    // Returns whether or not a GC is in progress.
+    virtual BOOL IsGCInProgressHelper(BOOL bConsiderGCStart = FALSE) = 0;
+
+    // Returns the number of GCs that have occured. Mainly used for
+    // sanity checks asserting that a GC has not occured.
+    virtual unsigned GetGcCount() = 0;
+
+    // Sets cards after an object has been memmoved. 
+    virtual void SetCardsAfterBulkCopy(Object** obj, size_t length) = 0;
+
+    // Gets whether or not the home heap of this alloc context matches the heap
+    // associated with this thread.
+    virtual bool IsThreadUsingAllocationContextHeap(gc_alloc_context* acontext, int thread_number) = 0;
+    
+    // Returns whether or not this object resides in an ephemeral generation.
+    virtual BOOL IsEphemeral(Object* object) = 0;
+
+    // Blocks until a GC is complete, returning a code indicating the wait was successful.
+    virtual uint32_t WaitUntilGCComplete(BOOL bConsiderGCStart = FALSE) = 0;
+
+    // "Fixes" an allocation context by binding its allocation pointer to a
+    // location on the heap.
+    virtual void FixAllocContext(gc_alloc_context* acontext, BOOL lockp, void* arg, void* heap) = 0;
+
+    // Gets the total survived size plus the total allocated bytes on the heap.
+    virtual size_t GetCurrentObjSize() = 0;
+
+    // Sets whether or not a GC is in progress.
+    virtual void SetGCInProgress(BOOL fInProgress) = 0;
+
+    /*
+    Add/RemoveMemoryPressure support routines. These are on the interface
+    for now, but we should move Add/RemoveMemoryPressure from the VM to the GC.
+    When that occurs, these three routines can be removed from the interface.
+    */
+
+    // Get the timestamp corresponding to the last GC that occured for the
+    // given generation.
+    virtual size_t GetLastGCStartTime(int generation) = 0;
+
+    // Gets the duration of the last GC that occured for the given generation.
+    virtual size_t GetLastGCDuration(int generation) = 0;
+
+    // Gets a timestamp for the current moment in time.
+    virtual size_t GetNow() = 0;
+
+    /*
+    ===========================================================================
+    Allocation routines. These all call into the GC's allocator and may trigger a garbage
+    collection.
+    ===========================================================================
+    */
+
+    // Allocates an object on the given allocation context with the given size and flags.
+    virtual Object* Alloc(gc_alloc_context* acontext, size_t size, uint32_t flags) = 0;
+
+    // Allocates an object on the default allocation context with the given size and flags.
+    virtual Object* Alloc(size_t size, uint32_t flags) = 0;
+
+    // Allocates an object on the large object heap with the given size and flags.
+    virtual Object* AllocLHeap(size_t size, uint32_t flags) = 0;
+
+    // Allocates an object on the default allocation context, aligned to 64 bits,
+    // with the given size and flags.
+    virtual Object* AllocAlign8 (size_t size, uint32_t flags) = 0;
+
+    // Allocates an object on the given allocation context, aligned to 64 bits,
+    // with the given size and flags.
+    virtual Object* AllocAlign8 (gc_alloc_context* acontext, size_t size, uint32_t flags) = 0;
+
+    // If allocating on the LOH, blocks if a BGC is in a position (concurrent mark)
+    // where the LOH allocator can't allocate.
+    virtual void PublishObject(uint8_t* obj) = 0;
+
+    // Gets the event that suspended threads will use to wait for the
+    // end of a GC.
+    virtual CLREventStatic* GetWaitForGCEvent() = 0;
+
+    /*
+    ===========================================================================
+    Heap verification routines. These are used during heap verification only.
+    ===========================================================================
+    */
+    // Returns whether or not this object is in the fixed heap.
+    virtual BOOL IsObjectInFixedHeap(Object* pObj) = 0;
+
+    // Walks an object and validates its members.
+    virtual void ValidateObjectMember(Object* obj) = 0;
+
+    // Retrieves the next object after the given object. When the EE
+    // is not suspended, the result is not accurate - if the input argument
+    // is in Gen0, the function could return zeroed out memory as the next object.
+    virtual Object* NextObj(Object* object) = 0;
+
+    // Given an interior pointer, return a pointer to the object
+    // containing that pointer. This is safe to call only when the EE is suspended.
+    virtual Object* GetContainingObject(void* pInteriorPtr) = 0;
+
+    /*
+    ===========================================================================
+    Profiling routines. Used for event tracing and profiling to broadcast
+    information regarding the heap.
+    ===========================================================================
+    */
+
+    // Walks an object, invoking a callback on each member.
+    virtual void WalkObject(Object* obj, walk_fn fn, void* context) = 0;
+
+    // Describes all generations to the profiler, invoking a callback on each generation.
+    virtual void DescrGenerationsToProfiler(gen_walk_fn fn, void* context) = 0;
+
+    // Traces all GC segments and fires ETW events with information on them.
+    virtual void TraceGCSegments() = 0;
+
+    /*
+    ===========================================================================
+    GC Stress routines. Used only when running under GC Stress.
+    ===========================================================================
+    */
+
+    // Returns TRUE if GC actually happens, otherwise FALSE
+    virtual BOOL StressHeap(gc_alloc_context* acontext = 0) = 0;
+
+    IGCHeap() {}
+    virtual ~IGCHeap() {}
+
+    typedef enum
+    {
+        GC_HEAP_INVALID = 0,
+        GC_HEAP_WKS     = 1,
+        GC_HEAP_SVR     = 2
+    } GC_HEAP_TYPE;
+
+#ifdef FEATURE_SVR_GC
+    SVAL_DECL(uint32_t, gcHeapType);
+#endif
+
+    SVAL_DECL(uint32_t, maxGeneration);
+};
+
+#ifdef WRITE_BARRIER_CHECK
+void updateGCShadow(Object** ptr, Object* val);
+#endif
+
+//constants for the flags parameter to the gc call back
+
+#define GC_CALL_INTERIOR            0x1
+#define GC_CALL_PINNED              0x2
+#define GC_CALL_CHECK_APP_DOMAIN    0x4
+
+//flags for IGCHeapAlloc(...)
+#define GC_ALLOC_FINALIZE 0x1
+#define GC_ALLOC_CONTAINS_REF 0x2
+#define GC_ALLOC_ALIGN8_BIAS 0x4
+#define GC_ALLOC_ALIGN8 0x8
+
+struct ScanContext
+{
+    Thread* thread_under_crawl;
+    int thread_number;
+    uintptr_t stack_limit; // Lowest point on the thread stack that the scanning logic is permitted to read
+    BOOL promotion; //TRUE: Promotion, FALSE: Relocation.
+    BOOL concurrent; //TRUE: concurrent scanning 
+#if CHECK_APP_DOMAIN_LEAKS || defined (FEATURE_APPDOMAIN_RESOURCE_MONITORING) || defined (DACCESS_COMPILE)
+    AppDomain *pCurrentDomain;
+#endif //CHECK_APP_DOMAIN_LEAKS || FEATURE_APPDOMAIN_RESOURCE_MONITORING || DACCESS_COMPILE
+
+#ifndef FEATURE_REDHAWK
+#if defined(GC_PROFILING) || defined (DACCESS_COMPILE)
+    MethodDesc *pMD;
+#endif //GC_PROFILING || DACCESS_COMPILE
+#endif // FEATURE_REDHAWK
+#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
+    EtwGCRootKind dwEtwRootKind;
+#endif // GC_PROFILING || FEATURE_EVENT_TRACE
+    
+    ScanContext()
+    {
+        LIMITED_METHOD_CONTRACT;
+
+        thread_under_crawl = 0;
+        thread_number = -1;
+        stack_limit = 0;
+        promotion = FALSE;
+        concurrent = FALSE;
+#ifdef GC_PROFILING
+        pMD = NULL;
+#endif //GC_PROFILING
+#ifdef FEATURE_EVENT_TRACE
+        dwEtwRootKind = kEtwGCRootKindOther;
+#endif // FEATURE_EVENT_TRACE
+    }
+};
+
+#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
+struct ProfilingScanContext : ScanContext
+{
+    BOOL fProfilerPinned;
+    void * pvEtwContext;
+    void *pHeapId;
+    
+    ProfilingScanContext(BOOL fProfilerPinnedParam) : ScanContext()
+    {
+        LIMITED_METHOD_CONTRACT;
+
+        pHeapId = NULL;
+        fProfilerPinned = fProfilerPinnedParam;
+        pvEtwContext = NULL;
+#ifdef FEATURE_CONSERVATIVE_GC
+        // To not confuse GCScan::GcScanRoots
+        promotion = g_pConfig->GetGCConservative();
+#endif
+    }
+};
+#endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
+
+#endif // _GC_INTERFACE_H_
diff --git a/src/gc/gcpriv.h b/src/gc/gcpriv.h
index 03a23454a0..9fbb289db8 100644
--- a/src/gc/gcpriv.h
+++ b/src/gc/gcpriv.h
@@ -2547,9 +2547,9 @@ protected:
     PER_HEAP
     void descr_generations (BOOL begin_gc_p);
 
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
     PER_HEAP_ISOLATED
     void descr_generations_to_profiler (gen_walk_fn fn, void *context);
+#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
     PER_HEAP
     void record_survived_for_profiler(int condemned_gen_number, uint8_t * first_condemned_address);
     PER_HEAP
@@ -2978,7 +2978,7 @@ protected:
     PER_HEAP
     VOLATILE(int) alloc_context_count;
 #else //MULTIPLE_HEAPS
-#define vm_heap ((GCHeap*) g_pGCHeap)
+#define vm_heap ((GCHeap*) g_theGcHeap)
 #define heap_number (0)
 #endif //MULTIPLE_HEAPS
 
diff --git a/src/gc/gcscan.cpp b/src/gc/gcscan.cpp
index 42989e0414..f22840a262 100644
--- a/src/gc/gcscan.cpp
+++ b/src/gc/gcscan.cpp
@@ -129,7 +129,7 @@ static void CALLBACK CheckPromoted(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t * /*
     LOG((LF_GC, LL_INFO100000, LOG_HANDLE_OBJECT_CLASS("Checking referent of Weak-", pObjRef, "to ", *pObjRef)));
 
     Object **pRef = (Object **)pObjRef;
-    if (!GCHeap::GetGCHeap()->IsPromoted(*pRef))
+    if (!g_theGcHeap->IsPromoted(*pRef))
     {
         LOG((LF_GC, LL_INFO100, LOG_HANDLE_OBJECT_CLASS("Severing Weak-", pObjRef, "to unreachable ", *pObjRef)));
 
@@ -240,14 +240,14 @@ void GCScan::GcRuntimeStructuresValid (BOOL bValid)
 void GCScan::GcDemote (int condemned, int max_gen, ScanContext* sc)
 {
     Ref_RejuvenateHandles (condemned, max_gen, (uintptr_t)sc);
-    if (!GCHeap::IsServerHeap() || sc->thread_number == 0)
+    if (!IsServerHeap() || sc->thread_number == 0)
         GCToEEInterface::SyncBlockCacheDemote(max_gen);
 }
 
 void GCScan::GcPromotionsGranted (int condemned, int max_gen, ScanContext* sc)
 {
     Ref_AgeHandles(condemned, max_gen, (uintptr_t)sc);
-    if (!GCHeap::IsServerHeap() || sc->thread_number == 0)
+    if (!IsServerHeap() || sc->thread_number == 0)
         GCToEEInterface::SyncBlockCachePromotionsGranted(max_gen);
 }
 
diff --git a/src/gc/handletable.cpp b/src/gc/handletable.cpp
index 43b43ffcea..fe184bf2ff 100644
--- a/src/gc/handletable.cpp
+++ b/src/gc/handletable.cpp
@@ -755,7 +755,7 @@ void HndLogSetEvent(OBJECTHANDLE handle, _UNCHECKED_OBJECTREF value)
         uint32_t hndType = HandleFetchType(handle);
         ADIndex appDomainIndex = HndGetHandleADIndex(handle);   
         AppDomain* pAppDomain = SystemDomain::GetAppDomainAtIndex(appDomainIndex);
-        uint32_t generation = value != 0 ? GCHeap::GetGCHeap()->WhichGeneration(value) : 0;
+        uint32_t generation = value != 0 ? g_theGcHeap->WhichGeneration(value) : 0;
         FireEtwSetGCHandle((void*) handle, value, hndType, generation, (int64_t) pAppDomain, GetClrInstanceId());
         FireEtwPrvSetGCHandle((void*) handle, value, hndType, generation, (int64_t) pAppDomain, GetClrInstanceId());
 
@@ -774,14 +774,14 @@ void HndLogSetEvent(OBJECTHANDLE handle, _UNCHECKED_OBJECTREF value)
                     for (size_t i = 0; i < num; i ++)
                     {
                         value = ppObj[i];
-                        uint32_t generation = value != 0 ? GCHeap::GetGCHeap()->WhichGeneration(value) : 0;
+                        uint32_t generation = value != 0 ? g_theGcHeap->WhichGeneration(value) : 0;
                         FireEtwSetGCHandle(overlapped, value, HNDTYPE_PINNED, generation, (int64_t) pAppDomain, GetClrInstanceId());
                     }
                 }
                 else
                 {
                     value = OBJECTREF_TO_UNCHECKED_OBJECTREF(overlapped->m_userObject);
-                    uint32_t generation = value != 0 ? GCHeap::GetGCHeap()->WhichGeneration(value) : 0;
+                    uint32_t generation = value != 0 ? g_theGcHeap->WhichGeneration(value) : 0;
                     FireEtwSetGCHandle(overlapped, value, HNDTYPE_PINNED, generation, (int64_t) pAppDomain, GetClrInstanceId());
                 }
             }
@@ -838,7 +838,7 @@ void HndWriteBarrier(OBJECTHANDLE handle, OBJECTREF objref)
     if (*pClumpAge != 0) // Perf optimization: if clumpAge is 0, nothing more to do
     {
         // find out generation
-        int generation = GCHeap::GetGCHeap()->WhichGeneration(value);
+        int generation = g_theGcHeap->WhichGeneration(value);
         uint32_t uType = HandleFetchType(handle);
 
 #ifndef FEATURE_REDHAWK
diff --git a/src/gc/handletablecore.cpp b/src/gc/handletablecore.cpp
index 5e077de8a2..c6f569d5fa 100644
--- a/src/gc/handletablecore.cpp
+++ b/src/gc/handletablecore.cpp
@@ -14,6 +14,7 @@
 #include "common.h"
 
 #include "gcenv.h"
+#include "gc.h"
 
 #ifndef FEATURE_REDHAWK
 #include "nativeoverlapped.h"
@@ -1111,13 +1112,13 @@ SLOW_PATH:
         // we have the lock held but the part we care about (the async table scan) takes the table lock during
         // a preparation step so we'll be able to complete our segment moves before the async scan has a
         // chance to interfere with us (or vice versa).
-        if (GCHeap::GetGCHeap()->IsConcurrentGCInProgress())
+        if (g_theGcHeap->IsConcurrentGCInProgress())
         {
             // A concurrent GC is in progress so someone might be scanning our segments asynchronously.
             // Release the lock, wait for the GC to complete and try again. The order is important; if we wait
             // before releasing the table lock we can deadlock with an async table scan.
             ch.Release();
-            GCHeap::GetGCHeap()->WaitUntilConcurrentGCComplete();
+            g_theGcHeap->WaitUntilConcurrentGCComplete();
             continue;
         }
 
diff --git a/src/gc/handletablescan.cpp b/src/gc/handletablescan.cpp
index 863b5a52b0..1f58336573 100644
--- a/src/gc/handletablescan.cpp
+++ b/src/gc/handletablescan.cpp
@@ -818,7 +818,7 @@ void BlockResetAgeMapForBlocksWorker(uint32_t *pdwGen, uint32_t dwClumpMask, Sca
             {
                 if (!HndIsNullOrDestroyedHandle(*pValue))
                 {
-                    int thisAge = GCHeap::GetGCHeap()->WhichGeneration(*pValue);
+                    int thisAge = g_theGcHeap->WhichGeneration(*pValue);
                     if (minAge > thisAge)
                         minAge = thisAge;
 
@@ -830,7 +830,7 @@ void BlockResetAgeMapForBlocksWorker(uint32_t *pdwGen, uint32_t dwClumpMask, Sca
                         if (pOverlapped->m_userObject != NULL)
                         {
                             Object * pUserObject = OBJECTREFToObject(pOverlapped->m_userObject);
-                            thisAge = GCHeap::GetGCHeap()->WhichGeneration(pUserObject);
+                            thisAge = g_theGcHeap->WhichGeneration(pUserObject);
                             if (minAge > thisAge)
                                 minAge = thisAge;
                             if (pOverlapped->m_isArray)
@@ -840,7 +840,7 @@ void BlockResetAgeMapForBlocksWorker(uint32_t *pdwGen, uint32_t dwClumpMask, Sca
                                 size_t num = pUserArrayObject->GetNumComponents();
                                 for (size_t i = 0; i < num; i ++)
                                 {
-                                     thisAge = GCHeap::GetGCHeap()->WhichGeneration(pObj[i]);
+                                     thisAge = g_theGcHeap->WhichGeneration(pObj[i]);
                                      if (minAge > thisAge)
                                          minAge = thisAge;
                                  }                                    
@@ -925,10 +925,10 @@ static void VerifyObjectAndAge(_UNCHECKED_OBJECTREF *pValue, _UNCHECKED_OBJECTRE
     UNREFERENCED_PARAMETER(pValue);
     VerifyObject(from, obj);
 
-    int thisAge = GCHeap::GetGCHeap()->WhichGeneration(obj);
+    int thisAge = g_theGcHeap->WhichGeneration(obj);
 
     //debugging code
-    //if (minAge > thisAge && thisAge < GCHeap::GetGCHeap()->GetMaxGeneration())
+    //if (minAge > thisAge && thisAge < g_theGcHeap->GetMaxGeneration())
     //{
     //    if ((*pValue) == obj)
     //        printf("Handle (age %u) %p -> %p (age %u)", minAge, pValue, obj, thisAge);
@@ -946,7 +946,7 @@ static void VerifyObjectAndAge(_UNCHECKED_OBJECTREF *pValue, _UNCHECKED_OBJECTRE
     //    }
     //}
 
-    if (minAge >= GEN_MAX_AGE || (minAge > thisAge && thisAge < static_cast<int>(GCHeap::GetGCHeap()->GetMaxGeneration())))
+    if (minAge >= GEN_MAX_AGE || (minAge > thisAge && thisAge < static_cast<int>(g_theGcHeap->GetMaxGeneration())))
     {
         _ASSERTE(!"Fatal Error in HandleTable.");
         EEPOLICY_HANDLE_FATAL_ERROR(COR_E_EXECUTIONENGINE);
diff --git a/src/gc/objecthandle.cpp b/src/gc/objecthandle.cpp
index 74a8a71c5e..231332a395 100644
--- a/src/gc/objecthandle.cpp
+++ b/src/gc/objecthandle.cpp
@@ -95,7 +95,7 @@ void CALLBACK PromoteRefCounted(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *pExtra
     Object *pOldObj = pObj;
 #endif
 
-    if (!HndIsNullOrDestroyedHandle(pObj) && !GCHeap::GetGCHeap()->IsPromoted(pObj))
+    if (!HndIsNullOrDestroyedHandle(pObj) && !g_theGcHeap->IsPromoted(pObj))
     {
         if (GCToEEInterface::RefCountedHandleCallbacks(pObj))
         {
@@ -186,9 +186,9 @@ void CALLBACK PromoteDependentHandle(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *p
     ScanContext *sc = (ScanContext*)lp1;
     DhContext *pDhContext = Ref_GetDependentHandleContext(sc);
 
-    if (*pObjRef && GCHeap::GetGCHeap()->IsPromoted(*pPrimaryRef))
+    if (*pObjRef && g_theGcHeap->IsPromoted(*pPrimaryRef))
     {
-        if (!GCHeap::GetGCHeap()->IsPromoted(*pSecondaryRef))
+        if (!g_theGcHeap->IsPromoted(*pSecondaryRef))
         {
             LOG((LF_GC|LF_ENC, LL_INFO10000, "\tPromoting secondary " LOG_OBJECT_CLASS(*pSecondaryRef)));
             _ASSERTE(lp2);
@@ -221,7 +221,7 @@ void CALLBACK ClearDependentHandle(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *pEx
     LOG((LF_GC|LF_ENC, LL_INFO1000, LOG_HANDLE_OBJECT_CLASS("\tPrimary:\t", pPrimaryRef, "to ", *pPrimaryRef)));
     LOG((LF_GC|LF_ENC, LL_INFO1000, LOG_HANDLE_OBJECT_CLASS("\tSecondary\t", pSecondaryRef, "to ", *pSecondaryRef)));
 
-    if (!GCHeap::GetGCHeap()->IsPromoted(*pPrimaryRef))
+    if (!g_theGcHeap->IsPromoted(*pPrimaryRef))
     {
         LOG((LF_GC|LF_ENC, LL_INFO1000, "\tunreachable ", LOG_OBJECT_CLASS(*pPrimaryRef)));
         LOG((LF_GC|LF_ENC, LL_INFO1000, "\tunreachable ", LOG_OBJECT_CLASS(*pSecondaryRef)));
@@ -230,7 +230,7 @@ void CALLBACK ClearDependentHandle(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *pEx
     }
     else
     {
-        _ASSERTE(GCHeap::GetGCHeap()->IsPromoted(*pSecondaryRef));
+        _ASSERTE(g_theGcHeap->IsPromoted(*pSecondaryRef));
         LOG((LF_GC|LF_ENC, LL_INFO10000, "\tPrimary is reachable " LOG_OBJECT_CLASS(*pPrimaryRef)));
         LOG((LF_GC|LF_ENC, LL_INFO10000, "\tSecondary is reachable " LOG_OBJECT_CLASS(*pSecondaryRef)));
     }
@@ -330,7 +330,7 @@ void CALLBACK CheckPromoted(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *pExtraInfo
     LOG((LF_GC, LL_INFO100000, LOG_HANDLE_OBJECT_CLASS("Checking referent of Weak-", pObjRef, "to ", *pObjRef)));
 
     Object **ppRef = (Object **)pObjRef;
-    if (!GCHeap::GetGCHeap()->IsPromoted(*ppRef))
+    if (!g_theGcHeap->IsPromoted(*ppRef))
     {
         LOG((LF_GC, LL_INFO100, LOG_HANDLE_OBJECT_CLASS("Severing Weak-", pObjRef, "to unreachable ", *pObjRef)));
 
@@ -355,9 +355,9 @@ void CALLBACK CalculateSizedRefSize(_UNCHECKED_OBJECTREF *pObjRef, uintptr_t *pE
     ScanContext* sc = (ScanContext *)lp1;
     promote_func* callback = (promote_func*) lp2;
 
-    size_t sizeBegin = GCHeap::GetGCHeap()->GetPromotedBytes(sc->thread_number);
+    size_t sizeBegin = g_theGcHeap->GetPromotedBytes(sc->thread_number);
     callback(ppSizedRef, (ScanContext *)lp1, 0);
-    size_t sizeEnd = GCHeap::GetGCHeap()->GetPromotedBytes(sc->thread_number);
+    size_t sizeEnd = g_theGcHeap->GetPromotedBytes(sc->thread_number);
     *pSize = sizeEnd - sizeBegin;
 }
 
@@ -583,10 +583,10 @@ int getNumberOfSlots()
 {
     WRAPPER_NO_CONTRACT;
 
-    // when Ref_Initialize called, GCHeap::GetNumberOfHeaps() is still 0, so use #procs as a workaround
+    // when Ref_Initialize called, IGCHeap::GetNumberOfHeaps() is still 0, so use #procs as a workaround
     // it is legal since even if later #heaps < #procs we create handles by thread home heap
     // and just have extra unused slots in HandleTableBuckets, which does not take a lot of space
-    if (!GCHeap::IsServerHeap())
+    if (!IsServerHeap())
         return 1;
 
 #ifdef FEATURE_REDHAWK
@@ -874,7 +874,7 @@ int getSlotNumber(ScanContext* sc)
 {
     WRAPPER_NO_CONTRACT;
 
-    return (GCHeap::IsServerHeap() ? sc->thread_number : 0);
+    return (IsServerHeap() ? sc->thread_number : 0);
 }
 
 // <TODO> - reexpress as complete only like hndtable does now!!! -fmh</REVISIT_TODO>
@@ -1152,7 +1152,7 @@ void Ref_TraceNormalRoots(uint32_t condemned, uint32_t maxgen, ScanContext* sc,
     // promote objects pointed to by strong handles
     // during ephemeral GCs we also want to promote the ones pointed to by sizedref handles.
     uint32_t types[2] = {HNDTYPE_STRONG, HNDTYPE_SIZEDREF};
-    uint32_t uTypeCount = (((condemned >= maxgen) && !GCHeap::GetGCHeap()->IsConcurrentGCInProgress()) ? 1 : _countof(types));
+    uint32_t uTypeCount = (((condemned >= maxgen) && !g_theGcHeap->IsConcurrentGCInProgress()) ? 1 : _countof(types));
     uint32_t flags = (sc->concurrent) ? HNDGCF_ASYNC : HNDGCF_NORMAL;
 
     HandleTableMap *walk = &g_HandleTableMap;
@@ -1454,7 +1454,7 @@ void ScanSizedRefByAD(uint32_t maxgen, HANDLESCANPROC scanProc, ScanContext* sc,
     HandleTableMap *walk = &g_HandleTableMap;
     uint32_t type = HNDTYPE_SIZEDREF;
     int uCPUindex = getSlotNumber(sc);
-    int n_slots = GCHeap::GetGCHeap()->GetNumberOfHeaps();
+    int n_slots = g_theGcHeap->GetNumberOfHeaps();
 
     while (walk)
     {
@@ -1574,11 +1574,11 @@ void Ref_UpdatePointers(uint32_t condemned, uint32_t maxgen, ScanContext* sc, Re
     // @TODO cwb: wait for compelling performance measurements.</REVISIT_TODO>
     BOOL bDo = TRUE;
 
-    if (GCHeap::IsServerHeap()) 
+    if (IsServerHeap()) 
     {
         bDo = (Interlocked::Increment(&uCount) == 1);
-        Interlocked::CompareExchange (&uCount, 0, GCHeap::GetGCHeap()->GetNumberOfHeaps());
-        _ASSERTE (uCount <= GCHeap::GetGCHeap()->GetNumberOfHeaps());
+        Interlocked::CompareExchange (&uCount, 0, g_theGcHeap->GetNumberOfHeaps());
+        _ASSERTE (uCount <= g_theGcHeap->GetNumberOfHeaps());
     }
 
     if (bDo)   
@@ -1906,9 +1906,9 @@ int GetCurrentThreadHomeHeapNumber()
 {
     WRAPPER_NO_CONTRACT;
 
-    if (!GCHeap::IsGCHeapInitialized())
+    if (g_theGcHeap == nullptr)
         return 0;
-    return GCHeap::GetGCHeap()->GetHomeHeapNumber();
+    return g_theGcHeap->GetHomeHeapNumber();
 }
 
 bool HandleTableBucket::Contains(OBJECTHANDLE handle)
@@ -1921,7 +1921,7 @@ bool HandleTableBucket::Contains(OBJECTHANDLE handle)
     }
     
     HHANDLETABLE hTable = HndGetHandleTable(handle);
-    for (int uCPUindex=0; uCPUindex < GCHeap::GetGCHeap()->GetNumberOfHeaps(); uCPUindex++)
+    for (int uCPUindex=0; uCPUindex < g_theGcHeap->GetNumberOfHeaps(); uCPUindex++)
     {
         if (hTable == this->pTable[uCPUindex]) 
         {
diff --git a/src/gc/sample/GCSample.cpp b/src/gc/sample/GCSample.cpp
index 7e07834ced..c242f08cac 100644
--- a/src/gc/sample/GCSample.cpp
+++ b/src/gc/sample/GCSample.cpp
@@ -68,7 +68,7 @@ Object * AllocateObject(MethodTable * pMT)
     }
     else
     {
-        pObject = GCHeap::GetGCHeap()->Alloc(acontext, size, 0);
+        pObject = g_theGcHeap->Alloc(acontext, size, 0);
         if (pObject == NULL)
             return NULL;
     }
@@ -137,7 +137,7 @@ int __cdecl main(int argc, char* argv[])
     //
     // Initialize GC heap
     //
-    GCHeap *pGCHeap = GCHeap::CreateGCHeap();
+    IGCHeap *pGCHeap = InitializeGarbageCollector(nullptr);
     if (!pGCHeap)
         return -1;
 
diff --git a/src/gc/sample/gcenv.ee.cpp b/src/gc/sample/gcenv.ee.cpp
index 330564a380..05359d954c 100644
--- a/src/gc/sample/gcenv.ee.cpp
+++ b/src/gc/sample/gcenv.ee.cpp
@@ -131,7 +131,7 @@ void ThreadStore::AttachCurrentThread()
 
 void GCToEEInterface::SuspendEE(GCToEEInterface::SUSPEND_REASON reason)
 {
-    GCHeap::GetGCHeap()->SetGCInProgress(TRUE);
+    g_theGcHeap->SetGCInProgress(TRUE);
 
     // TODO: Implement
 }
@@ -140,7 +140,7 @@ void GCToEEInterface::RestartEE(bool bFinishedGC)
 {
     // TODO: Implement
 
-    GCHeap::GetGCHeap()->SetGCInProgress(FALSE);
+    g_theGcHeap->SetGCInProgress(FALSE);
 }
 
 void GCToEEInterface::GcScanRoots(promote_func* fn,  int condemned, int max_gen, ScanContext* sc)
@@ -184,7 +184,7 @@ void GCToEEInterface::DisablePreemptiveGC(Thread * pThread)
     pThread->DisablePreemptiveGC();
 }
 
-alloc_context * GCToEEInterface::GetAllocContext(Thread * pThread)
+gc_alloc_context * GCToEEInterface::GetAllocContext(Thread * pThread)
 {
     return pThread->GetAllocContext();
 }
diff --git a/src/gc/sample/gcenv.h b/src/gc/sample/gcenv.h
index d560789751..3f43a3ffeb 100644
--- a/src/gc/sample/gcenv.h
+++ b/src/gc/sample/gcenv.h
@@ -64,6 +64,9 @@
 
 #define LOG(x)
 
+#define SVAL_IMPL_INIT(type, cls, var, init) \
+    type cls::var = init
+
 //
 // Thread
 //