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      928022 : JSHeapCopyReducer::JSHeapCopyReducer(JSHeapBroker* broker) : broker_(broker) {}
      24             : 
      25     8405429 : JSHeapBroker* JSHeapCopyReducer::broker() { return broker_; }
      26             : 
      27    35962550 : Reduction JSHeapCopyReducer::Reduce(Node* node) {
      28    35962550 :   switch (node->opcode()) {
      29             :     case IrOpcode::kHeapConstant: {
      30    12473958 :       ObjectRef object(broker(), HeapConstantOf(node->op()));
      31     6236968 :       if (object.IsJSFunction()) object.AsJSFunction().Serialize();
      32     6236961 :       if (object.IsJSObject()) object.AsJSObject().SerializeObjectCreateMap();
      33     6236956 :       if (object.IsModule()) object.AsModule().Serialize();
      34     6236960 :       if (object.IsContext()) object.AsContext().SerializeContextChain();
      35             :       break;
      36             :     }
      37             :     case IrOpcode::kJSCreateArray: {
      38        1565 :       CreateArrayParameters const& p = CreateArrayParametersOf(node->op());
      39             :       Handle<AllocationSite> site;
      40        2112 :       if (p.site().ToHandle(&site)) AllocationSiteRef(broker(), site);
      41             :       break;
      42             :     }
      43             :     case IrOpcode::kJSCreateArguments: {
      44       19439 :       Node* const frame_state = NodeProperties::GetFrameStateInput(node);
      45       19439 :       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       18830 :       ScopeInfoRef(broker(), ScopeInfoOf(node->op()));
      52        9415 :       break;
      53             :     }
      54             :     case IrOpcode::kJSCreateBoundFunction: {
      55             :       CreateBoundFunctionParameters const& p =
      56         117 :           CreateBoundFunctionParametersOf(node->op());
      57         117 :       MapRef(broker(), p.map());
      58         117 :       break;
      59             :     }
      60             :     case IrOpcode::kJSCreateCatchContext: {
      61       30734 :       ScopeInfoRef(broker(), ScopeInfoOf(node->op()));
      62       15367 :       break;
      63             :     }
      64             :     case IrOpcode::kJSCreateClosure: {
      65      442188 :       CreateClosureParameters const& p = CreateClosureParametersOf(node->op());
      66      442190 :       SharedFunctionInfoRef(broker(), p.shared_info());
      67      442189 :       HeapObjectRef(broker(), p.feedback_cell());
      68      442190 :       HeapObjectRef(broker(), p.code());
      69      442190 :       break;
      70             :     }
      71             :     case IrOpcode::kJSCreateEmptyLiteralArray: {
      72       22345 :       FeedbackParameter const& p = FeedbackParameterOf(node->op());
      73       22345 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      74       22345 :       break;
      75             :     }
      76             :     case IrOpcode::kJSCreateFunctionContext: {
      77             :       CreateFunctionContextParameters const& p =
      78       29704 :           CreateFunctionContextParametersOf(node->op());
      79       29704 :       ScopeInfoRef(broker(), p.scope_info());
      80       29704 :       break;
      81             :     }
      82             :     case IrOpcode::kJSCreateLiteralArray:
      83             :     case IrOpcode::kJSCreateLiteralObject: {
      84       24331 :       CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
      85       24330 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      86       24330 :       break;
      87             :     }
      88             :     case IrOpcode::kJSCreateLiteralRegExp: {
      89        6447 :       CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
      90        6447 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      91        6447 :       break;
      92             :     }
      93             :     case IrOpcode::kJSCreateWithContext: {
      94         992 :       ScopeInfoRef(broker(), ScopeInfoOf(node->op()));
      95         496 :       break;
      96             :     }
      97             :     case IrOpcode::kJSLoadNamed:
      98             :     case IrOpcode::kJSStoreNamed: {
      99      506318 :       NamedAccess const& p = NamedAccessOf(node->op());
     100      506318 :       NameRef(broker(), p.name());
     101      506318 :       break;
     102             :     }
     103             :     case IrOpcode::kStoreField:
     104             :     case IrOpcode::kLoadField: {
     105     1804960 :       FieldAccess access = FieldAccessOf(node->op());
     106             :       Handle<Map> map_handle;
     107     1804960 :       if (access.map.ToHandle(&map_handle)) {
     108        3609 :         MapRef(broker(), map_handle);
     109             :       }
     110             :       Handle<Name> name_handle;
     111     1804960 :       if (access.name.ToHandle(&name_handle)) {
     112       93453 :         NameRef(broker(), name_handle);
     113             :       }
     114             :       break;
     115             :     }
     116             :     case IrOpcode::kMapGuard: {
     117        6671 :       ZoneHandleSet<Map> const& maps = MapGuardMapsOf(node->op());
     118       13350 :       for (Handle<Map> map : maps) {
     119        6679 :         MapRef(broker(), map);
     120             :       }
     121             :       break;
     122             :     }
     123             :     case IrOpcode::kCheckMaps: {
     124       89470 :       ZoneHandleSet<Map> const& maps = CheckMapsParametersOf(node->op()).maps();
     125      186563 :       for (Handle<Map> map : maps) {
     126       97093 :         MapRef(broker(), map);
     127             :       }
     128             :       break;
     129             :     }
     130             :     case IrOpcode::kCompareMaps: {
     131        6517 :       ZoneHandleSet<Map> const& maps = CompareMapsParametersOf(node->op());
     132       13042 :       for (Handle<Map> map : maps) {
     133        6525 :         MapRef(broker(), map);
     134             :       }
     135             :       break;
     136             :     }
     137             : 
     138             :     default:
     139             :       break;
     140             :   }
     141    35962531 :   return NoChange();
     142             : }
     143             : 
     144             : }  // namespace compiler
     145             : }  // namespace internal
     146      122036 : }  // namespace v8