LCOV - code coverage report
Current view: top level - src/compiler - js-graph.h (source / functions) Hit Total Coverage
Test: app.info Lines: 12 13 92.3 %
Date: 2017-04-26 Functions: 2 2 100.0 %

          Line data    Source code
       1             : // Copyright 2014 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_JS_GRAPH_H_
       6             : #define V8_COMPILER_JS_GRAPH_H_
       7             : 
       8             : #include "src/base/compiler-specific.h"
       9             : #include "src/compiler/common-node-cache.h"
      10             : #include "src/compiler/common-operator.h"
      11             : #include "src/compiler/graph.h"
      12             : #include "src/compiler/js-operator.h"
      13             : #include "src/compiler/machine-operator.h"
      14             : #include "src/compiler/node-properties.h"
      15             : #include "src/globals.h"
      16             : #include "src/isolate.h"
      17             : 
      18             : namespace v8 {
      19             : namespace internal {
      20             : namespace compiler {
      21             : 
      22             : class SimplifiedOperatorBuilder;
      23             : class Typer;
      24             : 
      25             : // Implements a facade on a Graph, enhancing the graph with JS-specific
      26             : // notions, including various builders for operators, canonicalized global
      27             : // constants, and various helper methods.
      28             : class V8_EXPORT_PRIVATE JSGraph : public NON_EXPORTED_BASE(ZoneObject) {
      29             :  public:
      30             :   JSGraph(Isolate* isolate, Graph* graph, CommonOperatorBuilder* common,
      31             :           JSOperatorBuilder* javascript, SimplifiedOperatorBuilder* simplified,
      32             :           MachineOperatorBuilder* machine)
      33             :       : isolate_(isolate),
      34             :         graph_(graph),
      35             :         common_(common),
      36             :         javascript_(javascript),
      37             :         simplified_(simplified),
      38             :         machine_(machine),
      39     1076730 :         cache_(zone()) {
      40    12920736 :     for (int i = 0; i < kNumCachedNodes; i++) cached_nodes_[i] = nullptr;
      41             :   }
      42             : 
      43             :   // Canonicalized global constants.
      44             :   Node* AllocateInNewSpaceStubConstant();
      45             :   Node* AllocateInOldSpaceStubConstant();
      46             :   Node* ToNumberBuiltinConstant();
      47             :   Node* CEntryStubConstant(int result_size,
      48             :                            SaveFPRegsMode save_doubles = kDontSaveFPRegs,
      49             :                            ArgvMode argv_mode = kArgvOnStack,
      50             :                            bool builtin_exit_frame = false);
      51             :   Node* EmptyFixedArrayConstant();
      52             :   Node* EmptyStringConstant();
      53             :   Node* FixedArrayMapConstant();
      54             :   Node* FixedDoubleArrayMapConstant();
      55             :   Node* HeapNumberMapConstant();
      56             :   Node* OptimizedOutConstant();
      57             :   Node* StaleRegisterConstant();
      58             :   Node* UndefinedConstant();
      59             :   Node* TheHoleConstant();
      60             :   Node* TrueConstant();
      61             :   Node* FalseConstant();
      62             :   Node* NullConstant();
      63             :   Node* ZeroConstant();
      64             :   Node* OneConstant();
      65             :   Node* NaNConstant();
      66             : 
      67             :   // Creates a HeapConstant node, possibly canonicalized, and may access the
      68             :   // heap to inspect the object.
      69             :   Node* HeapConstant(Handle<HeapObject> value);
      70             : 
      71             :   // Creates a Constant node of the appropriate type for the given object.
      72             :   // Accesses the heap to inspect the object and determine whether one of the
      73             :   // canonicalized globals or a number constant should be returned.
      74             :   Node* Constant(Handle<Object> value);
      75             : 
      76             :   // Creates a NumberConstant node, usually canonicalized.
      77             :   Node* Constant(double value);
      78             : 
      79             :   // Creates a NumberConstant node, usually canonicalized.
      80             :   Node* Constant(int32_t value);
      81             : 
      82             :   // Creates a NumberConstant node, usually canonicalized.
      83             :   Node* Constant(uint32_t value);
      84             : 
      85             :   // Creates a Int32Constant node, usually canonicalized.
      86             :   Node* Int32Constant(int32_t value);
      87             :   Node* Uint32Constant(uint32_t value) {
      88       41546 :     return Int32Constant(bit_cast<int32_t>(value));
      89             :   }
      90             : 
      91             :   // Creates a HeapConstant node for either true or false.
      92        8630 :   Node* BooleanConstant(bool is_true) {
      93        8630 :     return is_true ? TrueConstant() : FalseConstant();
      94             :   }
      95             : 
      96             :   // Creates a Int64Constant node, usually canonicalized.
      97             :   Node* Int64Constant(int64_t value);
      98             :   Node* Uint64Constant(uint64_t value) {
      99             :     return Int64Constant(bit_cast<int64_t>(value));
     100             :   }
     101             : 
     102             :   // Creates a Int32Constant/Int64Constant node, depending on the word size of
     103             :   // the target machine.
     104             :   // TODO(turbofan): Code using Int32Constant/Int64Constant to store pointer
     105             :   // constants is probably not serializable.
     106     5444064 :   Node* IntPtrConstant(intptr_t value) {
     107           0 :     return machine()->Is32() ? Int32Constant(static_cast<int32_t>(value))
     108     5444064 :                              : Int64Constant(static_cast<int64_t>(value));
     109             :   }
     110             : 
     111             :   Node* RelocatableInt32Constant(int32_t value, RelocInfo::Mode rmode);
     112             :   Node* RelocatableInt64Constant(int64_t value, RelocInfo::Mode rmode);
     113             :   Node* RelocatableIntPtrConstant(intptr_t value, RelocInfo::Mode rmode);
     114             : 
     115             :   // Creates a Float32Constant node, usually canonicalized.
     116             :   Node* Float32Constant(float value);
     117             : 
     118             :   // Creates a Float64Constant node, usually canonicalized.
     119             :   Node* Float64Constant(double value);
     120             : 
     121             :   // Creates a PointerConstant node (asm.js only).
     122             :   Node* PointerConstant(intptr_t value);
     123             :   template <typename T>
     124             :   Node* PointerConstant(T* value) {
     125       13801 :     return PointerConstant(bit_cast<intptr_t>(value));
     126             :   }
     127             : 
     128             :   // Creates an ExternalConstant node, usually canonicalized.
     129             :   Node* ExternalConstant(ExternalReference ref);
     130             :   Node* ExternalConstant(Runtime::FunctionId function_id);
     131             : 
     132             :   Node* SmiConstant(int32_t immediate) {
     133             :     DCHECK(Smi::IsValid(immediate));
     134     1083111 :     return Constant(immediate);
     135             :   }
     136             : 
     137             :   // Creates a dummy Constant node, used to satisfy calling conventions of
     138             :   // stubs and runtime functions that do not require a context.
     139      255781 :   Node* NoContextConstant() { return ZeroConstant(); }
     140             : 
     141             :   // Creates an empty StateValues node, used when we don't have any concrete
     142             :   // values for a certain part of the frame state.
     143             :   Node* EmptyStateValues();
     144             : 
     145             :   // Create a control node that serves as dependency for dead nodes.
     146             :   Node* Dead();
     147             : 
     148             :   CommonOperatorBuilder* common() const { return common_; }
     149             :   JSOperatorBuilder* javascript() const { return javascript_; }
     150             :   SimplifiedOperatorBuilder* simplified() const { return simplified_; }
     151             :   MachineOperatorBuilder* machine() const { return machine_; }
     152             :   Graph* graph() const { return graph_; }
     153    10341175 :   Zone* zone() const { return graph()->zone(); }
     154             :   Isolate* isolate() const { return isolate_; }
     155     2289902 :   Factory* factory() const { return isolate()->factory(); }
     156             : 
     157             :   void GetCachedNodes(NodeVector* nodes);
     158             : 
     159             :  private:
     160             :   enum CachedNode {
     161             :     kAllocateInNewSpaceStubConstant,
     162             :     kAllocateInOldSpaceStubConstant,
     163             :     kToNumberBuiltinConstant,
     164             :     kCEntryStub1Constant,
     165             :     kCEntryStub2Constant,
     166             :     kCEntryStub3Constant,
     167             :     kCEntryStub1WithBuiltinExitFrameConstant,
     168             :     kEmptyFixedArrayConstant,
     169             :     kEmptyStringConstant,
     170             :     kFixedArrayMapConstant,
     171             :     kFixedDoubleArrayMapConstant,
     172             :     kHeapNumberMapConstant,
     173             :     kOptimizedOutConstant,
     174             :     kStaleRegisterConstant,
     175             :     kUndefinedConstant,
     176             :     kTheHoleConstant,
     177             :     kTrueConstant,
     178             :     kFalseConstant,
     179             :     kNullConstant,
     180             :     kZeroConstant,
     181             :     kOneConstant,
     182             :     kNaNConstant,
     183             :     kEmptyStateValues,
     184             :     kDead,
     185             :     kNumCachedNodes  // Must remain last.
     186             :   };
     187             : 
     188             :   Isolate* isolate_;
     189             :   Graph* graph_;
     190             :   CommonOperatorBuilder* common_;
     191             :   JSOperatorBuilder* javascript_;
     192             :   SimplifiedOperatorBuilder* simplified_;
     193             :   MachineOperatorBuilder* machine_;
     194             :   CommonNodeCache cache_;
     195             :   Node* cached_nodes_[kNumCachedNodes];
     196             : 
     197             :   Node* NumberConstant(double value);
     198             : 
     199             :   DISALLOW_COPY_AND_ASSIGN(JSGraph);
     200             : };
     201             : 
     202             : }  // namespace compiler
     203             : }  // namespace internal
     204             : }  // namespace v8
     205             : 
     206             : #endif

Generated by: LCOV version 1.10