Home | History | Annotate | Download | only in compiler 
      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_
    121