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
|
/* -*- 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_Ion_h
#define jit_Ion_h
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/Likely.h"
#include "mozilla/MemoryReporting.h"
#include <stddef.h>
#include <stdint.h>
#include "jsfriendapi.h"
#include "jspubtd.h"
#include "jit/BaselineJIT.h"
#include "jit/IonTypes.h"
#include "jit/JitContext.h"
#include "jit/JitOptions.h"
#include "js/Principals.h"
#include "js/TypeDecls.h"
#include "vm/BytecodeUtil.h"
#include "vm/JSContext.h"
#include "vm/JSFunction.h"
#include "vm/JSScript.h"
namespace js {
class RunState;
namespace jit {
class BaselineFrame;
bool CanIonCompileScript(JSContext* cx, JSScript* script);
bool CanIonInlineScript(JSScript* script);
[[nodiscard]] bool IonCompileScriptForBaselineAtEntry(JSContext* cx,
BaselineFrame* frame);
struct IonOsrTempData {
void* jitcode;
uint8_t* baselineFrame;
static constexpr size_t offsetOfJitCode() {
return offsetof(IonOsrTempData, jitcode);
}
static constexpr size_t offsetOfBaselineFrame() {
return offsetof(IonOsrTempData, baselineFrame);
}
};
[[nodiscard]] bool IonCompileScriptForBaselineOSR(JSContext* cx,
BaselineFrame* frame,
uint32_t frameSize,
jsbytecode* pc,
IonOsrTempData** infoPtr);
MethodStatus CanEnterIon(JSContext* cx, RunState& state);
class MIRGenerator;
class LIRGraph;
class CodeGenerator;
class LazyLinkExitFrameLayout;
class WarpSnapshot;
[[nodiscard]] bool OptimizeMIR(MIRGenerator* mir);
LIRGraph* GenerateLIR(MIRGenerator* mir);
CodeGenerator* GenerateCode(MIRGenerator* mir, LIRGraph* lir);
CodeGenerator* CompileBackEnd(MIRGenerator* mir, WarpSnapshot* snapshot);
void LinkIonScript(JSContext* cx, HandleScript calleescript);
uint8_t* LazyLinkTopActivation(JSContext* cx, LazyLinkExitFrameLayout* frame);
inline bool IsIonInlinableGetterOrSetterOp(JSOp op) {
// JSOp::GetProp, JSOp::CallProp, JSOp::Length, JSOp::GetElem,
// and JSOp::CallElem. (Inlined Getters)
// JSOp::SetProp, JSOp::SetName, JSOp::SetGName (Inlined Setters)
return IsGetPropOp(op) || IsGetElemOp(op) || IsSetPropOp(op);
}
inline bool IsIonInlinableOp(JSOp op) {
// JSOp::Call, JSOp::FunCall, JSOp::Eval, JSOp::New (Normal Callsites) or an
// inlinable getter or setter.
return (IsInvokeOp(op) && !IsSpreadOp(op)) ||
IsIonInlinableGetterOrSetterOp(op);
}
inline bool TooManyActualArguments(unsigned nargs) {
return nargs > JitOptions.maxStackArgs;
}
inline bool TooManyFormalArguments(unsigned nargs) {
return nargs >= SNAPSHOT_MAX_NARGS || TooManyActualArguments(nargs);
}
inline size_t NumLocalsAndArgs(JSScript* script) {
size_t num = 1 /* this */ + script->nfixed();
if (JSFunction* fun = script->function()) {
num += fun->nargs();
}
return num;
}
// Debugging RAII class which marks the current thread as performing an Ion
// backend compilation.
class MOZ_RAII AutoEnterIonBackend {
public:
AutoEnterIonBackend() {
#ifdef DEBUG
JitContext* jcx = GetJitContext();
jcx->enterIonBackend();
#endif
}
#ifdef DEBUG
~AutoEnterIonBackend() {
JitContext* jcx = GetJitContext();
jcx->leaveIonBackend();
}
#endif
};
bool OffThreadCompilationAvailable(JSContext* cx);
void ForbidCompilation(JSContext* cx, JSScript* script);
size_t SizeOfIonData(JSScript* script, mozilla::MallocSizeOf mallocSizeOf);
inline bool IsIonEnabled(JSContext* cx) {
if (MOZ_UNLIKELY(!IsBaselineJitEnabled(cx) || cx->options().disableIon())) {
return false;
}
if (MOZ_LIKELY(JitOptions.ion)) {
return true;
}
if (JitOptions.jitForTrustedPrincipals) {
JS::Realm* realm = js::GetContextRealm(cx);
return realm && JS::GetRealmPrincipals(realm) &&
JS::GetRealmPrincipals(realm)->isSystemOrAddonPrincipal();
}
return false;
}
// Implemented per-platform. Returns true if the flags will not require
// further (lazy) computation.
bool CPUFlagsHaveBeenComputed();
} // namespace jit
} // namespace js
#endif /* jit_Ion_h */
|
