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 
15 namespace v8 {
16 namespace internal {
17 namespace compiler {
18 
19 class Typer;
20 
21 // Implements a facade on a Graph, enhancing the graph with JS-specific
22 // notions, including a builder for for JS* operators, canonicalized global
23 // constants, and various helper methods.
24 class JSGraph : public ZoneObject {
25  public:
JSGraph(Graph * graph,CommonOperatorBuilder * common,JSOperatorBuilder * javascript,Typer * typer,MachineOperatorBuilder * machine)26   JSGraph(Graph* graph, CommonOperatorBuilder* common,
27           JSOperatorBuilder* javascript, Typer* typer,
28           MachineOperatorBuilder* machine)
29       : graph_(graph),
30         common_(common),
31         javascript_(javascript),
32         typer_(typer),
33         machine_(machine),
34         cache_(zone()) {}
35 
36   // Canonicalized global constants.
37   Node* CEntryStubConstant();
38   Node* UndefinedConstant();
39   Node* TheHoleConstant();
40   Node* TrueConstant();
41   Node* FalseConstant();
42   Node* NullConstant();
43   Node* ZeroConstant();
44   Node* OneConstant();
45   Node* NaNConstant();
46 
47   // Creates a HeapConstant node, possibly canonicalized, without inspecting the
48   // object.
49   Node* HeapConstant(Unique<Object> value);
50 
51   // Creates a HeapConstant node, possibly canonicalized, and may access the
52   // heap to inspect the object.
53   Node* HeapConstant(Handle<Object> value);
54 
55   // Creates a Constant node of the appropriate type for the given object.
56   // Accesses the heap to inspect the object and determine whether one of the
57   // canonicalized globals or a number constant should be returned.
58   Node* Constant(Handle<Object> value);
59 
60   // Creates a NumberConstant node, usually canonicalized.
61   Node* Constant(double value);
62 
63   // Creates a NumberConstant node, usually canonicalized.
64   Node* Constant(int32_t value);
65 
66   // Creates a Int32Constant node, usually canonicalized.
67   Node* Int32Constant(int32_t value);
Uint32Constant(uint32_t value)68   Node* Uint32Constant(uint32_t value) {
69     return Int32Constant(bit_cast<int32_t>(value));
70   }
71 
72   // Creates a Float64Constant node, usually canonicalized.
73   Node* Float64Constant(double value);
74 
75   // Creates an ExternalConstant node, usually canonicalized.
76   Node* ExternalConstant(ExternalReference ref);
77 
SmiConstant(int32_t immediate)78   Node* SmiConstant(int32_t immediate) {
79     DCHECK(Smi::IsValid(immediate));
80     return Constant(immediate);
81   }
82 
javascript()83   JSOperatorBuilder* javascript() { return javascript_; }
common()84   CommonOperatorBuilder* common() { return common_; }
machine()85   MachineOperatorBuilder* machine() { return machine_; }
graph()86   Graph* graph() { return graph_; }
zone()87   Zone* zone() { return graph()->zone(); }
isolate()88   Isolate* isolate() { return zone()->isolate(); }
89 
90  private:
91   Graph* graph_;
92   CommonOperatorBuilder* common_;
93   JSOperatorBuilder* javascript_;
94   Typer* typer_;
95   MachineOperatorBuilder* machine_;
96 
97   SetOncePointer<Node> c_entry_stub_constant_;
98   SetOncePointer<Node> undefined_constant_;
99   SetOncePointer<Node> the_hole_constant_;
100   SetOncePointer<Node> true_constant_;
101   SetOncePointer<Node> false_constant_;
102   SetOncePointer<Node> null_constant_;
103   SetOncePointer<Node> zero_constant_;
104   SetOncePointer<Node> one_constant_;
105   SetOncePointer<Node> nan_constant_;
106 
107   CommonNodeCache cache_;
108 
109   Node* ImmovableHeapConstant(Handle<Object> value);
110   Node* NumberConstant(double value);
111   Node* NewNode(const Operator* op);
112 
factory()113   Factory* factory() { return isolate()->factory(); }
114 };
115 
116 }  // namespace compiler
117 }  // namespace internal
118 }  // namespace v8
119 
120 #endif
121