1 // Copyright 2014 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef V8_COMPILER_SIMPLIFIED_OPERATOR_H_
6 #define V8_COMPILER_SIMPLIFIED_OPERATOR_H_
7
8 #include <iosfwd>
9
10 #include "src/base/compiler-specific.h"
11 #include "src/compiler/operator.h"
12 #include "src/compiler/types.h"
13 #include "src/deoptimize-reason.h"
14 #include "src/globals.h"
15 #include "src/handles.h"
16 #include "src/machine-type.h"
17 #include "src/objects.h"
18 #include "src/type-hints.h"
19 #include "src/vector-slot-pair.h"
20 #include "src/zone/zone-handle-set.h"
21
22 namespace v8 {
23 namespace internal {
24
25 // Forward declarations.
26 enum class AbortReason;
27 class Zone;
28
29 namespace compiler {
30
31 // Forward declarations.
32 class Operator;
33 struct SimplifiedOperatorGlobalCache;
34
35 enum BaseTaggedness : uint8_t { kUntaggedBase, kTaggedBase };
36
37 size_t hash_value(BaseTaggedness);
38
39 std::ostream& operator<<(std::ostream&, BaseTaggedness);
40
41 size_t hash_value(LoadSensitivity);
42
43 std::ostream& operator<<(std::ostream&, LoadSensitivity);
44
45 // An access descriptor for loads/stores of fixed structures like field
46 // accesses of heap objects. Accesses from either tagged or untagged base
47 // pointers are supported; untagging is done automatically during lowering.
48 struct FieldAccess {
49 BaseTaggedness base_is_tagged; // specifies if the base pointer is tagged.
50 int offset; // offset of the field, without tag.
51 MaybeHandle<Name> name; // debugging only.
52 MaybeHandle<Map> map; // map of the field value (if known).
53 Type type; // type of the field.
54 MachineType machine_type; // machine type of the field.
55 WriteBarrierKind write_barrier_kind; // write barrier hint.
56 LoadSensitivity load_sensitivity; // load safety for poisoning.
57
FieldAccessFieldAccess58 FieldAccess()
59 : base_is_tagged(kTaggedBase),
60 offset(0),
61 type(Type::None()),
62 machine_type(MachineType::None()),
63 write_barrier_kind(kFullWriteBarrier),
64 load_sensitivity(LoadSensitivity::kUnsafe) {}
65
66 FieldAccess(BaseTaggedness base_is_tagged, int offset, MaybeHandle<Name> name,
67 MaybeHandle<Map> map, Type type, MachineType machine_type,
68 WriteBarrierKind write_barrier_kind,
69 LoadSensitivity load_sensitivity = LoadSensitivity::kUnsafe)
base_is_taggedFieldAccess70 : base_is_tagged(base_is_tagged),
71 offset(offset),
72 name(name),
73 map(map),
74 type(type),
75 machine_type(machine_type),
76 write_barrier_kind(write_barrier_kind),
77 load_sensitivity(load_sensitivity) {}
78
tagFieldAccess79 int tag() const { return base_is_tagged == kTaggedBase ? kHeapObjectTag : 0; }
80 };
81
82 V8_EXPORT_PRIVATE bool operator==(FieldAccess const&, FieldAccess const&);
83
84 size_t hash_value(FieldAccess const&);
85
86 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, FieldAccess const&);
87
88 V8_EXPORT_PRIVATE FieldAccess const& FieldAccessOf(const Operator* op)
89 V8_WARN_UNUSED_RESULT;
90
91 template <>
92 void Operator1<FieldAccess>::PrintParameter(std::ostream& os,
93 PrintVerbosity verbose) const;
94
95 // An access descriptor for loads/stores of indexed structures like characters
96 // in strings or off-heap backing stores. Accesses from either tagged or
97 // untagged base pointers are supported; untagging is done automatically during
98 // lowering.
99 struct ElementAccess {
100 BaseTaggedness base_is_tagged; // specifies if the base pointer is tagged.
101 int header_size; // size of the header, without tag.
102 Type type; // type of the element.
103 MachineType machine_type; // machine type of the element.
104 WriteBarrierKind write_barrier_kind; // write barrier hint.
105 LoadSensitivity load_sensitivity; // load safety for poisoning.
106
ElementAccessElementAccess107 ElementAccess()
108 : base_is_tagged(kTaggedBase),
109 header_size(0),
110 type(Type::None()),
111 machine_type(MachineType::None()),
112 write_barrier_kind(kFullWriteBarrier),
113 load_sensitivity(LoadSensitivity::kUnsafe) {}
114
115 ElementAccess(BaseTaggedness base_is_tagged, int header_size, Type type,
116 MachineType machine_type, WriteBarrierKind write_barrier_kind,
117 LoadSensitivity load_sensitivity = LoadSensitivity::kUnsafe)
base_is_taggedElementAccess118 : base_is_tagged(base_is_tagged),
119 header_size(header_size),
120 type(type),
121 machine_type(machine_type),
122 write_barrier_kind(write_barrier_kind),
123 load_sensitivity(load_sensitivity) {}
124
tagElementAccess125 int tag() const { return base_is_tagged == kTaggedBase ? kHeapObjectTag : 0; }
126 };
127
128 V8_EXPORT_PRIVATE bool operator==(ElementAccess const&, ElementAccess const&);
129
130 size_t hash_value(ElementAccess const&);
131
132 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, ElementAccess const&);
133
134 V8_EXPORT_PRIVATE ElementAccess const& ElementAccessOf(const Operator* op)
135 V8_WARN_UNUSED_RESULT;
136
137 ExternalArrayType ExternalArrayTypeOf(const Operator* op) V8_WARN_UNUSED_RESULT;
138
139 // The ConvertReceiverMode is used as parameter by ConvertReceiver operators.
140 ConvertReceiverMode ConvertReceiverModeOf(Operator const* op)
141 V8_WARN_UNUSED_RESULT;
142
143 // A the parameters for several Check nodes. The {feedback} parameter is
144 // optional. If {feedback} references a valid CallIC slot and this MapCheck
145 // fails, then speculation on that CallIC slot will be disabled.
146 class CheckParameters final {
147 public:
CheckParameters(const VectorSlotPair & feedback)148 explicit CheckParameters(const VectorSlotPair& feedback)
149 : feedback_(feedback) {}
150
feedback()151 VectorSlotPair const& feedback() const { return feedback_; }
152
153 private:
154 VectorSlotPair feedback_;
155 };
156
157 bool operator==(CheckParameters const&, CheckParameters const&);
158
159 size_t hash_value(CheckParameters const&);
160
161 std::ostream& operator<<(std::ostream&, CheckParameters const&);
162
163 CheckParameters const& CheckParametersOf(Operator const*) V8_WARN_UNUSED_RESULT;
164
165 enum class CheckFloat64HoleMode : uint8_t {
166 kNeverReturnHole, // Never return the hole (deoptimize instead).
167 kAllowReturnHole // Allow to return the hole (signaling NaN).
168 };
169
170 size_t hash_value(CheckFloat64HoleMode);
171
172 std::ostream& operator<<(std::ostream&, CheckFloat64HoleMode);
173
174 CheckFloat64HoleMode CheckFloat64HoleModeOf(const Operator*)
175 V8_WARN_UNUSED_RESULT;
176
177 enum class CheckTaggedInputMode : uint8_t {
178 kNumber,
179 kNumberOrOddball,
180 };
181
182 size_t hash_value(CheckTaggedInputMode);
183
184 std::ostream& operator<<(std::ostream&, CheckTaggedInputMode);
185
186 class CheckTaggedInputParameters {
187 public:
CheckTaggedInputParameters(CheckTaggedInputMode mode,const VectorSlotPair & feedback)188 CheckTaggedInputParameters(CheckTaggedInputMode mode,
189 const VectorSlotPair& feedback)
190 : mode_(mode), feedback_(feedback) {}
191
mode()192 CheckTaggedInputMode mode() const { return mode_; }
feedback()193 const VectorSlotPair& feedback() const { return feedback_; }
194
195 private:
196 CheckTaggedInputMode mode_;
197 VectorSlotPair feedback_;
198 };
199
200 const CheckTaggedInputParameters& CheckTaggedInputParametersOf(const Operator*)
201 V8_WARN_UNUSED_RESULT;
202
203 std::ostream& operator<<(std::ostream&,
204 const CheckTaggedInputParameters& params);
205
206 size_t hash_value(const CheckTaggedInputParameters& params);
207
208 bool operator==(CheckTaggedInputParameters const&,
209 CheckTaggedInputParameters const&);
210
211 enum class CheckForMinusZeroMode : uint8_t {
212 kCheckForMinusZero,
213 kDontCheckForMinusZero,
214 };
215
216 size_t hash_value(CheckForMinusZeroMode);
217
218 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&,
219 CheckForMinusZeroMode);
220
221 CheckForMinusZeroMode CheckMinusZeroModeOf(const Operator*)
222 V8_WARN_UNUSED_RESULT;
223
224 class CheckMinusZeroParameters {
225 public:
CheckMinusZeroParameters(CheckForMinusZeroMode mode,const VectorSlotPair & feedback)226 CheckMinusZeroParameters(CheckForMinusZeroMode mode,
227 const VectorSlotPair& feedback)
228 : mode_(mode), feedback_(feedback) {}
229
mode()230 CheckForMinusZeroMode mode() const { return mode_; }
feedback()231 const VectorSlotPair& feedback() const { return feedback_; }
232
233 private:
234 CheckForMinusZeroMode mode_;
235 VectorSlotPair feedback_;
236 };
237
238 const CheckMinusZeroParameters& CheckMinusZeroParametersOf(const Operator* op)
239 V8_WARN_UNUSED_RESULT;
240
241 std::ostream& operator<<(std::ostream&, const CheckMinusZeroParameters& params);
242
243 size_t hash_value(const CheckMinusZeroParameters& params);
244
245 bool operator==(CheckMinusZeroParameters const&,
246 CheckMinusZeroParameters const&);
247
248 // Flags for map checks.
249 enum class CheckMapsFlag : uint8_t {
250 kNone = 0u,
251 kTryMigrateInstance = 1u << 0, // Try instance migration.
252 };
253 typedef base::Flags<CheckMapsFlag> CheckMapsFlags;
254
255 DEFINE_OPERATORS_FOR_FLAGS(CheckMapsFlags)
256
257 std::ostream& operator<<(std::ostream&, CheckMapsFlags);
258
259 class MapsParameterInfo {
260 public:
261 explicit MapsParameterInfo(ZoneHandleSet<Map> const& maps);
262
instance_type()263 Maybe<InstanceType> instance_type() const { return instance_type_; }
maps()264 ZoneHandleSet<Map> const& maps() const { return maps_; }
265
266 private:
267 ZoneHandleSet<Map> const maps_;
268 Maybe<InstanceType> instance_type_;
269 };
270
271 std::ostream& operator<<(std::ostream&, MapsParameterInfo const&);
272
273 bool operator==(MapsParameterInfo const&, MapsParameterInfo const&);
274 bool operator!=(MapsParameterInfo const&, MapsParameterInfo const&);
275
276 size_t hash_value(MapsParameterInfo const&);
277
278 // A descriptor for map checks. The {feedback} parameter is optional.
279 // If {feedback} references a valid CallIC slot and this MapCheck fails,
280 // then speculation on that CallIC slot will be disabled.
281 class CheckMapsParameters final {
282 public:
CheckMapsParameters(CheckMapsFlags flags,ZoneHandleSet<Map> const & maps,const VectorSlotPair & feedback)283 CheckMapsParameters(CheckMapsFlags flags, ZoneHandleSet<Map> const& maps,
284 const VectorSlotPair& feedback)
285 : flags_(flags), maps_info_(maps), feedback_(feedback) {}
286
flags()287 CheckMapsFlags flags() const { return flags_; }
maps()288 ZoneHandleSet<Map> const& maps() const { return maps_info_.maps(); }
maps_info()289 MapsParameterInfo const& maps_info() const { return maps_info_; }
feedback()290 VectorSlotPair const& feedback() const { return feedback_; }
291
292 private:
293 CheckMapsFlags const flags_;
294 MapsParameterInfo const maps_info_;
295 VectorSlotPair const feedback_;
296 };
297
298 bool operator==(CheckMapsParameters const&, CheckMapsParameters const&);
299
300 size_t hash_value(CheckMapsParameters const&);
301
302 std::ostream& operator<<(std::ostream&, CheckMapsParameters const&);
303
304 CheckMapsParameters const& CheckMapsParametersOf(Operator const*)
305 V8_WARN_UNUSED_RESULT;
306
307 MapsParameterInfo const& MapGuardMapsOf(Operator const*) V8_WARN_UNUSED_RESULT;
308
309 // Parameters for CompareMaps operator.
310 MapsParameterInfo const& CompareMapsParametersOf(Operator const*)
311 V8_WARN_UNUSED_RESULT;
312
313 // A descriptor for growing elements backing stores.
314 enum class GrowFastElementsMode : uint8_t {
315 kDoubleElements,
316 kSmiOrObjectElements
317 };
318
hash_value(GrowFastElementsMode mode)319 inline size_t hash_value(GrowFastElementsMode mode) {
320 return static_cast<uint8_t>(mode);
321 }
322
323 std::ostream& operator<<(std::ostream&, GrowFastElementsMode);
324
325 class GrowFastElementsParameters {
326 public:
GrowFastElementsParameters(GrowFastElementsMode mode,const VectorSlotPair & feedback)327 GrowFastElementsParameters(GrowFastElementsMode mode,
328 const VectorSlotPair& feedback)
329 : mode_(mode), feedback_(feedback) {}
330
mode()331 GrowFastElementsMode mode() const { return mode_; }
feedback()332 const VectorSlotPair& feedback() const { return feedback_; }
333
334 private:
335 GrowFastElementsMode mode_;
336 VectorSlotPair feedback_;
337 };
338
339 bool operator==(const GrowFastElementsParameters&,
340 const GrowFastElementsParameters&);
341
342 inline size_t hash_value(const GrowFastElementsParameters&);
343
344 std::ostream& operator<<(std::ostream&, const GrowFastElementsParameters&);
345
346 const GrowFastElementsParameters& GrowFastElementsParametersOf(const Operator*)
347 V8_WARN_UNUSED_RESULT;
348
349 // A descriptor for elements kind transitions.
350 class ElementsTransition final {
351 public:
352 enum Mode : uint8_t {
353 kFastTransition, // simple transition, just updating the map.
354 kSlowTransition // full transition, round-trip to the runtime.
355 };
356
ElementsTransition(Mode mode,Handle<Map> source,Handle<Map> target)357 ElementsTransition(Mode mode, Handle<Map> source, Handle<Map> target)
358 : mode_(mode), source_(source), target_(target) {}
359
mode()360 Mode mode() const { return mode_; }
source()361 Handle<Map> source() const { return source_; }
target()362 Handle<Map> target() const { return target_; }
363
364 private:
365 Mode const mode_;
366 Handle<Map> const source_;
367 Handle<Map> const target_;
368 };
369
370 bool operator==(ElementsTransition const&, ElementsTransition const&);
371
372 size_t hash_value(ElementsTransition);
373
374 std::ostream& operator<<(std::ostream&, ElementsTransition);
375
376 ElementsTransition const& ElementsTransitionOf(const Operator* op)
377 V8_WARN_UNUSED_RESULT;
378
379 // Parameters for TransitionAndStoreElement, or
380 // TransitionAndStoreNonNumberElement, or
381 // TransitionAndStoreNumberElement.
382 Handle<Map> DoubleMapParameterOf(const Operator* op) V8_WARN_UNUSED_RESULT;
383 Handle<Map> FastMapParameterOf(const Operator* op) V8_WARN_UNUSED_RESULT;
384
385 // Parameters for TransitionAndStoreNonNumberElement.
386 Type ValueTypeParameterOf(const Operator* op) V8_WARN_UNUSED_RESULT;
387
388 // A hint for speculative number operations.
389 enum class NumberOperationHint : uint8_t {
390 kSignedSmall, // Inputs were Smi, output was in Smi.
391 kSignedSmallInputs, // Inputs were Smi, output was Number.
392 kSigned32, // Inputs were Signed32, output was Number.
393 kNumber, // Inputs were Number, output was Number.
394 kNumberOrOddball, // Inputs were Number or Oddball, output was Number.
395 };
396
397 size_t hash_value(NumberOperationHint);
398
399 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, NumberOperationHint);
400
401 V8_EXPORT_PRIVATE NumberOperationHint NumberOperationHintOf(const Operator* op)
402 V8_WARN_UNUSED_RESULT;
403
404 class NumberOperationParameters {
405 public:
NumberOperationParameters(NumberOperationHint hint,const VectorSlotPair & feedback)406 NumberOperationParameters(NumberOperationHint hint,
407 const VectorSlotPair& feedback)
408 : hint_(hint), feedback_(feedback) {}
409
hint()410 NumberOperationHint hint() const { return hint_; }
feedback()411 const VectorSlotPair& feedback() const { return feedback_; }
412
413 private:
414 NumberOperationHint hint_;
415 VectorSlotPair feedback_;
416 };
417
418 size_t hash_value(NumberOperationParameters const&);
419 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&,
420 const NumberOperationParameters&);
421 bool operator==(NumberOperationParameters const&,
422 NumberOperationParameters const&);
423 const NumberOperationParameters& NumberOperationParametersOf(const Operator* op)
424 V8_WARN_UNUSED_RESULT;
425
426 int FormalParameterCountOf(const Operator* op) V8_WARN_UNUSED_RESULT;
427 bool IsRestLengthOf(const Operator* op) V8_WARN_UNUSED_RESULT;
428
429 class AllocateParameters {
430 public:
AllocateParameters(Type type,PretenureFlag pretenure)431 AllocateParameters(Type type, PretenureFlag pretenure)
432 : type_(type), pretenure_(pretenure) {}
433
type()434 Type type() const { return type_; }
pretenure()435 PretenureFlag pretenure() const { return pretenure_; }
436
437 private:
438 Type type_;
439 PretenureFlag pretenure_;
440 };
441
442 bool IsCheckedWithFeedback(const Operator* op);
443
444 size_t hash_value(AllocateParameters);
445
446 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, AllocateParameters);
447
448 bool operator==(AllocateParameters const&, AllocateParameters const&);
449
450 PretenureFlag PretenureFlagOf(const Operator* op) V8_WARN_UNUSED_RESULT;
451
452 Type AllocateTypeOf(const Operator* op) V8_WARN_UNUSED_RESULT;
453
454 UnicodeEncoding UnicodeEncodingOf(const Operator*) V8_WARN_UNUSED_RESULT;
455
456 AbortReason AbortReasonOf(const Operator* op) V8_WARN_UNUSED_RESULT;
457
458 DeoptimizeReason DeoptimizeReasonOf(const Operator* op) V8_WARN_UNUSED_RESULT;
459
460 int NewArgumentsElementsMappedCountOf(const Operator* op) V8_WARN_UNUSED_RESULT;
461
462 // Interface for building simplified operators, which represent the
463 // medium-level operations of V8, including adding numbers, allocating objects,
464 // indexing into objects and arrays, etc.
465 // All operators are typed but many are representation independent.
466
467 // Number values from JS can be in one of these representations:
468 // - Tagged: word-sized integer that is either
469 // - a signed small integer (31 or 32 bits plus a tag)
470 // - a tagged pointer to a HeapNumber object that has a float64 field
471 // - Int32: an untagged signed 32-bit integer
472 // - Uint32: an untagged unsigned 32-bit integer
473 // - Float64: an untagged float64
474
475 // Additional representations for intermediate code or non-JS code:
476 // - Int64: an untagged signed 64-bit integer
477 // - Uint64: an untagged unsigned 64-bit integer
478 // - Float32: an untagged float32
479
480 // Boolean values can be:
481 // - Bool: a tagged pointer to either the canonical JS #false or
482 // the canonical JS #true object
483 // - Bit: an untagged integer 0 or 1, but word-sized
484 class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final
NON_EXPORTED_BASE(ZoneObject)485 : public NON_EXPORTED_BASE(ZoneObject) {
486 public:
487 explicit SimplifiedOperatorBuilder(Zone* zone);
488
489 const Operator* BooleanNot();
490
491 const Operator* NumberEqual();
492 const Operator* NumberLessThan();
493 const Operator* NumberLessThanOrEqual();
494 const Operator* NumberAdd();
495 const Operator* NumberSubtract();
496 const Operator* NumberMultiply();
497 const Operator* NumberDivide();
498 const Operator* NumberModulus();
499 const Operator* NumberBitwiseOr();
500 const Operator* NumberBitwiseXor();
501 const Operator* NumberBitwiseAnd();
502 const Operator* NumberShiftLeft();
503 const Operator* NumberShiftRight();
504 const Operator* NumberShiftRightLogical();
505 const Operator* NumberImul();
506 const Operator* NumberAbs();
507 const Operator* NumberClz32();
508 const Operator* NumberCeil();
509 const Operator* NumberFloor();
510 const Operator* NumberFround();
511 const Operator* NumberAcos();
512 const Operator* NumberAcosh();
513 const Operator* NumberAsin();
514 const Operator* NumberAsinh();
515 const Operator* NumberAtan();
516 const Operator* NumberAtan2();
517 const Operator* NumberAtanh();
518 const Operator* NumberCbrt();
519 const Operator* NumberCos();
520 const Operator* NumberCosh();
521 const Operator* NumberExp();
522 const Operator* NumberExpm1();
523 const Operator* NumberLog();
524 const Operator* NumberLog1p();
525 const Operator* NumberLog10();
526 const Operator* NumberLog2();
527 const Operator* NumberMax();
528 const Operator* NumberMin();
529 const Operator* NumberPow();
530 const Operator* NumberRound();
531 const Operator* NumberSign();
532 const Operator* NumberSin();
533 const Operator* NumberSinh();
534 const Operator* NumberSqrt();
535 const Operator* NumberTan();
536 const Operator* NumberTanh();
537 const Operator* NumberTrunc();
538 const Operator* NumberToBoolean();
539 const Operator* NumberToInt32();
540 const Operator* NumberToString();
541 const Operator* NumberToUint32();
542 const Operator* NumberToUint8Clamped();
543
544 const Operator* NumberSilenceNaN();
545
546 const Operator* SpeculativeSafeIntegerAdd(NumberOperationHint hint);
547 const Operator* SpeculativeSafeIntegerSubtract(NumberOperationHint hint);
548
549 const Operator* SpeculativeNumberAdd(NumberOperationHint hint);
550 const Operator* SpeculativeNumberSubtract(NumberOperationHint hint);
551 const Operator* SpeculativeNumberMultiply(NumberOperationHint hint);
552 const Operator* SpeculativeNumberDivide(NumberOperationHint hint);
553 const Operator* SpeculativeNumberModulus(NumberOperationHint hint);
554 const Operator* SpeculativeNumberShiftLeft(NumberOperationHint hint);
555 const Operator* SpeculativeNumberShiftRight(NumberOperationHint hint);
556 const Operator* SpeculativeNumberShiftRightLogical(NumberOperationHint hint);
557 const Operator* SpeculativeNumberBitwiseAnd(NumberOperationHint hint);
558 const Operator* SpeculativeNumberBitwiseOr(NumberOperationHint hint);
559 const Operator* SpeculativeNumberBitwiseXor(NumberOperationHint hint);
560
561 const Operator* SpeculativeNumberLessThan(NumberOperationHint hint);
562 const Operator* SpeculativeNumberLessThanOrEqual(NumberOperationHint hint);
563 const Operator* SpeculativeNumberEqual(NumberOperationHint hint);
564
565 const Operator* ReferenceEqual();
566 const Operator* SameValue();
567
568 const Operator* TypeOf();
569
570 const Operator* ToBoolean();
571
572 const Operator* StringEqual();
573 const Operator* StringLessThan();
574 const Operator* StringLessThanOrEqual();
575 const Operator* StringCharCodeAt();
576 const Operator* StringCodePointAt(UnicodeEncoding encoding);
577 const Operator* StringFromSingleCharCode();
578 const Operator* StringFromSingleCodePoint(UnicodeEncoding encoding);
579 const Operator* StringIndexOf();
580 const Operator* StringLength();
581 const Operator* StringToLowerCaseIntl();
582 const Operator* StringToUpperCaseIntl();
583 const Operator* StringSubstring();
584
585 const Operator* FindOrderedHashMapEntry();
586 const Operator* FindOrderedHashMapEntryForInt32Key();
587
588 const Operator* SpeculativeToNumber(NumberOperationHint hint,
589 const VectorSlotPair& feedback);
590
591 const Operator* StringToNumber();
592 const Operator* PlainPrimitiveToNumber();
593 const Operator* PlainPrimitiveToWord32();
594 const Operator* PlainPrimitiveToFloat64();
595
596 const Operator* ChangeTaggedSignedToInt32();
597 const Operator* ChangeTaggedToInt32();
598 const Operator* ChangeTaggedToUint32();
599 const Operator* ChangeTaggedToFloat64();
600 const Operator* ChangeTaggedToTaggedSigned();
601 const Operator* ChangeInt31ToTaggedSigned();
602 const Operator* ChangeInt32ToTagged();
603 const Operator* ChangeUint32ToTagged();
604 const Operator* ChangeFloat64ToTagged(CheckForMinusZeroMode);
605 const Operator* ChangeFloat64ToTaggedPointer();
606 const Operator* ChangeTaggedToBit();
607 const Operator* ChangeBitToTagged();
608 const Operator* TruncateTaggedToWord32();
609 const Operator* TruncateTaggedToFloat64();
610 const Operator* TruncateTaggedToBit();
611 const Operator* TruncateTaggedPointerToBit();
612
613 const Operator* PoisonIndex();
614 const Operator* CompareMaps(ZoneHandleSet<Map>);
615 const Operator* MapGuard(ZoneHandleSet<Map> maps);
616
617 const Operator* CheckBounds(const VectorSlotPair& feedback);
618 const Operator* CheckEqualsInternalizedString();
619 const Operator* CheckEqualsSymbol();
620 const Operator* CheckFloat64Hole(CheckFloat64HoleMode);
621 const Operator* CheckHeapObject();
622 const Operator* CheckIf(DeoptimizeReason deoptimize_reason);
623 const Operator* CheckInternalizedString();
624 const Operator* CheckMaps(CheckMapsFlags, ZoneHandleSet<Map>,
625 const VectorSlotPair& = VectorSlotPair());
626 const Operator* CheckNotTaggedHole();
627 const Operator* CheckNumber(const VectorSlotPair& feedback);
628 const Operator* CheckReceiver();
629 const Operator* CheckSmi(const VectorSlotPair& feedback);
630 const Operator* CheckString(const VectorSlotPair& feedback);
631 const Operator* CheckSymbol();
632
633 const Operator* CheckedFloat64ToInt32(CheckForMinusZeroMode,
634 const VectorSlotPair& feedback);
635 const Operator* CheckedInt32Add();
636 const Operator* CheckedInt32Div();
637 const Operator* CheckedInt32Mod();
638 const Operator* CheckedInt32Mul(CheckForMinusZeroMode);
639 const Operator* CheckedInt32Sub();
640 const Operator* CheckedInt32ToTaggedSigned(const VectorSlotPair& feedback);
641 const Operator* CheckedTaggedSignedToInt32(const VectorSlotPair& feedback);
642 const Operator* CheckedTaggedToFloat64(CheckTaggedInputMode,
643 const VectorSlotPair& feedback);
644 const Operator* CheckedTaggedToInt32(CheckForMinusZeroMode,
645 const VectorSlotPair& feedback);
646 const Operator* CheckedTaggedToTaggedPointer(const VectorSlotPair& feedback);
647 const Operator* CheckedTaggedToTaggedSigned(const VectorSlotPair& feedback);
648 const Operator* CheckedTruncateTaggedToWord32(CheckTaggedInputMode,
649 const VectorSlotPair& feedback);
650 const Operator* CheckedUint32Div();
651 const Operator* CheckedUint32Mod();
652 const Operator* CheckedUint32ToInt32(const VectorSlotPair& feedback);
653 const Operator* CheckedUint32ToTaggedSigned(const VectorSlotPair& feedback);
654
655 const Operator* ConvertReceiver(ConvertReceiverMode);
656
657 const Operator* ConvertTaggedHoleToUndefined();
658
659 const Operator* ObjectIsArrayBufferView();
660 const Operator* ObjectIsBigInt();
661 const Operator* ObjectIsCallable();
662 const Operator* ObjectIsConstructor();
663 const Operator* ObjectIsDetectableCallable();
664 const Operator* ObjectIsMinusZero();
665 const Operator* ObjectIsNaN();
666 const Operator* NumberIsNaN();
667 const Operator* ObjectIsNonCallable();
668 const Operator* ObjectIsNumber();
669 const Operator* ObjectIsReceiver();
670 const Operator* ObjectIsSmi();
671 const Operator* ObjectIsString();
672 const Operator* ObjectIsSymbol();
673 const Operator* ObjectIsUndetectable();
674
675 const Operator* NumberIsFloat64Hole();
676 const Operator* NumberIsFinite();
677 const Operator* ObjectIsFiniteNumber();
678 const Operator* NumberIsInteger();
679 const Operator* ObjectIsSafeInteger();
680 const Operator* NumberIsSafeInteger();
681 const Operator* ObjectIsInteger();
682
683 const Operator* ArgumentsFrame();
684 const Operator* ArgumentsLength(int formal_parameter_count,
685 bool is_rest_length);
686
687 const Operator* NewDoubleElements(PretenureFlag);
688 const Operator* NewSmiOrObjectElements(PretenureFlag);
689
690 // new-arguments-elements arguments-frame, arguments-length
691 const Operator* NewArgumentsElements(int mapped_count);
692
693 // new-cons-string length, first, second
694 const Operator* NewConsString();
695
696 // array-buffer-was-neutered buffer
697 const Operator* ArrayBufferWasNeutered();
698
699 // ensure-writable-fast-elements object, elements
700 const Operator* EnsureWritableFastElements();
701
702 // maybe-grow-fast-elements object, elements, index, length
703 const Operator* MaybeGrowFastElements(GrowFastElementsMode mode,
704 const VectorSlotPair& feedback);
705
706 // transition-elements-kind object, from-map, to-map
707 const Operator* TransitionElementsKind(ElementsTransition transition);
708
709 const Operator* Allocate(Type type, PretenureFlag pretenure = NOT_TENURED);
710 const Operator* AllocateRaw(Type type, PretenureFlag pretenure = NOT_TENURED);
711
712 const Operator* LoadFieldByIndex();
713 const Operator* LoadField(FieldAccess const&);
714 const Operator* StoreField(FieldAccess const&);
715
716 // load-element [base + index]
717 const Operator* LoadElement(ElementAccess const&);
718
719 // store-element [base + index], value
720 const Operator* StoreElement(ElementAccess const&);
721
722 // store-element [base + index], value, only with fast arrays.
723 const Operator* TransitionAndStoreElement(Handle<Map> double_map,
724 Handle<Map> fast_map);
725 // store-element [base + index], smi value, only with fast arrays.
726 const Operator* StoreSignedSmallElement();
727
728 // store-element [base + index], double value, only with fast arrays.
729 const Operator* TransitionAndStoreNumberElement(Handle<Map> double_map);
730
731 // store-element [base + index], object value, only with fast arrays.
732 const Operator* TransitionAndStoreNonNumberElement(Handle<Map> fast_map,
733 Type value_type);
734
735 // load-typed-element buffer, [base + external + index]
736 const Operator* LoadTypedElement(ExternalArrayType const&);
737
738 // store-typed-element buffer, [base + external + index], value
739 const Operator* StoreTypedElement(ExternalArrayType const&);
740
741 // Abort (for terminating execution on internal error).
742 const Operator* RuntimeAbort(AbortReason reason);
743
744 const Operator* DateNow();
745
746 private:
747 Zone* zone() const { return zone_; }
748
749 const SimplifiedOperatorGlobalCache& cache_;
750 Zone* const zone_;
751
752 DISALLOW_COPY_AND_ASSIGN(SimplifiedOperatorBuilder);
753 };
754
755 } // namespace compiler
756 } // namespace internal
757 } // namespace v8
758
759 #endif // V8_COMPILER_SIMPLIFIED_OPERATOR_H_
760