Line data    Source code

       1             : // Copyright 2018 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-heap-copy-reducer.h"
       6             : 
       7             : #include "src/compiler/common-operator.h"
       8             : #include "src/compiler/js-heap-broker.h"
       9             : #include "src/compiler/js-operator.h"
      10             : #include "src/compiler/node-properties.h"
      11             : #include "src/compiler/simplified-operator.h"
      12             : #include "src/heap/factory-inl.h"
      13             : #include "src/objects/map.h"
      14             : #include "src/objects/scope-info.h"
      15             : 
      16             : namespace v8 {
      17             : namespace internal {
      18             : namespace compiler {
      19             : 
      20             : // In the functions below, we call the ObjectRef (or subclass) constructor in
      21             : // order to trigger serialization if not yet done.
      22             : 
      23      913578 : JSHeapCopyReducer::JSHeapCopyReducer(JSHeapBroker* broker) : broker_(broker) {}
      24             : 
      25     8275457 : JSHeapBroker* JSHeapCopyReducer::broker() { return broker_; }
      26             : 
      27    36913451 : Reduction JSHeapCopyReducer::Reduce(Node* node) {
      28    36913451 :   switch (node->opcode()) {
      29             :     case IrOpcode::kHeapConstant: {
      30    12288876 :       ObjectRef object(broker(), HeapConstantOf(node->op()));
      31     6144437 :       if (object.IsJSFunction()) object.AsJSFunction().Serialize();
      32     6144437 :       if (object.IsJSObject()) object.AsJSObject().SerializeObjectCreateMap();
      33     6144438 :       if (object.IsModule()) object.AsModule().Serialize();
      34     6144438 :       if (object.IsContext()) object.AsContext().Serialize();
      35             :       break;
      36             :     }
      37             :     case IrOpcode::kJSCreateArray: {
      38        1367 :       CreateArrayParameters const& p = CreateArrayParametersOf(node->op());
      39             :       Handle<AllocationSite> site;
      40        1904 :       if (p.site().ToHandle(&site)) AllocationSiteRef(broker(), site);
      41             :       break;
      42             :     }
      43             :     case IrOpcode::kJSCreateArguments: {
      44       19278 :       Node* const frame_state = NodeProperties::GetFrameStateInput(node);
      45       19278 :       FrameStateInfo state_info = FrameStateInfoOf(frame_state->op());
      46             :       SharedFunctionInfoRef shared(broker(),
      47             :                                    state_info.shared_info().ToHandleChecked());
      48             :       break;
      49             :     }
      50             :     case IrOpcode::kJSCreateBlockContext: {
      51       18276 :       ScopeInfoRef(broker(), ScopeInfoOf(node->op()));
      52        9138 :       break;
      53             :     }
      54             :     case IrOpcode::kJSCreateBoundFunction: {
      55             :       CreateBoundFunctionParameters const& p =
      56         105 :           CreateBoundFunctionParametersOf(node->op());
      57         105 :       MapRef(broker(), p.map());
      58         105 :       break;
      59             :     }
      60             :     case IrOpcode::kJSCreateCatchContext: {
      61       28698 :       ScopeInfoRef(broker(), ScopeInfoOf(node->op()));
      62       14349 :       break;
      63             :     }
      64             :     case IrOpcode::kJSCreateClosure: {
      65      437241 :       CreateClosureParameters const& p = CreateClosureParametersOf(node->op());
      66      437241 :       SharedFunctionInfoRef(broker(), p.shared_info());
      67      437241 :       HeapObjectRef(broker(), p.feedback_cell());
      68      437241 :       HeapObjectRef(broker(), p.code());
      69      437241 :       break;
      70             :     }
      71             :     case IrOpcode::kJSCreateEmptyLiteralArray: {
      72       21661 :       FeedbackParameter const& p = FeedbackParameterOf(node->op());
      73       21661 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      74       21661 :       break;
      75             :     }
      76             :     case IrOpcode::kJSCreateFunctionContext: {
      77             :       CreateFunctionContextParameters const& p =
      78       29247 :           CreateFunctionContextParametersOf(node->op());
      79       29247 :       ScopeInfoRef(broker(), p.scope_info());
      80       29247 :       break;
      81             :     }
      82             :     case IrOpcode::kJSCreateLiteralArray:
      83             :     case IrOpcode::kJSCreateLiteralObject: {
      84       23230 :       CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
      85       23230 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      86       23230 :       break;
      87             :     }
      88             :     case IrOpcode::kJSCreateLiteralRegExp: {
      89        6421 :       CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
      90        6421 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      91        6421 :       break;
      92             :     }
      93             :     case IrOpcode::kJSCreateWithContext: {
      94         978 :       ScopeInfoRef(broker(), ScopeInfoOf(node->op()));
      95         489 :       break;
      96             :     }
      97             :     case IrOpcode::kJSLoadNamed:
      98             :     case IrOpcode::kJSStoreNamed: {
      99      480459 :       NamedAccess const& p = NamedAccessOf(node->op());
     100      480459 :       NameRef(broker(), p.name());
     101      480459 :       break;
     102             :     }
     103             :     case IrOpcode::kStoreField:
     104             :     case IrOpcode::kLoadField: {
     105     1809327 :       FieldAccess access = FieldAccessOf(node->op());
     106             :       Handle<Map> map_handle;
     107     1809327 :       if (access.map.ToHandle(&map_handle)) {
     108        3058 :         MapRef(broker(), map_handle);
     109             :       }
     110             :       Handle<Name> name_handle;
     111     1809327 :       if (access.name.ToHandle(&name_handle)) {
     112       95697 :         NameRef(broker(), name_handle);
     113             :       }
     114             :       break;
     115             :     }
     116             :     case IrOpcode::kMapGuard: {
     117        6648 :       ZoneHandleSet<Map> const maps = MapGuardMapsOf(node->op()).maps();
     118       13296 :       for (Handle<Map> map : maps) {
     119        6648 :         MapRef(broker(), map);
     120             :       }
     121             :       break;
     122             :     }
     123             :     case IrOpcode::kCheckMaps: {
     124       94073 :       ZoneHandleSet<Map> const maps = CheckMapsParametersOf(node->op()).maps();
     125      196540 :       for (Handle<Map> map : maps) {
     126      102467 :         MapRef(broker(), map);
     127             :       }
     128             :       break;
     129             :     }
     130             :     case IrOpcode::kCompareMaps: {
     131             :       ZoneHandleSet<Map> const maps =
     132        6512 :           CompareMapsParametersOf(node->op()).maps();
     133       13024 :       for (Handle<Map> map : maps) {
     134        6512 :         MapRef(broker(), map);
     135             :       }
     136             :       break;
     137             :     }
     138             : 
     139             :     default:
     140             :       break;
     141             :   }
     142    36913450 :   return NoChange();
     143             : }
     144             : 
     145             : }  // namespace compiler
     146             : }  // namespace internal
     147      178779 : }  // namespace v8