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_JS_TYPED_LOWERING_H_ 6 #define V8_COMPILER_JS_TYPED_LOWERING_H_ 7 8 #include "src/base/flags.h" 9 #include "src/compiler/graph-reducer.h" 10 #include "src/compiler/opcodes.h" 11 12 namespace v8 { 13 namespace internal { 14 15 // Forward declarations. 16 class CompilationDependencies; 17 class Factory; 18 class TypeCache; 19 20 21 namespace compiler { 22 23 // Forward declarations. 24 class CommonOperatorBuilder; 25 class JSGraph; 26 class JSOperatorBuilder; 27 class MachineOperatorBuilder; 28 class SimplifiedOperatorBuilder; 29 30 31 // Lowers JS-level operators to simplified operators based on types. 32 class JSTypedLowering final : public AdvancedReducer { 33 public: 34 // Flags that control the mode of operation. 35 enum Flag { 36 kNoFlags = 0u, 37 kDeoptimizationEnabled = 1u << 0, 38 kDisableBinaryOpReduction = 1u << 1, 39 kTypeFeedbackEnabled = 1u << 2, 40 }; 41 typedef base::Flags<Flag> Flags; 42 43 JSTypedLowering(Editor* editor, CompilationDependencies* dependencies, 44 Flags flags, JSGraph* jsgraph, Zone* zone); ~JSTypedLowering()45 ~JSTypedLowering() final {} 46 47 Reduction Reduce(Node* node) final; 48 49 private: 50 friend class JSBinopReduction; 51 52 Reduction ReduceJSAdd(Node* node); 53 Reduction ReduceJSModulus(Node* node); 54 Reduction ReduceJSBitwiseOr(Node* node); 55 Reduction ReduceJSMultiply(Node* node); 56 Reduction ReduceJSComparison(Node* node); 57 Reduction ReduceJSLoadNamed(Node* node); 58 Reduction ReduceJSLoadProperty(Node* node); 59 Reduction ReduceJSStoreProperty(Node* node); 60 Reduction ReduceJSInstanceOf(Node* node); 61 Reduction ReduceJSLoadContext(Node* node); 62 Reduction ReduceJSStoreContext(Node* node); 63 Reduction ReduceJSEqualTypeOf(Node* node, bool invert); 64 Reduction ReduceJSEqual(Node* node, bool invert); 65 Reduction ReduceJSStrictEqual(Node* node, bool invert); 66 Reduction ReduceJSToBoolean(Node* node); 67 Reduction ReduceJSToInteger(Node* node); 68 Reduction ReduceJSToLength(Node* node); 69 Reduction ReduceJSToNumberInput(Node* input); 70 Reduction ReduceJSToNumber(Node* node); 71 Reduction ReduceJSToStringInput(Node* input); 72 Reduction ReduceJSToString(Node* node); 73 Reduction ReduceJSToObject(Node* node); 74 Reduction ReduceJSConvertReceiver(Node* node); 75 Reduction ReduceJSCallConstruct(Node* node); 76 Reduction ReduceJSCallFunction(Node* node); 77 Reduction ReduceJSForInDone(Node* node); 78 Reduction ReduceJSForInNext(Node* node); 79 Reduction ReduceJSForInStep(Node* node); 80 Reduction ReduceJSGeneratorStore(Node* node); 81 Reduction ReduceJSGeneratorRestoreContinuation(Node* node); 82 Reduction ReduceJSGeneratorRestoreRegister(Node* node); 83 Reduction ReduceSelect(Node* node); 84 Reduction ReduceJSSubtract(Node* node); 85 Reduction ReduceJSDivide(Node* node); 86 Reduction ReduceInt32Binop(Node* node, const Operator* intOp); 87 Reduction ReduceUI32Shift(Node* node, Signedness left_signedness, 88 const Operator* shift_op); 89 90 Node* Word32Shl(Node* const lhs, int32_t const rhs); 91 92 Node* EmptyFrameState(); 93 94 Factory* factory() const; 95 Graph* graph() const; jsgraph()96 JSGraph* jsgraph() const { return jsgraph_; } 97 Isolate* isolate() const; 98 JSOperatorBuilder* javascript() const; 99 CommonOperatorBuilder* common() const; 100 SimplifiedOperatorBuilder* simplified() const; 101 MachineOperatorBuilder* machine() const; 102 CompilationDependencies* dependencies() const; flags()103 Flags flags() const { return flags_; } 104 105 CompilationDependencies* dependencies_; 106 Flags flags_; 107 JSGraph* jsgraph_; 108 Type* shifted_int32_ranges_[4]; 109 Type* const true_type_; 110 Type* const false_type_; 111 Type* const the_hole_type_; 112 TypeCache const& type_cache_; 113 }; 114 115 DEFINE_OPERATORS_FOR_FLAGS(JSTypedLowering::Flags) 116 117 } // namespace compiler 118 } // namespace internal 119 } // namespace v8 120 121 #endif // V8_COMPILER_JS_TYPED_LOWERING_H_ 122