Use off-heap data for class check instructions

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 456 matching lines @@
                      PolymorphicInstanceCallInstr* call,
                      const Function& caller_function,
                      intptr_t caller_inlining_id);
 
   void Inline();
 
  private:
   bool CheckInlinedDuplicate(const Function& target);
   bool CheckNonInlinedDuplicate(const Function& target);
 
-  bool TryInliningPoly(const CidRangeTarget& target);
+  bool TryInliningPoly(const TargetInfo& target);
   bool TryInlineRecognizedMethod(intptr_t receiver_cid, const Function& target);
 
   TargetEntryInstr* BuildDecisionGraph();
 
   Isolate* isolate() const;
   Zone* zone() const;
   intptr_t AllocateBlockId() const;
   inline bool trace_inlining() const;
 
   CallSiteInliner* const owner_;
@@ skipping 951 matching lines @@
 
 
 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner,
                                        PolymorphicInstanceCallInstr* call,
                                        const Function& caller_function,
                                        intptr_t caller_inlining_id)
     : owner_(owner),
       call_(call),
       num_variants_(call->NumberOfChecks()),
       variants_(call->targets_),
-      inlined_variants_(),
-      non_inlined_variants_(new (zone()) CallTargets()),
+      inlined_variants_(zone()),
+      non_inlined_variants_(new (zone()) CallTargets(zone())),
       inlined_entries_(num_variants_),
       exit_collector_(new (Z) InlineExitCollector(owner->caller_graph(), call)),
       caller_function_(caller_function),
       caller_inlining_id_(caller_inlining_id) {}
 
 
 Isolate* PolymorphicInliner::isolate() const {
   return owner_->caller_graph()->isolate();
 }
 
