state-values-utils.h 2.77 KB
Newer Older
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
// 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"

namespace v8 {
namespace internal {

namespace compiler {

class Graph;

class 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_;
  ZoneHashMap hash_map_;
  ZoneVector<NodeVector*> working_space_;  // One working space per level.
  Node* empty_state_values_;
};

class StateValuesAccess {
 public:
65 66 67 68 69 70
  struct TypedNode {
    Node* node;
    MachineType type;
    TypedNode(Node* node, MachineType type) : node(node), type(type) {}
  };

71 72 73 74 75
  class iterator {
   public:
    // Bare minimum of operators needed for range iteration.
    bool operator!=(iterator& other);
    iterator& operator++();
76
    TypedNode operator*();
77 78 79 80 81 82 83 84

   private:
    friend class StateValuesAccess;

    iterator() : current_depth_(-1) {}
    explicit iterator(Node* node);

    Node* node();
85
    MachineType type();
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
    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_