LCOV - code coverage report
Current view: top level - src/compiler - js-intrinsic-lowering.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 229 241 95.0 %
Date: 2017-04-26 Functions: 36 43 83.7 %

          Line data    Source code
       1             : // Copyright 2015 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-intrinsic-lowering.h"
       6             : 
       7             : #include <stack>
       8             : 
       9             : #include "src/code-factory.h"
      10             : #include "src/compiler/access-builder.h"
      11             : #include "src/compiler/js-graph.h"
      12             : #include "src/compiler/linkage.h"
      13             : #include "src/compiler/node-matchers.h"
      14             : #include "src/compiler/node-properties.h"
      15             : #include "src/compiler/operator-properties.h"
      16             : #include "src/counters.h"
      17             : #include "src/objects-inl.h"
      18             : 
      19             : namespace v8 {
      20             : namespace internal {
      21             : namespace compiler {
      22             : 
      23      395346 : JSIntrinsicLowering::JSIntrinsicLowering(Editor* editor, JSGraph* jsgraph,
      24             :                                          DeoptimizationMode mode)
      25      395346 :     : AdvancedReducer(editor), jsgraph_(jsgraph), mode_(mode) {}
      26             : 
      27    31927923 : Reduction JSIntrinsicLowering::Reduce(Node* node) {
      28    31927923 :   if (node->opcode() != IrOpcode::kJSCallRuntime) return NoChange();
      29             :   const Runtime::Function* const f =
      30      422633 :       Runtime::FunctionForId(CallRuntimeParametersOf(node->op()).id());
      31      422633 :   if (f->intrinsic_type != Runtime::IntrinsicType::INLINE) return NoChange();
      32       84252 :   switch (f->function_id) {
      33             :     case Runtime::kInlineCreateIterResultObject:
      34       11259 :       return ReduceCreateIterResultObject(node);
      35             :     case Runtime::kInlineDebugIsActive:
      36          30 :       return ReduceDebugIsActive(node);
      37             :     case Runtime::kInlineDeoptimizeNow:
      38         126 :       return ReduceDeoptimizeNow(node);
      39             :     case Runtime::kInlineGeneratorClose:
      40        1241 :       return ReduceGeneratorClose(node);
      41             :     case Runtime::kInlineGeneratorGetInputOrDebugPos:
      42        6838 :       return ReduceGeneratorGetInputOrDebugPos(node);
      43             :     case Runtime::kInlineAsyncGeneratorGetAwaitInputOrDebugPos:
      44          36 :       return ReduceAsyncGeneratorGetAwaitInputOrDebugPos(node);
      45             :     case Runtime::kInlineAsyncGeneratorReject:
      46          50 :       return ReduceAsyncGeneratorReject(node);
      47             :     case Runtime::kInlineAsyncGeneratorResolve:
      48         158 :       return ReduceAsyncGeneratorResolve(node);
      49             :     case Runtime::kInlineGeneratorGetResumeMode:
      50        6683 :       return ReduceGeneratorGetResumeMode(node);
      51             :     case Runtime::kInlineGeneratorGetContext:
      52        2325 :       return ReduceGeneratorGetContext(node);
      53             :     case Runtime::kInlineIsArray:
      54         751 :       return ReduceIsInstanceType(node, JS_ARRAY_TYPE);
      55             :     case Runtime::kInlineIsTypedArray:
      56         257 :       return ReduceIsInstanceType(node, JS_TYPED_ARRAY_TYPE);
      57             :     case Runtime::kInlineIsJSProxy:
      58         827 :       return ReduceIsInstanceType(node, JS_PROXY_TYPE);
      59             :     case Runtime::kInlineIsJSReceiver:
      60       13469 :       return ReduceIsJSReceiver(node);
      61             :     case Runtime::kInlineIsSmi:
      62        1573 :       return ReduceIsSmi(node);
      63             :     case Runtime::kInlineFixedArrayGet:
      64        6623 :       return ReduceFixedArrayGet(node);
      65             :     case Runtime::kInlineFixedArraySet:
      66        2277 :       return ReduceFixedArraySet(node);
      67             :     case Runtime::kInlineSubString:
      68         138 :       return ReduceSubString(node);
      69             :     case Runtime::kInlineToInteger:
      70         271 :       return ReduceToInteger(node);
      71             :     case Runtime::kInlineToLength:
      72         257 :       return ReduceToLength(node);
      73             :     case Runtime::kInlineToNumber:
      74         146 :       return ReduceToNumber(node);
      75             :     case Runtime::kInlineToObject:
      76         320 :       return ReduceToObject(node);
      77             :     case Runtime::kInlineToString:
      78        2636 :       return ReduceToString(node);
      79             :     case Runtime::kInlineCall:
      80       15460 :       return ReduceCall(node);
      81             :     case Runtime::kInlineGetSuperConstructor:
      82          15 :       return ReduceGetSuperConstructor(node);
      83             :     case Runtime::kInlineArrayBufferViewGetByteLength:
      84             :       return ReduceArrayBufferViewField(
      85           9 :           node, AccessBuilder::ForJSArrayBufferViewByteLength());
      86             :     case Runtime::kInlineArrayBufferViewGetByteOffset:
      87             :       return ReduceArrayBufferViewField(
      88          49 :           node, AccessBuilder::ForJSArrayBufferViewByteOffset());
      89             :     case Runtime::kInlineArrayBufferViewWasNeutered:
      90           1 :       return ReduceArrayBufferViewWasNeutered(node);
      91             :     case Runtime::kInlineMaxSmi:
      92          22 :       return ReduceMaxSmi(node);
      93             :     case Runtime::kInlineTypedArrayGetLength:
      94             :       return ReduceArrayBufferViewField(node,
      95          43 :                                         AccessBuilder::ForJSTypedArrayLength());
      96             :     case Runtime::kInlineTypedArrayMaxSizeInHeap:
      97           0 :       return ReduceTypedArrayMaxSizeInHeap(node);
      98             :     case Runtime::kInlineJSCollectionGetTable:
      99        1125 :       return ReduceJSCollectionGetTable(node);
     100             :     case Runtime::kInlineStringGetRawHashField:
     101         813 :       return ReduceStringGetRawHashField(node);
     102             :     case Runtime::kInlineTheHole:
     103         291 :       return ReduceTheHole(node);
     104             :     case Runtime::kInlineClassOf:
     105        6613 :       return ReduceClassOf(node);
     106             :     default:
     107             :       break;
     108             :   }
     109             :   return NoChange();
     110             : }
     111             : 
     112             : 
     113       11259 : Reduction JSIntrinsicLowering::ReduceCreateIterResultObject(Node* node) {
     114       11259 :   Node* const value = NodeProperties::GetValueInput(node, 0);
     115       11259 :   Node* const done = NodeProperties::GetValueInput(node, 1);
     116       11259 :   Node* const context = NodeProperties::GetContextInput(node);
     117       11259 :   Node* const effect = NodeProperties::GetEffectInput(node);
     118             :   return Change(node, javascript()->CreateIterResultObject(), value, done,
     119       11259 :                 context, effect);
     120             : }
     121             : 
     122          60 : Reduction JSIntrinsicLowering::ReduceDebugIsActive(Node* node) {
     123             :   Node* const value = jsgraph()->ExternalConstant(
     124          60 :       ExternalReference::debug_is_active_address(isolate()));
     125          30 :   Node* const effect = NodeProperties::GetEffectInput(node);
     126          30 :   Node* const control = NodeProperties::GetControlInput(node);
     127             :   Operator const* const op =
     128          60 :       simplified()->LoadField(AccessBuilder::ForExternalUint8Value());
     129          30 :   return Change(node, op, value, effect, control);
     130             : }
     131             : 
     132         126 : Reduction JSIntrinsicLowering::ReduceDeoptimizeNow(Node* node) {
     133         126 :   if (mode() != kDeoptimizationEnabled) return NoChange();
     134         126 :   Node* const frame_state = NodeProperties::GetFrameStateInput(node);
     135         126 :   Node* const effect = NodeProperties::GetEffectInput(node);
     136         126 :   Node* const control = NodeProperties::GetControlInput(node);
     137             : 
     138             :   // TODO(bmeurer): Move MergeControlToEnd() to the AdvancedReducer.
     139             :   Node* deoptimize = graph()->NewNode(
     140             :       common()->Deoptimize(DeoptimizeKind::kEager, DeoptimizeReason::kNoReason),
     141         126 :       frame_state, effect, control);
     142         126 :   NodeProperties::MergeControlToEnd(graph(), common(), deoptimize);
     143         126 :   Revisit(graph()->end());
     144             : 
     145         126 :   node->TrimInputCount(0);
     146         126 :   NodeProperties::ChangeOp(node, common()->Dead());
     147             :   return Changed(node);
     148             : }
     149             : 
     150        3723 : Reduction JSIntrinsicLowering::ReduceGeneratorClose(Node* node) {
     151        1241 :   Node* const generator = NodeProperties::GetValueInput(node, 0);
     152        1241 :   Node* const effect = NodeProperties::GetEffectInput(node);
     153        1241 :   Node* const control = NodeProperties::GetControlInput(node);
     154        1241 :   Node* const closed = jsgraph()->Constant(JSGeneratorObject::kGeneratorClosed);
     155        1241 :   Node* const undefined = jsgraph()->UndefinedConstant();
     156             :   Operator const* const op = simplified()->StoreField(
     157        2482 :       AccessBuilder::ForJSGeneratorObjectContinuation());
     158             : 
     159        1241 :   ReplaceWithValue(node, undefined, node);
     160             :   NodeProperties::RemoveType(node);
     161        1241 :   return Change(node, op, generator, closed, effect, control);
     162             : }
     163             : 
     164        6838 : Reduction JSIntrinsicLowering::ReduceGeneratorGetInputOrDebugPos(Node* node) {
     165        6838 :   Node* const generator = NodeProperties::GetValueInput(node, 0);
     166        6838 :   Node* const effect = NodeProperties::GetEffectInput(node);
     167        6838 :   Node* const control = NodeProperties::GetControlInput(node);
     168             :   Operator const* const op = simplified()->LoadField(
     169       13676 :       AccessBuilder::ForJSGeneratorObjectInputOrDebugPos());
     170             : 
     171        6838 :   return Change(node, op, generator, effect, control);
     172             : }
     173             : 
     174          36 : Reduction JSIntrinsicLowering::ReduceAsyncGeneratorGetAwaitInputOrDebugPos(
     175             :     Node* node) {
     176          36 :   Node* const generator = NodeProperties::GetValueInput(node, 0);
     177          36 :   Node* const effect = NodeProperties::GetEffectInput(node);
     178          36 :   Node* const control = NodeProperties::GetControlInput(node);
     179             :   Operator const* const op = simplified()->LoadField(
     180          72 :       AccessBuilder::ForJSAsyncGeneratorObjectAwaitInputOrDebugPos());
     181             : 
     182          36 :   return Change(node, op, generator, effect, control);
     183             : }
     184             : 
     185          50 : Reduction JSIntrinsicLowering::ReduceAsyncGeneratorReject(Node* node) {
     186          50 :   return Change(node, CodeFactory::AsyncGeneratorReject(isolate()), 0);
     187             : }
     188             : 
     189         158 : Reduction JSIntrinsicLowering::ReduceAsyncGeneratorResolve(Node* node) {
     190         158 :   return Change(node, CodeFactory::AsyncGeneratorResolve(isolate()), 0);
     191             : }
     192             : 
     193        2325 : Reduction JSIntrinsicLowering::ReduceGeneratorGetContext(Node* node) {
     194        2325 :   Node* const generator = NodeProperties::GetValueInput(node, 0);
     195        2325 :   Node* const effect = NodeProperties::GetEffectInput(node);
     196        2325 :   Node* const control = NodeProperties::GetControlInput(node);
     197             :   Operator const* const op =
     198        4650 :       simplified()->LoadField(AccessBuilder::ForJSGeneratorObjectContext());
     199             : 
     200        2325 :   return Change(node, op, generator, effect, control);
     201             : }
     202             : 
     203        6683 : Reduction JSIntrinsicLowering::ReduceGeneratorGetResumeMode(Node* node) {
     204        6683 :   Node* const generator = NodeProperties::GetValueInput(node, 0);
     205        6683 :   Node* const effect = NodeProperties::GetEffectInput(node);
     206        6683 :   Node* const control = NodeProperties::GetControlInput(node);
     207             :   Operator const* const op =
     208       13366 :       simplified()->LoadField(AccessBuilder::ForJSGeneratorObjectResumeMode());
     209             : 
     210        6683 :   return Change(node, op, generator, effect, control);
     211             : }
     212             : 
     213        1835 : Reduction JSIntrinsicLowering::ReduceIsInstanceType(
     214        3670 :     Node* node, InstanceType instance_type) {
     215             :   // if (%_IsSmi(value)) {
     216             :   //   return false;
     217             :   // } else {
     218             :   //   return %_GetInstanceType(%_GetMap(value)) == instance_type;
     219             :   // }
     220        1835 :   Node* value = NodeProperties::GetValueInput(node, 0);
     221        1835 :   Node* effect = NodeProperties::GetEffectInput(node);
     222        1835 :   Node* control = NodeProperties::GetControlInput(node);
     223             : 
     224        1835 :   Node* check = graph()->NewNode(simplified()->ObjectIsSmi(), value);
     225        1835 :   Node* branch = graph()->NewNode(common()->Branch(), check, control);
     226             : 
     227        1835 :   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
     228             :   Node* etrue = effect;
     229        1835 :   Node* vtrue = jsgraph()->FalseConstant();
     230             : 
     231        1835 :   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
     232             :   Node* efalse = graph()->NewNode(
     233             :       simplified()->LoadField(AccessBuilder::ForMapInstanceType()),
     234             :       graph()->NewNode(simplified()->LoadField(AccessBuilder::ForMap()), value,
     235             :                        effect, if_false),
     236        9175 :       effect, if_false);
     237             :   Node* vfalse = graph()->NewNode(simplified()->NumberEqual(), efalse,
     238        5505 :                                   jsgraph()->Constant(instance_type));
     239             : 
     240        1835 :   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
     241             : 
     242             :   // Replace all effect uses of {node} with the {ephi}.
     243        1835 :   Node* ephi = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, merge);
     244        1835 :   ReplaceWithValue(node, node, ephi);
     245             : 
     246             :   // Turn the {node} into a Phi.
     247             :   return Change(node, common()->Phi(MachineRepresentation::kTagged, 2), vtrue,
     248        1835 :                 vfalse, merge);
     249             : }
     250             : 
     251             : 
     252       13469 : Reduction JSIntrinsicLowering::ReduceIsJSReceiver(Node* node) {
     253       13469 :   return Change(node, simplified()->ObjectIsReceiver());
     254             : }
     255             : 
     256             : 
     257        1573 : Reduction JSIntrinsicLowering::ReduceIsSmi(Node* node) {
     258        1573 :   return Change(node, simplified()->ObjectIsSmi());
     259             : }
     260             : 
     261             : 
     262       15042 : Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op) {
     263             :   // Replace all effect uses of {node} with the effect dependency.
     264             :   RelaxEffectsAndControls(node);
     265             :   // Remove the inputs corresponding to context, effect and control.
     266       15042 :   NodeProperties::RemoveNonValueInputs(node);
     267             :   // Finally update the operator to the new one.
     268       15042 :   NodeProperties::ChangeOp(node, op);
     269       15042 :   return Changed(node);
     270             : }
     271             : 
     272             : 
     273        6623 : Reduction JSIntrinsicLowering::ReduceFixedArrayGet(Node* node) {
     274             :   Node* base = node->InputAt(0);
     275             :   Node* index = node->InputAt(1);
     276        6623 :   Node* effect = NodeProperties::GetEffectInput(node);
     277        6623 :   Node* control = NodeProperties::GetControlInput(node);
     278             :   return Change(
     279             :       node, simplified()->LoadElement(AccessBuilder::ForFixedArrayElement()),
     280       13246 :       base, index, effect, control);
     281             : }
     282             : 
     283             : 
     284        2277 : Reduction JSIntrinsicLowering::ReduceFixedArraySet(Node* node) {
     285             :   Node* base = node->InputAt(0);
     286             :   Node* index = node->InputAt(1);
     287             :   Node* value = node->InputAt(2);
     288        2277 :   Node* effect = NodeProperties::GetEffectInput(node);
     289        2277 :   Node* control = NodeProperties::GetControlInput(node);
     290             :   Node* store = (graph()->NewNode(
     291             :       simplified()->StoreElement(AccessBuilder::ForFixedArrayElement()), base,
     292        6831 :       index, value, effect, control));
     293        2277 :   ReplaceWithValue(node, value, store);
     294        2277 :   return Changed(store);
     295             : }
     296             : 
     297             : 
     298         138 : Reduction JSIntrinsicLowering::ReduceSubString(Node* node) {
     299         138 :   return Change(node, CodeFactory::SubString(isolate()), 3);
     300             : }
     301             : 
     302             : 
     303         271 : Reduction JSIntrinsicLowering::ReduceToInteger(Node* node) {
     304         271 :   NodeProperties::ChangeOp(node, javascript()->ToInteger());
     305         271 :   return Changed(node);
     306             : }
     307             : 
     308             : 
     309         146 : Reduction JSIntrinsicLowering::ReduceToNumber(Node* node) {
     310         146 :   NodeProperties::ChangeOp(node, javascript()->ToNumber());
     311         146 :   return Changed(node);
     312             : }
     313             : 
     314             : 
     315         257 : Reduction JSIntrinsicLowering::ReduceToLength(Node* node) {
     316         257 :   NodeProperties::ChangeOp(node, javascript()->ToLength());
     317         257 :   return Changed(node);
     318             : }
     319             : 
     320             : 
     321         320 : Reduction JSIntrinsicLowering::ReduceToObject(Node* node) {
     322         320 :   NodeProperties::ChangeOp(node, javascript()->ToObject());
     323         320 :   return Changed(node);
     324             : }
     325             : 
     326             : 
     327        2636 : Reduction JSIntrinsicLowering::ReduceToString(Node* node) {
     328             :   // ToString is unnecessary if the input is a string.
     329        2636 :   HeapObjectMatcher m(NodeProperties::GetValueInput(node, 0));
     330        3013 :   if (m.HasValue() && m.Value()->IsString()) {
     331         345 :     ReplaceWithValue(node, m.node());
     332             :     return Replace(m.node());
     333             :   }
     334        2291 :   NodeProperties::ChangeOp(node, javascript()->ToString());
     335             :   return Changed(node);
     336             : }
     337             : 
     338             : 
     339       15460 : Reduction JSIntrinsicLowering::ReduceCall(Node* node) {
     340       15460 :   size_t const arity = CallRuntimeParametersOf(node->op()).arity();
     341             :   NodeProperties::ChangeOp(
     342             :       node,
     343             :       javascript()->Call(arity, 0.0f, VectorSlotPair(),
     344       30920 :                          ConvertReceiverMode::kAny, TailCallMode::kDisallow));
     345       15460 :   return Changed(node);
     346             : }
     347             : 
     348          15 : Reduction JSIntrinsicLowering::ReduceGetSuperConstructor(Node* node) {
     349          15 :   NodeProperties::ChangeOp(node, javascript()->GetSuperConstructor());
     350          15 :   return Changed(node);
     351             : }
     352             : 
     353         101 : Reduction JSIntrinsicLowering::ReduceArrayBufferViewField(
     354         101 :     Node* node, FieldAccess const& access) {
     355         101 :   Node* receiver = NodeProperties::GetValueInput(node, 0);
     356         101 :   Node* effect = NodeProperties::GetEffectInput(node);
     357         101 :   Node* control = NodeProperties::GetControlInput(node);
     358             : 
     359             :   // Load the {receiver}s field.
     360             :   Node* value = effect = graph()->NewNode(simplified()->LoadField(access),
     361         101 :                                           receiver, effect, control);
     362             : 
     363             :   // Check if the {receiver}s buffer was neutered.
     364             :   Node* receiver_buffer = effect = graph()->NewNode(
     365             :       simplified()->LoadField(AccessBuilder::ForJSArrayBufferViewBuffer()),
     366         303 :       receiver, effect, control);
     367             :   Node* check = effect = graph()->NewNode(
     368         101 :       simplified()->ArrayBufferWasNeutered(), receiver_buffer, effect, control);
     369             : 
     370             :   // Default to zero if the {receiver}s buffer was neutered.
     371             :   value = graph()->NewNode(
     372             :       common()->Select(MachineRepresentation::kTagged, BranchHint::kFalse),
     373         202 :       check, jsgraph()->ZeroConstant(), value);
     374             : 
     375         101 :   ReplaceWithValue(node, value, effect, control);
     376         101 :   return Replace(value);
     377             : }
     378             : 
     379           1 : Reduction JSIntrinsicLowering::ReduceArrayBufferViewWasNeutered(Node* node) {
     380           1 :   Node* receiver = NodeProperties::GetValueInput(node, 0);
     381           1 :   Node* effect = NodeProperties::GetEffectInput(node);
     382           1 :   Node* control = NodeProperties::GetControlInput(node);
     383             : 
     384             :   // Check if the {receiver}s buffer was neutered.
     385             :   Node* receiver_buffer = effect = graph()->NewNode(
     386             :       simplified()->LoadField(AccessBuilder::ForJSArrayBufferViewBuffer()),
     387           3 :       receiver, effect, control);
     388             :   Node* value = effect = graph()->NewNode(
     389           1 :       simplified()->ArrayBufferWasNeutered(), receiver_buffer, effect, control);
     390             : 
     391           1 :   ReplaceWithValue(node, value, effect, control);
     392           1 :   return Replace(value);
     393             : }
     394             : 
     395          22 : Reduction JSIntrinsicLowering::ReduceMaxSmi(Node* node) {
     396          22 :   Node* value = jsgraph()->Constant(Smi::kMaxValue);
     397          22 :   ReplaceWithValue(node, value);
     398          22 :   return Replace(value);
     399             : }
     400             : 
     401           0 : Reduction JSIntrinsicLowering::ReduceTypedArrayMaxSizeInHeap(Node* node) {
     402           0 :   Node* value = jsgraph()->Constant(FLAG_typed_array_max_size_in_heap);
     403           0 :   ReplaceWithValue(node, value);
     404           0 :   return Replace(value);
     405             : }
     406             : 
     407        1125 : Reduction JSIntrinsicLowering::ReduceJSCollectionGetTable(Node* node) {
     408        1125 :   Node* collection = NodeProperties::GetValueInput(node, 0);
     409        1125 :   Node* effect = NodeProperties::GetEffectInput(node);
     410        1125 :   Node* control = NodeProperties::GetControlInput(node);
     411             :   return Change(node,
     412             :                 simplified()->LoadField(AccessBuilder::ForJSCollectionTable()),
     413        2250 :                 collection, effect, control);
     414             : }
     415             : 
     416         813 : Reduction JSIntrinsicLowering::ReduceStringGetRawHashField(Node* node) {
     417         813 :   Node* string = NodeProperties::GetValueInput(node, 0);
     418         813 :   Node* effect = NodeProperties::GetEffectInput(node);
     419         813 :   Node* control = NodeProperties::GetControlInput(node);
     420             :   return Change(node,
     421             :                 simplified()->LoadField(AccessBuilder::ForNameHashField()),
     422        1626 :                 string, effect, control);
     423             : }
     424             : 
     425         291 : Reduction JSIntrinsicLowering::ReduceTheHole(Node* node) {
     426         291 :   Node* value = jsgraph()->TheHoleConstant();
     427         291 :   ReplaceWithValue(node, value);
     428         291 :   return Replace(value);
     429             : }
     430             : 
     431        6613 : Reduction JSIntrinsicLowering::ReduceClassOf(Node* node) {
     432             :   RelaxEffectsAndControls(node);
     433        6613 :   node->TrimInputCount(2);
     434        6613 :   NodeProperties::ChangeOp(node, javascript()->ClassOf());
     435        6613 :   return Changed(node);
     436             : }
     437             : 
     438           0 : Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op, Node* a,
     439             :                                       Node* b) {
     440             :   RelaxControls(node);
     441           0 :   node->ReplaceInput(0, a);
     442           0 :   node->ReplaceInput(1, b);
     443           0 :   node->TrimInputCount(2);
     444           0 :   NodeProperties::ChangeOp(node, op);
     445           0 :   return Changed(node);
     446             : }
     447             : 
     448             : 
     449       19685 : Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op, Node* a,
     450             :                                       Node* b, Node* c) {
     451             :   RelaxControls(node);
     452       19685 :   node->ReplaceInput(0, a);
     453       19685 :   node->ReplaceInput(1, b);
     454       19685 :   node->ReplaceInput(2, c);
     455       19685 :   node->TrimInputCount(3);
     456       19685 :   NodeProperties::ChangeOp(node, op);
     457       19685 :   return Changed(node);
     458             : }
     459             : 
     460             : 
     461       19123 : Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op, Node* a,
     462             :                                       Node* b, Node* c, Node* d) {
     463             :   RelaxControls(node);
     464       19123 :   node->ReplaceInput(0, a);
     465       19123 :   node->ReplaceInput(1, b);
     466       19123 :   node->ReplaceInput(2, c);
     467       19123 :   node->ReplaceInput(3, d);
     468       19123 :   node->TrimInputCount(4);
     469       19123 :   NodeProperties::ChangeOp(node, op);
     470       19123 :   return Changed(node);
     471             : }
     472             : 
     473             : 
     474         346 : Reduction JSIntrinsicLowering::Change(Node* node, Callable const& callable,
     475         346 :                                       int stack_parameter_count) {
     476             :   CallDescriptor const* const desc = Linkage::GetStubCallDescriptor(
     477             :       isolate(), graph()->zone(), callable.descriptor(), stack_parameter_count,
     478        1038 :       CallDescriptor::kNeedsFrameState, node->op()->properties());
     479             :   node->InsertInput(graph()->zone(), 0,
     480         692 :                     jsgraph()->HeapConstant(callable.code()));
     481         346 :   NodeProperties::ChangeOp(node, common()->Call(desc));
     482         346 :   return Changed(node);
     483             : }
     484             : 
     485             : 
     486       20268 : Graph* JSIntrinsicLowering::graph() const { return jsgraph()->graph(); }
     487             : 
     488             : 
     489         722 : Isolate* JSIntrinsicLowering::isolate() const { return jsgraph()->isolate(); }
     490             : 
     491             : 
     492       11835 : CommonOperatorBuilder* JSIntrinsicLowering::common() const {
     493       11835 :   return jsgraph()->common();
     494             : }
     495             : 
     496           0 : JSOperatorBuilder* JSIntrinsicLowering::javascript() const {
     497       36632 :   return jsgraph_->javascript();
     498             : }
     499             : 
     500       50678 : SimplifiedOperatorBuilder* JSIntrinsicLowering::simplified() const {
     501       50678 :   return jsgraph()->simplified();
     502             : }
     503             : 
     504             : }  // namespace compiler
     505             : }  // namespace internal
     506             : }  // namespace v8

Generated by: LCOV version 1.10