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
|
/* -*- 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 jit_JitOptions_h
#define jit_JitOptions_h
#include "mozilla/Maybe.h"
#include "jit/IonTypes.h"
#include "js/TypeDecls.h"
namespace js {
namespace jit {
// Possible register allocators which may be used.
enum IonRegisterAllocator {
RegisterAllocator_Backtracking,
RegisterAllocator_Testbed,
};
// Which register to use as base register to access stack slots: frame pointer,
// stack pointer, or whichever is the default for this platform. See comment
// for baseRegForLocals in JitOptions.cpp for more information.
enum class BaseRegForAddress { Default, FP, SP };
enum class UseMonomorphicInlining : uint8_t {
Default,
Always,
Never,
};
static inline mozilla::Maybe<IonRegisterAllocator> LookupRegisterAllocator(
const char* name) {
if (!strcmp(name, "backtracking")) {
return mozilla::Some(RegisterAllocator_Backtracking);
}
if (!strcmp(name, "testbed")) {
return mozilla::Some(RegisterAllocator_Testbed);
}
return mozilla::Nothing();
}
struct DefaultJitOptions {
bool checkGraphConsistency;
#ifdef CHECK_OSIPOINT_REGISTERS
bool checkOsiPointRegisters;
#endif
bool checkRangeAnalysis;
bool runExtraChecks;
bool disableJitBackend;
bool disableJitHints;
bool disableAma;
bool disableEaa;
bool disableEdgeCaseAnalysis;
bool disableGvn;
bool disableInlining;
bool disableLicm;
bool disablePruning;
bool disableInstructionReordering;
bool disableIteratorIndices;
bool disableMarkLoadsUsedAsPropertyKeys;
bool disableRangeAnalysis;
bool disableRecoverIns;
bool disableScalarReplacement;
bool disableCacheIR;
bool disableSink;
bool disableRedundantShapeGuards;
bool disableRedundantGCBarriers;
bool disableBailoutLoopCheck;
#ifdef ENABLE_PORTABLE_BASELINE_INTERP
bool portableBaselineInterpreter;
#endif
bool baselineInterpreter;
bool baselineJit;
bool ion;
bool jitForTrustedPrincipals;
bool nativeRegExp;
bool forceInlineCaches;
bool forceMegamorphicICs;
bool fullDebugChecks;
bool limitScriptSize;
bool osr;
bool wasmFoldOffsets;
bool wasmDelayTier2;
bool lessDebugCode;
bool onlyInlineSelfHosted;
bool enableICFramePointers;
bool enableWasmJitExit;
bool enableWasmJitEntry;
bool enableWasmIonFastCalls;
#ifdef WASM_CODEGEN_DEBUG
bool enableWasmImportCallSpew;
bool enableWasmFuncCallSpew;
#endif
bool emitInterpreterEntryTrampoline;
uint32_t baselineInterpreterWarmUpThreshold;
uint32_t baselineJitWarmUpThreshold;
uint32_t trialInliningWarmUpThreshold;
uint32_t trialInliningInitialWarmUpCount;
UseMonomorphicInlining monomorphicInlining = UseMonomorphicInlining::Default;
uint32_t normalIonWarmUpThreshold;
uint32_t regexpWarmUpThreshold;
#ifdef ENABLE_PORTABLE_BASELINE_INTERP
uint32_t portableBaselineInterpreterWarmUpThreshold;
#endif
uint32_t exceptionBailoutThreshold;
uint32_t frequentBailoutThreshold;
uint32_t maxStackArgs;
uint32_t osrPcMismatchesBeforeRecompile;
uint32_t smallFunctionMaxBytecodeLength;
uint32_t inliningEntryThreshold;
uint32_t jumpThreshold;
uint32_t branchPruningHitCountFactor;
uint32_t branchPruningInstFactor;
uint32_t branchPruningBlockSpanFactor;
uint32_t branchPruningEffectfulInstFactor;
uint32_t branchPruningThreshold;
uint32_t ionMaxScriptSize;
uint32_t ionMaxScriptSizeMainThread;
uint32_t ionMaxLocalsAndArgs;
uint32_t ionMaxLocalsAndArgsMainThread;
uint32_t wasmBatchBaselineThreshold;
uint32_t wasmBatchIonThreshold;
mozilla::Maybe<IonRegisterAllocator> forcedRegisterAllocator;
// Spectre mitigation flags. Each mitigation has its own flag in order to
// measure the effectiveness of each mitigation with various proof of
// concept.
bool spectreIndexMasking;
bool spectreObjectMitigations;
bool spectreStringMitigations;
bool spectreValueMasking;
bool spectreJitToCxxCalls;
bool writeProtectCode;
bool supportsUnalignedAccesses;
BaseRegForAddress baseRegForLocals;
// Irregexp shim flags
bool correctness_fuzzer_suppressions;
bool enable_regexp_unaligned_accesses;
bool regexp_possessive_quantifier;
bool regexp_optimization;
bool regexp_peephole_optimization;
bool regexp_tier_up;
bool trace_regexp_assembler;
bool trace_regexp_bytecodes;
bool trace_regexp_parser;
bool trace_regexp_peephole_optimization;
DefaultJitOptions();
bool isSmallFunction(JSScript* script) const;
#ifdef ENABLE_PORTABLE_BASELINE_INTERP
void setEagerPortableBaselineInterpreter();
#endif
void setEagerBaselineCompilation();
void setEagerIonCompilation();
void setNormalIonWarmUpThreshold(uint32_t warmUpThreshold);
void resetNormalIonWarmUpThreshold();
void enableGvn(bool val);
void setFastWarmUp();
void maybeSetWriteProtectCode(bool val);
bool eagerIonCompilation() const { return normalIonWarmUpThreshold == 0; }
};
extern DefaultJitOptions JitOptions;
inline bool HasJitBackend() {
#if defined(JS_CODEGEN_NONE)
return false;
#else
return !JitOptions.disableJitBackend;
#endif
}
inline bool IsBaselineInterpreterEnabled() {
return HasJitBackend() && JitOptions.baselineInterpreter;
}
#ifdef ENABLE_PORTABLE_BASELINE_INTERP
inline bool IsPortableBaselineInterpreterEnabled() {
return JitOptions.portableBaselineInterpreter;
}
#else
inline bool IsPortableBaselineInterpreterEnabled() { return false; }
#endif
inline bool TooManyActualArguments(size_t nargs) {
return nargs > JitOptions.maxStackArgs;
}
} // namespace jit
extern mozilla::Atomic<bool> fuzzingSafe;
static inline bool IsFuzzing() {
#ifdef FUZZING
return true;
#else
return fuzzingSafe;
#endif
}
} // namespace js
#endif /* jit_JitOptions_h */
|
