Bug 1429727 - Rename js::ThreadLocalData to prevent confusion with mozilla::ThreadLocal r=lth
authorJon Coppeard <jcoppeard@mozilla.com>
Tue, 17 Apr 2018 15:32:02 +0200
changeset 414106 a1ceebb96b78f8cfc82ad4d7fbcc972205213ce9
parent 414105 079bd3d58e34e91d002f906748be9f62f0aec318
child 414107 af53333e6e32bf01bfe243d10ba22b017eb9e0ad
push id33858
push userncsoregi@mozilla.com
push dateTue, 17 Apr 2018 21:55:44 +0000
treeherdermozilla-central@d6eb5597d744 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerslth
bugs1429727
milestone61.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1429727 - Rename js::ThreadLocalData to prevent confusion with mozilla::ThreadLocal r=lth
js/src/builtin/AtomicsObject.h
js/src/threading/ProtectedData.h
js/src/vm/JSContext.h
js/src/wasm/WasmStubs.cpp
--- a/js/src/builtin/AtomicsObject.h
+++ b/js/src/builtin/AtomicsObject.h
@@ -134,17 +134,17 @@ public:
     FutexState state_;
 
     // Shared futex lock for all runtimes.  We can perhaps do better,
     // but any lock will need to be per-domain (consider SharedWorker)
     // or coarser.
     static mozilla::Atomic<js::Mutex*> lock_;
 
     // A flag that controls whether waiting is allowed.
-    ThreadLocalData<bool> canWait_;
+    ThreadData<bool> canWait_;
 };
 
 JSObject*
 InitAtomicsClass(JSContext* cx, Handle<GlobalObject*> global);
 
 // Go to sleep if the int32_t value at the given address equals `value`.
 MOZ_MUST_USE FutexThread::WaitResult
 atomics_wait_impl(JSContext* cx, SharedArrayRawBuffer* sarb, uint32_t byteOffset, int32_t value,
--- a/js/src/threading/ProtectedData.h
+++ b/js/src/threading/ProtectedData.h
@@ -184,17 +184,17 @@ class CheckThreadLocal
     {}
 
     void check() const;
 #endif
 };
 
 // Data which may only be accessed by the thread on which it is created.
 template <typename T>
