Move NotifyUnload method

(cherry picked from commit 97ee0de)

Author: alexey-zakharov

src/coreclr/vm/ceeload.cpp

@@ -1957,9 +1957,9 @@ void Module::FreeClassTables()
 
         if (pMT != NULL && pMT->IsRestored())
         {
-            EEClass::NotifyUnload(pMT, true);
-            pMT->GetClass()->Destruct(pMT);
-            EEClass::NotifyUnload(pMT, false);
+            ClassLoader::NotifyUnload(pMT, true);
+            pMT->GetClass()->Destruct();
+            ClassLoader::NotifyUnload(pMT, false);
         }
     }
 
@@ -1980,15 +1980,15 @@ void Module::FreeClassTables()
                     continue;
 
                 MethodTable * pMT = th.AsMethodTable();
-                EEClass::NotifyUnload(pMT, true);
+                ClassLoader::NotifyUnload(pMT, true);
 
                 // We need to call destruct on instances of EEClass whose "canonical" dependent lives in this table
                 if (pMT->IsCanonicalMethodTable())
                 {
-                    pMT->GetClass()->Destruct(pMT);
+                    pMT->GetClass()->Destruct();
                 }
 
-                EEClass::NotifyUnload(pMT, false);
+                ClassLoader::NotifyUnload(pMT, false);
             }
         }
     }

src/coreclr/vm/class.cpp

@@ -73,14 +73,13 @@ void *EEClass::operator new(
 }
 
 //*******************************************************************************
-void EEClass::Destruct(MethodTable * pOwningMT)
+void EEClass::Destruct()
 {
     CONTRACTL
     {
         NOTHROW;
         GC_TRIGGERS;
         FORBID_FAULT;
-        PRECONDITION(pOwningMT != NULL);
     }
     CONTRACTL_END
 
@@ -137,68 +136,6 @@ void EEClass::Destruct(MethodTable * pOwningMT)
 #endif // FEATURE_COMINTEROP
 }
 
-//*******************************************************************************
-void EEClass::NotifyUnload(MethodTable* pMT, bool unloadStarted)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_TRIGGERS;
-        MODE_ANY;
-        FORBID_FAULT;
-        PRECONDITION(pMT != NULL);
-    }
-    CONTRACTL_END
-
-#ifdef PROFILING_SUPPORTED
-    // If profiling, then notify the class is getting unloaded.
-    {
-        BEGIN_PROFILER_CALLBACK(CORProfilerTrackClasses());
-        {
-            if (pMT->ContainsGenericVariables() || pMT->IsArray())
-            {
-                // Don't notify the profiler about types with unbound variables or arrays.
-                // See ClassLoadStarted callback for more details.
-                return;
-            }
-        
-            // Calls to the profiler callback may throw, or otherwise fail, if
-            // the profiler AVs/throws an unhandled exception/etc. We don't want
-            // those failures to affect the runtime, so we'll ignore them.
-            //
-            // Note that the profiler callback may turn around and make calls into
-            // the profiling runtime that may throw. This try/catch block doesn't
-            // protect the profiler against such failures. To protect the profiler
-            // against that, we will need try/catch blocks around all calls into the
-            // profiling API.
-            //
-            // (Bug #26467)
-            //
-
-            FAULT_NOT_FATAL();
-
-            EX_TRY
-            {
-                GCX_PREEMP();
-
-                if (unloadStarted)
-                    (&g_profControlBlock)->ClassUnloadStarted((ClassID) pMT);
-                else
-                    (&g_profControlBlock)->ClassUnloadFinished((ClassID) pMT, S_OK);
-            }
-            EX_CATCH
-            {
-                // The exception here came from the profiler itself. We'll just
-                // swallow the exception, since we don't want the profiler to bring
-                // down the runtime.
-            }
-            EX_END_CATCH(RethrowTerminalExceptions);
-        }
-        END_PROFILER_CALLBACK();
-    }
-#endif // PROFILING_SUPPORTED
-}
-
 //*******************************************************************************
 /*static*/ EEClass *
 EEClass::CreateMinimalClass(LoaderHeap *pHeap, AllocMemTracker *pamTracker)

src/coreclr/vm/class.h

@@ -773,10 +773,7 @@ class EEClass // DO NOT CREATE A NEW EEClass USING NEW!
 
 #ifndef DACCESS_COMPILE
     void *operator new(size_t size, LoaderHeap* pHeap, AllocMemTracker *pamTracker);
