Bug 1619229, part 1 - Thread GC reason into the GC callback. r=sfink

Differential Revision: https://phabricator.services.mozilla.com/D65647

--HG--
extra : moz-landing-system : lando

js/public/GCAPI.h

@@ -356,8 +356,6 @@ typedef void (*JSTraceDataOp)(JSTracer* trc, void* data);
 
 typedef enum JSGCStatus { JSGC_BEGIN, JSGC_END } JSGCStatus;
 
-typedef void (*JSGCCallback)(JSContext* cx, JSGCStatus status, void* data);
-
 typedef void (*JSObjectsTenuredCallback)(JSContext* cx, void* data);
 
 typedef enum JSFinalizeStatus {
@@ -957,6 +955,9 @@ extern JS_FRIEND_API void NotifyGCRootsRemoved(JSContext* cx);
 
 } /* namespace JS */
 
+typedef void (*JSGCCallback)(JSContext* cx, JSGCStatus status,
+                             JS::GCReason reason, void* data);
+
 /**
  * Register externally maintained GC roots.
  *

js/src/builtin/TestingFunctions.cpp

@@ -4595,7 +4595,8 @@ struct MajorGC {
   int32_t phases;
 };
 
-static void majorGC(JSContext* cx, JSGCStatus status, void* data) {
+static void majorGC(JSContext* cx, JSGCStatus status, JS::GCReason reason,
+                    void* data) {
   auto info = static_cast<MajorGC*>(data);
   if (!(info->phases & (1 << status))) {
     return;
@@ -4614,7 +4615,8 @@ struct MinorGC {
   bool active;
 };
 
-static void minorGC(JSContext* cx, JSGCStatus status, void* data) {
+static void minorGC(JSContext* cx, JSGCStatus status, JS::GCReason reason,
+                    void* data) {
   auto info = static_cast<MinorGC*>(data);
   if (!(info->phases & (1 << status))) {
     return;
@@ -4633,7 +4635,8 @@ static void minorGC(JSContext* cx, JSGCStatus status, void* data) {
 static MajorGC majorGCInfo;
 static MinorGC minorGCInfo;
 
-static void enterNullRealm(JSContext* cx, JSGCStatus status, void* data) {
+static void enterNullRealm(JSContext* cx, JSGCStatus status,
+                           JS::GCReason reason, void* data) {
   JSAutoNullableRealm enterRealm(cx, nullptr);
 }
 

js/src/gc/GC.cpp

@@ -1522,10 +1522,10 @@ void GCRuntime::setGCCallback(JSGCCallback callback, void* data) {
   gcCallback.ref() = {callback, data};
 }
 
-void GCRuntime::callGCCallback(JSGCStatus status) const {
+void GCRuntime::callGCCallback(JSGCStatus status, JS::GCReason reason) const {
   const auto& callback = gcCallback.ref();
   MOZ_ASSERT(callback.op);
-  callback.op(rt->mainContextFromOwnThread(), status, callback.data);
+  callback.op(rt->mainContextFromOwnThread(), status, reason, callback.data);
 }
 
 void GCRuntime::setObjectsTenuredCallback(JSObjectsTenuredCallback callback,
@@ -6877,15 +6877,17 @@ static void UnscheduleZones(GCRuntime* gc) {
 
 class js::gc::AutoCallGCCallbacks {
   GCRuntime& gc_;
+  JS::GCReason reason_;
 
  public:
-  explicit AutoCallGCCallbacks(GCRuntime& gc) : gc_(gc) {
-    gc_.maybeCallGCCallback(JSGC_BEGIN);
+  explicit AutoCallGCCallbacks(GCRuntime& gc, JS::GCReason reason)
+      : gc_(gc), reason_(reason) {
+    gc_.maybeCallGCCallback(JSGC_BEGIN, reason);
   }
-  ~AutoCallGCCallbacks() { gc_.maybeCallGCCallback(JSGC_END); }
+  ~AutoCallGCCallbacks() { gc_.maybeCallGCCallback(JSGC_END, reason_); }
 };
 
-void GCRuntime::maybeCallGCCallback(JSGCStatus status) {
+void GCRuntime::maybeCallGCCallback(JSGCStatus status, JS::GCReason reason) {
   if (!gcCallback.ref().op) {
     return;
   }
@@ -6903,7 +6905,7 @@ void GCRuntime::maybeCallGCCallback(JSGCStatus status) {
 
   gcCallbackDepth++;
 
-  callGCCallback(status);
+  callGCCallback(status, reason);
 
   MOZ_ASSERT(gcCallbackDepth != 0);
   gcCallbackDepth--;
@@ -6932,7 +6934,7 @@ MOZ_NEVER_INLINE GCRuntime::IncrementalResult GCRuntime::gcCycle(
   MOZ_ASSERT(!rt->mainContextFromOwnThread()->suppressGC);
 
   // Note that GC callbacks are allowed to re-enter GC.
-  AutoCallGCCallbacks callCallbacks(*this);
+  AutoCallGCCallbacks callCallbacks(*this, reason);
 
   // Increase slice budget for long running collections before it is recorded by
   // AutoGCSlice.

js/src/gc/GCRuntime.h

@@ -413,7 +413,7 @@ class GCRuntime {
   void updateMemoryCountersOnGCStart();
 
   void setGCCallback(JSGCCallback callback, void* data);
-  void callGCCallback(JSGCStatus status) const;
+  void callGCCallback(JSGCStatus status, JS::GCReason reason) const;
   void setObjectsTenuredCallback(JSObjectsTenuredCallback callback, void* data);
   void callObjectsTenuredCallback();
   MOZ_MUST_USE bool addFinalizeCallback(JSFinalizeCallback callback,
@@ -667,7 +667,7 @@ class GCRuntime {
                                                  SliceBudget& budget);
 
   friend class AutoCallGCCallbacks;
-  void maybeCallGCCallback(JSGCStatus status);
+  void maybeCallGCCallback(JSGCStatus status, JS::GCReason reason);
 
   void purgeRuntime();
   MOZ_MUST_USE bool beginMarkPhase(JS::GCReason reason, AutoGCSession& session);

xpcom/base/CycleCollectedJSRuntime.cpp

@@ -818,13 +818,14 @@ void CycleCollectedJSRuntime::TraceGrayJS(JSTracer* aTracer, void* aData) {
 
 /* static */
 void CycleCollectedJSRuntime::GCCallback(JSContext* aContext,
-                                         JSGCStatus aStatus, void* aData) {
+                                         JSGCStatus aStatus,
+                                         JS::GCReason aReason, void* aData) {
   CycleCollectedJSRuntime* self = static_cast<CycleCollectedJSRuntime*>(aData);
 
   MOZ_ASSERT(CycleCollectedJSContext::Get()->Context() == aContext);
   MOZ_ASSERT(CycleCollectedJSContext::Get()->Runtime() == self);
 
-  self->OnGC(aContext, aStatus);
+  self->OnGC(aContext, aStatus, aReason);
 }
 
 /* static */