@@ skipping 12 matching lines @@
 // inlined target.  This sharing is represented by using three different
 // types of entries in the inlined_entries_ array:
 //
 //   * GraphEntry: the inlined body is not shared.
 //
 //   * TargetEntry: the inlined body is shared and this is the first variant.
 //
 //   * JoinEntry: the inlined body is shared and this is a subsequent variant.
 bool PolymorphicInliner::CheckInlinedDuplicate(const Function& target) {
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
-    if ((target.raw() == inlined_variants_[i].target->raw()) &&
+    if ((target.raw() == inlined_variants_.TargetAt(i)->target->raw()) &&
         !MethodRecognizer::PolymorphicTarget(target)) {
       // The call target is shared with a previous inlined variant.  Share
       // the graph.  This requires a join block at the entry, and edge-split
       // form requires a target for each branch.
       //
       // Represent the sharing by recording a fresh target for the first
       // variant and the shared join for all later variants.
       if (inlined_entries_[i]->IsGraphEntry()) {
         // Convert the old target entry to a new join entry.
         TargetEntryInstr* old_target =
@@ skipping 31 matching lines @@
       return true;
     }
   }
 
   return false;
 }
 
 
 bool PolymorphicInliner::CheckNonInlinedDuplicate(const Function& target) {
   for (intptr_t i = 0; i < non_inlined_variants_->length(); ++i) {
-    if (target.raw() == non_inlined_variants_->At(i).target->raw()) {
+    if (target.raw() == non_inlined_variants_->TargetAt(i)->target->raw()) {
       return true;
     }
   }
 
   return false;
 }
 
 
-bool PolymorphicInliner::TryInliningPoly(const CidRangeTarget& range) {
+bool PolymorphicInliner::TryInliningPoly(const TargetInfo& target_info) {
   if ((!FLAG_precompiled_mode ||
        owner_->inliner_->use_speculative_inlining()) &&
-      range.cid_start == range.cid_end &&
-      TryInlineRecognizedMethod(range.cid_start, *range.target)) {
+      target_info.cid_start == target_info.cid_end &&
+      TryInlineRecognizedMethod(target_info.cid_start, *target_info.target)) {
     owner_->inlined_ = true;
     return true;
   }
 
   GrowableArray<Value*> arguments(call_->ArgumentCount());
   for (int i = 0; i < call_->ArgumentCount(); ++i) {
     arguments.Add(call_->PushArgumentAt(i)->value());
   }
   InlinedCallData call_data(call_, &arguments, caller_function_,
                             caller_inlining_id_);
-  Function& target = Function::ZoneHandle(zone(), range.target->raw());
+  Function& target = Function::ZoneHandle(zone(), target_info.target->raw());
   if (!owner_->TryInlining(target, call_->instance_call()->argument_names(),
                            &call_data)) {
     return false;
   }
 
   FlowGraph* callee_graph = call_data.callee_graph;
   call_data.exit_collector->PrepareGraphs(callee_graph);
   inlined_entries_.Add(callee_graph->graph_entry());
   exit_collector_->Union(call_data.exit_collector);
 
   // Replace parameter stubs and constants.  Replace the receiver argument
   // with a redefinition to prevent code from the inlined body from being
   // hoisted above the inlined entry.
   ASSERT(arguments.length() > 0);
   Value* actual = arguments[0];
   RedefinitionInstr* redefinition = new (Z) RedefinitionInstr(actual->Copy(Z));
   redefinition->set_ssa_temp_index(
       owner_->caller_graph()->alloc_ssa_temp_index());
-  if (range.cid_start == range.cid_end) {
-    redefinition->UpdateType(CompileType::FromCid(range.cid_start));
+  if (target_info.cid_start == target_info.cid_end) {
+    redefinition->UpdateType(CompileType::FromCid(target_info.cid_start));
   }
   redefinition->InsertAfter(callee_graph->graph_entry()->normal_entry());
   Definition* stub = (*call_data.parameter_stubs)[0];
   stub->ReplaceUsesWith(redefinition);
 
   for (intptr_t i = 1; i < arguments.length(); ++i) {
     actual = arguments[i];
     if (actual != NULL) {
       stub = (*call_data.parameter_stubs)[i];
       stub->ReplaceUsesWith(actual->definition());
@@ skipping 99 matching lines @@
 
   Definition* receiver = call_->ArgumentAt(0);
   // There are at least two variants including non-inlined ones, so we have
   // at least one branch on the class id.
   LoadClassIdInstr* load_cid =
       new (Z) LoadClassIdInstr(new (Z) Value(receiver));
   load_cid->set_ssa_temp_index(owner_->caller_graph()->alloc_ssa_temp_index());
   cursor = AppendInstruction(cursor, load_cid);
   bool follow_with_deopt = false;
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
-    const CidRangeTarget& variant = inlined_variants_[i];
+    const CidRange& variant = inlined_variants_[i];
     bool test_is_range = (variant.cid_start != variant.cid_end);
     bool is_last_test = (i == inlined_variants_.length() - 1);
     // 1. Guard the body with a class id check.  We don't need any check if
     // it's the last test and global analysis has told us that the call is
     // complete.  TODO(erikcorry): Enhance CheckClassIdInstr so it can take an
     // arbitrary CidRangeTarget.  Currently we don't go into this branch if the
     // last test is a range test - instead we set the follow_with_deopt flag.
     if (is_last_test && (!test_is_range || call_->complete()) &&
         non_inlined_variants_->is_empty()) {
       // If it is the last variant use a check class id instruction which can
@@ skipping 209 matching lines @@
     for (intptr_t i = 0; i < call_->ArgumentCount(); ++i) {
       PushArgumentInstr* push = call_->PushArgumentAt(i);
       push->ReplaceUsesWith(push->value()->definition());
       push->RemoveFromGraph();
     }
   }
   return entry;
 }
 
 
-static void TracePolyInlining(const CidRangeTarget& crt,
+static void TracePolyInlining(const CallTargets& targets,
+                              intptr_t idx,
                               intptr_t total,
                               const char* message) {
-  String& name = String::Handle(crt.target->QualifiedUserVisibleName());
-  int percent = total == 0 ? 0 : (100 * crt.count) / total;
+  String& name =
+      String::Handle(targets.TargetAt(idx)->target->QualifiedUserVisibleName());
+  int percent = total == 0 ? 0 : (100 * targets.TargetAt(idx)->count) / total;
   THR_Print("%s cid %" Pd "-%" Pd ": %" Pd "/%" Pd " %d%% %s\n",
-            name.ToCString(), crt.cid_start, crt.cid_end, crt.count, total,
-            percent, message);
+            name.ToCString(), targets[idx].cid_start, targets[idx].cid_end,
+            targets.TargetAt(idx)->count, total, percent, message);
 }
 
 
 bool PolymorphicInliner::trace_inlining() const {
   return owner_->trace_inlining();
 }
 
 
 void PolymorphicInliner::Inline() {
   ASSERT(&variants_ == &call_->targets_);
 
   intptr_t total = call_->total_call_count();
   for (intptr_t var_idx = 0; var_idx < variants_.length(); ++var_idx) {
+    TargetInfo* info = variants_.TargetAt(var_idx);
     if (variants_.length() > FLAG_max_polymorphic_checks) {
-      non_inlined_variants_->Add(variants_[var_idx]);
+      non_inlined_variants_->Add(info);
       continue;
     }
 
+    const Function& target = *variants_.TargetAt(var_idx)->target;
+    const intptr_t count = variants_.TargetAt(var_idx)->count;
+
     // We we almost inlined all the cases then try a little harder to inline
     // the last two, because it's a big win if we inline all of them (compiler
     // can see all side effects).
     const bool try_harder = (var_idx >= variants_.length() - 2) &&
                             non_inlined_variants_->length() == 0;
-    const Function& target = *variants_[var_idx].target;
-    const intptr_t count = variants_[var_idx].count;
 
     intptr_t size = target.optimized_instruction_count();
     bool small = (size != 0 && size < FLAG_inlining_size_threshold);
 
     // If it's less than 3% of the dispatches, we won't even consider
     // checking for the class ID and branching to another already-inlined
     // version.
     if (!try_harder && count < (total >> 5)) {
       TRACE_INLINING(
-          TracePolyInlining(variants_[var_idx], total, "way too infrequent"));
-      non_inlined_variants_->Add(variants_[var_idx]);
+          TracePolyInlining(variants_, var_idx, total, "way too infrequent"));
+      non_inlined_variants_->Add(info);
       continue;
     }
 
     // First check if this is the same target as an earlier inlined variant.
     if (CheckInlinedDuplicate(target)) {
-      TRACE_INLINING(TracePolyInlining(variants_[var_idx], total,
+      TRACE_INLINING(TracePolyInlining(variants_, var_idx, total,
                                        "duplicate already inlined"));
-      inlined_variants_.Add(variants_[var_idx]);
+      inlined_variants_.Add(info);
       continue;
     }
 
     // If it's less than 12% of the dispatches and it's not already inlined, we
     // don't consider inlining.  For very small functions we are willing to
     // consider inlining for 6% of the cases.
     if (!try_harder && count < (total >> (small ? 4 : 3))) {
       TRACE_INLINING(
-          TracePolyInlining(variants_[var_idx], total, "too infrequent"));
-      non_inlined_variants_->Add(variants_[var_idx]);
+          TracePolyInlining(variants_, var_idx, total, "too infrequent"));
+      non_inlined_variants_->Add(&variants_[var_idx]);
       continue;
     }
 
     // Also check if this is the same target as an earlier non-inlined
     // variant.  If so and since inlining decisions are costly, do not try
     // to inline this variant.
     if (CheckNonInlinedDuplicate(target)) {
       TRACE_INLINING(
-          TracePolyInlining(variants_[var_idx], total, "already not inlined"));
-      non_inlined_variants_->Add(variants_[var_idx]);
+          TracePolyInlining(variants_, var_idx, total, "already not inlined"));
+      non_inlined_variants_->Add(&variants_[var_idx]);
       continue;
     }
 
     // Make an inlining decision.
-    if (TryInliningPoly(variants_[var_idx])) {
-      TRACE_INLINING(TracePolyInlining(variants_[var_idx], total, "inlined"));
-      inlined_variants_.Add(variants_[var_idx]);
+    if (TryInliningPoly(*info)) {
+      TRACE_INLINING(TracePolyInlining(variants_, var_idx, total, "inlined"));
+      inlined_variants_.Add(&variants_[var_idx]);
     } else {
       TRACE_INLINING(
-          TracePolyInlining(variants_[var_idx], total, "not inlined"));
-      non_inlined_variants_->Add(variants_[var_idx]);
+          TracePolyInlining(variants_, var_idx, total, "not inlined"));
+      non_inlined_variants_->Add(&variants_[var_idx]);
     }
   }
 
   // If there are no inlined variants, leave the call in place.
   if (inlined_variants_.is_empty()) return;
 
   // Now build a decision tree (a DAG because of shared inline variants) and
   // inline it at the call site.
   TargetEntryInstr* entry = BuildDecisionGraph();
   exit_collector_->ReplaceCall(entry);
@@ skipping 240 matching lines @@
   } else if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements = new (Z) LoadUntaggedInstr(
         new (Z) Value(*array), ExternalTypedData::data_offset());
     *cursor = flow_graph->AppendTo(*cursor, elements, NULL, FlowGraph::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
 
-static Instruction* GetCheckClass(FlowGraph* flow_graph,
-                                  Definition* to_check,
-                                  const ICData& unary_checks,
-                                  intptr_t deopt_id,
-                                  TokenPosition token_pos) {
-  if ((unary_checks.NumberOfUsedChecks() == 1) &&
-      unary_checks.HasReceiverClassId(kSmiCid)) {
-    return new (Z) CheckSmiInstr(new (Z) Value(to_check), deopt_id, token_pos);
-  }
-  return new (Z) CheckClassInstr(new (Z) Value(to_check), deopt_id,
-                                 unary_checks, token_pos);
-}
-
-
 static bool InlineGetIndexed(FlowGraph* flow_graph,
                              MethodRecognizer::Kind kind,
                              Instruction* call,
                              Definition* receiver,
                              TargetEntryInstr** entry,
                              Definition** last) {
   intptr_t array_cid = MethodRecognizer::MethodKindToReceiverCid(kind);
 
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
@@ skipping 30 matching lines @@
   return true;
 }
 
 
 static bool InlineSetIndexed(FlowGraph* flow_graph,
                              MethodRecognizer::Kind kind,
                              const Function& target,
                              Instruction* call,
                              Definition* receiver,
                              TokenPosition token_pos,
-                             const ICData& value_check,
+                             const Cids* value_check,
                              TargetEntryInstr** entry,
                              Definition** last) {
   intptr_t array_cid = MethodRecognizer::MethodKindToReceiverCid(kind);
 
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
 
   *entry = new (Z) TargetEntryInstr(flow_graph->allocate_block_id(),
                                     call->GetBlock()->try_index());
@@ skipping 74 matching lines @@
   StoreBarrierType needs_store_barrier =
       (RawObject::IsTypedDataClassId(array_cid) ||
        RawObject::IsTypedDataViewClassId(array_cid) ||
        RawObject::IsExternalTypedDataClassId(array_cid))
           ? kNoStoreBarrier
           : kEmitStoreBarrier;
 
   // No need to class check stores to Int32 and Uint32 arrays because
   // we insert unboxing instructions below which include a class check.
   if ((array_cid != kTypedDataUint32ArrayCid) &&
-      (array_cid != kTypedDataInt32ArrayCid) && !value_check.IsNull()) {
+      (array_cid != kTypedDataInt32ArrayCid) && value_check != NULL) {
     // No store barrier needed because checked value is a smi, an unboxed mint,
     // an unboxed double, an unboxed Float32x4, or unboxed Int32x4.
     needs_store_barrier = kNoStoreBarrier;
-    Instruction* check = GetCheckClass(flow_graph, stored_value, value_check,
-                                       call->deopt_id(), call->token_pos());
+    Instruction* check = flow_graph->CreateCheckClass(
+        stored_value, *value_check, call->deopt_id(), call->token_pos());
     cursor =
         flow_graph->AppendTo(cursor, check, call->env(), FlowGraph::kEffect);
   }
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     stored_value = new (Z)
         DoubleToFloatInstr(new (Z) Value(stored_value), call->deopt_id());
     cursor =
         flow_graph->AppendTo(cursor, stored_value, NULL, FlowGraph::kValue);
   } else if (array_cid == kTypedDataInt32ArrayCid) {
@@ skipping 242 matching lines @@
   // Extract the instance call so we can use the function_name in the stored
   // value check ICData.
   InstanceCallInstr* i_call = NULL;
   if (call->IsPolymorphicInstanceCall()) {
     i_call = call->AsPolymorphicInstanceCall()->instance_call();
   } else {
     ASSERT(call->IsInstanceCall());
     i_call = call->AsInstanceCall();
   }
   ASSERT(i_call != NULL);
-  ICData& value_check = ICData::ZoneHandle(Z);
+  Cids* value_check = NULL;
   switch (view_cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       // Check that value is always smi.
-      value_check = ICData::New(flow_graph->function(), i_call->function_name(),
-                                Object::empty_array(),  // Dummy args. descr.
-                                Thread::kNoDeoptId, 1, false);
-      value_check.AddReceiverCheck(kSmiCid, target);
+      value_check = Cids::CreateMonomorphic(Z, kSmiCid);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid:
       // On 64-bit platforms assume that stored value is always a smi.
       if (kSmiBits >= 32) {
-        value_check =
-            ICData::New(flow_graph->function(), i_call->function_name(),
-                        Object::empty_array(),  // Dummy args. descr.
-                        Thread::kNoDeoptId, 1, false);
-        value_check.AddReceiverCheck(kSmiCid, target);
+        value_check = Cids::CreateMonomorphic(Z, kSmiCid);
       }
       break;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat64ArrayCid: {
       // Check that value is always double.
-      value_check = ICData::New(flow_graph->function(), i_call->function_name(),
-                                Object::empty_array(),  // Dummy args. descr.
-                                Thread::kNoDeoptId, 1, false);
-      value_check.AddReceiverCheck(kDoubleCid, target);
+      value_check = Cids::CreateMonomorphic(Z, kDoubleCid);
       break;
     }
     case kTypedDataInt32x4ArrayCid: {
       // Check that value is always Int32x4.
-      value_check = ICData::New(flow_graph->function(), i_call->function_name(),
-                                Object::empty_array(),  // Dummy args. descr.
-                                Thread::kNoDeoptId, 1, false);
-      value_check.AddReceiverCheck(kInt32x4Cid, target);
+      value_check = Cids::CreateMonomorphic(Z, kInt32x4Cid);
       break;
     }
     case kTypedDataFloat32x4ArrayCid: {
       // Check that value is always Float32x4.
-      value_check = ICData::New(flow_graph->function(), i_call->function_name(),
-                                Object::empty_array(),  // Dummy args. descr.
-                                Thread::kNoDeoptId, 1, false);
-      value_check.AddReceiverCheck(kFloat32x4Cid, target);
+      value_check = Cids::CreateMonomorphic(Z, kFloat32x4Cid);
       break;
     }
     default:
       // Array cids are already checked in the caller.
       UNREACHABLE();
   }
 
   Definition* stored_value = call->ArgumentAt(2);
-  if (!value_check.IsNull()) {
-    Instruction* check = GetCheckClass(flow_graph, stored_value, value_check,
-                                       call->deopt_id(), call->token_pos());
+  if (value_check != NULL) {
+    Instruction* check = flow_graph->CreateCheckClass(
+        stored_value, *value_check, call->deopt_id(), call->token_pos());
     cursor =
         flow_graph->AppendTo(cursor, check, call->env(), FlowGraph::kEffect);
   }
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
     stored_value = new (Z)
         DoubleToFloatInstr(new (Z) Value(stored_value), call->deopt_id());
     cursor =
         flow_graph->AppendTo(cursor, stored_value, NULL, FlowGraph::kValue);
   } else if (view_cid == kTypedDataInt32ArrayCid) {
@@ skipping 139 matching lines @@
   const intptr_t receiver_cid = class_ids[0];
 
   TargetEntryInstr* entry;
   Definition* last;
   if (FlowGraphInliner::TryInlineRecognizedMethod(
           flow_graph, receiver_cid, target, call, call->ArgumentAt(0),
           call->token_pos(), *call->ic_data(), &entry, &last)) {
     // Insert receiver class check if needed.
     if (MethodRecognizer::PolymorphicTarget(target) ||
         flow_graph->InstanceCallNeedsClassCheck(call, target.kind())) {
-      Instruction* check = GetCheckClass(
-          flow_graph, call->ArgumentAt(0),
-          ICData::ZoneHandle(Z, call->ic_data()->AsUnaryClassChecks()),
+      Instruction* check = flow_graph->CreateCheckClass(
+          call->ArgumentAt(0), *Cids::Create(Z, *call->ic_data(), 0),
           call->deopt_id(), call->token_pos());
       flow_graph->InsertBefore(call, check, call->env(), FlowGraph::kEffect);
     }
 
     // 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();
     }
@@ skipping 466 matching lines @@
 
 bool FlowGraphInliner::TryInlineRecognizedMethod(FlowGraph* flow_graph,
                                                  intptr_t receiver_cid,
                                                  const Function& target,
                                                  Definition* call,
                                                  Definition* receiver,
                                                  TokenPosition token_pos,
                                                  const ICData& ic_data,
                                                  TargetEntryInstr** entry,
                                                  Definition** last) {
-  ICData& value_check = ICData::ZoneHandle(Z);
   MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(target);
   switch (kind) {
     // Recognized [] operators.
     case MethodRecognizer::kImmutableArrayGetIndexed:
     case MethodRecognizer::kObjectArrayGetIndexed:
     case MethodRecognizer::kGrowableArrayGetIndexed:
     case MethodRecognizer::kInt8ArrayGetIndexed:
     case MethodRecognizer::kUint8ArrayGetIndexed:
     case MethodRecognizer::kUint8ClampedArrayGetIndexed:
     case MethodRecognizer::kExternalUint8ArrayGetIndexed:
@@ skipping 20 matching lines @@
 
     case MethodRecognizer::kInt64ArrayGetIndexed:
       if (!ShouldInlineInt64ArrayOps()) {
         return false;
       }
       return InlineGetIndexed(flow_graph, kind, call, receiver, entry, last);
     // Recognized []= operators.
     case MethodRecognizer::kObjectArraySetIndexed:
     case MethodRecognizer::kGrowableArraySetIndexed:
       return InlineSetIndexed(flow_graph, kind, target, call, receiver,
-                              token_pos, value_check, entry, last);
+                              token_pos, /* value_check = */ NULL, entry, last);
     case MethodRecognizer::kInt8ArraySetIndexed:
     case MethodRecognizer::kUint8ArraySetIndexed:
     case MethodRecognizer::kUint8ClampedArraySetIndexed:
     case MethodRecognizer::kExternalUint8ArraySetIndexed:
     case MethodRecognizer::kExternalUint8ClampedArraySetIndexed:
     case MethodRecognizer::kInt16ArraySetIndexed:
-    case MethodRecognizer::kUint16ArraySetIndexed:
+    case MethodRecognizer::kUint16ArraySetIndexed: {
       // Optimistically assume Smi.
       if (ic_data.HasDeoptReason(ICData::kDeoptCheckSmi)) {
         // Optimistic assumption failed at least once.
         return false;
       }
-      value_check = ic_data.AsUnaryClassChecksForCid(kSmiCid, target);
+      Cids* value_check = Cids::CreateMonomorphic(Z, kSmiCid);
       return InlineSetIndexed(flow_graph, kind, target, call, receiver,
                               token_pos, value_check, entry, last);
+    }
     case MethodRecognizer::kInt32ArraySetIndexed:
     case MethodRecognizer::kUint32ArraySetIndexed: {
       // Value check not needed for Int32 and Uint32 arrays because they
       // implicitly contain unboxing instructions which check for right type.
-      ICData& value_check = ICData::Handle();
       return InlineSetIndexed(flow_graph, kind, target, call, receiver,
-                              token_pos, value_check, entry, last);
+                              token_pos, /* value_check = */ NULL, entry, last);
     }
     case MethodRecognizer::kInt64ArraySetIndexed:
       if (!ShouldInlineInt64ArrayOps()) {
         return false;
       }
       return InlineSetIndexed(flow_graph, kind, target, call, receiver,
-                              token_pos, value_check, entry, last);
+                              token_pos, /* value_check = */ NULL, entry, last);
     case MethodRecognizer::kFloat32ArraySetIndexed:
-    case MethodRecognizer::kFloat64ArraySetIndexed:
+    case MethodRecognizer::kFloat64ArraySetIndexed: {
       if (!CanUnboxDouble()) {
         return false;
       }
-      value_check = ic_data.AsUnaryClassChecksForCid(kDoubleCid, target);
+      Cids* value_check = Cids::CreateMonomorphic(Z, kDoubleCid);
       return InlineSetIndexed(flow_graph, kind, target, call, receiver,
                               token_pos, value_check, entry, last);
-    case MethodRecognizer::kFloat32x4ArraySetIndexed:
+    }
+    case MethodRecognizer::kFloat32x4ArraySetIndexed: {
       if (!ShouldInlineSimd()) {
         return false;
       }
-      value_check = ic_data.AsUnaryClassChecksForCid(kFloat32x4Cid, target);
-
+      Cids* value_check = Cids::CreateMonomorphic(Z, kFloat32x4Cid);
       return InlineSetIndexed(flow_graph, kind, target, call, receiver,
                               token_pos, value_check, entry, last);
-    case MethodRecognizer::kFloat64x2ArraySetIndexed:
+    }
+    case MethodRecognizer::kFloat64x2ArraySetIndexed: {
       if (!ShouldInlineSimd()) {
         return false;
       }
-      value_check = ic_data.AsUnaryClassChecksForCid(kFloat64x2Cid, target);
+      Cids* value_check = Cids::CreateMonomorphic(Z, kFloat64x2Cid);
       return InlineSetIndexed(flow_graph, kind, target, call, receiver,
                               token_pos, value_check, entry, last);
+    }
     case MethodRecognizer::kByteArrayBaseGetInt8:
       return InlineByteArrayBaseLoad(flow_graph, call, receiver, receiver_cid,
                                      kTypedDataInt8ArrayCid, entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint8:
       return InlineByteArrayBaseLoad(flow_graph, call, receiver, receiver_cid,
                                      kTypedDataUint8ArrayCid, entry, last);
     case MethodRecognizer::kByteArrayBaseGetInt16:
       return InlineByteArrayBaseLoad(flow_graph, call, receiver, receiver_cid,
                                      kTypedDataInt16ArrayCid, entry, last);
     case MethodRecognizer::kByteArrayBaseGetUint16:
@@ skipping 297 matching lines @@
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)