blob: 618735627b8479cceab5f434366bd291045bba8d (
plain)
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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* 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 jit_CompileWrappers_h
#define jit_CompileWrappers_h
#include "jscntxt.h"
namespace js {
namespace jit {
class JitRuntime;
// During Ion compilation we need access to various bits of the current
// compartment, runtime and so forth. However, since compilation can run off
// thread while the main thread is actively mutating the VM, this access needs
// to be restricted. The classes below give the compiler an interface to access
// all necessary information in a threadsafe fashion.
class CompileRuntime
{
JSRuntime* runtime();
public:
static CompileRuntime* get(JSRuntime* rt);
bool onMainThread();
js::PerThreadData* mainThread();
// &runtime()->jitTop
const void* addressOfJitTop();
// &runtime()->jitActivation
const void* addressOfJitActivation();
// &runtime()->profilingActivation
const void* addressOfProfilingActivation();
// rt->runtime()->jitStackLimit;
const void* addressOfJitStackLimit();
#ifdef DEBUG
// rt->runtime()->addressOfIonBailAfter;
const void* addressOfIonBailAfter();
#endif
// &runtime()->activation_
const void* addressOfActivation();
const void* addressOfInterruptUint32();
// We have to bake JSContext* into JIT code, but this pointer shouldn't be
// used/dereferenced on the background thread so we return it as void*.
const void* getJSContext();
const JitRuntime* jitRuntime();
// Compilation does not occur off thread when the SPS profiler is enabled.
SPSProfiler& spsProfiler();
bool jitSupportsFloatingPoint();
bool hadOutOfMemory();
bool profilingScripts();
const JSAtomState& names();
const PropertyName* emptyString();
const StaticStrings& staticStrings();
const Value& NaNValue();
const Value& positiveInfinityValue();
const WellKnownSymbols& wellKnownSymbols();
#ifdef DEBUG
bool isInsideNursery(gc::Cell* cell);
#endif
// DOM callbacks must be threadsafe (and will hopefully be removed soon).
const DOMCallbacks* DOMcallbacks();
const Nursery& gcNursery();
void setMinorGCShouldCancelIonCompilations();
bool runtimeMatches(JSRuntime* rt);
};
class CompileZone
{
Zone* zone();
public:
static CompileZone* get(Zone* zone);
const void* addressOfNeedsIncrementalBarrier();
const void* addressOfFreeList(gc::AllocKind allocKind);
};
class JitCompartment;
class CompileCompartment
{
JSCompartment* compartment();
public:
static CompileCompartment* get(JSCompartment* comp);
CompileZone* zone();
CompileRuntime* runtime();
const void* addressOfEnumerators();
const void* addressOfRandomNumberGenerator();
const void* addressOfLastCachedNativeIterator();
const JitCompartment* jitCompartment();
const GlobalObject* maybeGlobal();
bool hasAllocationMetadataBuilder();
// Mirror CompartmentOptions.
void setSingletonsAsValues();
};
class JitCompileOptions
{
public:
JitCompileOptions();
explicit JitCompileOptions(JSContext* cx);
bool cloneSingletons() const {
return cloneSingletons_;
}
bool spsSlowAssertionsEnabled() const {
return spsSlowAssertionsEnabled_;
}
bool offThreadCompilationAvailable() const {
return offThreadCompilationAvailable_;
}
private:
bool cloneSingletons_;
bool spsSlowAssertionsEnabled_;
bool offThreadCompilationAvailable_;
};
} // namespace jit
} // namespace js
#endif // jit_CompileWrappers_h
|
