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