1// Copyright 2013 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_NODE_PROPERTIES_H_
6#define V8_COMPILER_NODE_PROPERTIES_H_
7
8#include "src/compiler/node.h"
9#include "src/types.h"
10
11namespace v8 {
12namespace internal {
13namespace compiler {
14
15class Graph;
16class Operator;
17class CommonOperatorBuilder;
18
19// A facade that simplifies access to the different kinds of inputs to a node.
20class NodeProperties final {
21 public:
22  // ---------------------------------------------------------------------------
23  // Input layout.
24  // Inputs are always arranged in order as follows:
25  //     0 [ values, context, frame state, effects, control ] node->InputCount()
26
27  static int FirstValueIndex(Node* node) { return 0; }
28  static int FirstContextIndex(Node* node) { return PastValueIndex(node); }
29  static int FirstFrameStateIndex(Node* node) { return PastContextIndex(node); }
30  static int FirstEffectIndex(Node* node) { return PastFrameStateIndex(node); }
31  static int FirstControlIndex(Node* node) { return PastEffectIndex(node); }
32  static int PastValueIndex(Node* node);
33  static int PastContextIndex(Node* node);
34  static int PastFrameStateIndex(Node* node);
35  static int PastEffectIndex(Node* node);
36  static int PastControlIndex(Node* node);
37
38
39  // ---------------------------------------------------------------------------
40  // Input accessors.
41
42  static Node* GetValueInput(Node* node, int index);
43  static Node* GetContextInput(Node* node);
44  static Node* GetFrameStateInput(Node* node, int index);
45  static Node* GetEffectInput(Node* node, int index = 0);
46  static Node* GetControlInput(Node* node, int index = 0);
47
48
49  // ---------------------------------------------------------------------------
50  // Edge kinds.
51
52  static bool IsValueEdge(Edge edge);
53  static bool IsContextEdge(Edge edge);
54  static bool IsFrameStateEdge(Edge edge);
55  static bool IsEffectEdge(Edge edge);
56  static bool IsControlEdge(Edge edge);
57
58
59  // ---------------------------------------------------------------------------
60  // Miscellaneous predicates.
61
62  static bool IsCommon(Node* node) {
63    return IrOpcode::IsCommonOpcode(node->opcode());
64  }
65  static bool IsControl(Node* node) {
66    return IrOpcode::IsControlOpcode(node->opcode());
67  }
68  static bool IsConstant(Node* node) {
69    return IrOpcode::IsConstantOpcode(node->opcode());
70  }
71  static bool IsPhi(Node* node) {
72    return IrOpcode::IsPhiOpcode(node->opcode());
73  }
74
75  // Determines whether exceptions thrown by the given node are handled locally
76  // within the graph (i.e. an IfException projection is present).
77  static bool IsExceptionalCall(Node* node);
78
79  // ---------------------------------------------------------------------------
80  // Miscellaneous mutators.
81
82  static void ReplaceValueInput(Node* node, Node* value, int index);
83  static void ReplaceContextInput(Node* node, Node* context);
84  static void ReplaceControlInput(Node* node, Node* control, int index = 0);
85  static void ReplaceEffectInput(Node* node, Node* effect, int index = 0);
86  static void ReplaceFrameStateInput(Node* node, int index, Node* frame_state);
87  static void RemoveNonValueInputs(Node* node);
88  static void RemoveValueInputs(Node* node);
89
90  // Replaces all value inputs of {node} with the single input {value}.
91  static void ReplaceValueInputs(Node* node, Node* value);
92
93  // Merge the control node {node} into the end of the graph, introducing a
94  // merge node or expanding an existing merge node if necessary.
95  static void MergeControlToEnd(Graph* graph, CommonOperatorBuilder* common,
96                                Node* node);
97
98  // Replace all uses of {node} with the given replacement nodes. All occurring
99  // use kinds need to be replaced, {nullptr} is only valid if a use kind is
100  // guaranteed not to exist.
101  static void ReplaceUses(Node* node, Node* value, Node* effect = nullptr,
102                          Node* success = nullptr, Node* exception = nullptr);
103
104  // Safe wrapper to mutate the operator of a node. Checks that the node is
105  // currently in a state that satisfies constraints of the new operator.
106  static void ChangeOp(Node* node, const Operator* new_op);
107
108  // ---------------------------------------------------------------------------
109  // Miscellaneous utilities.
110
111  // Find the last frame state that is effect-wise before the given node. This
112  // assumes a linear effect-chain up to a {CheckPoint} node in the graph.
113  static Node* FindFrameStateBefore(Node* node);
114
115  // Collect the output-value projection for the given output index.
116  static Node* FindProjection(Node* node, size_t projection_index);
117
118  // Collect the branch-related projections from a node, such as IfTrue,
119  // IfFalse, IfSuccess, IfException, IfValue and IfDefault.
120  //  - Branch: [ IfTrue, IfFalse ]
121  //  - Call  : [ IfSuccess, IfException ]
122  //  - Switch: [ IfValue, ..., IfDefault ]
123  static void CollectControlProjections(Node* node, Node** proj, size_t count);
124
125  // ---------------------------------------------------------------------------
126  // Context.
127
128  // Try to retrieve the specialization context from the given {node},
129  // optionally utilizing the knowledge about the (outermost) function
130  // {context}.
131  static MaybeHandle<Context> GetSpecializationContext(
132      Node* node, MaybeHandle<Context> context = MaybeHandle<Context>());
133
134  // Try to retrieve the specialization native context from the given
135  // {node}, optionally utilizing the knowledge about the (outermost)
136  // {native_context}.
137  static MaybeHandle<Context> GetSpecializationNativeContext(
138      Node* node, MaybeHandle<Context> native_context = MaybeHandle<Context>());
139
140  // Try to retrieve the specialization global object from the given
141  // {node}, optionally utilizing the knowledge about the (outermost)
142  // {native_context}.
143  static MaybeHandle<JSGlobalObject> GetSpecializationGlobalObject(
144      Node* node, MaybeHandle<Context> native_context = MaybeHandle<Context>());
145
146  // ---------------------------------------------------------------------------
147  // Type.
148
149  static bool IsTyped(Node* node) { return node->type() != nullptr; }
150  static Type* GetType(Node* node) {
151    DCHECK(IsTyped(node));
152    return node->type();
153  }
154  static Type* GetTypeOrAny(Node* node);
155  static void SetType(Node* node, Type* type) {
156    DCHECK_NOT_NULL(type);
157    node->set_type(type);
158  }
159  static void RemoveType(Node* node) { node->set_type(nullptr); }
160  static bool AllValueInputsAreTyped(Node* node);
161
162 private:
163  static inline bool IsInputRange(Edge edge, int first, int count);
164};
165
166}  // namespace compiler
167}  // namespace internal
168}  // namespace v8
169
170#endif  // V8_COMPILER_NODE_PROPERTIES_H_
171