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
|
// Copyright 2013 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_COMPILER_MACHINE_OPERATOR_H_
#define V8_COMPILER_MACHINE_OPERATOR_H_
#include "src/base/flags.h"
#include "src/compiler/machine-type.h"
namespace v8 {
namespace internal {
namespace compiler {
// Forward declarations.
struct MachineOperatorGlobalCache;
class Operator;
// For operators that are not supported on all platforms.
class OptionalOperator final {
public:
explicit OptionalOperator(const Operator* op) : op_(op) {}
bool IsSupported() const { return op_ != nullptr; }
const Operator* op() const {
DCHECK_NOT_NULL(op_);
return op_;
}
private:
const Operator* const op_;
};
// Supported float64 to int32 truncation modes.
enum class TruncationMode : uint8_t {
kJavaScript, // ES6 section 7.1.5
kRoundToZero // Round towards zero. Implementation defined for NaN and ovf.
};
V8_INLINE size_t hash_value(TruncationMode mode) {
return static_cast<uint8_t>(mode);
}
std::ostream& operator<<(std::ostream&, TruncationMode);
TruncationMode TruncationModeOf(Operator const*);
// Supported write barrier modes.
enum WriteBarrierKind {
kNoWriteBarrier,
kMapWriteBarrier,
kPointerWriteBarrier,
kFullWriteBarrier
};
std::ostream& operator<<(std::ostream& os, WriteBarrierKind);
// A Load needs a MachineType.
typedef MachineType LoadRepresentation;
// A Store needs a MachineType and a WriteBarrierKind in order to emit the
// correct write barrier.
class StoreRepresentation final {
public:
StoreRepresentation(MachineType machine_type,
WriteBarrierKind write_barrier_kind)
: machine_type_(machine_type), write_barrier_kind_(write_barrier_kind) {}
MachineType machine_type() const { return machine_type_; }
WriteBarrierKind write_barrier_kind() const { return write_barrier_kind_; }
private:
MachineType machine_type_;
WriteBarrierKind write_barrier_kind_;
};
bool operator==(StoreRepresentation, StoreRepresentation);
bool operator!=(StoreRepresentation, StoreRepresentation);
size_t hash_value(StoreRepresentation);
std::ostream& operator<<(std::ostream&, StoreRepresentation);
StoreRepresentation const& StoreRepresentationOf(Operator const*);
// A CheckedLoad needs a MachineType.
typedef MachineType CheckedLoadRepresentation;
CheckedLoadRepresentation CheckedLoadRepresentationOf(Operator const*);
// A CheckedStore needs a MachineType.
typedef MachineType CheckedStoreRepresentation;
CheckedStoreRepresentation CheckedStoreRepresentationOf(Operator const*);
// Interface for building machine-level operators. These operators are
// machine-level but machine-independent and thus define a language suitable
// for generating code to run on architectures such as ia32, x64, arm, etc.
class MachineOperatorBuilder final : public ZoneObject {
public:
// Flags that specify which operations are available. This is useful
// for operations that are unsupported by some back-ends.
enum Flag {
kNoFlags = 0u,
// Note that Float*Max behaves like `(b < a) ? a : b`, not like Math.max().
// Note that Float*Min behaves like `(a < b) ? a : b`, not like Math.min().
kFloat32Max = 1u << 0,
kFloat32Min = 1u << 1,
kFloat64Max = 1u << 2,
kFloat64Min = 1u << 3,
kFloat64RoundDown = 1u << 4,
kFloat64RoundTruncate = 1u << 5,
kFloat64RoundTiesAway = 1u << 6,
kInt32DivIsSafe = 1u << 7,
kUint32DivIsSafe = 1u << 8,
kWord32ShiftIsSafe = 1u << 9,
kWord32Ctz = 1u << 10,
kWord32Popcnt = 1u << 11,
kWord64Ctz = 1u << 12,
kWord64Popcnt = 1u << 13,
kAllOptionalOps = kFloat32Max | kFloat32Min | kFloat64Max | kFloat64Min |
kFloat64RoundDown | kFloat64RoundTruncate |
kFloat64RoundTiesAway | kWord32Ctz | kWord32Popcnt |
kWord64Ctz | kWord64Popcnt
};
typedef base::Flags<Flag, unsigned> Flags;
explicit MachineOperatorBuilder(Zone* zone, MachineType word = kMachPtr,
Flags supportedOperators = kNoFlags);
const Operator* Word32And();
const Operator* Word32Or();
const Operator* Word32Xor();
const Operator* Word32Shl();
const Operator* Word32Shr();
const Operator* Word32Sar();
const Operator* Word32Ror();
const Operator* Word32Equal();
const Operator* Word32Clz();
const OptionalOperator Word32Ctz();
const OptionalOperator Word32Popcnt();
const OptionalOperator Word64Popcnt();
bool Word32ShiftIsSafe() const { return flags_ & kWord32ShiftIsSafe; }
const Operator* Word64And();
const Operator* Word64Or();
const Operator* Word64Xor();
const Operator* Word64Shl();
const Operator* Word64Shr();
const Operator* Word64Sar();
const Operator* Word64Ror();
const Operator* Word64Clz();
const OptionalOperator Word64Ctz();
const Operator* Word64Equal();
const Operator* Int32Add();
const Operator* Int32AddWithOverflow();
const Operator* Int32Sub();
const Operator* Int32SubWithOverflow();
const Operator* Int32Mul();
const Operator* Int32MulHigh();
const Operator* Int32Div();
const Operator* Int32Mod();
const Operator* Int32LessThan();
const Operator* Int32LessThanOrEqual();
const Operator* Uint32Div();
const Operator* Uint32LessThan();
const Operator* Uint32LessThanOrEqual();
const Operator* Uint32Mod();
const Operator* Uint32MulHigh();
bool Int32DivIsSafe() const { return flags_ & kInt32DivIsSafe; }
bool Uint32DivIsSafe() const { return flags_ & kUint32DivIsSafe; }
const Operator* Int64Add();
const Operator* Int64Sub();
const Operator* Int64Mul();
const Operator* Int64Div();
const Operator* Int64Mod();
const Operator* Int64LessThan();
const Operator* Int64LessThanOrEqual();
const Operator* Uint64Div();
const Operator* Uint64LessThan();
const Operator* Uint64LessThanOrEqual();
const Operator* Uint64Mod();
// These operators change the representation of numbers while preserving the
// value of the number. Narrowing operators assume the input is representable
// in the target type and are *not* defined for other inputs.
// Use narrowing change operators only when there is a static guarantee that
// the input value is representable in the target value.
const Operator* ChangeFloat32ToFloat64();
const Operator* ChangeFloat64ToInt32(); // narrowing
const Operator* ChangeFloat64ToUint32(); // narrowing
const Operator* ChangeInt32ToFloat64();
const Operator* ChangeInt32ToInt64();
const Operator* ChangeUint32ToFloat64();
const Operator* ChangeUint32ToUint64();
// These operators truncate or round numbers, both changing the representation
// of the number and mapping multiple input values onto the same output value.
const Operator* TruncateFloat64ToFloat32();
const Operator* TruncateFloat64ToInt32(TruncationMode);
const Operator* TruncateInt64ToInt32();
const Operator* RoundInt64ToFloat32();
const Operator* RoundInt64ToFloat64();
// These operators reinterpret the bits of a floating point number as an
// integer and vice versa.
const Operator* BitcastFloat32ToInt32();
const Operator* BitcastFloat64ToInt64();
const Operator* BitcastInt32ToFloat32();
const Operator* BitcastInt64ToFloat64();
// Floating point operators always operate with IEEE 754 round-to-nearest
// (single-precision).
const Operator* Float32Add();
const Operator* Float32Sub();
const Operator* Float32Mul();
const Operator* Float32Div();
const Operator* Float32Sqrt();
// Floating point operators always operate with IEEE 754 round-to-nearest
// (double-precision).
const Operator* Float64Add();
const Operator* Float64Sub();
const Operator* Float64Mul();
const Operator* Float64Div();
const Operator* Float64Mod();
const Operator* Float64Sqrt();
// Floating point comparisons complying to IEEE 754 (single-precision).
const Operator* Float32Equal();
const Operator* Float32LessThan();
const Operator* Float32LessThanOrEqual();
// Floating point comparisons complying to IEEE 754 (double-precision).
const Operator* Float64Equal();
const Operator* Float64LessThan();
const Operator* Float64LessThanOrEqual();
// Floating point min/max complying to IEEE 754 (single-precision).
const OptionalOperator Float32Max();
const OptionalOperator Float32Min();
// Floating point min/max complying to IEEE 754 (double-precision).
const OptionalOperator Float64Max();
const OptionalOperator Float64Min();
// Floating point abs complying to IEEE 754 (single-precision).
const Operator* Float32Abs();
// Floating point abs complying to IEEE 754 (double-precision).
const Operator* Float64Abs();
// Floating point rounding.
const OptionalOperator Float64RoundDown();
const OptionalOperator Float64RoundTruncate();
const OptionalOperator Float64RoundTiesAway();
// Floating point bit representation.
const Operator* Float64ExtractLowWord32();
const Operator* Float64ExtractHighWord32();
const Operator* Float64InsertLowWord32();
const Operator* Float64InsertHighWord32();
// load [base + index]
const Operator* Load(LoadRepresentation rep);
// store [base + index], value
const Operator* Store(StoreRepresentation rep);
// Access to the machine stack.
const Operator* LoadStackPointer();
const Operator* LoadFramePointer();
// checked-load heap, index, length
const Operator* CheckedLoad(CheckedLoadRepresentation);
// checked-store heap, index, length, value
const Operator* CheckedStore(CheckedStoreRepresentation);
// Target machine word-size assumed by this builder.
bool Is32() const { return word() == kRepWord32; }
bool Is64() const { return word() == kRepWord64; }
MachineType word() const { return word_; }
// Pseudo operators that translate to 32/64-bit operators depending on the
// word-size of the target machine assumed by this builder.
#define PSEUDO_OP_LIST(V) \
V(Word, And) \
V(Word, Or) \
V(Word, Xor) \
V(Word, Shl) \
V(Word, Shr) \
V(Word, Sar) \
V(Word, Ror) \
V(Word, Equal) \
V(Int, Add) \
V(Int, Sub) \
V(Int, Mul) \
V(Int, Div) \
V(Int, Mod) \
V(Int, LessThan) \
V(Int, LessThanOrEqual) \
V(Uint, Div) \
V(Uint, LessThan) \
V(Uint, Mod)
#define PSEUDO_OP(Prefix, Suffix) \
const Operator* Prefix##Suffix() { \
return Is32() ? Prefix##32##Suffix() : Prefix##64##Suffix(); \
}
PSEUDO_OP_LIST(PSEUDO_OP)
#undef PSEUDO_OP
#undef PSEUDO_OP_LIST
private:
MachineOperatorGlobalCache const& cache_;
MachineType const word_;
Flags const flags_;
DISALLOW_COPY_AND_ASSIGN(MachineOperatorBuilder);
};
DEFINE_OPERATORS_FOR_FLAGS(MachineOperatorBuilder::Flags)
} // namespace compiler
} // namespace internal
} // namespace v8
#endif // V8_COMPILER_MACHINE_OPERATOR_H_
|