@@ -1379,7 +1380,8 @@ void CycleCollectedJSRuntime::AnnotateAndSetOutOfMemory(OOMState* aStatePtr,
       annotation, nsDependentCString(OOMStateToString(aNewState)));
 }
 
-void CycleCollectedJSRuntime::OnGC(JSContext* aContext, JSGCStatus aStatus) {
+void CycleCollectedJSRuntime::OnGC(JSContext* aContext, JSGCStatus aStatus,
+                                   JS::GCReason aReason) {
   switch (aStatus) {
     case JSGC_BEGIN:
       nsCycleCollector_prepareForGarbageCollection();

xpcom/base/CycleCollectedJSRuntime.h

@@ -148,7 +148,8 @@ class CycleCollectedJSRuntime {
 
   static void TraceBlackJS(JSTracer* aTracer, void* aData);
   static void TraceGrayJS(JSTracer* aTracer, void* aData);
-  static void GCCallback(JSContext* aContext, JSGCStatus aStatus, void* aData);
+  static void GCCallback(JSContext* aContext, JSGCStatus aStatus,
+                         JS::GCReason aReason, void* aData);
   static void GCSliceCallback(JSContext* aContext, JS::GCProgress aProgress,
                               const JS::GCDescription& aDesc);
   static void GCNurseryCollectionCallback(JSContext* aContext,
@@ -208,7 +209,7 @@ class CycleCollectedJSRuntime {
   void SetLargeAllocationFailure(OOMState aNewState);
 
   void AnnotateAndSetOutOfMemory(OOMState* aStatePtr, OOMState aNewState);
-  void OnGC(JSContext* aContext, JSGCStatus aStatus);
+  void OnGC(JSContext* aContext, JSGCStatus aStatus, JS::GCReason aReason);
   void OnOutOfMemory();
   void OnLargeAllocationFailure();