Fixup redefinitions before doing code motion

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/precompiler.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
@@ skipping 2292 matching lines @@
       needs_store_barrier, index_scale, array_cid, kAlignedAccess,
       call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(cursor, *last, call->env(), FlowGraph::kEffect);
   return true;
 }
 
 
 static bool InlineDoubleOp(FlowGraph* flow_graph,
                            Token::Kind op_kind,
                            Instruction* call,
+                           Definition* receiver,
                            TargetEntryInstr** entry,
                            Definition** last) {
   if (!CanUnboxDouble()) {
     return false;
   }
-  Definition* left = call->ArgumentAt(0);
+  Definition* left = receiver;
   Definition* right = call->ArgumentAt(1);
 
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   // Arguments are checked. No need for class check.
   BinaryDoubleOpInstr* double_bin_op = new (Z)
       BinaryDoubleOpInstr(op_kind, new (Z) Value(left), new (Z) Value(right),
                           call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(*entry, double_bin_op, call->env(), FlowGraph::kValue);
   *last = double_bin_op;
 
   return true;
 }
 
 
 static bool InlineDoubleTestOp(FlowGraph* flow_graph,
                                Instruction* call,
+                               Definition* receiver,
                                MethodRecognizer::Kind kind,
                                TargetEntryInstr** entry,
                                Definition** last) {
   if (!CanUnboxDouble()) {
     return false;
   }
-  Definition* d = call->ArgumentAt(0);
 
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   // Arguments are checked. No need for class check.
 
   DoubleTestOpInstr* double_test_op = new (Z) DoubleTestOpInstr(
-      kind, new (Z) Value(d), call->deopt_id(), call->token_pos());
+      kind, new (Z) Value(receiver), call->deopt_id(), call->token_pos());
   flow_graph->AppendTo(*entry, double_test_op, call->env(), FlowGraph::kValue);
   *last = double_test_op;
 
   return true;
 }
 
 
 static bool InlineSmiBitAndFromSmi(FlowGraph* flow_graph,
                                    Instruction* call,
+                                   Definition* receiver,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
-  Definition* left = call->ArgumentAt(0);
+  Definition* left = receiver;
   Definition* right = call->ArgumentAt(1);
 
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   // Right arguments is known to be smi: other._bitAndFromSmi(this);
   BinarySmiOpInstr* smi_op =
       new (Z) BinarySmiOpInstr(Token::kBIT_AND, new (Z) Value(left),
                                new (Z) Value(right), call->deopt_id());
   flow_graph->AppendTo(*entry, smi_op, call->env(), FlowGraph::kValue);
   *last = smi_op;
 
   return true;
 }
 
 
 static bool InlineGrowableArraySetter(FlowGraph* flow_graph,
                                       intptr_t offset,
                                       StoreBarrierType store_barrier_type,
                                       Instruction* call,
+                                      Definition* receiver,
                                       TargetEntryInstr** entry,
                                       Definition** last) {
-  Definition* array = call->ArgumentAt(0);
+  Definition* array = receiver;
   Definition* value = call->ArgumentAt(1);
 
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
 
   // This is an internal method, no need to check argument types.
   StoreInstanceFieldInstr* store = new (Z) StoreInstanceFieldInstr(
       offset, new (Z) Value(array), new (Z) Value(value), store_barrier_type,
       call->token_pos());
@@ skipping 283 matching lines @@
       cid, kAlignedAccess, Thread::kNoDeoptId, call->token_pos());
 
   cursor = flow_graph->AppendTo(cursor, load_indexed, NULL, FlowGraph::kValue);
   ASSERT(cursor == load_indexed);
   return load_indexed;
 }
 
 
 static bool InlineStringBaseCharAt(FlowGraph* flow_graph,
                                    Instruction* call,
+                                   Definition* receiver,
                                    intptr_t cid,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   if ((cid != kOneByteStringCid) && (cid != kExternalOneByteStringCid)) {
     return false;
   }
-  Definition* str = call->ArgumentAt(0);
+  Definition* str = receiver;
   Definition* index = call->ArgumentAt(1);
 
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
 
   *last = PrepareInlineStringIndexOp(flow_graph, call, cid, str, index, *entry);
 
   OneByteStringFromCharCodeInstr* char_at =
       new (Z) OneByteStringFromCharCodeInstr(new (Z) Value(*last));
 
   flow_graph->AppendTo(*last, char_at, NULL, FlowGraph::kValue);
   *last = char_at;
 
   return true;
 }
 
 
 static bool InlineStringCodeUnitAt(FlowGraph* flow_graph,
                                    Instruction* call,
+                                   Definition* receiver,
                                    intptr_t cid,
                                    TargetEntryInstr** entry,
                                    Definition** last) {
   ASSERT((cid == kOneByteStringCid) || (cid == kTwoByteStringCid) ||
          (cid == kExternalOneByteStringCid) ||
          (cid == kExternalTwoByteStringCid));
-  Definition* str = call->ArgumentAt(0);
+  Definition* str = receiver;
   Definition* index = call->ArgumentAt(1);
 
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
 
   *last = PrepareInlineStringIndexOp(flow_graph, call, cid, str, index, *entry);
 
   return true;
 }