-using ThreadLocalData = ProtectedDataNoCheckArgs<CheckThreadLocal, T>;
+using ThreadData = ProtectedDataNoCheckArgs<CheckThreadLocal, T>;
 
 // Enum describing which helper threads (GC tasks or Ion compilations) may
 // access data even though they do not have exclusive access to any zone.
 enum class AllowedHelperThread
 {
     None,
     GCTask,
     IonCompile,
--- a/js/src/vm/JSContext.h
+++ b/js/src/vm/JSContext.h
@@ -106,24 +106,24 @@ struct JSContext : public JS::RootingCon
 
     bool init(js::ContextKind kind);
 
   private:
     js::UnprotectedData<JSRuntime*> runtime_;
     js::WriteOnceData<js::ContextKind> kind_;
 
     // The thread on which this context is running if this is not the main thread.
-    js::ThreadLocalData<js::HelperThread*> helperThread_;
+    js::ThreadData<js::HelperThread*> helperThread_;
 
     friend class js::gc::AutoSuppressNurseryCellAlloc;
-    js::ThreadLocalData<size_t> nurserySuppressions_;
+    js::ThreadData<size_t> nurserySuppressions_;
 
-    js::ThreadLocalData<JS::ContextOptions> options_;
+    js::ThreadData<JS::ContextOptions> options_;
 
-    js::ThreadLocalData<js::gc::ArenaLists*> arenas_;
+    js::ThreadData<js::gc::ArenaLists*> arenas_;
 
   public:
     // This is used by helper threads to change the runtime their context is
     // currently operating on.
     void setRuntime(JSRuntime* rt);
 
     bool isMainThreadContext() const { return kind_ == js::ContextKind::MainThread; }
 
@@ -190,17 +190,17 @@ struct JSContext : public JS::RootingCon
      * Compartments should be entered/left in a LIFO fasion. The depth of this
      * enter/leave stack is maintained by enterCompartmentDepth_ and queried by
      * hasEnteredCompartment.
      *
      * To enter a compartment, code should prefer using AutoCompartment over
      * manually calling cx->enterCompartment/leaveCompartment.
      */
   protected:
-    js::ThreadLocalData<unsigned> enterCompartmentDepth_;
+    js::ThreadData<unsigned> enterCompartmentDepth_;
 
     inline void setCompartment(JSCompartment* comp,
                                const js::AutoLockForExclusiveAccess* maybeLock = nullptr);
   public:
     bool hasEnteredCompartment() const {
         return enterCompartmentDepth_ > 0;
     }
 #ifdef DEBUG
@@ -330,26 +330,26 @@ struct JSContext : public JS::RootingCon
 
     mozilla::GenericErrorResult<JS::OOM&> alreadyReportedOOM();
     mozilla::GenericErrorResult<JS::Error&> alreadyReportedError();
 
     /*
      * Points to the most recent JitActivation pushed on the thread.
      * See JitActivation constructor in vm/Stack.cpp
      */
-    js::ThreadLocalData<js::jit::JitActivation*> jitActivation;
+    js::ThreadData<js::jit::JitActivation*> jitActivation;
 
     // Information about the heap allocated backtrack stack used by RegExp JIT code.
-    js::ThreadLocalData<js::irregexp::RegExpStack> regexpStack;
+    js::ThreadData<js::irregexp::RegExpStack> regexpStack;
 
     /*
      * Points to the most recent activation running on the thread.
      * See Activation comment in vm/Stack.h.
      */
-    js::ThreadLocalData<js::Activation*> activation_;
+    js::ThreadData<js::Activation*> activation_;
 
     /*
      * Points to the most recent profiling activation running on the
      * thread.
      */
     js::Activation* volatile profilingActivation_;
 
   public:
@@ -374,128 +374,128 @@ struct JSContext : public JS::RootingCon
 #ifdef DEBUG
     static size_t offsetOfInUnsafeCallWithABI() {
         return offsetof(JSContext, inUnsafeCallWithABI);
     }
 #endif
 
   private:
     /* Space for interpreter frames. */
-    js::ThreadLocalData<js::InterpreterStack> interpreterStack_;
+    js::ThreadData<js::InterpreterStack> interpreterStack_;
 
   public:
     js::InterpreterStack& interpreterStack() {
         return interpreterStack_.ref();
     }
 
     /* Base address of the native stack for the current thread. */
     const uintptr_t     nativeStackBase;
 
     /* The native stack size limit that runtime should not exceed. */
-    js::ThreadLocalData<size_t> nativeStackQuota[JS::StackKindCount];
+    js::ThreadData<size_t> nativeStackQuota[JS::StackKindCount];
 
   public:
     /* If non-null, report JavaScript entry points to this monitor. */
-    js::ThreadLocalData<JS::dbg::AutoEntryMonitor*> entryMonitor;
+    js::ThreadData<JS::dbg::AutoEntryMonitor*> entryMonitor;
 
     /*
      * Stack of debuggers that currently disallow debuggee execution.
      *
      * When we check for NX we are inside the debuggee compartment, and thus a
      * stack of Debuggers that have prevented execution need to be tracked to
      * enter the correct Debugger compartment to report the error.
      */
-    js::ThreadLocalData<js::EnterDebuggeeNoExecute*> noExecuteDebuggerTop;
+    js::ThreadData<js::EnterDebuggeeNoExecute*> noExecuteDebuggerTop;
 
-    js::ThreadLocalData<js::ActivityCallback> activityCallback;
-    js::ThreadLocalData<void*>                activityCallbackArg;
+    js::ThreadData<js::ActivityCallback> activityCallback;
+    js::ThreadData<void*>                activityCallbackArg;
     void triggerActivityCallback(bool active);
 
     /* The request depth for this thread. */
-    js::ThreadLocalData<unsigned> requestDepth;
+    js::ThreadData<unsigned> requestDepth;
 
 #ifdef DEBUG
-    js::ThreadLocalData<unsigned> checkRequestDepth;
-    js::ThreadLocalData<uint32_t> inUnsafeCallWithABI;
-    js::ThreadLocalData<bool> hasAutoUnsafeCallWithABI;
+    js::ThreadData<unsigned> checkRequestDepth;
+    js::ThreadData<uint32_t> inUnsafeCallWithABI;
+    js::ThreadData<bool> hasAutoUnsafeCallWithABI;
 #endif
 
 #ifdef JS_SIMULATOR
   private:
-    js::ThreadLocalData<js::jit::Simulator*> simulator_;
+    js::ThreadData<js::jit::Simulator*> simulator_;
   public:
     js::jit::Simulator* simulator() const;
     uintptr_t* addressOfSimulatorStackLimit();
 #endif
 
 #ifdef JS_TRACE_LOGGING
-    js::ThreadLocalData<js::TraceLoggerThread*> traceLogger;
+    js::ThreadData<js::TraceLoggerThread*> traceLogger;
 #endif
 
   private:
     /* Pointer to the current AutoFlushICache. */
-    js::ThreadLocalData<js::jit::AutoFlushICache*> autoFlushICache_;
+    js::ThreadData<js::jit::AutoFlushICache*> autoFlushICache_;
   public:
 
     js::jit::AutoFlushICache* autoFlushICache() const;
     void setAutoFlushICache(js::jit::AutoFlushICache* afc);
 
     // State used by util/DoubleToString.cpp.
-    js::ThreadLocalData<DtoaState*> dtoaState;
+    js::ThreadData<DtoaState*> dtoaState;
 
     // Any GC activity occurring on this thread.
-    js::ThreadLocalData<JS::HeapState> heapState;
+    js::ThreadData<JS::HeapState> heapState;
 
     /*
      * When this flag is non-zero, any attempt to GC will be skipped. It is used
      * to suppress GC when reporting an OOM (see ReportOutOfMemory) and in
      * debugging facilities that cannot tolerate a GC and would rather OOM
      * immediately, such as utilities exposed to GDB. Setting this flag is
      * extremely dangerous and should only be used when in an OOM situation or
      * in non-exposed debugging facilities.
      */
-    js::ThreadLocalData<int32_t> suppressGC;
+    js::ThreadData<int32_t> suppressGC;
 
 #ifdef DEBUG
     // Whether this thread is actively Ion compiling.
-    js::ThreadLocalData<bool> ionCompiling;
+    js::ThreadData<bool> ionCompiling;
 
     // Whether this thread is actively Ion compiling in a context where a minor
     // GC could happen simultaneously. If this is true, this thread cannot use
     // any pointers into the nursery.
-    js::ThreadLocalData<bool> ionCompilingSafeForMinorGC;
+    js::ThreadData<bool> ionCompilingSafeForMinorGC;
 
     // Whether this thread is currently performing GC.  This thread could be the
     // active thread or a helper thread while the active thread is running the
     // collector.
-    js::ThreadLocalData<bool> performingGC;
+    js::ThreadData<bool> performingGC;
 
     // Whether this thread is currently sweeping GC things.  This thread could
     // be the active thread or a helper thread while the active thread is running
     // the mutator.  This is used to assert that destruction of GCPtr only
     // happens when we are sweeping.
-    js::ThreadLocalData<bool> gcSweeping;
+    js::ThreadData<bool> gcSweeping;
 
     // Whether this thread is performing work in the background for a runtime's
     // GCHelperState.
-    js::ThreadLocalData<bool> gcHelperStateThread;
+    js::ThreadData<bool> gcHelperStateThread;
 
     // Whether this thread is currently manipulating possibly-gray GC things.
-    js::ThreadLocalData<size_t> isTouchingGrayThings;
+    js::ThreadData<size_t> isTouchingGrayThings;
 
-    js::ThreadLocalData<size_t> noGCOrAllocationCheck;
-    js::ThreadLocalData<size_t> noNurseryAllocationCheck;
+    js::ThreadData<size_t> noGCOrAllocationCheck;
+    js::ThreadData<size_t> noNurseryAllocationCheck;
 
     /*
      * If this is 0, all cross-compartment proxies must be registered in the
      * wrapper map. This checking must be disabled temporarily while creating
      * new wrappers. When non-zero, this records the recursion depth of wrapper
      * creation.
      */
-    js::ThreadLocalData<uintptr_t> disableStrictProxyCheckingCount;
+    js::ThreadData<uintptr_t> disableStrictProxyCheckingCount;
 
     bool isAllocAllowed() { return noGCOrAllocationCheck == 0; }
     void disallowAlloc() { ++noGCOrAllocationCheck; }
     void allowAlloc() {
         MOZ_ASSERT(!isAllocAllowed());
         --noGCOrAllocationCheck;
     }
 
@@ -511,59 +511,59 @@ struct JSContext : public JS::RootingCon
     void enableStrictProxyChecking() {
         MOZ_ASSERT(disableStrictProxyCheckingCount > 0);
         --disableStrictProxyCheckingCount;
     }
 #endif
 
 #if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
     // We are currently running a simulated OOM test.
-    js::ThreadLocalData<bool> runningOOMTest;
+    js::ThreadData<bool> runningOOMTest;
 #endif
 
     // True if we should assert that
     //     !comp->validAccessPtr || *comp->validAccessPtr
     // is true for every |comp| that we run JS code in.
-    js::ThreadLocalData<unsigned> enableAccessValidation;
+    js::ThreadData<unsigned> enableAccessValidation;
 
     /*
      * Some regions of code are hard for the static rooting hazard analysis to
      * understand. In those cases, we trade the static analysis for a dynamic
      * analysis. When this is non-zero, we should assert if we trigger, or
      * might trigger, a GC.
      */
-    js::ThreadLocalData<int> inUnsafeRegion;
+    js::ThreadData<int> inUnsafeRegion;
 
     // Count of AutoDisableGenerationalGC instances on the thread's stack.
-    js::ThreadLocalData<unsigned> generationalDisabled;
+    js::ThreadData<unsigned> generationalDisabled;
 
     // Some code cannot tolerate compacting GC so it can be disabled temporarily
     // with AutoDisableCompactingGC which uses this counter.
-    js::ThreadLocalData<unsigned> compactingDisabledCount;
+    js::ThreadData<unsigned> compactingDisabledCount;
 
     // Count of AutoKeepAtoms instances on the current thread's stack. When any
     // instances exist, atoms in the runtime will not be collected. Threads
     // parsing off the active thread do not increment this value, but the presence
     // of any such threads also inhibits collection of atoms. We don't scan the
     // stacks of exclusive threads, so we need to avoid collecting their
     // objects in another way. The only GC thing pointers they have are to
     // their exclusive compartment (which is not collected) or to the atoms
     // compartment. Therefore, we avoid collecting the atoms compartment when
     // exclusive threads are running.
-    js::ThreadLocalData<unsigned> keepAtoms;
+    js::ThreadData<unsigned> keepAtoms;
 
     bool canCollectAtoms() const {
         return !keepAtoms && !runtime()->hasHelperThreadZones();
     }
 
   private:
     // Pools used for recycling name maps and vectors when parsing and
     // emitting bytecode. Purged on GC when there are no active script
     // compilations.
-    js::ThreadLocalData<js::frontend::NameCollectionPool> frontendCollectionPool_;
+    js::ThreadData<js::frontend::NameCollectionPool> frontendCollectionPool_;
   public:
 
     js::frontend::NameCollectionPool& frontendCollectionPool() {
         return frontendCollectionPool_.ref();
     }
 
     void verifyIsSafeToGC() {
         MOZ_DIAGNOSTIC_ASSERT(!inUnsafeRegion,
@@ -587,65 +587,65 @@ struct JSContext : public JS::RootingCon
 
 #if defined(XP_DARWIN)
     js::wasm::MachExceptionHandler wasmMachExceptionHandler;
 #endif
 
     /* Temporary arena pool used while compiling and decompiling. */
     static const size_t TEMP_LIFO_ALLOC_PRIMARY_CHUNK_SIZE = 4 * 1024;
   private:
-    js::ThreadLocalData<js::LifoAlloc> tempLifoAlloc_;
+    js::ThreadData<js::LifoAlloc> tempLifoAlloc_;
   public:
     js::LifoAlloc& tempLifoAlloc() { return tempLifoAlloc_.ref(); }
     const js::LifoAlloc& tempLifoAlloc() const { return tempLifoAlloc_.ref(); }
 
-    js::ThreadLocalData<uint32_t> debuggerMutations;
+    js::ThreadData<uint32_t> debuggerMutations;
 
     // Cache for jit::GetPcScript().
-    js::ThreadLocalData<js::jit::PcScriptCache*> ionPcScriptCache;
+    js::ThreadData<js::jit::PcScriptCache*> ionPcScriptCache;
 
   private:
     /* Exception state -- the exception member is a GC root by definition. */
-    js::ThreadLocalData<bool> throwing;            /* is there a pending exception? */
-    js::ThreadLocalData<JS::PersistentRooted<JS::Value>> unwrappedException_; /* most-recently-thrown exception */
+    js::ThreadData<bool> throwing;            /* is there a pending exception? */
+    js::ThreadData<JS::PersistentRooted<JS::Value>> unwrappedException_; /* most-recently-thrown exception */
 
     JS::Value& unwrappedException() {
         if (!unwrappedException_.ref().initialized())
             unwrappedException_.ref().init(this);
         return unwrappedException_.ref().get();
     }
 
     // True if the exception currently being thrown is by result of
     // ReportOverRecursed. See Debugger::slowPathOnExceptionUnwind.
-    js::ThreadLocalData<bool> overRecursed_;
+    js::ThreadData<bool> overRecursed_;
 
     // True if propagating a forced return from an interrupt handler during
     // debug mode.
-    js::ThreadLocalData<bool> propagatingForcedReturn_;
+    js::ThreadData<bool> propagatingForcedReturn_;
 
     // A stack of live iterators that need to be updated in case of debug mode
     // OSR.
-    js::ThreadLocalData<js::jit::DebugModeOSRVolatileJitFrameIter*>
+    js::ThreadData<js::jit::DebugModeOSRVolatileJitFrameIter*>
         liveVolatileJitFrameIter_;
 
   public:
-    js::ThreadLocalData<int32_t> reportGranularity;  /* see vm/Probes.h */
+    js::ThreadData<int32_t> reportGranularity;  /* see vm/Probes.h */
 
-    js::ThreadLocalData<js::AutoResolving*> resolvingList;
+    js::ThreadData<js::AutoResolving*> resolvingList;
 
 #ifdef DEBUG
-    js::ThreadLocalData<js::AutoEnterPolicy*> enteredPolicy;
+    js::ThreadData<js::AutoEnterPolicy*> enteredPolicy;
 #endif
 
     /* True if generating an error, to prevent runaway recursion. */
-    js::ThreadLocalData<bool> generatingError;
+    js::ThreadData<bool> generatingError;
 
   private:
     /* State for object and array toSource conversion. */
-    js::ThreadLocalData<js::AutoCycleDetector::Vector> cycleDetectorVector_;
+    js::ThreadData<js::AutoCycleDetector::Vector> cycleDetectorVector_;
 
   public:
     js::AutoCycleDetector::Vector& cycleDetectorVector() {
         return cycleDetectorVector_.ref();
     }
     const js::AutoCycleDetector::Vector& cycleDetectorVector() const {
         return cycleDetectorVector_.ref();
     }
@@ -661,51 +661,51 @@ struct JSContext : public JS::RootingCon
         return options_.ref();
     }
 
     bool runtimeMatches(JSRuntime* rt) const {
         return runtime_ == rt;
     }
 
     // Number of JS_BeginRequest calls without the corresponding JS_EndRequest.
-    js::ThreadLocalData<unsigned> outstandingRequests;
+    js::ThreadData<unsigned> outstandingRequests;
 
-    js::ThreadLocalData<bool> jitIsBroken;
+    js::ThreadData<bool> jitIsBroken;
 
     void updateJITEnabled();
 
   private:
     /*
      * Youngest frame of a saved stack that will be picked up as an async stack
      * by any new Activation, and is nullptr when no async stack should be used.
      *
      * The JS::AutoSetAsyncStackForNewCalls class can be used to set this.
      *
      * New activations will reset this to nullptr on construction after getting
      * the current value, and will restore the previous value on destruction.
      */
-    js::ThreadLocalData<JS::PersistentRooted<js::SavedFrame*>> asyncStackForNewActivations_;
+    js::ThreadData<JS::PersistentRooted<js::SavedFrame*>> asyncStackForNewActivations_;
   public:
 
     js::SavedFrame*& asyncStackForNewActivations() {
         if (!asyncStackForNewActivations_.ref().initialized())
             asyncStackForNewActivations_.ref().init(this);
         return asyncStackForNewActivations_.ref().get();
     }
 
     /*
      * Value of asyncCause to be attached to asyncStackForNewActivations.
      */
-    js::ThreadLocalData<const char*> asyncCauseForNewActivations;
+    js::ThreadData<const char*> asyncCauseForNewActivations;
 
     /*
      * True if the async call was explicitly requested, e.g. via
      * callFunctionWithAsyncStack.
      */
-    js::ThreadLocalData<bool> asyncCallIsExplicit;
+    js::ThreadData<bool> asyncCallIsExplicit;
 
     bool currentlyRunningInInterpreter() const {
         return activation()->isInterpreter();
     }
     bool currentlyRunningInJit() const {
         return activation()->isJit();
     }
     js::InterpreterFrame* interpreterFrame() const {
@@ -776,21 +776,21 @@ struct JSContext : public JS::RootingCon
      * a boolean flag to minimize the amount of code in its inlined callers.
      */
     JS_FRIEND_API(void) checkMallocGCPressure(void* p);
 
   public:
     using InterruptCallbackVector = js::Vector<JSInterruptCallback, 2, js::SystemAllocPolicy>;
 
   private:
-    js::ThreadLocalData<InterruptCallbackVector> interruptCallbacks_;
+    js::ThreadData<InterruptCallbackVector> interruptCallbacks_;
   public:
     InterruptCallbackVector& interruptCallbacks() { return interruptCallbacks_.ref(); }
 
-    js::ThreadLocalData<bool> interruptCallbackDisabled;
+    js::ThreadData<bool> interruptCallbackDisabled;
 
     mozilla::Atomic<uint32_t, mozilla::Relaxed> interrupt_;
     mozilla::Atomic<uint32_t, mozilla::Relaxed> interruptRegExpJit_;
 
     enum InterruptMode {
         RequestInterruptUrgent,
         RequestInterruptCanWait
     };
@@ -836,34 +836,34 @@ struct JSContext : public JS::RootingCon
         return &jitStackLimitNoInterrupt;
     }
 
     /* Futex state, used by Atomics.wait() and Atomics.wake() on the Atomics object */
     js::FutexThread fx;
 
     // Buffer for OSR from baseline to Ion. To avoid holding on to this for
     // too long, it's also freed in EnterBaseline (after returning from JIT code).
-    js::ThreadLocalData<uint8_t*> osrTempData_;
+    js::ThreadData<uint8_t*> osrTempData_;
 
     uint8_t* allocateOsrTempData(size_t size);
     void freeOsrTempData();
 
     // In certain cases, we want to optimize certain opcodes to typed instructions,
     // to avoid carrying an extra register to feed into an unbox. Unfortunately,
     // that's not always possible. For example, a GetPropertyCacheT could return a
     // typed double, but if it takes its out-of-line path, it could return an
     // object, and trigger invalidation. The invalidation bailout will consider the
     // return value to be a double, and create a garbage Value.
     //
     // To allow the GetPropertyCacheT optimization, we allow the ability for
     // GetPropertyCache to override the return value at the top of the stack - the
     // value that will be temporarily corrupt. This special override value is set
     // only in callVM() targets that are about to return *and* have invalidated
     // their callee.
-    js::ThreadLocalData<js::Value> ionReturnOverride_;
+    js::ThreadData<js::Value> ionReturnOverride_;
 
     bool hasIonReturnOverride() const {
         return !ionReturnOverride_.ref().isMagic(JS_ARG_POISON);
     }
     js::Value takeIonReturnOverride() {
         js::Value v = ionReturnOverride_;
         ionReturnOverride_ = js::MagicValue(JS_ARG_POISON);
         return v;
@@ -872,32 +872,32 @@ struct JSContext : public JS::RootingCon
         MOZ_ASSERT(!hasIonReturnOverride());
         MOZ_ASSERT(!v.isMagic());
         ionReturnOverride_ = v;
     }
 
     mozilla::Atomic<uintptr_t, mozilla::Relaxed> jitStackLimit;
 
     // Like jitStackLimit, but not reset to trigger interrupts.
-    js::ThreadLocalData<uintptr_t> jitStackLimitNoInterrupt;
+    js::ThreadData<uintptr_t> jitStackLimitNoInterrupt;
 
     // Promise callbacks.
-    js::ThreadLocalData<JSGetIncumbentGlobalCallback> getIncumbentGlobalCallback;
-    js::ThreadLocalData<JSEnqueuePromiseJobCallback> enqueuePromiseJobCallback;
-    js::ThreadLocalData<void*> enqueuePromiseJobCallbackData;
+    js::ThreadData<JSGetIncumbentGlobalCallback> getIncumbentGlobalCallback;
+    js::ThreadData<JSEnqueuePromiseJobCallback> enqueuePromiseJobCallback;
+    js::ThreadData<void*> enqueuePromiseJobCallbackData;
 
     // Queue of pending jobs as described in ES2016 section 8.4.
     // Only used if internal job queue handling was activated using
     // `js::UseInternalJobQueues`.
-    js::ThreadLocalData<JS::PersistentRooted<js::JobQueue>*> jobQueue;
-    js::ThreadLocalData<bool> drainingJobQueue;
-    js::ThreadLocalData<bool> stopDrainingJobQueue;
+    js::ThreadData<JS::PersistentRooted<js::JobQueue>*> jobQueue;
+    js::ThreadData<bool> drainingJobQueue;
+    js::ThreadData<bool> stopDrainingJobQueue;
 
-    js::ThreadLocalData<JSPromiseRejectionTrackerCallback> promiseRejectionTrackerCallback;
-    js::ThreadLocalData<void*> promiseRejectionTrackerCallbackData;
+    js::ThreadData<JSPromiseRejectionTrackerCallback> promiseRejectionTrackerCallback;
+    js::ThreadData<void*> promiseRejectionTrackerCallbackData;
 
     JSObject* getIncumbentGlobal(JSContext* cx);
     bool enqueuePromiseJob(JSContext* cx, js::HandleFunction job, js::HandleObject promise,
                            js::HandleObject incumbentGlobal);
     void addUnhandledRejectedPromise(JSContext* cx, js::HandleObject promise);
     void removeUnhandledRejectedPromise(JSContext* cx, js::HandleObject promise);
 }; /* struct JSContext */
 
--- a/js/src/wasm/WasmStubs.cpp
+++ b/js/src/wasm/WasmStubs.cpp
@@ -323,17 +323,17 @@ MoveSPForJitABI(MacroAssembler& masm)
 
 #ifdef ENABLE_WASM_GC
 static void
 SuppressGC(MacroAssembler& masm, int32_t increment, Register scratch)
 {
     masm.loadPtr(Address(WasmTlsReg, offsetof(TlsData, cx)), scratch);
     masm.add32(Imm32(increment),
                Address(scratch, offsetof(JSContext, suppressGC) +
-                                js::ThreadLocalData<int32_t>::offsetOfValue()));
+                                js::ThreadData<int32_t>::offsetOfValue()));
 }
 #endif
 
 static void
 CallFuncExport(MacroAssembler& masm, const FuncExport& fe, const Maybe<ImmPtr>& funcPtr)
 {
     MOZ_ASSERT(fe.hasEagerStubs() == !funcPtr);
     if (funcPtr)