LCOV - code coverage report
Current view: top level - src/compiler - memory-optimizer.h (source / functions) Hit Total Coverage
Test: app.info Lines: 1 1 100.0 %
Date: 2017-04-26 Functions: 0 0 -

          Line data    Source code
       1             : // Copyright 2016 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_MEMORY_OPTIMIZER_H_
       6             : #define V8_COMPILER_MEMORY_OPTIMIZER_H_
       7             : 
       8             : #include "src/compiler/graph-assembler.h"
       9             : #include "src/zone/zone-containers.h"
      10             : 
      11             : namespace v8 {
      12             : namespace internal {
      13             : namespace compiler {
      14             : 
      15             : // Forward declarations.
      16             : class CommonOperatorBuilder;
      17             : struct ElementAccess;
      18             : class Graph;
      19             : class JSGraph;
      20             : class MachineOperatorBuilder;
      21             : class Node;
      22             : class Operator;
      23             : 
      24             : // NodeIds are identifying numbers for nodes that can be used to index auxiliary
      25             : // out-of-line data associated with each node.
      26             : typedef uint32_t NodeId;
      27             : 
      28             : // Lowers all simplified memory access and allocation related nodes (i.e.
      29             : // Allocate, LoadField, StoreField and friends) to machine operators.
      30             : // Performs allocation folding and store write barrier elimination
      31             : // implicitly.
      32             : class MemoryOptimizer final {
      33             :  public:
      34             :   MemoryOptimizer(JSGraph* jsgraph, Zone* zone);
      35             :   ~MemoryOptimizer() {}
      36             : 
      37             :   void Optimize();
      38             : 
      39             :  private:
      40             :   // An allocation group represents a set of allocations that have been folded
      41             :   // together.
      42             :   class AllocationGroup final : public ZoneObject {
      43             :    public:
      44             :     AllocationGroup(Node* node, PretenureFlag pretenure, Zone* zone);
      45             :     AllocationGroup(Node* node, PretenureFlag pretenure, Node* size,
      46             :                     Zone* zone);
      47             :     ~AllocationGroup() {}
      48             : 
      49             :     void Add(Node* object);
      50             :     bool Contains(Node* object) const;
      51      843982 :     bool IsNewSpaceAllocation() const { return pretenure() == NOT_TENURED; }
      52             : 
      53             :     PretenureFlag pretenure() const { return pretenure_; }
      54             :     Node* size() const { return size_; }
      55             : 
      56             :    private:
      57             :     ZoneSet<NodeId> node_ids_;
      58             :     PretenureFlag const pretenure_;
      59             :     Node* const size_;
      60             : 
      61             :     DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationGroup);
      62             :   };
      63             : 
      64             :   // An allocation state is propagated on the effect paths through the graph.
      65             :   class AllocationState final : public ZoneObject {
      66             :    public:
      67             :     static AllocationState const* Empty(Zone* zone) {
      68             :       return new (zone) AllocationState();
      69             :     }
      70             :     static AllocationState const* Closed(AllocationGroup* group, Zone* zone) {
      71             :       return new (zone) AllocationState(group);
      72             :     }
      73             :     static AllocationState const* Open(AllocationGroup* group, int size,
      74             :                                        Node* top, Zone* zone) {
      75             :       return new (zone) AllocationState(group, size, top);
      76             :     }
      77             : 
      78             :     bool IsNewSpaceAllocation() const;
      79             : 
      80             :     AllocationGroup* group() const { return group_; }
      81             :     Node* top() const { return top_; }
      82             :     int size() const { return size_; }
      83             : 
      84             :    private:
      85             :     AllocationState();
      86             :     explicit AllocationState(AllocationGroup* group);
      87             :     AllocationState(AllocationGroup* group, int size, Node* top);
      88             : 
      89             :     AllocationGroup* const group_;
      90             :     // The upper bound of the combined allocated object size on the current path
      91             :     // (max int if allocation folding is impossible on this path).
      92             :     int const size_;
      93             :     Node* const top_;
      94             : 
      95             :     DISALLOW_COPY_AND_ASSIGN(AllocationState);
      96             :   };
      97             : 
      98             :   // An array of allocation states used to collect states on merges.
      99             :   typedef ZoneVector<AllocationState const*> AllocationStates;
     100             : 
     101             :   // We thread through tokens to represent the current state on a given effect
     102             :   // path through the graph.
     103             :   struct Token {
     104             :     Node* node;
     105             :     AllocationState const* state;
     106             :   };
     107             : 
     108             :   void VisitNode(Node*, AllocationState const*);
     109             :   void VisitAllocate(Node*, AllocationState const*);
     110             :   void VisitCall(Node*, AllocationState const*);
     111             :   void VisitLoadElement(Node*, AllocationState const*);
     112             :   void VisitLoadField(Node*, AllocationState const*);
     113             :   void VisitStoreElement(Node*, AllocationState const*);
     114             :   void VisitStoreField(Node*, AllocationState const*);
     115             :   void VisitOtherEffect(Node*, AllocationState const*);
     116             : 
     117             :   Node* ComputeIndex(ElementAccess const&, Node*);
     118             :   WriteBarrierKind ComputeWriteBarrierKind(Node* object,
     119             :                                            AllocationState const* state,
     120             :                                            WriteBarrierKind);
     121             : 
     122             :   AllocationState const* MergeStates(AllocationStates const& states);
     123             : 
     124             :   void EnqueueMerge(Node*, int, AllocationState const*);
     125             :   void EnqueueUses(Node*, AllocationState const*);
     126             :   void EnqueueUse(Node*, int, AllocationState const*);
     127             : 
     128             :   AllocationState const* empty_state() const { return empty_state_; }
     129             :   Graph* graph() const;
     130             :   Isolate* isolate() const;
     131             :   JSGraph* jsgraph() const { return jsgraph_; }
     132             :   CommonOperatorBuilder* common() const;
     133             :   MachineOperatorBuilder* machine() const;
     134             :   Zone* zone() const { return zone_; }
     135             :   GraphAssembler* gasm() { return &graph_assembler_; }
     136             : 
     137             :   SetOncePointer<const Operator> allocate_operator_;
     138             :   JSGraph* const jsgraph_;
     139             :   AllocationState const* const empty_state_;
     140             :   ZoneMap<NodeId, AllocationStates> pending_;
     141             :   ZoneQueue<Token> tokens_;
     142             :   Zone* const zone_;
     143             :   GraphAssembler graph_assembler_;
     144             : 
     145             :   DISALLOW_IMPLICIT_CONSTRUCTORS(MemoryOptimizer);
     146             : };
     147             : 
     148             : }  // namespace compiler
     149             : }  // namespace internal
     150             : }  // namespace v8
     151             : 
     152             : #endif  // V8_COMPILER_MEMORY_OPTIMIZER_H_

Generated by: LCOV version 1.10