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