1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_COMPILER_STATE_VALUES_UTILS_H_
#define V8_COMPILER_STATE_VALUES_UTILS_H_
#include "src/compiler/js-graph.h"
#include "src/globals.h"
namespace v8 {
namespace internal {
namespace compiler {
class Graph;
class V8_EXPORT_PRIVATE StateValuesCache {
public:
explicit StateValuesCache(JSGraph* js_graph);
Node* GetNodeForValues(Node** values, size_t count);
private:
static const size_t kMaxInputCount = 8;
struct NodeKey {
Node* node;
explicit NodeKey(Node* node) : node(node) {}
};
struct StateValuesKey : public NodeKey {
// ValueArray - array of nodes ({node} has to be nullptr).
size_t count;
Node** values;
StateValuesKey(size_t count, Node** values)
: NodeKey(nullptr), count(count), values(values) {}
};
class ValueArrayIterator;
static bool AreKeysEqual(void* key1, void* key2);
static bool IsKeysEqualToNode(StateValuesKey* key, Node* node);
static bool AreValueKeysEqual(StateValuesKey* key1, StateValuesKey* key2);
Node* BuildTree(ValueArrayIterator* it, size_t max_height);
NodeVector* GetWorkingSpace(size_t level);
Node* GetEmptyStateValues();
Node* GetValuesNodeFromCache(Node** nodes, size_t count);
Graph* graph() { return js_graph_->graph(); }
CommonOperatorBuilder* common() { return js_graph_->common(); }
Zone* zone() { return graph()->zone(); }
JSGraph* js_graph_;
CustomMatcherZoneHashMap hash_map_;
ZoneVector<NodeVector*> working_space_; // One working space per level.
Node* empty_state_values_;
};
class V8_EXPORT_PRIVATE StateValuesAccess {
public:
struct TypedNode {
Node* node;
MachineType type;
TypedNode(Node* node, MachineType type) : node(node), type(type) {}
};
class V8_EXPORT_PRIVATE iterator {
public:
// Bare minimum of operators needed for range iteration.
bool operator!=(iterator& other);
iterator& operator++();
TypedNode operator*();
private:
friend class StateValuesAccess;
iterator() : current_depth_(-1) {}
explicit iterator(Node* node);
Node* node();
MachineType type();
bool done();
void Advance();
struct StatePos {
Node* node;
int index;
explicit StatePos(Node* node) : node(node), index(0) {}
StatePos() {}
};
StatePos* Top();
void Push(Node* node);
void Pop();
static const int kMaxInlineDepth = 8;
StatePos stack_[kMaxInlineDepth];
int current_depth_;
};
explicit StateValuesAccess(Node* node) : node_(node) {}
size_t size();
iterator begin() { return iterator(node_); }
iterator end() { return iterator(); }
private:
Node* node_;
};
} // namespace compiler
} // namespace internal
} // namespace v8
#endif // V8_COMPILER_STATE_VALUES_UTILS_H_
|
