deps/v8/src/compiler/state-values-utils.h

   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
  10 namespace v8 {
  11 namespace internal {
  12
  13 namespace compiler {
  14
  15 class Graph;
  16
  17 class 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   ZoneHashMap hash_map_;
  59   ZoneVector<NodeVector*> working_space_;  // One working space per level.
  60   Node* empty_state_values_;
  61 };
  62
  63 class 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_