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      927904 : JSHeapCopyReducer::JSHeapCopyReducer(JSHeapBroker* broker) : broker_(broker) {}
      24             : 
      25     8404444 : JSHeapBroker* JSHeapCopyReducer::broker() { return broker_; }
      26             : 
      27    37249204 : Reduction JSHeapCopyReducer::Reduce(Node* node) {
      28    37249204 :   switch (node->opcode()) {
      29             :     case IrOpcode::kHeapConstant: {
      30    12448890 :       ObjectRef object(broker(), HeapConstantOf(node->op()));
      31     6224449 :       if (object.IsJSFunction()) object.AsJSFunction().Serialize();
      32     6224441 :       if (object.IsJSObject()) object.AsJSObject().SerializeObjectCreateMap();
      33     6224430 :       if (object.IsModule()) object.AsModule().Serialize();
      34     6224430 :       if (object.IsContext()) object.AsContext().SerializeContextChain();
      35             :       break;
      36             :     }
      37             :     case IrOpcode::kJSCreateArray: {
      38        1140 :       CreateArrayParameters const& p = CreateArrayParametersOf(node->op());
      39             :       Handle<AllocationSite> site;
      40        1652 :       if (p.site().ToHandle(&site)) AllocationSiteRef(broker(), site);
      41             :       break;
      42             :     }
      43             :     case IrOpcode::kJSCreateArguments: {
      44       19015 :       Node* const frame_state = NodeProperties::GetFrameStateInput(node);
      45       19015 :       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       18600 :       ScopeInfoRef(broker(), ScopeInfoOf(node->op()));
      52        9300 :       break;
      53             :     }
      54             :     case IrOpcode::kJSCreateBoundFunction: {
      55             :       CreateBoundFunctionParameters const& p =
      56         111 :           CreateBoundFunctionParametersOf(node->op());
      57         111 :       MapRef(broker(), p.map());
      58         111 :       break;
      59             :     }
      60             :     case IrOpcode::kJSCreateCatchContext: {
      61       28976 :       ScopeInfoRef(broker(), ScopeInfoOf(node->op()));
      62       14488 :       break;
      63             :     }
      64             :     case IrOpcode::kJSCreateClosure: {
      65      446501 :       CreateClosureParameters const& p = CreateClosureParametersOf(node->op());
      66      446502 :       SharedFunctionInfoRef(broker(), p.shared_info());
      67      446503 :       HeapObjectRef(broker(), p.feedback_cell());
      68      446503 :       HeapObjectRef(broker(), p.code());
      69      446503 :       break;
      70             :     }
      71             :     case IrOpcode::kJSCreateEmptyLiteralArray: {
      72       22085 :       FeedbackParameter const& p = FeedbackParameterOf(node->op());
      73       22085 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      74       22085 :       break;
      75             :     }
      76             :     case IrOpcode::kJSCreateFunctionContext: {
      77             :       CreateFunctionContextParameters const& p =
      78       29498 :           CreateFunctionContextParametersOf(node->op());
      79       29498 :       ScopeInfoRef(broker(), p.scope_info());
      80       29498 :       break;
      81             :     }
      82             :     case IrOpcode::kJSCreateLiteralArray:
      83             :     case IrOpcode::kJSCreateLiteralObject: {
      84       23821 :       CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
      85       23821 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      86       23821 :       break;
      87             :     }
      88             :     case IrOpcode::kJSCreateLiteralRegExp: {
      89        6443 :       CreateLiteralParameters const& p = CreateLiteralParametersOf(node->op());
      90        6443 :       FeedbackVectorRef(broker(), p.feedback().vector()).SerializeSlots();
      91        6443 :       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      504781 :       NamedAccess const& p = NamedAccessOf(node->op());
     100      504781 :       NameRef(broker(), p.name());
     101      504781 :       break;
     102             :     }
     103             :     case IrOpcode::kStoreField:
     104             :     case IrOpcode::kLoadField: {
     105     1808367 :       FieldAccess access = FieldAccessOf(node->op());
     106             :       Handle<Map> map_handle;
     107     1808367 :       if (access.map.ToHandle(&map_handle)) {
     108        4047 :         MapRef(broker(), map_handle);
     109             :       }
     110             :       Handle<Name> name_handle;
     111     1808367 :       if (access.name.ToHandle(&name_handle)) {
     112       95069 :         NameRef(broker(), name_handle);
     113             :       }
     114             :       break;
     115             :     }
     116             :     case IrOpcode::kMapGuard: {
     117        6824 :       ZoneHandleSet<Map> const& maps = MapGuardMapsOf(node->op());
     118       13657 :       for (Handle<Map> map : maps) {
     119        6833 :         MapRef(broker(), map);
     120             :       }
     121             :       break;
     122             :     }
     123             :     case IrOpcode::kCheckMaps: {
     124       90034 :       ZoneHandleSet<Map> const& maps = CheckMapsParametersOf(node->op()).maps();
     125      187351 :       for (Handle<Map> map : maps) {
     126       97317 :         MapRef(broker(), map);
     127             :       }
     128             :       break;
     129             :     }
     130             :     case IrOpcode::kCompareMaps: {
     131        6670 :       ZoneHandleSet<Map> const& maps = CompareMapsParametersOf(node->op());
     132       13349 :       for (Handle<Map> map : maps) {
     133        6679 :         MapRef(broker(), map);
     134             :       }
     135             :       break;
     136             :     }
     137             : 
     138             :     default:
     139             :       break;
     140             :   }
     141    37249191 :   return NoChange();
     142             : }
     143             : 
     144             : }  // namespace compiler
     145             : }  // namespace internal
     146      120216 : }  // namespace v8