-    void Destruct(MethodTable * pMT);
-
-    // Notify profiler about class unload
-    static void NotifyUnload(MethodTable* pMT, bool unloadStarted);
+    void Destruct();
 
     static EEClass * CreateMinimalClass(LoaderHeap *pHeap, AllocMemTracker *pamTracker);
 #endif // !DACCESS_COMPILE

src/coreclr/vm/clsload.cpp

@@ -2906,7 +2906,7 @@ TypeHandle ClassLoader::DoIncrementalLoad(TypeKey *pTypeKey, TypeHandle typeHnd,
 
     if (typeHnd.GetLoadLevel() >= CLASS_LOAD_EXACTPARENTS)
     {
-        Notify(typeHnd);
+        NotifyLoad(typeHnd);
     }
 
     return typeHnd;
@@ -3109,7 +3109,7 @@ TypeHandle ClassLoader::PublishType(TypeKey *pTypeKey, TypeHandle typeHnd)
 // Notify profiler and debugger that a type load has completed
 // Also adjust perf counters
 /*static*/
-void ClassLoader::Notify(TypeHandle typeHnd)
+void ClassLoader::NotifyLoad(TypeHandle typeHnd)
 {
     CONTRACTL
     {
@@ -3177,6 +3177,68 @@ void ClassLoader::Notify(TypeHandle typeHnd)
     }
 }
 
+// Notify profiler that a MethodTable is being unloaded
+/*static*/
+void ClassLoader::NotifyUnload(MethodTable* pMT, bool unloadStarted)
+{
+    CONTRACTL
+    {
+        NOTHROW;
+        GC_TRIGGERS;
+        MODE_ANY;
+        FORBID_FAULT;
+        PRECONDITION(pMT != NULL);
+    }
+    CONTRACTL_END
+
+#ifdef PROFILING_SUPPORTED
+    // If profiling, then notify the class is getting unloaded.
+    {
+        BEGIN_PROFILER_CALLBACK(CORProfilerTrackClasses());
+        {
+            if (pMT->ContainsGenericVariables() || pMT->IsArray())
+            {
+                // Don't notify the profiler about types with unbound variables or arrays.
+                // See ClassLoadStarted callback for more details.
+                return;
+            }
+        
+            // Calls to the profiler callback may throw, or otherwise fail, if
+            // the profiler AVs/throws an unhandled exception/etc. We don't want
+            // those failures to affect the runtime, so we'll ignore them.
+            //
+            // Note that the profiler callback may turn around and make calls into
+            // the profiling runtime that may throw. This try/catch block doesn't
+            // protect the profiler against such failures. To protect the profiler
+            // against that, we will need try/catch blocks around all calls into the
+            // profiling API.
+            //
+            // (Bug #26467)
+            //
+
+            FAULT_NOT_FATAL();
+
+            EX_TRY
+            {
+                GCX_PREEMP();
+
+                if (unloadStarted)
+                    (&g_profControlBlock)->ClassUnloadStarted((ClassID) pMT);
+                else
+                    (&g_profControlBlock)->ClassUnloadFinished((ClassID) pMT, S_OK);
+            }
+            EX_CATCH
+            {
+                // The exception here came from the profiler itself. We'll just
+                // swallow the exception, since we don't want the profiler to bring
+                // down the runtime.
+            }
+            EX_END_CATCH(RethrowTerminalExceptions);
+        }
+        END_PROFILER_CALLBACK();
+    }
+#endif // PROFILING_SUPPORTED
+}
 
 //-----------------------------------------------------------------------------
 // Common helper for LoadTypeHandleForTypeKey and LoadTypeHandleForTypeKeyNoLock.

src/coreclr/vm/clsload.hpp

@@ -951,7 +951,9 @@ class ClassLoader
 
     // Notify profiler and debugger that a type load has completed
     // Also update perf counters
-    static void Notify(TypeHandle typeHnd);
+    static void NotifyLoad(TypeHandle typeHnd);
+    // Notify profiler that a MethodTable is being unloaded
+    static void NotifyUnload(MethodTable* pMT, bool unloadStarted);
 
     // Phase CLASS_LOAD_EXACTPARENTS of class loading
     // Load exact parents and interfaces and dependent structures (generics dictionary, vtable fixes)