Eliminated with_checks variable

runtime/vm/jit_optimizer.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.
 #ifndef DART_PRECOMPILED_RUNTIME
 #include "vm/jit_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 181 matching lines @@
   return false;
 }
 
 
 void JitOptimizer::SpecializePolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* call) {
   if (!FLAG_polymorphic_with_deopt) {
     // Specialization adds receiver checks which can lead to deoptimization.
     return;
   }
-  if (!call->with_checks()) {
-    return;  // Already specialized.
-  }
 
   const intptr_t receiver_cid =
       call->PushArgumentAt(0)->value()->Type()->ToCid();
   if (receiver_cid == kDynamicCid) {
     return;  // No information about receiver was infered.
   }
 
   const ICData& ic_data = *call->instance_call()->ic_data();
 
   const CallTargets* targets =
       FlowGraphCompiler::ResolveCallTargetsForReceiverCid(
           receiver_cid, String::Handle(zone(), ic_data.target_name()),
           Array::Handle(zone(), ic_data.arguments_descriptor()));
   if (targets == NULL) {
     // No specialization.
     return;
   }
 
-  const bool with_checks = false;
-  const bool complete = false;
-  PolymorphicInstanceCallInstr* specialized =
-      new (Z) PolymorphicInstanceCallInstr(call->instance_call(), *targets,
-                                           with_checks, complete);
+  ASSERT(targets->HasSingleTarget());
+  const Function& target = targets->FirstTarget();
+  StaticCallInstr* specialized = StaticCallInstr::FromCall(Z, call, target);
   call->ReplaceWith(specialized, current_iterator());
 }
 
 
 static bool ClassIdIsOneOf(intptr_t class_id,
                            const GrowableArray<intptr_t>& class_ids) {
   for (intptr_t i = 0; i < class_ids.length(); i++) {
     ASSERT(class_ids[i] != kIllegalCid);
     if (class_ids[i] == class_id) {
       return true;
@@ skipping 1286 matching lines @@
       const bool polymorphic_target =
           MethodRecognizer::PolymorphicTarget(target);
       has_one_target = !polymorphic_target;
     }
   }
 
   if (has_one_target) {
     const Function& target = Function::Handle(Z, unary_checks.GetTargetAt(0));
     const RawFunction::Kind function_kind = target.kind();
     if (!flow_graph()->InstanceCallNeedsClassCheck(instr, function_kind)) {
-      PolymorphicInstanceCallInstr* call =
-          new (Z) PolymorphicInstanceCallInstr(instr, *targets,
-                                               /* call_with_checks = */ false,
-                                               /* complete = */ false);
+      StaticCallInstr* call = StaticCallInstr::FromCall(Z, instr, target);
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
 
   // If there is only one target we can make this into a deopting class check,
   // followed by a call instruction that does not check the class of the
   // receiver.  This enables a lot of optimizations because after the class
   // check we can probably inline the call and not worry about side effects.
   // However, this can fall down if new receiver classes arrive at this call
   // site after we generated optimized code.  This causes a deopt, and after a
   // few deopts we won't optimize this function any more at all.  Therefore for
   // very polymorphic sites we don't make this optimization, keeping it as a
   // regular checked PolymorphicInstanceCall, which falls back to the slow but
   // non-deopting megamorphic call stub when it sees new receiver classes.
-  bool call_with_checks;
   if (has_one_target && FLAG_polymorphic_with_deopt &&
       (!instr->ic_data()->HasDeoptReason(ICData::kDeoptCheckClass) ||
        unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks)) {
     // Type propagation has not run yet, we cannot eliminate the check.
     // TODO(erikcorry): The receiver check should use the off-heap targets
     // array, not the IC array.
     AddReceiverCheck(instr);
     // Call can still deoptimize, do not detach environment from instr.
-    call_with_checks = false;
+    const Function& target = Function::Handle(Z, unary_checks.GetTargetAt(0));
+    StaticCallInstr* call = StaticCallInstr::FromCall(Z, instr, target);
+    instr->ReplaceWith(call, current_iterator());
   } else {
-    call_with_checks = true;
+    PolymorphicInstanceCallInstr* call =
+        new (Z) PolymorphicInstanceCallInstr(instr, *targets,
+                                             /* complete = */ false);
+    instr->ReplaceWith(call, current_iterator());
   }
-  PolymorphicInstanceCallInstr* call =
-      new (Z) PolymorphicInstanceCallInstr(instr, *targets, call_with_checks,
-                                           /* complete = */ false);
-  instr->ReplaceWith(call, current_iterator());
 }
 
 
 void JitOptimizer::VisitStaticCall(StaticCallInstr* call) {
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   switch (recognized_kind) {
     case MethodRecognizer::kObjectConstructor:
     case MethodRecognizer::kObjectArrayAllocate:
     case MethodRecognizer::kFloat32x4Zero:
@@ skipping 233 matching lines @@
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 }  // namespace dart
 #endif  // DART_PRECOMPILED_RUNTIME