@@ skipping 53 matching lines @@
 }
 
 
 bool FlowGraphInliner::TryReplaceStaticCallWithInline(
     FlowGraph* flow_graph,
     ForwardInstructionIterator* iterator,
     StaticCallInstr* call) {
   TargetEntryInstr* entry;
   Definition* last;
   if (FlowGraphInliner::TryInlineRecognizedMethod(
-          flow_graph, kIllegalCid, call->function(), call, call->ArgumentAt(0),
+          flow_graph, kIllegalCid, call->function(), call, NULL,
           call->token_pos(), *call->ic_data(), &entry, &last)) {
     // Remove the original push arguments.
     for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
       PushArgumentInstr* push = call->PushArgumentAt(i);
       push->ReplaceUsesWith(push->value()->definition());
       push->RemoveFromGraph();
     }
     // Replace all uses of this definition with the result.
     if (call->HasUses()) {
       call->ReplaceUsesWith(last);
@@ skipping 13 matching lines @@
     call->set_previous(NULL);
     call->set_next(NULL);
     return true;
   }
   return false;
 }
 
 
 static bool InlineFloat32x4Method(FlowGraph* flow_graph,
                                   Instruction* call,
+                                  Definition* receiver,
                                   MethodRecognizer::Kind kind,
                                   TargetEntryInstr** entry,
                                   Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
+
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   switch (kind) {
     case MethodRecognizer::kFloat32x4ShuffleX:
     case MethodRecognizer::kFloat32x4ShuffleY:
     case MethodRecognizer::kFloat32x4ShuffleZ:
     case MethodRecognizer::kFloat32x4ShuffleW: {
-      *last =
-          new (Z) Simd32x4ShuffleInstr(kind, new (Z) Value(call->ArgumentAt(0)),
-                                       0,  // mask ignored.
-                                       call->deopt_id());
+      *last = new (Z) Simd32x4ShuffleInstr(kind, new (Z) Value(receiver),
+                                           0,  // mask ignored.
+                                           call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat32x4GetSignMask: {
-      *last = new (Z) Simd32x4GetSignMaskInstr(
-          kind, new (Z) Value(call->ArgumentAt(0)), call->deopt_id());
+      *last = new (Z) Simd32x4GetSignMaskInstr(kind, new (Z) Value(receiver),
+                                               call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat32x4Equal:
     case MethodRecognizer::kFloat32x4GreaterThan:
     case MethodRecognizer::kFloat32x4GreaterThanOrEqual:
     case MethodRecognizer::kFloat32x4LessThan:
     case MethodRecognizer::kFloat32x4LessThanOrEqual:
     case MethodRecognizer::kFloat32x4NotEqual: {
-      Definition* left = call->ArgumentAt(0);
+      Definition* left = receiver;
       Definition* right = call->ArgumentAt(1);
       *last = new (Z) Float32x4ComparisonInstr(
           kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat32x4Min:
     case MethodRecognizer::kFloat32x4Max: {
-      Definition* left = call->ArgumentAt(0);
+      Definition* left = receiver;
       Definition* right = call->ArgumentAt(1);
       *last = new (Z) Float32x4MinMaxInstr(
           kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat32x4Scale: {
-      Definition* left = call->ArgumentAt(0);
+      Definition* left = receiver;
       Definition* right = call->ArgumentAt(1);
       // Left and right values are swapped when handed to the instruction,
       // this is done so that the double value is loaded into the output
       // register and can be destroyed.
       *last = new (Z) Float32x4ScaleInstr(
           kind, new (Z) Value(right), new (Z) Value(left), call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat32x4Sqrt:
     case MethodRecognizer::kFloat32x4ReciprocalSqrt:
     case MethodRecognizer::kFloat32x4Reciprocal: {
-      Definition* left = call->ArgumentAt(0);
+      Definition* left = receiver;
       *last = new (Z)
           Float32x4SqrtInstr(kind, new (Z) Value(left), call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat32x4WithX:
     case MethodRecognizer::kFloat32x4WithY:
     case MethodRecognizer::kFloat32x4WithZ:
     case MethodRecognizer::kFloat32x4WithW: {
-      Definition* left = call->ArgumentAt(0);
+      Definition* left = receiver;
       Definition* right = call->ArgumentAt(1);
       *last = new (Z) Float32x4WithInstr(
           kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat32x4Absolute:
     case MethodRecognizer::kFloat32x4Negate: {
-      Definition* left = call->ArgumentAt(0);
+      Definition* left = receiver;
       *last = new (Z)
           Float32x4ZeroArgInstr(kind, new (Z) Value(left), call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat32x4Clamp: {
-      Definition* left = call->ArgumentAt(0);
+      Definition* left = receiver;
       Definition* lower = call->ArgumentAt(1);
       Definition* upper = call->ArgumentAt(2);
       *last =
           new (Z) Float32x4ClampInstr(new (Z) Value(left), new (Z) Value(lower),
                                       new (Z) Value(upper), call->deopt_id());
       break;
     }
     default:
       UNREACHABLE();
       return false;
@@ skipping 15 matching lines @@
   if ((mask < 0) || (mask > 255)) {
     return false;  // Not a valid mask.
   }
   *mask_ptr = mask;
   return true;
 }
 
 
 static bool InlineSimdShuffleMethod(FlowGraph* flow_graph,
                                     Instruction* call,
+                                    Definition* receiver,
                                     MethodRecognizer::Kind kind,
                                     TargetEntryInstr** entry,
                                     Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   Definition* mask_definition = call->ArgumentAt(1);
   intptr_t mask = 0;
   if (!CheckMask(mask_definition, &mask)) {
     return false;
   }
   *last = new (Z) Simd32x4ShuffleInstr(kind, new (Z) Value(call->ArgumentAt(0)),
                                        mask, call->deopt_id());
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
 
 static bool InlineSimdShuffleMixMethod(FlowGraph* flow_graph,
                                        Instruction* call,
+                                       Definition* receiver,
                                        MethodRecognizer::Kind kind,
                                        TargetEntryInstr** entry,
                                        Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   Definition* mask_definition = call->ArgumentAt(2);
   intptr_t mask = 0;
   if (!CheckMask(mask_definition, &mask)) {
     return false;
   }
-  *last = new (Z) Simd32x4ShuffleMixInstr(
-      kind, new (Z) Value(call->ArgumentAt(0)),
-      new (Z) Value(call->ArgumentAt(1)), mask, call->deopt_id());
+  *last = new (Z) Simd32x4ShuffleMixInstr(kind, new (Z) Value(receiver),
+                                          new (Z) Value(call->ArgumentAt(1)),
+                                          mask, call->deopt_id());
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
 
 static bool InlineInt32x4Method(FlowGraph* flow_graph,
                                 Instruction* call,
+                                Definition* receiver,
                                 MethodRecognizer::Kind kind,
                                 TargetEntryInstr** entry,
                                 Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   switch (kind) {
     case MethodRecognizer::kInt32x4GetFlagX:
     case MethodRecognizer::kInt32x4GetFlagY:
     case MethodRecognizer::kInt32x4GetFlagZ:
     case MethodRecognizer::kInt32x4GetFlagW: {
-      *last = new (Z) Int32x4GetFlagInstr(
-          kind, new (Z) Value(call->ArgumentAt(0)), call->deopt_id());
+      *last = new (Z)
+          Int32x4GetFlagInstr(kind, new (Z) Value(receiver), call->deopt_id());
       break;
     }
     case MethodRecognizer::kInt32x4GetSignMask: {
-      *last = new (Z) Simd32x4GetSignMaskInstr(
-          kind, new (Z) Value(call->ArgumentAt(0)), call->deopt_id());
+      *last = new (Z) Simd32x4GetSignMaskInstr(kind, new (Z) Value(receiver),
+                                               call->deopt_id());
       break;
     }
     case MethodRecognizer::kInt32x4Select: {
-      Definition* mask = call->ArgumentAt(0);
+      Definition* mask = receiver;
       Definition* trueValue = call->ArgumentAt(1);
       Definition* falseValue = call->ArgumentAt(2);
       *last = new (Z)
           Int32x4SelectInstr(new (Z) Value(mask), new (Z) Value(trueValue),
                              new (Z) Value(falseValue), call->deopt_id());
       break;
     }
     case MethodRecognizer::kInt32x4WithFlagX:
     case MethodRecognizer::kInt32x4WithFlagY:
     case MethodRecognizer::kInt32x4WithFlagZ:
     case MethodRecognizer::kInt32x4WithFlagW: {
-      *last = new (Z) Int32x4SetFlagInstr(
-          kind, new (Z) Value(call->ArgumentAt(0)),
-          new (Z) Value(call->ArgumentAt(1)), call->deopt_id());
+      *last = new (Z) Int32x4SetFlagInstr(kind, new (Z) Value(receiver),
+                                          new (Z) Value(call->ArgumentAt(1)),
+                                          call->deopt_id());
       break;
     }
     default:
       return false;
   }
   flow_graph->AppendTo(
       cursor, *last,
       call->deopt_id() != Thread::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
   return true;
 }
 
 
 static bool InlineFloat64x2Method(FlowGraph* flow_graph,
                                   Instruction* call,
+                                  Definition* receiver,
                                   MethodRecognizer::Kind kind,
                                   TargetEntryInstr** entry,
                                   Definition** last) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
   (*entry)->InheritDeoptTarget(Z, call);
   Instruction* cursor = *entry;
   switch (kind) {
     case MethodRecognizer::kFloat64x2GetX:
     case MethodRecognizer::kFloat64x2GetY: {
-      *last =
-          new (Z) Simd64x2ShuffleInstr(kind, new (Z) Value(call->ArgumentAt(0)),
-                                       0,  // mask is ignored.
-                                       call->deopt_id());
+      *last = new (Z) Simd64x2ShuffleInstr(kind, new (Z) Value(receiver),
+                                           0,  // mask is ignored.
+                                           call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat64x2Negate:
     case MethodRecognizer::kFloat64x2Abs:
     case MethodRecognizer::kFloat64x2Sqrt:
     case MethodRecognizer::kFloat64x2GetSignMask: {
-      *last = new (Z) Float64x2ZeroArgInstr(
-          kind, new (Z) Value(call->ArgumentAt(0)), call->deopt_id());
+      *last = new (Z) Float64x2ZeroArgInstr(kind, new (Z) Value(receiver),
+                                            call->deopt_id());
       break;
     }
     case MethodRecognizer::kFloat64x2Scale:
     case MethodRecognizer::kFloat64x2WithX:
     case MethodRecognizer::kFloat64x2WithY:
     case MethodRecognizer::kFloat64x2Min:
     case MethodRecognizer::kFloat64x2Max: {
-      Definition* left = call->ArgumentAt(0);
+      Definition* left = receiver;
       Definition* right = call->ArgumentAt(1);
       *last = new (Z) Float64x2OneArgInstr(
           kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
       break;
     }
     default:
       UNREACHABLE();
       return false;
   }
   flow_graph->AppendTo(
@@ skipping 324 matching lines @@
       if (!ShouldInlineSimd()) {
         return false;
       }
       return InlineByteArrayBaseStore(flow_graph, target, call, receiver,
                                       receiver_cid, kTypedDataInt32x4ArrayCid,
                                       entry, last);
     case MethodRecognizer::kOneByteStringCodeUnitAt:
     case MethodRecognizer::kTwoByteStringCodeUnitAt:
     case MethodRecognizer::kExternalOneByteStringCodeUnitAt:
     case MethodRecognizer::kExternalTwoByteStringCodeUnitAt:
-      return InlineStringCodeUnitAt(flow_graph, call, receiver_cid, entry,
-                                    last);
+      return InlineStringCodeUnitAt(flow_graph, call, receiver, receiver_cid,
+                                    entry, last);
     case MethodRecognizer::kStringBaseCharAt:
-      return InlineStringBaseCharAt(flow_graph, call, receiver_cid, entry,
-                                    last);
+      return InlineStringBaseCharAt(flow_graph, call, receiver, receiver_cid,
+                                    entry, last);
     case MethodRecognizer::kDoubleAdd:
-      return InlineDoubleOp(flow_graph, Token::kADD, call, entry, last);
+      return InlineDoubleOp(flow_graph, Token::kADD, call, receiver, entry,
+                            last);
     case MethodRecognizer::kDoubleSub:
-      return InlineDoubleOp(flow_graph, Token::kSUB, call, entry, last);
+      return InlineDoubleOp(flow_graph, Token::kSUB, call, receiver, entry,
+                            last);
     case MethodRecognizer::kDoubleMul:
-      return InlineDoubleOp(flow_graph, Token::kMUL, call, entry, last);
+      return InlineDoubleOp(flow_graph, Token::kMUL, call, receiver, entry,
+                            last);
     case MethodRecognizer::kDoubleDiv:
-      return InlineDoubleOp(flow_graph, Token::kDIV, call, entry, last);
+      return InlineDoubleOp(flow_graph, Token::kDIV, call, receiver, entry,
+                            last);
     case MethodRecognizer::kDouble_getIsNaN:
     case MethodRecognizer::kDouble_getIsInfinite:
-      return InlineDoubleTestOp(flow_graph, call, kind, entry, last);
+      return InlineDoubleTestOp(flow_graph, call, receiver, kind, entry, last);
     case MethodRecognizer::kGrowableArraySetData:
       ASSERT(receiver_cid == kGrowableObjectArrayCid);
       ASSERT(ic_data.NumberOfChecks() == 1);
-      return InlineGrowableArraySetter(flow_graph,
-                                       GrowableObjectArray::data_offset(),
-                                       kEmitStoreBarrier, call, entry, last);
+      return InlineGrowableArraySetter(
+          flow_graph, GrowableObjectArray::data_offset(), kEmitStoreBarrier,
+          call, receiver, entry, last);
     case MethodRecognizer::kGrowableArraySetLength:
       ASSERT(receiver_cid == kGrowableObjectArrayCid);
       ASSERT(ic_data.NumberOfChecks() == 1);
-      return InlineGrowableArraySetter(flow_graph,
-                                       GrowableObjectArray::length_offset(),
-                                       kNoStoreBarrier, call, entry, last);
+      return InlineGrowableArraySetter(
+          flow_graph, GrowableObjectArray::length_offset(), kNoStoreBarrier,
+          call, receiver, entry, last);
     case MethodRecognizer::kSmi_bitAndFromSmi:
-      return InlineSmiBitAndFromSmi(flow_graph, call, entry, last);
+      return InlineSmiBitAndFromSmi(flow_graph, call, receiver, entry, last);
 
     case MethodRecognizer::kFloat32x4ShuffleX:
     case MethodRecognizer::kFloat32x4ShuffleY:
     case MethodRecognizer::kFloat32x4ShuffleZ:
     case MethodRecognizer::kFloat32x4ShuffleW:
     case MethodRecognizer::kFloat32x4GetSignMask:
     case MethodRecognizer::kFloat32x4Equal:
     case MethodRecognizer::kFloat32x4GreaterThan:
     case MethodRecognizer::kFloat32x4GreaterThanOrEqual:
     case MethodRecognizer::kFloat32x4LessThan:
     case MethodRecognizer::kFloat32x4LessThanOrEqual:
     case MethodRecognizer::kFloat32x4NotEqual:
     case MethodRecognizer::kFloat32x4Min:
     case MethodRecognizer::kFloat32x4Max:
     case MethodRecognizer::kFloat32x4Scale:
     case MethodRecognizer::kFloat32x4Sqrt:
     case MethodRecognizer::kFloat32x4ReciprocalSqrt:
     case MethodRecognizer::kFloat32x4Reciprocal:
     case MethodRecognizer::kFloat32x4WithX:
     case MethodRecognizer::kFloat32x4WithY:
     case MethodRecognizer::kFloat32x4WithZ:
     case MethodRecognizer::kFloat32x4WithW:
     case MethodRecognizer::kFloat32x4Absolute:
     case MethodRecognizer::kFloat32x4Negate:
     case MethodRecognizer::kFloat32x4Clamp:
-      return InlineFloat32x4Method(flow_graph, call, kind, entry, last);
+      return InlineFloat32x4Method(flow_graph, call, receiver, kind, entry,
+                                   last);
 
     case MethodRecognizer::kFloat32x4ShuffleMix:
     case MethodRecognizer::kInt32x4ShuffleMix:
-      return InlineSimdShuffleMixMethod(flow_graph, call, kind, entry, last);
+      return InlineSimdShuffleMixMethod(flow_graph, call, receiver, kind, entry,
+                                        last);
 
     case MethodRecognizer::kFloat32x4Shuffle:
     case MethodRecognizer::kInt32x4Shuffle:
-      return InlineSimdShuffleMethod(flow_graph, call, kind, entry, last);
+      return InlineSimdShuffleMethod(flow_graph, call, receiver, kind, entry,
+                                     last);
 
     case MethodRecognizer::kInt32x4GetFlagX:
     case MethodRecognizer::kInt32x4GetFlagY:
     case MethodRecognizer::kInt32x4GetFlagZ:
     case MethodRecognizer::kInt32x4GetFlagW:
     case MethodRecognizer::kInt32x4GetSignMask:
     case MethodRecognizer::kInt32x4Select:
     case MethodRecognizer::kInt32x4WithFlagX:
     case MethodRecognizer::kInt32x4WithFlagY:
     case MethodRecognizer::kInt32x4WithFlagZ:
     case MethodRecognizer::kInt32x4WithFlagW:
-      return InlineInt32x4Method(flow_graph, call, kind, entry, last);
+      return InlineInt32x4Method(flow_graph, call, receiver, kind, entry, last);
 
     case MethodRecognizer::kFloat64x2GetX:
     case MethodRecognizer::kFloat64x2GetY:
     case MethodRecognizer::kFloat64x2Negate:
     case MethodRecognizer::kFloat64x2Abs:
     case MethodRecognizer::kFloat64x2Sqrt:
     case MethodRecognizer::kFloat64x2GetSignMask:
     case MethodRecognizer::kFloat64x2Scale:
     case MethodRecognizer::kFloat64x2WithX:
     case MethodRecognizer::kFloat64x2WithY:
     case MethodRecognizer::kFloat64x2Min:
     case MethodRecognizer::kFloat64x2Max:
-      return InlineFloat64x2Method(flow_graph, call, kind, entry, last);
+      return InlineFloat64x2Method(flow_graph, call, receiver, kind, entry,
+                                   last);
 
     case MethodRecognizer::kFloat32x4Zero:
     case MethodRecognizer::kFloat32x4Splat:
     case MethodRecognizer::kFloat32x4Constructor:
     case MethodRecognizer::kFloat32x4FromFloat64x2:
     case MethodRecognizer::kFloat64x2Constructor:
     case MethodRecognizer::kFloat64x2Zero:
     case MethodRecognizer::kFloat64x2Splat:
     case MethodRecognizer::kFloat64x2FromFloat32x4:
     case MethodRecognizer::kInt32x4BoolConstructor:
@@ skipping 96 matching lines @@
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)