LCOV - code coverage report
Current view: top level - src/compiler - js-graph.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 84 87 96.6 %
Date: 2019-04-17 Functions: 33 33 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             : #include "src/compiler/js-graph.h"
       6             : 
       7             : #include "src/code-factory.h"
       8             : #include "src/compiler/node-properties.h"
       9             : #include "src/compiler/typer.h"
      10             : #include "src/objects-inl.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : namespace compiler {
      15             : 
      16             : #define GET_CACHED_FIELD(ptr, expr) (*(ptr)) ? *(ptr) : (*(ptr) = (expr))
      17             : 
      18             : #define DEFINE_GETTER(name, expr) \
      19             :   Node* JSGraph::name() { return GET_CACHED_FIELD(&name##_, expr); }
      20             : 
      21      882291 : Node* JSGraph::CEntryStubConstant(int result_size, SaveFPRegsMode save_doubles,
      22             :                                   ArgvMode argv_mode, bool builtin_exit_frame) {
      23      882291 :   if (save_doubles == kDontSaveFPRegs && argv_mode == kArgvOnStack) {
      24             :     DCHECK(result_size >= 1 && result_size <= 3);
      25      882291 :     if (!builtin_exit_frame) {
      26             :       Node** ptr = nullptr;
      27      879348 :       if (result_size == 1) {
      28      878408 :         ptr = &CEntryStub1Constant_;
      29         940 :       } else if (result_size == 2) {
      30         940 :         ptr = &CEntryStub2Constant_;
      31             :       } else {
      32             :         DCHECK_EQ(3, result_size);
      33           0 :         ptr = &CEntryStub3Constant_;
      34             :       }
      35     1343891 :       return GET_CACHED_FIELD(ptr, HeapConstant(CodeFactory::CEntry(
      36             :                                        isolate(), result_size, save_doubles,
      37             :                                        argv_mode, builtin_exit_frame)));
      38             :     }
      39             :     Node** ptr = builtin_exit_frame ? &CEntryStub1WithBuiltinExitFrameConstant_
      40        2943 :                                     : &CEntryStub1Constant_;
      41        5225 :     return GET_CACHED_FIELD(ptr, HeapConstant(CodeFactory::CEntry(
      42             :                                      isolate(), result_size, save_doubles,
      43             :                                      argv_mode, builtin_exit_frame)));
      44             :   }
      45           0 :   return HeapConstant(CodeFactory::CEntry(isolate(), result_size, save_doubles,
      46           0 :                                           argv_mode, builtin_exit_frame));
      47             : }
      48             : 
      49      892832 : Node* JSGraph::Constant(Handle<Object> value) {
      50             :   // Dereference the handle to determine if a number constant or other
      51             :   // canonicalized node can be used.
      52      892832 :   if (value->IsNumber()) {
      53       81228 :     return Constant(value->Number());
      54      811604 :   } else if (value->IsUndefined(isolate())) {
      55        1534 :     return UndefinedConstant();
      56      810070 :   } else if (value->IsTrue(isolate())) {
      57          19 :     return TrueConstant();
      58      810051 :   } else if (value->IsFalse(isolate())) {
      59          92 :     return FalseConstant();
      60      809959 :   } else if (value->IsNull(isolate())) {
      61         116 :     return NullConstant();
      62      809843 :   } else if (value->IsTheHole(isolate())) {
      63           5 :     return TheHoleConstant();
      64             :   } else {
      65      809838 :     return HeapConstant(Handle<HeapObject>::cast(value));
      66             :   }
      67             : }
      68             : 
      69     1015146 : Node* JSGraph::Constant(const ObjectRef& ref) {
      70     1015146 :   if (ref.IsSmi()) return Constant(ref.AsSmi());
      71             :   OddballType oddball_type =
      72     1001497 :       ref.AsHeapObject().GetHeapObjectType().oddball_type();
      73     1001497 :   if (ref.IsHeapNumber()) {
      74        4461 :     return Constant(ref.AsHeapNumber().value());
      75      997035 :   } else if (oddball_type == OddballType::kUndefined) {
      76             :     DCHECK(ref.object().equals(isolate()->factory()->undefined_value()));
      77        2496 :     return UndefinedConstant();
      78      994539 :   } else if (oddball_type == OddballType::kNull) {
      79             :     DCHECK(ref.object().equals(isolate()->factory()->null_value()));
      80         189 :     return NullConstant();
      81      994350 :   } else if (oddball_type == OddballType::kHole) {
      82             :     DCHECK(ref.object().equals(isolate()->factory()->the_hole_value()));
      83        2509 :     return TheHoleConstant();
      84      991841 :   } else if (oddball_type == OddballType::kBoolean) {
      85      191004 :     if (ref.object().equals(isolate()->factory()->true_value())) {
      86       63735 :       return TrueConstant();
      87             :     } else {
      88             :       DCHECK(ref.object().equals(isolate()->factory()->false_value()));
      89      127268 :       return FalseConstant();
      90             :     }
      91             :   } else {
      92      800837 :     return HeapConstant(ref.AsHeapObject().object());
      93             :   }
      94             : }
      95             : 
      96     3210584 : Node* JSGraph::Constant(double value) {
      97     3912310 :   if (bit_cast<int64_t>(value) == bit_cast<int64_t>(0.0)) return ZeroConstant();
      98     2744538 :   if (bit_cast<int64_t>(value) == bit_cast<int64_t>(1.0)) return OneConstant();
      99     2273178 :   return NumberConstant(value);
     100             : }
     101             : 
     102     3354050 : Node* JSGraph::NumberConstant(double value) {
     103             :   Node** loc = cache_.FindNumberConstant(value);
     104     3354048 :   if (*loc == nullptr) {
     105     5240228 :     *loc = graph()->NewNode(common()->NumberConstant(value));
     106             :   }
     107     3354054 :   return *loc;
     108             : }
     109             : 
     110    12960017 : Node* JSGraph::HeapConstant(Handle<HeapObject> value) {
     111    12960017 :   Node** loc = cache_.FindHeapConstant(value);
     112    12960000 :   if (*loc == nullptr) {
     113    14386799 :     *loc = graph()->NewNode(common()->HeapConstant(value));
     114             :   }
     115    12960001 :   return *loc;
     116             : }
     117             : 
     118     4721838 : void JSGraph::GetCachedNodes(NodeVector* nodes) {
     119     4721838 :   cache_.GetCachedNodes(nodes);
     120             : #define DO_CACHED_FIELD(name) \
     121             :   if (name##_) nodes->push_back(name##_);
     122             : 
     123     4721847 :   CACHED_GLOBAL_LIST(DO_CACHED_FIELD)
     124     4721846 :   CACHED_CENTRY_LIST(DO_CACHED_FIELD)
     125             : #undef DO_CACHED_FIELD
     126     4721846 : }
     127             : 
     128      415262 : DEFINE_GETTER(AllocateInYoungGenerationStubConstant,
     129             :               HeapConstant(BUILTIN_CODE(isolate(), AllocateInYoungGeneration)))
     130             : 
     131        1257 : DEFINE_GETTER(AllocateInOldGenerationStubConstant,
     132             :               HeapConstant(BUILTIN_CODE(isolate(), AllocateInOldGeneration)))
     133             : 
     134         433 : DEFINE_GETTER(ArrayConstructorStubConstant,
     135             :               HeapConstant(BUILTIN_CODE(isolate(), ArrayConstructorImpl)))
     136             : 
     137       72891 : DEFINE_GETTER(BigIntMapConstant, HeapConstant(factory()->bigint_map()))
     138             : 
     139         122 : DEFINE_GETTER(BooleanMapConstant, HeapConstant(factory()->boolean_map()))
     140             : 
     141          87 : DEFINE_GETTER(ToNumberBuiltinConstant,
     142             :               HeapConstant(BUILTIN_CODE(isolate(), ToNumber)))
     143             : 
     144      158627 : DEFINE_GETTER(EmptyFixedArrayConstant,
     145             :               HeapConstant(factory()->empty_fixed_array()))
     146             : 
     147       75979 : DEFINE_GETTER(EmptyStringConstant, HeapConstant(factory()->empty_string()))
     148             : 
     149        3258 : DEFINE_GETTER(FixedArrayMapConstant, HeapConstant(factory()->fixed_array_map()))
     150             : 
     151        2491 : DEFINE_GETTER(PropertyArrayMapConstant,
     152             :               HeapConstant(factory()->property_array_map()))
     153             : 
     154          56 : DEFINE_GETTER(FixedDoubleArrayMapConstant,
     155             :               HeapConstant(factory()->fixed_double_array_map()))
     156             : 
     157      245452 : DEFINE_GETTER(HeapNumberMapConstant, HeapConstant(factory()->heap_number_map()))
     158             : 
     159    17487997 : DEFINE_GETTER(OptimizedOutConstant, HeapConstant(factory()->optimized_out()))
     160             : 
     161       17080 : DEFINE_GETTER(StaleRegisterConstant, HeapConstant(factory()->stale_register()))
     162             : 
     163     2209555 : DEFINE_GETTER(UndefinedConstant, HeapConstant(factory()->undefined_value()))
     164             : 
     165      514425 : DEFINE_GETTER(TheHoleConstant, HeapConstant(factory()->the_hole_value()))
     166             : 
     167     1505732 : DEFINE_GETTER(TrueConstant, HeapConstant(factory()->true_value()))
     168             : 
     169     1592395 : DEFINE_GETTER(FalseConstant, HeapConstant(factory()->false_value()))
     170             : 
     171       43592 : DEFINE_GETTER(NullConstant, HeapConstant(factory()->null_value()))
     172             : 
     173     1828432 : DEFINE_GETTER(ZeroConstant, NumberConstant(0.0))
     174             : 
     175      418225 : DEFINE_GETTER(OneConstant, NumberConstant(1.0))
     176             : 
     177         295 : DEFINE_GETTER(MinusOneConstant, NumberConstant(-1.0))
     178             : 
     179        1493 : DEFINE_GETTER(NaNConstant,
     180             :               NumberConstant(std::numeric_limits<double>::quiet_NaN()))
     181             : 
     182       23160 : DEFINE_GETTER(EmptyStateValues,
     183             :               graph()->NewNode(common()->StateValues(0,
     184             :                                                      SparseInputMask::Dense())))
     185             : 
     186     5780064 : DEFINE_GETTER(SingleDeadTypedStateValues,
     187             :               graph()->NewNode(common()->TypedStateValues(
     188             :                   new (graph()->zone()->New(sizeof(ZoneVector<MachineType>)))
     189             :                       ZoneVector<MachineType>(0, graph()->zone()),
     190             :                   SparseInputMask(SparseInputMask::kEndMarker << 1))))
     191             : 
     192             : #undef DEFINE_GETTER
     193             : #undef GET_CACHED_FIELD
     194             : 
     195             : }  // namespace compiler
     196             : }  // namespace internal
     197      121996 : }  // namespace v8

Generated by: LCOV version 1.10