-
Notifications
You must be signed in to change notification settings - Fork 54
/
Runtime.h
1103 lines (872 loc) · 36.3 KB
/
Runtime.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef vm_Runtime_h
#define vm_Runtime_h
#include "mozilla/Atomics.h"
#include "mozilla/Attributes.h"
#include "mozilla/DoublyLinkedList.h"
#include "mozilla/LinkedList.h"
#include "mozilla/Maybe.h"
#include "mozilla/MaybeOneOf.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/ThreadLocal.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/Vector.h"
#include <algorithm>
#include <setjmp.h>
#include "builtin/AtomicsObject.h"
#include "builtin/intl/SharedIntlData.h"
#include "builtin/Promise.h"
#include "frontend/BinASTRuntimeSupport.h"
#include "frontend/NameCollections.h"
#include "gc/GCRuntime.h"
#include "gc/Tracer.h"
#include "irregexp/RegExpStack.h"
#include "js/AllocationRecording.h"
#include "js/BuildId.h" // JS::BuildIdOp
#include "js/Debug.h"
#include "js/experimental/SourceHook.h" // js::SourceHook
#include "js/GCVector.h"
#include "js/HashTable.h"
#include "js/Modules.h" // JS::Module{DynamicImport,Metadata,Resolve}Hook
#ifdef DEBUG
# include "js/Proxy.h" // For AutoEnterPolicy
#endif
#include "js/Stream.h"
#include "js/Symbol.h"
#include "js/UniquePtr.h"
#include "js/Utility.h"
#include "js/Vector.h"
#include "js/Warnings.h" // JS::WarningReporter
#include "threading/Thread.h"
#include "vm/Caches.h"
#include "vm/CodeCoverage.h"
#include "vm/CommonPropertyNames.h"
#include "vm/GeckoProfiler.h"
#include "vm/JSAtom.h"
#include "vm/JSScript.h"
#include "vm/Scope.h"
#include "vm/SharedImmutableStringsCache.h"
#include "vm/Stack.h"
#include "vm/SymbolType.h"
#include "wasm/WasmTypes.h"
namespace js {
class AutoAssertNoContentJS;
class AutoKeepAtoms;
class EnterDebuggeeNoExecute;
#ifdef JS_TRACE_LOGGING
class TraceLoggerThread;
#endif
namespace gc {
class AutoHeapSession;
}
} // namespace js
struct DtoaState;
struct JSLocaleCallbacks;
#ifdef JS_SIMULATOR_ARM64
namespace vixl {
class Simulator;
}
#endif
namespace js {
extern MOZ_COLD void ReportOutOfMemory(JSContext* cx);
/* Different signature because the return type has MOZ_MUST_USE_TYPE. */
extern MOZ_COLD mozilla::GenericErrorResult<OOM&> ReportOutOfMemoryResult(
JSContext* cx);
extern MOZ_COLD void ReportAllocationOverflow(JSContext* maybecx);
extern MOZ_COLD void ReportOverRecursed(JSContext* cx);
class Activation;
class ActivationIterator;
namespace jit {
class JitRuntime;
class JitActivation;
struct PcScriptCache;
struct AutoFlushICache;
class CompileRuntime;
#ifdef JS_SIMULATOR_ARM64
typedef vixl::Simulator Simulator;
#elif defined(JS_SIMULATOR)
class Simulator;
#endif
} // namespace jit
// [SMDOC] JS Engine Threading
//
// Threads interacting with a runtime are divided into two categories:
//
// - The main thread is capable of running JS. There's at most one main thread
// per runtime.
//
// - Helper threads do not run JS, and are controlled or triggered by activity
// on the main thread (or main threads, since all runtimes in a process share
// helper threads). Helper threads may have exclusive access to zones created
// for them, for parsing and similar tasks, but their activities do not cause
// observable changes in script behaviors. Activity on helper threads may be
// referred to as happening 'off thread' or on a background thread in some
// parts of the VM.
} /* namespace js */
namespace JS {
struct RuntimeSizes;
} // namespace JS
/* Various built-in or commonly-used names pinned on first context. */
struct JSAtomState {
#define PROPERTYNAME_FIELD(idpart, id, text) js::ImmutablePropertyNamePtr id;
FOR_EACH_COMMON_PROPERTYNAME(PROPERTYNAME_FIELD)
#undef PROPERTYNAME_FIELD
#define PROPERTYNAME_FIELD(name, init, clasp) js::ImmutablePropertyNamePtr name;
JS_FOR_EACH_PROTOTYPE(PROPERTYNAME_FIELD)
#undef PROPERTYNAME_FIELD
#define PROPERTYNAME_FIELD(name) js::ImmutablePropertyNamePtr name;
JS_FOR_EACH_WELL_KNOWN_SYMBOL(PROPERTYNAME_FIELD)
#undef PROPERTYNAME_FIELD
#define PROPERTYNAME_FIELD(name) js::ImmutablePropertyNamePtr Symbol_##name;
JS_FOR_EACH_WELL_KNOWN_SYMBOL(PROPERTYNAME_FIELD)
#undef PROPERTYNAME_FIELD
js::ImmutablePropertyNamePtr* wellKnownSymbolNames() {
#define FIRST_PROPERTYNAME_FIELD(name) return &name;
JS_FOR_EACH_WELL_KNOWN_SYMBOL(FIRST_PROPERTYNAME_FIELD)
#undef FIRST_PROPERTYNAME_FIELD
}
js::ImmutablePropertyNamePtr* wellKnownSymbolDescriptions() {
#define FIRST_PROPERTYNAME_FIELD(name) return &Symbol_##name;
JS_FOR_EACH_WELL_KNOWN_SYMBOL(FIRST_PROPERTYNAME_FIELD)
#undef FIRST_PROPERTYNAME_FIELD
}
};
namespace js {
/*
* Storage for well-known symbols. It's a separate struct from the Runtime so
* that it can be shared across multiple runtimes. As in JSAtomState, each
* field is a smart pointer that's immutable once initialized.
* `rt->wellKnownSymbols->iterator` is convertible to Handle<Symbol*>.
*
* Well-known symbols are never GC'd. The description() of each well-known
* symbol is a permanent atom.
*/
struct WellKnownSymbols {
#define DECLARE_SYMBOL(name) js::ImmutableSymbolPtr name;
JS_FOR_EACH_WELL_KNOWN_SYMBOL(DECLARE_SYMBOL)
#undef DECLARE_SYMBOL
const ImmutableSymbolPtr& get(size_t u) const {
MOZ_ASSERT(u < JS::WellKnownSymbolLimit);
const ImmutableSymbolPtr* symbols =
reinterpret_cast<const ImmutableSymbolPtr*>(this);
return symbols[u];
}
const ImmutableSymbolPtr& get(JS::SymbolCode code) const {
return get(size_t(code));
}
WellKnownSymbols() {}
WellKnownSymbols(const WellKnownSymbols&) = delete;
WellKnownSymbols& operator=(const WellKnownSymbols&) = delete;
};
#define NAME_OFFSET(name) offsetof(JSAtomState, name)
inline HandlePropertyName AtomStateOffsetToName(const JSAtomState& atomState,
size_t offset) {
return *reinterpret_cast<js::ImmutablePropertyNamePtr*>((char*)&atomState +
offset);
}
// There are several coarse locks in the enum below. These may be either
// per-runtime or per-process. When acquiring more than one of these locks,
// the acquisition must be done in the order below to avoid deadlocks.
enum RuntimeLock { HelperThreadStateLock, GCLock };
inline bool CanUseExtraThreads() {
extern bool gCanUseExtraThreads;
return gCanUseExtraThreads;
}
void DisableExtraThreads();
using ScriptAndCountsVector = GCVector<ScriptAndCounts, 0, SystemAllocPolicy>;
class AutoLockScriptData;
} // namespace js
struct JSRuntime : public js::MallocProvider<JSRuntime> {
private:
friend class js::Activation;
friend class js::ActivationIterator;
friend class js::jit::JitActivation;
friend class js::jit::CompileRuntime;
/* Space for interpreter frames. */
js::MainThreadData<js::InterpreterStack> interpreterStack_;
public:
js::InterpreterStack& interpreterStack() { return interpreterStack_.ref(); }
/*
* If non-null, another runtime guaranteed to outlive this one and whose
* permanent data may be used by this one where possible.
*/
JSRuntime* const parentRuntime;
#ifdef DEBUG
/* The number of child runtimes that have this runtime as their parent. */
mozilla::Atomic<size_t> childRuntimeCount;
class AutoUpdateChildRuntimeCount {
JSRuntime* parent_;
public:
explicit AutoUpdateChildRuntimeCount(JSRuntime* parent) : parent_(parent) {
if (parent_) {
parent_->childRuntimeCount++;
}
}
~AutoUpdateChildRuntimeCount() {
if (parent_) {
parent_->childRuntimeCount--;
}
}
};
AutoUpdateChildRuntimeCount updateChildRuntimeCount;
#endif
private:
#ifdef DEBUG
js::WriteOnceData<bool> initialized_;
#endif
// The JSContext* for the runtime's main thread. Immutable after this is set
// in JSRuntime::init.
JSContext* mainContext_;
public:
JSContext* mainContextFromAnyThread() const { return mainContext_; }
const void* addressOfMainContext() { return &mainContext_; }
inline JSContext* mainContextFromOwnThread();
/*
* The start of the range stored in the profiler sample buffer, as measured
* after the most recent sample.
* All JitcodeGlobalTable entries referenced from a given sample are
* assigned the buffer position of the START of the sample. The buffer
* entries that reference the JitcodeGlobalTable entries will only ever be
* read from the buffer while the entire sample is still inside the buffer;
* if some buffer entries at the start of the sample have left the buffer,
* the entire sample will be considered inaccessible.
* This means that, once profilerSampleBufferRangeStart_ advances beyond
* the sample position that's stored on a JitcodeGlobalTable entry, the
* buffer entries that reference this JitcodeGlobalTable entry will be
* considered inaccessible, and those JitcodeGlobalTable entry can be
* disposed of.
*/
mozilla::Atomic<uint64_t, mozilla::ReleaseAcquire,
mozilla::recordreplay::Behavior::DontPreserve>
profilerSampleBufferRangeStart_;
mozilla::Maybe<uint64_t> profilerSampleBufferRangeStart() {
if (beingDestroyed_ || !geckoProfiler().enabled()) {
return mozilla::Nothing();
}
uint64_t rangeStart = profilerSampleBufferRangeStart_;
return mozilla::Some(rangeStart);
}
void setProfilerSampleBufferRangeStart(uint64_t rangeStart) {
profilerSampleBufferRangeStart_ = rangeStart;
}
/* Call this to accumulate telemetry data. */
js::MainThreadData<JSAccumulateTelemetryDataCallback> telemetryCallback;
/* Call this to accumulate use counter data. */
js::MainThreadData<JSSetUseCounterCallback> useCounterCallback;
public:
// Accumulates data for Firefox telemetry. |id| is the ID of a JS_TELEMETRY_*
// histogram. |key| provides an additional key to identify the histogram.
// |sample| is the data to add to the histogram.
void addTelemetry(int id, uint32_t sample, const char* key = nullptr);
void setTelemetryCallback(JSRuntime* rt,
JSAccumulateTelemetryDataCallback callback);
// Sets the use counter for a specific feature, measuring the presence or
// absence of usage of a feature on a specific web page and document which
// the passed JSObject belongs to.
void setUseCounter(JSObject* obj, JSUseCounter counter);
void setUseCounterCallback(JSRuntime* rt, JSSetUseCounterCallback callback);
public:
js::UnprotectedData<js::OffThreadPromiseRuntimeState> offThreadPromiseState;
js::UnprotectedData<JS::ConsumeStreamCallback> consumeStreamCallback;
js::UnprotectedData<JS::ReportStreamErrorCallback> reportStreamErrorCallback;
js::GlobalObject* getIncumbentGlobal(JSContext* cx);
bool enqueuePromiseJob(JSContext* cx, js::HandleFunction job,
js::HandleObject promise,
js::Handle<js::GlobalObject*> incumbentGlobal);
void addUnhandledRejectedPromise(JSContext* cx, js::HandleObject promise);
void removeUnhandledRejectedPromise(JSContext* cx, js::HandleObject promise);
/* Had an out-of-memory error which did not populate an exception. */
mozilla::Atomic<bool, mozilla::SequentiallyConsistent,
mozilla::recordreplay::Behavior::DontPreserve>
hadOutOfMemory;
/*
* Allow relazifying functions in compartments that are active. This is
* only used by the relazifyFunctions() testing function.
*/
js::MainThreadData<bool> allowRelazificationForTesting;
/* Compartment destroy callback. */
js::MainThreadData<JSDestroyCompartmentCallback> destroyCompartmentCallback;
/* Compartment memory reporting callback. */
js::MainThreadData<JSSizeOfIncludingThisCompartmentCallback>
sizeOfIncludingThisCompartmentCallback;
/* Callback for creating ubi::Nodes representing DOM node objects. Set by
* JS::ubi::SetConstructUbiNodeForDOMObjectCallback. Refer to
* js/public/UbiNode.h.
*/
void (*constructUbiNodeForDOMObjectCallback)(void*, JSObject*) = nullptr;
/* Realm destroy callback. */
js::MainThreadData<JS::DestroyRealmCallback> destroyRealmCallback;
/* Call this to get the name of a realm. */
js::MainThreadData<JS::RealmNameCallback> realmNameCallback;
/* Callback for doing memory reporting on external strings. */
js::MainThreadData<JSExternalStringSizeofCallback>
externalStringSizeofCallback;
js::MainThreadData<mozilla::UniquePtr<js::SourceHook>> sourceHook;
js::MainThreadData<const JSSecurityCallbacks*> securityCallbacks;
js::MainThreadData<const js::DOMCallbacks*> DOMcallbacks;
js::MainThreadData<JSDestroyPrincipalsOp> destroyPrincipals;
js::MainThreadData<JSReadPrincipalsOp> readPrincipals;
/* Optional warning reporter. */
js::MainThreadData<JS::WarningReporter> warningReporter;
private:
/* Gecko profiling metadata */
js::UnprotectedData<js::GeckoProfilerRuntime> geckoProfiler_;
public:
js::GeckoProfilerRuntime& geckoProfiler() { return geckoProfiler_.ref(); }
// Heap GC roots for PersistentRooted pointers.
js::MainThreadData<mozilla::EnumeratedArray<
JS::RootKind, JS::RootKind::Limit,
mozilla::LinkedList<JS::PersistentRooted<void*>>>>
heapRoots;
void tracePersistentRoots(JSTracer* trc);
void finishPersistentRoots();
void finishRoots();
private:
js::UnprotectedData<const JSPrincipals*> trustedPrincipals_;
public:
void setTrustedPrincipals(const JSPrincipals* p) { trustedPrincipals_ = p; }
const JSPrincipals* trustedPrincipals() const { return trustedPrincipals_; }
js::MainThreadData<const JSWrapObjectCallbacks*> wrapObjectCallbacks;
js::MainThreadData<js::PreserveWrapperCallback> preserveWrapperCallback;
js::MainThreadData<js::ScriptEnvironmentPreparer*> scriptEnvironmentPreparer;
js::MainThreadData<js::CTypesActivityCallback> ctypesActivityCallback;
private:
js::WriteOnceData<const js::Class*> windowProxyClass_;
public:
const js::Class* maybeWindowProxyClass() const { return windowProxyClass_; }
void setWindowProxyClass(const js::Class* clasp) {
windowProxyClass_ = clasp;
}
private:
// List of non-ephemeron weak containers to sweep during
// beginSweepingSweepGroup.
js::MainThreadData<mozilla::LinkedList<JS::detail::WeakCacheBase>>
weakCaches_;
public:
mozilla::LinkedList<JS::detail::WeakCacheBase>& weakCaches() {
return weakCaches_.ref();
}
void registerWeakCache(JS::detail::WeakCacheBase* cachep) {
weakCaches().insertBack(cachep);
}
template <typename T>
struct GlobalObjectWatchersLinkAccess {
static mozilla::DoublyLinkedListElement<T>& Get(T* aThis) {
return aThis->onNewGlobalObjectWatchersLink;
}
};
using WatchersList =
mozilla::DoublyLinkedList<js::Debugger,
GlobalObjectWatchersLinkAccess<js::Debugger>>;
private:
/*
* List of all enabled Debuggers that have onNewGlobalObject handler
* methods established.
*/
js::MainThreadData<WatchersList> onNewGlobalObjectWatchers_;
public:
WatchersList& onNewGlobalObjectWatchers() {
return onNewGlobalObjectWatchers_.ref();
}
private:
/* Linked list of all Debugger objects in the runtime. */
js::MainThreadData<mozilla::LinkedList<js::Debugger>> debuggerList_;
public:
mozilla::LinkedList<js::Debugger>& debuggerList() {
return debuggerList_.ref();
}
private:
/*
* Lock used to protect the script data table, which can be used by
* off-thread parsing.
*
* Locking this only occurs if there is actually a thread other than the
* main thread which could access this.
*/
js::Mutex scriptDataLock;
#ifdef DEBUG
bool activeThreadHasScriptDataAccess;
#endif
// Number of zones which may be operated on by helper threads.
mozilla::Atomic<size_t, mozilla::SequentiallyConsistent,
mozilla::recordreplay::Behavior::DontPreserve>
numActiveHelperThreadZones;
// Any activity affecting the heap.
mozilla::Atomic<JS::HeapState, mozilla::SequentiallyConsistent,
mozilla::recordreplay::Behavior::DontPreserve>
heapState_;
friend class js::AutoLockScriptData;
public:
void setUsedByHelperThread(JS::Zone* zone);
void clearUsedByHelperThread(JS::Zone* zone);
bool hasHelperThreadZones() const { return numActiveHelperThreadZones > 0; }
#ifdef DEBUG
bool currentThreadHasScriptDataAccess() const {
if (!hasHelperThreadZones()) {
return CurrentThreadCanAccessRuntime(this) &&
activeThreadHasScriptDataAccess;
}
return scriptDataLock.ownedByCurrentThread();
}
bool currentThreadHasAtomsTableAccess() const {
return CurrentThreadCanAccessRuntime(this) &&
atoms_->mainThreadHasAllLocks();
}
#endif
JS::HeapState heapState() const { return heapState_; }
// How many realms there are across all zones. This number includes
// off-thread context realms, so it isn't necessarily equal to the
// number of realms visited by RealmsIter.
js::MainThreadData<size_t> numRealms;
// The Gecko Profiler may want to sample the allocations happening across the
// browser. This callback can be registered to record the allocation.
js::MainThreadData<JS::RecordAllocationsCallback> recordAllocationCallback;
js::MainThreadData<double> allocationSamplingProbability;
private:
// Number of debuggee realms in the runtime.
js::MainThreadData<size_t> numDebuggeeRealms_;
// Number of debuggee realms in the runtime observing code coverage.
js::MainThreadData<size_t> numDebuggeeRealmsObservingCoverage_;
public:
void incrementNumDebuggeeRealms();
void decrementNumDebuggeeRealms();
size_t numDebuggeeRealms() const { return numDebuggeeRealms_; }
void incrementNumDebuggeeRealmsObservingCoverage();
void decrementNumDebuggeeRealmsObservingCoverage();
void startRecordingAllocations(double probability,
JS::RecordAllocationsCallback callback);
void stopRecordingAllocations();
void ensureRealmIsRecordingAllocations(JS::Handle<js::GlobalObject*> global);
/* Locale-specific callbacks for string conversion. */
js::MainThreadData<const JSLocaleCallbacks*> localeCallbacks;
/* Default locale for Internationalization API */
js::MainThreadData<js::UniqueChars> defaultLocale;
/* If true, new scripts must be created with PC counter information. */
js::MainThreadOrIonCompileData<bool> profilingScripts;
/* Strong references on scripts held for PCCount profiling API. */
js::MainThreadData<JS::PersistentRooted<js::ScriptAndCountsVector>*>
scriptAndCountsVector;
private:
/* Code coverage output. */
js::UnprotectedData<js::coverage::LCovRuntime> lcovOutput_;
public:
js::coverage::LCovRuntime& lcovOutput() { return lcovOutput_.ref(); }
private:
js::UnprotectedData<js::jit::JitRuntime*> jitRuntime_;
/*
* Self-hosting state cloned on demand into other compartments. Shared with
* the parent runtime if there is one.
*/
js::WriteOnceData<js::NativeObject*> selfHostingGlobal_;
static js::GlobalObject* createSelfHostingGlobal(JSContext* cx);
bool getUnclonedSelfHostedValue(JSContext* cx, js::HandlePropertyName name,
js::MutableHandleValue vp);
JSFunction* getUnclonedSelfHostedFunction(JSContext* cx,
js::HandlePropertyName name);
public:
MOZ_MUST_USE bool createJitRuntime(JSContext* cx);
js::jit::JitRuntime* jitRuntime() const { return jitRuntime_.ref(); }
bool hasJitRuntime() const { return !!jitRuntime_; }
private:
// Used to generate random keys for hash tables.
mozilla::Maybe<mozilla::non_crypto::XorShift128PlusRNG> randomKeyGenerator_;
mozilla::non_crypto::XorShift128PlusRNG& randomKeyGenerator();
// Used to generate random hash codes for symbols.
mozilla::Maybe<mozilla::non_crypto::XorShift128PlusRNG>
randomHashCodeGenerator_;
public:
mozilla::HashCodeScrambler randomHashCodeScrambler();
mozilla::non_crypto::XorShift128PlusRNG forkRandomKeyGenerator();
js::HashNumber randomHashCode();
//-------------------------------------------------------------------------
// Self-hosting support
//-------------------------------------------------------------------------
bool hasInitializedSelfHosting() const { return selfHostingGlobal_; }
bool initSelfHosting(JSContext* cx);
void finishSelfHosting();
void traceSelfHostingGlobal(JSTracer* trc);
bool isSelfHostingGlobal(JSObject* global) {
return global == selfHostingGlobal_;
}
bool isSelfHostingZone(const JS::Zone* zone) const;
bool createLazySelfHostedFunctionClone(JSContext* cx,
js::HandlePropertyName selfHostedName,
js::HandleAtom name, unsigned nargs,
js::HandleObject proto,
js::NewObjectKind newKind,
js::MutableHandleFunction fun);
bool cloneSelfHostedFunctionScript(JSContext* cx,
js::Handle<js::PropertyName*> name,
js::Handle<JSFunction*> targetFun);
bool cloneSelfHostedValue(JSContext* cx, js::Handle<js::PropertyName*> name,
js::MutableHandleValue vp);
void assertSelfHostedFunctionHasCanonicalName(JSContext* cx,
js::HandlePropertyName name);
//-------------------------------------------------------------------------
// Locale information
//-------------------------------------------------------------------------
/*
* Set the default locale for the ECMAScript Internationalization API
* (Intl.Collator, Intl.NumberFormat, Intl.DateTimeFormat).
* Note that the Internationalization API encourages clients to
* specify their own locales.
* The locale string remains owned by the caller.
*/
bool setDefaultLocale(const char* locale);
/* Reset the default locale to OS defaults. */
void resetDefaultLocale();
/* Gets current default locale. String remains owned by context. */
const char* getDefaultLocale();
/* Garbage collector state. */
js::gc::GCRuntime gc;
/* Garbage collector state has been successfully initialized. */
js::WriteOnceData<bool> gcInitialized;
bool hasZealMode(js::gc::ZealMode mode) { return gc.hasZealMode(mode); }
void lockGC() { gc.lockGC(); }
void unlockGC() { gc.unlockGC(); }
js::WriteOnceData<js::PropertyName*> emptyString;
private:
js::MainThreadData<js::FreeOp*> defaultFreeOp_;
public:
js::FreeOp* defaultFreeOp() {
MOZ_ASSERT(defaultFreeOp_);
return defaultFreeOp_;
}
#if !EXPOSE_INTL_API
/* Number localization, used by jsnum.cpp. */
js::WriteOnceData<const char*> thousandsSeparator;
js::WriteOnceData<const char*> decimalSeparator;
js::WriteOnceData<const char*> numGrouping;
#endif
private:
mozilla::Maybe<js::SharedImmutableStringsCache> sharedImmutableStrings_;
public:
// If this particular JSRuntime has a SharedImmutableStringsCache, return a
// pointer to it, otherwise return nullptr.
js::SharedImmutableStringsCache* maybeThisRuntimeSharedImmutableStrings() {
return sharedImmutableStrings_.isSome() ? &*sharedImmutableStrings_
: nullptr;
}
// Get a reference to this JSRuntime's or its parent's
// SharedImmutableStringsCache.
js::SharedImmutableStringsCache& sharedImmutableStrings() {
MOZ_ASSERT_IF(parentRuntime, !sharedImmutableStrings_);
MOZ_ASSERT_IF(!parentRuntime, sharedImmutableStrings_);
return parentRuntime ? parentRuntime->sharedImmutableStrings()
: *sharedImmutableStrings_;
}
private:
js::WriteOnceData<bool> beingDestroyed_;
public:
bool isBeingDestroyed() const { return beingDestroyed_; }
private:
bool allowContentJS_;
public:
bool allowContentJS() const { return allowContentJS_; }
friend class js::AutoAssertNoContentJS;
private:
// Table of all atoms other than those in permanentAtoms and staticStrings.
js::WriteOnceData<js::AtomsTable*> atoms_;
// Set of all live symbols produced by Symbol.for(). All such symbols are
// allocated in the atoms zone. Reading or writing the symbol registry
// can only be done from the main thread.
js::MainThreadOrGCTaskData<js::SymbolRegistry> symbolRegistry_;
js::WriteOnceData<js::AtomSet*> permanentAtomsDuringInit_;
js::WriteOnceData<js::FrozenAtomSet*> permanentAtoms_;
public:
bool initializeAtoms(JSContext* cx);
void finishAtoms();
bool atomsAreFinished() const {
return !atoms_ && !permanentAtomsDuringInit_;
}
js::AtomsTable* atomsForSweeping() {
MOZ_ASSERT(JS::RuntimeHeapIsCollecting());
return atoms_;
}
js::AtomsTable& atoms() {
MOZ_ASSERT(atoms_);
return *atoms_;
}
const JS::Zone* atomsZone(const js::AutoAccessAtomsZone& access) const {
return gc.atomsZone;
}
JS::Zone* atomsZone(const js::AutoAccessAtomsZone& access) {
return gc.atomsZone;
}
JS::Zone* unsafeAtomsZone() { return gc.atomsZone; }
bool isAtomsZone(const JS::Zone* zone) const { return zone == gc.atomsZone; }
bool activeGCInAtomsZone();
js::SymbolRegistry& symbolRegistry() { return symbolRegistry_.ref(); }
// Permanent atoms are fixed during initialization of the runtime and are
// not modified or collected until the runtime is destroyed. These may be
// shared with another, longer living runtime through |parentRuntime| and
// can be freely accessed with no locking necessary.
// Permanent atoms pre-allocated for general use.
js::WriteOnceData<js::StaticStrings*> staticStrings;
// Cached pointers to various permanent property names.
js::WriteOnceData<JSAtomState*> commonNames;
// All permanent atoms in the runtime, other than those in staticStrings.
// Access to this does not require a lock because it is frozen and thus
// read-only.
const js::FrozenAtomSet* permanentAtoms() const {
MOZ_ASSERT(permanentAtomsPopulated());
return permanentAtoms_.ref();
}
// The permanent atoms table is populated during initialization.
bool permanentAtomsPopulated() const { return permanentAtoms_; }
// For internal use, return the permanent atoms table while it is being
// populated.
js::AtomSet* permanentAtomsDuringInit() const {
MOZ_ASSERT(!permanentAtoms_);
return permanentAtomsDuringInit_.ref();
}
bool initMainAtomsTables(JSContext* cx);
void tracePermanentAtoms(JSTracer* trc);
// Cached well-known symbols (ES6 rev 24 6.1.5.1). Like permanent atoms,
// these are shared with the parentRuntime, if any.
js::WriteOnceData<js::WellKnownSymbols*> wellKnownSymbols;
/* Shared Intl data for this runtime. */
js::MainThreadData<js::intl::SharedIntlData> sharedIntlData;
void traceSharedIntlData(JSTracer* trc);
// Table of bytecode and other data that may be shared across scripts
// within the runtime. This may be modified by threads using
// AutoLockScriptData.
private:
js::ScriptDataLockData<js::ScriptDataTable> scriptDataTable_;
public:
js::ScriptDataTable& scriptDataTable(const js::AutoLockScriptData& lock) {
return scriptDataTable_.ref();
}
js::WriteOnceData<bool> jitSupportsFloatingPoint;
js::WriteOnceData<bool> jitSupportsUnalignedAccesses;
js::WriteOnceData<bool> jitSupportsSimd;
private:
static mozilla::Atomic<size_t> liveRuntimesCount;
public:
static bool hasLiveRuntimes() { return liveRuntimesCount > 0; }
explicit JSRuntime(JSRuntime* parentRuntime);
~JSRuntime();
// destroyRuntime is used instead of a destructor, to ensure the downcast
// to JSContext remains valid. The final GC triggered here depends on this.
void destroyRuntime();
bool init(JSContext* cx, uint32_t maxbytes, uint32_t maxNurseryBytes);
JSRuntime* thisFromCtor() { return this; }
public:
/*
* Call this after allocating memory held by GC things, to update memory
* pressure counters or report the OOM error if necessary. If oomError and
* cx is not null the function also reports OOM error.
*
* The function must be called outside the GC lock and in case of OOM error
* the caller must ensure that no deadlock possible during OOM reporting.
*/
void updateMallocCounter(size_t nbytes);
void reportAllocationOverflow() { js::ReportAllocationOverflow(nullptr); }
/*
* This should be called after system malloc/calloc/realloc returns nullptr
* to try to recove some memory or to report an error. For realloc, the
* original pointer must be passed as reallocPtr.
*
* The function must be called outside the GC lock.
*/
JS_FRIEND_API void* onOutOfMemory(js::AllocFunction allocator,
arena_id_t arena, size_t nbytes,
void* reallocPtr = nullptr,
JSContext* maybecx = nullptr);
/* onOutOfMemory but can call OnLargeAllocationFailure. */
JS_FRIEND_API void* onOutOfMemoryCanGC(js::AllocFunction allocator,
arena_id_t arena, size_t nbytes,
void* reallocPtr = nullptr);
static const unsigned LARGE_ALLOCATION = 25 * 1024 * 1024;
void addSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf,
JS::RuntimeSizes* rtSizes);
private:
// Settings for how helper threads can be used.
mozilla::Atomic<bool, mozilla::SequentiallyConsistent,
mozilla::recordreplay::Behavior::DontPreserve>
offthreadIonCompilationEnabled_;
mozilla::Atomic<bool, mozilla::SequentiallyConsistent,
mozilla::recordreplay::Behavior::DontPreserve>
parallelParsingEnabled_;
#ifdef DEBUG
mozilla::Atomic<uint32_t> offThreadParsesRunning_;
mozilla::Atomic<bool> offThreadParsingBlocked_;
#endif
js::MainThreadData<bool> autoWritableJitCodeActive_;
public:
// Note: these values may be toggled dynamically (in response to about:config
// prefs changing).
void setOffthreadIonCompilationEnabled(bool value) {
offthreadIonCompilationEnabled_ = value;
}
bool canUseOffthreadIonCompilation() const {
return offthreadIonCompilationEnabled_;
}
void setParallelParsingEnabled(bool value) {
parallelParsingEnabled_ = value;
}
bool canUseParallelParsing() const { return parallelParsingEnabled_; }
#ifdef DEBUG
void incOffThreadParsesRunning() {
MOZ_ASSERT(!isOffThreadParsingBlocked());
offThreadParsesRunning_++;
}
void decOffThreadParsesRunning() {
MOZ_ASSERT(isOffThreadParseRunning());
offThreadParsesRunning_--;
}
bool isOffThreadParseRunning() const { return offThreadParsesRunning_; }
bool isOffThreadParsingBlocked() const { return offThreadParsingBlocked_; }
void setOffThreadParsingBlocked(bool blocked) {
MOZ_ASSERT(offThreadParsingBlocked_ != blocked);
MOZ_ASSERT(!isOffThreadParseRunning());
offThreadParsingBlocked_ = blocked;
}
#endif
void toggleAutoWritableJitCodeActive(bool b) {
MOZ_ASSERT(autoWritableJitCodeActive_ != b,
"AutoWritableJitCode should not be nested.");
autoWritableJitCodeActive_ = b;
}
/* See comment for JS::SetOutOfMemoryCallback in jsapi.h. */
js::MainThreadData<JS::OutOfMemoryCallback> oomCallback;
js::MainThreadData<void*> oomCallbackData;
/*
* Debugger.Memory functions like takeCensus use this embedding-provided
* function to assess the size of malloc'd blocks of memory.
*/
js::MainThreadData<mozilla::MallocSizeOf> debuggerMallocSizeOf;
/* Last time at which an animation was played for this runtime. */
js::MainThreadData<mozilla::TimeStamp> lastAnimationTime;
private:
/* The stack format for the current runtime. Only valid on non-child
* runtimes. */
mozilla::Atomic<js::StackFormat, mozilla::ReleaseAcquire> stackFormat_;
public:
js::StackFormat stackFormat() const {
const JSRuntime* rt = this;
while (rt->parentRuntime) {
MOZ_ASSERT(rt->stackFormat_ == js::StackFormat::Default);
rt = rt->parentRuntime;
}
MOZ_ASSERT(rt->stackFormat_ != js::StackFormat::Default);
return rt->stackFormat_;
}
void setStackFormat(js::StackFormat format) {
MOZ_ASSERT(!parentRuntime);
MOZ_ASSERT(format != js::StackFormat::Default);
stackFormat_ = format;
}
// For inherited heap state accessors.
friend class js::gc::AutoHeapSession;
friend class JS::AutoEnterCycleCollection;
private:
js::MainThreadData<js::RuntimeCaches> caches_;
public:
js::RuntimeCaches& caches() { return caches_.ref(); }
// List of all the live wasm::Instances in the runtime. Equal to the union
// of all instances registered in all JS::Realms. Accessed from watchdog
// threads for purposes of wasm::InterruptRunningCode().
js::ExclusiveData<js::wasm::InstanceVector> wasmInstances;
// The implementation-defined abstract operation HostResolveImportedModule.
js::MainThreadData<JS::ModuleResolveHook> moduleResolveHook;
// A hook that implements the abstract operations
// HostGetImportMetaProperties and HostFinalizeImportMeta.
js::MainThreadData<JS::ModuleMetadataHook> moduleMetadataHook;
// A hook that implements the abstract operation
// HostImportModuleDynamically. This is also used to enable/disable dynamic
// module import and can accessed by off-thread parsing.
mozilla::Atomic<JS::ModuleDynamicImportHook> moduleDynamicImportHook;
// Hooks called when script private references are created and destroyed.
js::MainThreadData<JS::ScriptPrivateReferenceHook> scriptPrivateAddRefHook;
js::MainThreadData<JS::ScriptPrivateReferenceHook> scriptPrivateReleaseHook;
void addRefScriptPrivate(const JS::Value& value) {
if (!value.isUndefined() && scriptPrivateAddRefHook) {
scriptPrivateAddRefHook(value);
}
}