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
|
/* -*- 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_x86_shared_CodeGenerator_x86_shared_h
#define jit_x86_shared_CodeGenerator_x86_shared_h
#include "jit/shared/CodeGenerator-shared.h"
#include "js/ScalarType.h" // js::Scalar::Type
namespace js {
namespace jit {
class CodeGeneratorX86Shared;
class OutOfLineBailout;
class OutOfLineUndoALUOperation;
class OutOfLineLoadTypedArrayOutOfBounds;
class MulNegativeZeroCheck;
class ModOverflowCheck;
class ReturnZero;
class OutOfLineTableSwitch;
using OutOfLineWasmTruncateCheck =
OutOfLineWasmTruncateCheckBase<CodeGeneratorX86Shared>;
class CodeGeneratorX86Shared : public CodeGeneratorShared {
friend class MoveResolverX86;
template <typename T>
void bailout(const T& t, LSnapshot* snapshot);
protected:
CodeGeneratorX86Shared(MIRGenerator* gen, LIRGraph* graph,
MacroAssembler* masm);
// Load a NaN or zero into a register for an out of bounds AsmJS or static
// typed array load.
class OutOfLineLoadTypedArrayOutOfBounds
: public OutOfLineCodeBase<CodeGeneratorX86Shared> {
AnyRegister dest_;
Scalar::Type viewType_;
public:
OutOfLineLoadTypedArrayOutOfBounds(AnyRegister dest, Scalar::Type viewType)
: dest_(dest), viewType_(viewType) {}
AnyRegister dest() const { return dest_; }
Scalar::Type viewType() const { return viewType_; }
void accept(CodeGeneratorX86Shared* codegen) override {
codegen->visitOutOfLineLoadTypedArrayOutOfBounds(this);
}
};
NonAssertingLabel deoptLabel_;
Operand ToOperand(const LAllocation& a);
Operand ToOperand(const LAllocation* a);
Operand ToOperand(const LDefinition* def);
#ifdef JS_PUNBOX64
Operand ToOperandOrRegister64(const LInt64Allocation input);
#else
Register64 ToOperandOrRegister64(const LInt64Allocation input);
#endif
MoveOperand toMoveOperand(LAllocation a) const;
void bailoutIf(Assembler::Condition condition, LSnapshot* snapshot);
void bailoutIf(Assembler::DoubleCondition condition, LSnapshot* snapshot);
void bailoutFrom(Label* label, LSnapshot* snapshot);
void bailout(LSnapshot* snapshot);
template <typename T1, typename T2>
void bailoutCmpPtr(Assembler::Condition c, T1 lhs, T2 rhs,
LSnapshot* snapshot) {
masm.cmpPtr(lhs, rhs);
bailoutIf(c, snapshot);
}
void bailoutTestPtr(Assembler::Condition c, Register lhs, Register rhs,
LSnapshot* snapshot) {
masm.testPtr(lhs, rhs);
bailoutIf(c, snapshot);
}
template <typename T1, typename T2>
void bailoutCmp32(Assembler::Condition c, T1 lhs, T2 rhs,
LSnapshot* snapshot) {
masm.cmp32(lhs, rhs);
bailoutIf(c, snapshot);
}
template <typename T1, typename T2>
void bailoutTest32(Assembler::Condition c, T1 lhs, T2 rhs,
LSnapshot* snapshot) {
masm.test32(lhs, rhs);
bailoutIf(c, snapshot);
}
void bailoutIfFalseBool(Register reg, LSnapshot* snapshot) {
masm.test32(reg, Imm32(0xFF));
bailoutIf(Assembler::Zero, snapshot);
}
void bailoutCvttsd2si(FloatRegister src, Register dest, LSnapshot* snapshot) {
Label bail;
masm.truncateDoubleToInt32(src, dest, &bail);
bailoutFrom(&bail, snapshot);
}
void bailoutCvttss2si(FloatRegister src, Register dest, LSnapshot* snapshot) {
Label bail;
masm.truncateFloat32ToInt32(src, dest, &bail);
bailoutFrom(&bail, snapshot);
}
bool generateOutOfLineCode();
void emitCompare(MCompare::CompareType type, const LAllocation* left,
const LAllocation* right);
// Emits a branch that directs control flow to the true block if |cond| is
// true, and the false block if |cond| is false.
void emitBranch(Assembler::Condition cond, MBasicBlock* ifTrue,
MBasicBlock* ifFalse,
Assembler::NaNCond ifNaN = Assembler::NaN_HandledByCond);
void emitBranch(Assembler::DoubleCondition cond, MBasicBlock* ifTrue,
MBasicBlock* ifFalse);
void testNullEmitBranch(Assembler::Condition cond, const ValueOperand& value,
MBasicBlock* ifTrue, MBasicBlock* ifFalse) {
cond = masm.testNull(cond, value);
emitBranch(cond, ifTrue, ifFalse);
}
void testUndefinedEmitBranch(Assembler::Condition cond,
const ValueOperand& value, MBasicBlock* ifTrue,
MBasicBlock* ifFalse) {
cond = masm.testUndefined(cond, value);
emitBranch(cond, ifTrue, ifFalse);
}
void testObjectEmitBranch(Assembler::Condition cond,
const ValueOperand& value, MBasicBlock* ifTrue,
MBasicBlock* ifFalse) {
cond = masm.testObject(cond, value);
emitBranch(cond, ifTrue, ifFalse);
}
void testZeroEmitBranch(Assembler::Condition cond, Register reg,
MBasicBlock* ifTrue, MBasicBlock* ifFalse) {
MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual);
masm.cmpPtr(reg, ImmWord(0));
emitBranch(cond, ifTrue, ifFalse);
}
void emitTableSwitchDispatch(MTableSwitch* mir, Register index,
Register base);
void generateInvalidateEpilogue();
void canonicalizeIfDeterministic(Scalar::Type type, const LAllocation* value);
template <typename T>
Operand toMemoryAccessOperand(T* lir, int32_t disp);
public:
// Out of line visitors.
void visitOutOfLineBailout(OutOfLineBailout* ool);
void visitOutOfLineUndoALUOperation(OutOfLineUndoALUOperation* ool);
void visitMulNegativeZeroCheck(MulNegativeZeroCheck* ool);
void visitModOverflowCheck(ModOverflowCheck* ool);
void visitReturnZero(ReturnZero* ool);
void visitOutOfLineTableSwitch(OutOfLineTableSwitch* ool);
void visitOutOfLineLoadTypedArrayOutOfBounds(
OutOfLineLoadTypedArrayOutOfBounds* ool);
void visitOutOfLineWasmTruncateCheck(OutOfLineWasmTruncateCheck* ool);
};
// An out-of-line bailout thunk.
class OutOfLineBailout : public OutOfLineCodeBase<CodeGeneratorX86Shared> {
LSnapshot* snapshot_;
public:
explicit OutOfLineBailout(LSnapshot* snapshot) : snapshot_(snapshot) {}
void accept(CodeGeneratorX86Shared* codegen) override;
LSnapshot* snapshot() const { return snapshot_; }
};
} // namespace jit
} // namespace js
#endif /* jit_x86_shared_CodeGenerator_x86_shared_h */
|
