Line data    Source code

       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 <array>
       9             : #include "src/compiler/common-operator.h"
      10             : #include "src/compiler/js-graph.h"
      11             : #include "src/globals.h"
      12             : 
      13             : namespace v8 {
      14             : namespace internal {
      15             : 
      16             : class BitVector;
      17             : 
      18             : namespace compiler {
      19             : 
      20             : class Graph;
      21             : 
      22      530231 : class V8_EXPORT_PRIVATE StateValuesCache {
      23             :  public:
      24             :   explicit StateValuesCache(JSGraph* js_graph);
      25             : 
      26             :   Node* GetNodeForValues(Node** values, size_t count,
      27             :                          const BitVector* liveness = nullptr,
      28             :                          int liveness_offset = 0);
      29             : 
      30             :  private:
      31             :   static const size_t kMaxInputCount = 8;
      32             :   using WorkingBuffer = std::array<Node*, kMaxInputCount>;
      33             : 
      34             :   struct NodeKey {
      35             :     Node* node;
      36             : 
      37    11609567 :     explicit NodeKey(Node* node) : node(node) {}
      38             :   };
      39             : 
      40             :   struct StateValuesKey : public NodeKey {
      41             :     // ValueArray - array of nodes ({node} has to be nullptr).
      42             :     size_t count;
      43             :     SparseInputMask mask;
      44             :     Node** values;
      45             : 
      46             :     StateValuesKey(size_t count, SparseInputMask mask, Node** values)
      47     8568959 :         : NodeKey(nullptr), count(count), mask(mask), values(values) {}
      48             :   };
      49             : 
      50             :   static bool AreKeysEqual(void* key1, void* key2);
      51             :   static bool IsKeysEqualToNode(StateValuesKey* key, Node* node);
      52             :   static bool AreValueKeysEqual(StateValuesKey* key1, StateValuesKey* key2);
      53             : 
      54             :   // Fills {node_buffer}, starting from {node_count}, with {values}, starting
      55             :   // at {values_idx}, sparsely encoding according to {liveness}. {node_count} is
      56             :   // updated with the new number of inputs in {node_buffer}, and a bitmask of
      57             :   // the sparse encoding is returned.
      58             :   SparseInputMask::BitMaskType FillBufferWithValues(WorkingBuffer* node_buffer,
      59             :                                                     size_t* node_count,
      60             :                                                     size_t* values_idx,
      61             :                                                     Node** values, size_t count,
      62             :                                                     const BitVector* liveness,
      63             :                                                     int liveness_offset);
      64             : 
      65             :   Node* BuildTree(size_t* values_idx, Node** values, size_t count,
      66             :                   const BitVector* liveness, int liveness_offset, size_t level);
      67             : 
      68             :   WorkingBuffer* GetWorkingSpace(size_t level);
      69             :   Node* GetEmptyStateValues();
      70             :   Node* GetValuesNodeFromCache(Node** nodes, size_t count,
      71             :                                SparseInputMask mask);
      72             : 
      73             :   Graph* graph() { return js_graph_->graph(); }
      74             :   CommonOperatorBuilder* common() { return js_graph_->common(); }
      75             : 
      76             :   Zone* zone() { return graph()->zone(); }
      77             : 
      78             :   JSGraph* js_graph_;
      79             :   CustomMatcherZoneHashMap hash_map_;
      80             :   ZoneVector<WorkingBuffer> working_space_;  // One working space per level.
      81             :   Node* empty_state_values_;
      82             : };
      83             : 
      84             : class V8_EXPORT_PRIVATE StateValuesAccess {
      85             :  public:
      86             :   struct TypedNode {
      87             :     Node* node;
      88             :     MachineType type;
      89             :     TypedNode(Node* node, MachineType type) : node(node), type(type) {}
      90             :   };
      91             : 
      92             :   class V8_EXPORT_PRIVATE iterator {
      93             :    public:
      94             :     // Bare minimum of operators needed for range iteration.
      95             :     bool operator!=(iterator& other);
      96             :     iterator& operator++();
      97             :     TypedNode operator*();
      98             : 
      99             :    private:
     100             :     friend class StateValuesAccess;
     101             : 
     102    11069790 :     iterator() : current_depth_(-1) {}
     103             :     explicit iterator(Node* node);
     104             : 
     105             :     Node* node();
     106             :     MachineType type();
     107             :     bool done();
     108             :     void Advance();
     109             :     void EnsureValid();
     110             : 
     111             :     SparseInputMask::InputIterator* Top();
     112             :     void Push(Node* node);
     113             :     void Pop();
     114             : 
     115             :     static const int kMaxInlineDepth = 8;
     116             :     SparseInputMask::InputIterator stack_[kMaxInlineDepth];
     117             :     int current_depth_;
     118             :   };
     119             : 
     120    11602277 :   explicit StateValuesAccess(Node* node) : node_(node) {}
     121             : 
     122             :   size_t size();
     123    11071152 :   iterator begin() { return iterator(node_); }
     124             :   iterator end() { return iterator(); }
     125             : 
     126             :  private:
     127             :   Node* node_;
     128             : };
     129             : 
     130             : }  // namespace compiler
     131             : }  // namespace internal
     132             : }  // namespace v8
     133             : 
     134             : #endif  // V8_COMPILER_STATE_VALUES_UTILS_H_