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_GRAPH_H_ 6 #define V8_COMPILER_JS_GRAPH_H_ 7 8 #include "src/compiler/common-node-cache.h" 9 #include "src/compiler/common-operator.h" 10 #include "src/compiler/graph.h" 11 #include "src/compiler/js-operator.h" 12 #include "src/compiler/machine-operator.h" 13 #include "src/compiler/node-properties.h" 14 #include "src/isolate.h" 15 16 namespace v8 { 17 namespace internal { 18 namespace compiler { 19 20 class SimplifiedOperatorBuilder; 21 class Typer; 22 23 // Implements a facade on a Graph, enhancing the graph with JS-specific 24 // notions, including various builders for operators, canonicalized global 25 // constants, and various helper methods. 26 class JSGraph : public ZoneObject { 27 public: JSGraph(Isolate * isolate,Graph * graph,CommonOperatorBuilder * common,JSOperatorBuilder * javascript,SimplifiedOperatorBuilder * simplified,MachineOperatorBuilder * machine)28 JSGraph(Isolate* isolate, Graph* graph, CommonOperatorBuilder* common, 29 JSOperatorBuilder* javascript, SimplifiedOperatorBuilder* simplified, 30 MachineOperatorBuilder* machine) 31 : isolate_(isolate), 32 graph_(graph), 33 common_(common), 34 javascript_(javascript), 35 simplified_(simplified), 36 machine_(machine), 37 cache_(zone()) { 38 for (int i = 0; i < kNumCachedNodes; i++) cached_nodes_[i] = nullptr; 39 } 40 41 // Canonicalized global constants. 42 Node* AllocateInNewSpaceStubConstant(); 43 Node* AllocateInOldSpaceStubConstant(); 44 Node* ToNumberBuiltinConstant(); 45 Node* CEntryStubConstant(int result_size); 46 Node* EmptyFixedArrayConstant(); 47 Node* EmptyLiteralsArrayConstant(); 48 Node* HeapNumberMapConstant(); 49 Node* OptimizedOutConstant(); 50 Node* StaleRegisterConstant(); 51 Node* UndefinedConstant(); 52 Node* TheHoleConstant(); 53 Node* TrueConstant(); 54 Node* FalseConstant(); 55 Node* NullConstant(); 56 Node* ZeroConstant(); 57 Node* OneConstant(); 58 Node* NaNConstant(); 59 60 // Creates a HeapConstant node, possibly canonicalized, and may access the 61 // heap to inspect the object. 62 Node* HeapConstant(Handle<HeapObject> value); 63 64 // Creates a Constant node of the appropriate type for the given object. 65 // Accesses the heap to inspect the object and determine whether one of the 66 // canonicalized globals or a number constant should be returned. 67 Node* Constant(Handle<Object> value); 68 69 // Creates a NumberConstant node, usually canonicalized. 70 Node* Constant(double value); 71 72 // Creates a NumberConstant node, usually canonicalized. 73 Node* Constant(int32_t value); 74 75 // Creates a Int32Constant node, usually canonicalized. 76 Node* Int32Constant(int32_t value); Uint32Constant(uint32_t value)77 Node* Uint32Constant(uint32_t value) { 78 return Int32Constant(bit_cast<int32_t>(value)); 79 } 80 81 // Creates a HeapConstant node for either true or false. BooleanConstant(bool is_true)82 Node* BooleanConstant(bool is_true) { 83 return is_true ? TrueConstant() : FalseConstant(); 84 } 85 86 // Creates a Int64Constant node, usually canonicalized. 87 Node* Int64Constant(int64_t value); Uint64Constant(uint64_t value)88 Node* Uint64Constant(uint64_t value) { 89 return Int64Constant(bit_cast<int64_t>(value)); 90 } 91 92 // Creates a Int32Constant/Int64Constant node, depending on the word size of 93 // the target machine. 94 // TODO(turbofan): Code using Int32Constant/Int64Constant to store pointer 95 // constants is probably not serializable. IntPtrConstant(intptr_t value)96 Node* IntPtrConstant(intptr_t value) { 97 return machine()->Is32() ? Int32Constant(static_cast<int32_t>(value)) 98 : Int64Constant(static_cast<int64_t>(value)); 99 } 100 template <typename T> PointerConstant(T * value)101 Node* PointerConstant(T* value) { 102 return IntPtrConstant(bit_cast<intptr_t>(value)); 103 } 104 105 Node* RelocatableInt32Constant(int32_t value, RelocInfo::Mode rmode); 106 Node* RelocatableInt64Constant(int64_t value, RelocInfo::Mode rmode); 107 Node* RelocatableIntPtrConstant(intptr_t value, RelocInfo::Mode rmode); 108 109 // Creates a Float32Constant node, usually canonicalized. 110 Node* Float32Constant(float value); 111 112 // Creates a Float64Constant node, usually canonicalized. 113 Node* Float64Constant(double value); 114 115 // Creates an ExternalConstant node, usually canonicalized. 116 Node* ExternalConstant(ExternalReference ref); 117 Node* ExternalConstant(Runtime::FunctionId function_id); 118 SmiConstant(int32_t immediate)119 Node* SmiConstant(int32_t immediate) { 120 DCHECK(Smi::IsValid(immediate)); 121 return Constant(immediate); 122 } 123 124 // Creates a dummy Constant node, used to satisfy calling conventions of 125 // stubs and runtime functions that do not require a context. NoContextConstant()126 Node* NoContextConstant() { return ZeroConstant(); } 127 128 // Creates an empty StateValues node, used when we don't have any concrete 129 // values for a certain part of the frame state. 130 Node* EmptyStateValues(); 131 132 // Create a control node that serves as dependency for dead nodes. 133 Node* Dead(); 134 common()135 CommonOperatorBuilder* common() const { return common_; } javascript()136 JSOperatorBuilder* javascript() const { return javascript_; } simplified()137 SimplifiedOperatorBuilder* simplified() const { return simplified_; } machine()138 MachineOperatorBuilder* machine() const { return machine_; } graph()139 Graph* graph() const { return graph_; } zone()140 Zone* zone() const { return graph()->zone(); } isolate()141 Isolate* isolate() const { return isolate_; } factory()142 Factory* factory() const { return isolate()->factory(); } 143 144 void GetCachedNodes(NodeVector* nodes); 145 146 private: 147 enum CachedNode { 148 kAllocateInNewSpaceStubConstant, 149 kAllocateInOldSpaceStubConstant, 150 kToNumberBuiltinConstant, 151 kCEntryStubConstant, 152 kEmptyFixedArrayConstant, 153 kEmptyLiteralsArrayConstant, 154 kHeapNumberMapConstant, 155 kOptimizedOutConstant, 156 kStaleRegisterConstant, 157 kUndefinedConstant, 158 kTheHoleConstant, 159 kTrueConstant, 160 kFalseConstant, 161 kNullConstant, 162 kZeroConstant, 163 kOneConstant, 164 kNaNConstant, 165 kEmptyStateValues, 166 kDead, 167 kNumCachedNodes // Must remain last. 168 }; 169 170 Isolate* isolate_; 171 Graph* graph_; 172 CommonOperatorBuilder* common_; 173 JSOperatorBuilder* javascript_; 174 SimplifiedOperatorBuilder* simplified_; 175 MachineOperatorBuilder* machine_; 176 CommonNodeCache cache_; 177 Node* cached_nodes_[kNumCachedNodes]; 178 179 Node* NumberConstant(double value); 180 181 DISALLOW_COPY_AND_ASSIGN(JSGraph); 182 }; 183 184 } // namespace compiler 185 } // namespace internal 186 } // namespace v8 187 188 #endif 189