VM: Re-format to use at most one newline between functions

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 18 matching lines @@
 namespace dart {
 
 // Quick access to the current isolate and zone.
 #define I (isolate())
 #define Z (zone())
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
-
 static bool CanUnboxDouble() {
   return FlowGraphCompiler::SupportsUnboxedDoubles();
 }
 
-
 static bool CanConvertUnboxedMintToDouble() {
   return FlowGraphCompiler::CanConvertUnboxedMintToDouble();
 }
 
-
 // Optimize instance calls using ICData.
 void JitOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
-
 // Optimize instance calls using cid.  This is called after optimizer
 // converted instance calls to instructions. Any remaining
 // instance calls are either megamorphic calls, cannot be optimized or
 // have no runtime type feedback collected.
 // Attempts to convert an instance call (IC call) using propagated class-ids,
 // e.g., receiver class id, guarded-cid, or by guessing cid-s.
 void JitOptimizer::ApplyClassIds() {
   ASSERT(current_iterator_ == NULL);
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
@@ skipping 10 matching lines @@
           }
         }
       } else if (instr->IsPolymorphicInstanceCall()) {
         SpecializePolymorphicInstanceCall(instr->AsPolymorphicInstanceCall());
       }
     }
     current_iterator_ = NULL;
   }
 }
 
-
 // TODO(srdjan): Test/support other number types as well.
 static bool IsNumberCid(intptr_t cid) {
   return (cid == kSmiCid) || (cid == kDoubleCid);
 }
 
-
 bool JitOptimizer::TryCreateICData(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   if (call->ic_data()->NumberOfUsedChecks() > 0) {
     // This occurs when an instance call has too many checks, will be converted
     // to megamorphic call.
     return false;
   }
 
   const intptr_t receiver_index = call->FirstParamIndex();
   GrowableArray<intptr_t> class_ids(call->ic_data()->NumArgsTested());
@@ skipping 86 matching lines @@
         ic_data.AddReceiverCheck(owner_class.id(), function);
         call->set_ic_data(&ic_data);
         return true;
       }
     }
   }
 
   return false;
 }
 
-
 void JitOptimizer::SpecializePolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* call) {
   if (!FLAG_polymorphic_with_deopt) {
     // Specialization adds receiver checks which can lead to deoptimization.
     return;
   }
 
   const intptr_t receiver_cid =
       call->PushArgumentAt(0)->value()->Type()->ToCid();
   if (receiver_cid == kDynamicCid) {
@@ skipping 10 matching lines @@
     // No specialization.
     return;
   }
 
   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;
     }
   }
   return false;
 }
 
-
 // Returns true if ICData tests two arguments and all ICData cids are in the
 // required sets 'receiver_class_ids' or 'argument_class_ids', respectively.
 static bool ICDataHasOnlyReceiverArgumentClassIds(
     const ICData& ic_data,
     const GrowableArray<intptr_t>& receiver_class_ids,
     const GrowableArray<intptr_t>& argument_class_ids) {
   if (ic_data.NumArgsTested() != 2) {
     return false;
   }
   const intptr_t len = ic_data.NumberOfChecks();
   GrowableArray<intptr_t> class_ids;
   for (intptr_t i = 0; i < len; i++) {
     if (ic_data.IsUsedAt(i)) {
       ic_data.GetClassIdsAt(i, &class_ids);
       ASSERT(class_ids.length() == 2);
       if (!ClassIdIsOneOf(class_ids[0], receiver_class_ids) ||
           !ClassIdIsOneOf(class_ids[1], argument_class_ids)) {
         return false;
       }
     }
   }
   return true;
 }
 
-
 static bool ICDataHasReceiverArgumentClassIds(const ICData& ic_data,
                                               intptr_t receiver_class_id,
                                               intptr_t argument_class_id) {
   if (ic_data.NumArgsTested() != 2) {
     return false;
   }
   const intptr_t len = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     if (ic_data.IsUsedAt(i)) {
       GrowableArray<intptr_t> class_ids;
       ic_data.GetClassIdsAt(i, &class_ids);
       ASSERT(class_ids.length() == 2);
       if ((class_ids[0] == receiver_class_id) &&
           (class_ids[1] == argument_class_id)) {
         return true;
       }
     }
   }
   return false;
 }
 
-
 static bool HasOnlyOneSmi(const ICData& ic_data) {
   return (ic_data.NumberOfUsedChecks() == 1) &&
          ic_data.HasReceiverClassId(kSmiCid);
 }
 
-
 static bool HasOnlySmiOrMint(const ICData& ic_data) {
   if (ic_data.NumberOfUsedChecks() == 1) {
     return ic_data.HasReceiverClassId(kSmiCid) ||
            ic_data.HasReceiverClassId(kMintCid);
   }
   return (ic_data.NumberOfUsedChecks() == 2) &&
          ic_data.HasReceiverClassId(kSmiCid) &&
          ic_data.HasReceiverClassId(kMintCid);
 }
 
-
 static bool HasOnlyTwoOf(const ICData& ic_data, intptr_t cid) {
   if (ic_data.NumberOfUsedChecks() != 1) {
     return false;
   }
   GrowableArray<intptr_t> first;
   GrowableArray<intptr_t> second;
   ic_data.GetUsedCidsForTwoArgs(&first, &second);
   return (first[0] == cid) && (second[0] == cid);
 }
 
 // Returns false if the ICData contains anything other than the 4 combinations
 // of Mint and Smi for the receiver and argument classes.
 static bool HasTwoMintOrSmi(const ICData& ic_data) {
   GrowableArray<intptr_t> first;
   GrowableArray<intptr_t> second;
   ic_data.GetUsedCidsForTwoArgs(&first, &second);
   for (intptr_t i = 0; i < first.length(); i++) {
     if ((first[i] != kSmiCid) && (first[i] != kMintCid)) {
       return false;
     }
     if ((second[i] != kSmiCid) && (second[i] != kMintCid)) {
       return false;
     }
   }
   return true;
 }
 
-
 // Returns false if the ICData contains anything other than the 4 combinations
 // of Double and Smi for the receiver and argument classes.
 static bool HasTwoDoubleOrSmi(const ICData& ic_data) {
   GrowableArray<intptr_t> class_ids(2);
   class_ids.Add(kSmiCid);
   class_ids.Add(kDoubleCid);
   return ICDataHasOnlyReceiverArgumentClassIds(ic_data, class_ids, class_ids);
 }
 
-
 static bool HasOnlyOneDouble(const ICData& ic_data) {
   return (ic_data.NumberOfUsedChecks() == 1) &&
          ic_data.HasReceiverClassId(kDoubleCid);
 }
 
-
 static bool ShouldSpecializeForDouble(const ICData& ic_data) {
   // Don't specialize for double if we can't unbox them.
   if (!CanUnboxDouble()) {
     return false;
   }
 
   // Unboxed double operation can't handle case of two smis.
   if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
     return false;
   }
 
   // Check that it have seen only smis and doubles.
   return HasTwoDoubleOrSmi(ic_data);
 }
 
-
 void JitOptimizer::ReplaceCall(Definition* call, Definition* replacement) {
   // 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();
   }
   call->ReplaceWith(replacement, current_iterator());
 }
 
-
 void JitOptimizer::AddCheckSmi(Definition* to_check,
                                intptr_t deopt_id,
                                Environment* deopt_environment,
                                Instruction* insert_before) {
   if (to_check->Type()->ToCid() != kSmiCid) {
     InsertBefore(insert_before,
                  new (Z) CheckSmiInstr(new (Z) Value(to_check), deopt_id,
                                        insert_before->token_pos()),
                  deopt_environment, FlowGraph::kEffect);
   }
 }
 
-
 void JitOptimizer::AddCheckClass(Definition* to_check,
                                  const Cids& cids,
                                  intptr_t deopt_id,
                                  Environment* deopt_environment,
                                  Instruction* insert_before) {
   // Type propagation has not run yet, we cannot eliminate the check.
   Instruction* check = flow_graph_->CreateCheckClass(
       to_check, cids, deopt_id, insert_before->token_pos());
   InsertBefore(insert_before, check, deopt_environment, FlowGraph::kEffect);
 }
 
-
 void JitOptimizer::AddChecksForArgNr(InstanceCallInstr* call,
                                      Definition* instr,
                                      int argument_number) {
   const Cids* cids = Cids::Create(Z, *call->ic_data(), argument_number);
   AddCheckClass(instr, *cids, call->deopt_id(), call->env(), call);
 }
 
-
 static bool ArgIsAlways(intptr_t cid,
                         const ICData& ic_data,
                         intptr_t arg_number) {
   ASSERT(ic_data.NumArgsTested() > arg_number);
   if (ic_data.NumberOfUsedChecks() == 0) {
     return false;
   }
   const intptr_t num_checks = ic_data.NumberOfChecks();
   for (intptr_t i = 0; i < num_checks; i++) {
     if (ic_data.IsUsedAt(i) && ic_data.GetClassIdAt(i, arg_number) != cid) {
       return false;
     }
   }
   return true;
 }
 
-
 bool JitOptimizer::TryReplaceWithIndexedOp(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
   const ICData& ic_data =
       ICData::Handle(Z, call->ic_data()->AsUnaryClassChecks());
   if (!ic_data.NumberOfChecksIs(1)) {
     return false;
   }
   return FlowGraphInliner::TryReplaceInstanceCallWithInline(
       flow_graph_, current_iterator(), call);
 }
 
-
 // Return true if d is a string of length one (a constant or result from
 // from string-from-char-code instruction.
 static bool IsLengthOneString(Definition* d) {
   if (d->IsConstant()) {
     const Object& obj = d->AsConstant()->value();
     if (obj.IsString()) {
       return String::Cast(obj).Length() == 1;
     } else {
       return false;
     }
   } else {
     return d->IsOneByteStringFromCharCode();
   }
 }
 
-
 // Returns true if the string comparison was converted into char-code
 // comparison. Conversion is only possible for strings of length one.
 // E.g., detect str[x] == "x"; and use an integer comparison of char-codes.
 // TODO(srdjan): Expand for two-byte and external strings.
 bool JitOptimizer::TryStringLengthOneEquality(InstanceCallInstr* call,
                                               Token::Kind op_kind) {
   ASSERT(HasOnlyTwoOf(*call->ic_data(), kOneByteStringCid));
   // Check that left and right are length one strings (either string constants
   // or results of string-from-char-code.
   Definition* left = call->ArgumentAt(0);
@@ skipping 60 matching lines @@
     if ((to_remove_right != NULL) &&
         (to_remove_right->input_use_list() == NULL)) {
       to_remove_right->ReplaceUsesWith(flow_graph()->constant_null());
       to_remove_right->RemoveFromGraph();
     }
     return true;
   }
   return false;
 }
 
-
 static bool SmiFitsInDouble() {
   return kSmiBits < 53;
 }
 
 bool JitOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
                                             Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
@@ skipping 23 matching lines @@
   } else if (HasTwoDoubleOrSmi(ic_data) && CanUnboxDouble()) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
     } else {
       if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
         // We cannot use double comparison on two smis. Need polymorphic
         // call.
         return false;
       } else {
-        InsertBefore(call, new (Z) CheckEitherNonSmiInstr(new (Z) Value(left),
-                                                          new (Z) Value(right),
-                                                          call->deopt_id()),
-                     call->env(), FlowGraph::kEffect);
+        InsertBefore(
+            call,
+            new (Z) CheckEitherNonSmiInstr(
+                new (Z) Value(left), new (Z) Value(right), call->deopt_id()),
+            call->env(), FlowGraph::kEffect);
         cid = kDoubleCid;
       }
     }
   } else {
     // Check if ICDData contains checks with Smi/Null combinations. In that case
     // we can still emit the optimized Smi equality operation but need to add
     // checks for null or Smi.
     GrowableArray<intptr_t> smi_or_null(2);
     smi_or_null.Add(kSmiCid);
     smi_or_null.Add(kNullCid);
@@ skipping 19 matching lines @@
     }
   }
   ASSERT(cid != kIllegalCid);
   EqualityCompareInstr* comp = new (Z)
       EqualityCompareInstr(call->token_pos(), op_kind, new (Z) Value(left),
                            new (Z) Value(right), cid, call->deopt_id());
   ReplaceCall(call, comp);
   return true;
 }
 
-
 bool JitOptimizer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
                                               Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
@@ skipping 13 matching lines @@
   } else if (HasTwoDoubleOrSmi(ic_data) && CanUnboxDouble()) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
     } else {
       if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
         // We cannot use double comparison on two smis. Need polymorphic
         // call.
         return false;
       } else {
-        InsertBefore(call, new (Z) CheckEitherNonSmiInstr(new (Z) Value(left),
-                                                          new (Z) Value(right),
-                                                          call->deopt_id()),
-                     call->env(), FlowGraph::kEffect);
+        InsertBefore(
+            call,
+            new (Z) CheckEitherNonSmiInstr(
+                new (Z) Value(left), new (Z) Value(right), call->deopt_id()),
+            call->env(), FlowGraph::kEffect);
         cid = kDoubleCid;
       }
     }
   } else {
     return false;
   }
   ASSERT(cid != kIllegalCid);
   RelationalOpInstr* comp =
       new (Z) RelationalOpInstr(call->token_pos(), op_kind, new (Z) Value(left),
                                 new (Z) Value(right), cid, call->deopt_id());
   ReplaceCall(call, comp);
   return true;
 }
 
-
 bool JitOptimizer::TryReplaceWithBinaryOp(InstanceCallInstr* call,
                                           Token::Kind op_kind) {
   intptr_t operands_type = kIllegalCid;
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   switch (op_kind) {
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL:
       if (HasOnlyTwoOf(ic_data, kSmiCid)) {
@@ skipping 93 matching lines @@
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   if (operands_type == kDoubleCid) {
     if (!CanUnboxDouble()) {
       return false;
     }
     // Check that either left or right are not a smi.  Result of a
     // binary operation with two smis is a smi not a double, except '/' which
     // returns a double for two smis.
     if (op_kind != Token::kDIV) {
-      InsertBefore(call, new (Z) CheckEitherNonSmiInstr(new (Z) Value(left),
-                                                        new (Z) Value(right),
-                                                        call->deopt_id()),
-                   call->env(), FlowGraph::kEffect);
+      InsertBefore(
+          call,
+          new (Z) CheckEitherNonSmiInstr(
+              new (Z) Value(left), new (Z) Value(right), call->deopt_id()),
+          call->env(), FlowGraph::kEffect);
     }
 
     BinaryDoubleOpInstr* double_bin_op = new (Z)
         BinaryDoubleOpInstr(op_kind, new (Z) Value(left), new (Z) Value(right),
                             call->deopt_id(), call->token_pos());
     ReplaceCall(call, double_bin_op);
   } else if (operands_type == kMintCid) {
     if (!FlowGraphCompiler::SupportsUnboxedMints()) return false;
     if ((op_kind == Token::kSHR) || (op_kind == Token::kSHL)) {
       ShiftMintOpInstr* shift_op = new (Z) ShiftMintOpInstr(
@@ skipping 50 matching lines @@
       left = right;
       right = temp;
     }
     BinarySmiOpInstr* bin_op = new (Z) BinarySmiOpInstr(
         op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
     ReplaceCall(call, bin_op);
   }
   return true;
 }
 
-
 bool JitOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
                                          Token::Kind op_kind) {
   ASSERT(call->ArgumentCount() == 1);
   Definition* input = call->ArgumentAt(0);
   Definition* unary_op = NULL;
   if (HasOnlyOneSmi(*call->ic_data())) {
     InsertBefore(call,
                  new (Z) CheckSmiInstr(new (Z) Value(input), call->deopt_id(),
                                        call->token_pos()),
                  call->env(), FlowGraph::kEffect);
@@ skipping 10 matching lines @@
     unary_op = new (Z) UnaryDoubleOpInstr(Token::kNEGATE, new (Z) Value(input),
                                           call->deopt_id());
   } else {
     return false;
   }
   ASSERT(unary_op != NULL);
   ReplaceCall(call, unary_op);
   return true;
 }
 
-
 // Using field class.
 RawField* JitOptimizer::GetField(intptr_t class_id, const String& field_name) {
   Class& cls = Class::Handle(Z, isolate()->class_table()->At(class_id));
   Field& field = Field::Handle(Z);
   while (!cls.IsNull()) {
     field = cls.LookupInstanceField(field_name);
     if (!field.IsNull()) {
       if (Compiler::IsBackgroundCompilation() ||
           FLAG_force_clone_compiler_objects) {
         return field.CloneFromOriginal();
       } else {
         return field.raw();
       }
     }
     cls = cls.SuperClass();
   }
   return Field::null();
 }
 
-
 bool JitOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.HasOneTarget());
   GrowableArray<intptr_t> class_ids;
   ic_data.GetClassIdsAt(0, &class_ids);
   ASSERT(class_ids.length() == 1);
   // Inline implicit instance getter.
   const String& field_name =
       String::Handle(Z, Field::NameFromGetter(call->function_name()));
@@ skipping 17 matching lines @@
 
   if (load->result_cid() != kDynamicCid) {
     // Reset value types if guarded_cid was used.
     for (Value::Iterator it(load->input_use_list()); !it.Done(); it.Advance()) {
       it.Current()->SetReachingType(NULL);
     }
   }
   return true;
 }
 
-
 bool JitOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
                                            Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, 0);
   AddChecksForArgNr(call, right, 1);
   // Replace call.
   BinaryFloat32x4OpInstr* float32x4_bin_op = new (Z) BinaryFloat32x4OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, float32x4_bin_op);
 
   return true;
 }
 
-
 bool JitOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
                                          Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, 0);
   AddChecksForArgNr(call, right, 1);
   // Replace call.
   BinaryInt32x4OpInstr* int32x4_bin_op = new (Z) BinaryInt32x4OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, int32x4_bin_op);
   return true;
 }
 
-
 bool JitOptimizer::InlineFloat64x2BinaryOp(InstanceCallInstr* call,
                                            Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, 0);
   AddChecksForArgNr(call, right, 1);
   // Replace call.
   BinaryFloat64x2OpInstr* float64x2_bin_op = new (Z) BinaryFloat64x2OpInstr(
       op_kind, new (Z) Value(left), new (Z) Value(right), call->deopt_id());
   ReplaceCall(call, float64x2_bin_op);
   return true;
 }
 
-
 // Only unique implicit instance getters can be currently handled.
 bool JitOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfUsedChecks() == 0) {
     // No type feedback collected.
     return false;
   }
 
   if (!ic_data.HasOneTarget()) {
     // Polymorphic sites are inlined like normal methods by conventional
     // inlining in FlowGraphInliner.
     return false;
   }
 
   const Function& target = Function::Handle(Z, ic_data.GetTargetAt(0));
   if (target.kind() != RawFunction::kImplicitGetter) {
     // Non-implicit getters are inlined like normal methods by conventional
     // inlining in FlowGraphInliner.
     return false;
   }
   return InlineImplicitInstanceGetter(call);
 }
 
-
 void JitOptimizer::ReplaceWithMathCFunction(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   AddReceiverCheck(call);
   ZoneGrowableArray<Value*>* args =
       new (Z) ZoneGrowableArray<Value*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
     args->Add(new (Z) Value(call->ArgumentAt(i)));
   }
   InvokeMathCFunctionInstr* invoke = new (Z) InvokeMathCFunctionInstr(
       args, call->deopt_id(), recognized_kind, call->token_pos());
   ReplaceCall(call, invoke);
 }
 
-
 // Inline only simple, frequently called core library methods.
 bool JitOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfUsedChecks() != 1) {
     // No type feedback collected or multiple targets found.
     return false;
   }
 
   Function& target = Function::Handle(Z);
@@ skipping 60 matching lines @@
         return true;
       default:
         break;
     }
   }
 
   return FlowGraphInliner::TryReplaceInstanceCallWithInline(
       flow_graph_, current_iterator(), call);
 }
 
-
 // If type tests specified by 'ic_data' do not depend on type arguments,
 // return mapping cid->result in 'results' (i : cid; i + 1: result).
 // If all tests yield the same result, return it otherwise return Bool::null.
 // If no mapping is possible, 'results' is empty.
 // An instance-of test returning all same results can be converted to a class
 // check.
 RawBool* JitOptimizer::InstanceOfAsBool(
     const ICData& ic_data,
     const AbstractType& type,
     ZoneGrowableArray<intptr_t>* results) const {
@@ skipping 47 matching lines @@
       prev = Bool::Get(is_subtype).raw();
     } else {
       if (is_subtype != prev.value()) {
         results_differ = true;
       }
     }
   }
   return results_differ ? Bool::null() : prev.raw();
 }
 
-
 // Returns true if checking against this type is a direct class id comparison.
 bool JitOptimizer::TypeCheckAsClassEquality(const AbstractType& type) {
   ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
   // Requires CHA.
   if (!type.IsInstantiated()) return false;
   // Function types have different type checking rules.
   if (type.IsFunctionType()) return false;
   const Class& type_class = Class::Handle(type.type_class());
   // Could be an interface check?
   if (CHA::IsImplemented(type_class)) return false;
@@ skipping 26 matching lines @@
     const intptr_t from_index = num_type_args - num_type_params;
     const TypeArguments& type_arguments =
         TypeArguments::Handle(type.arguments());
     const bool is_raw_type = type_arguments.IsNull() ||
                              type_arguments.IsRaw(from_index, num_type_params);
     return is_raw_type;
   }
   return true;
 }
 
-
 // TODO(srdjan): Use ICData to check if always true or false.
 void JitOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeTestOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* instantiator_type_args = NULL;
   Definition* function_type_args = NULL;
   AbstractType& type = AbstractType::ZoneHandle(Z);
   if (call->ArgumentCount() == 2) {
     instantiator_type_args = flow_graph()->constant_null();
     function_type_args = flow_graph()->constant_null();
@@ skipping 56 matching lines @@
     }
   }
 
   InstanceOfInstr* instance_of = new (Z) InstanceOfInstr(
       call->token_pos(), new (Z) Value(left),
       new (Z) Value(instantiator_type_args), new (Z) Value(function_type_args),
       type, call->deopt_id());
   ReplaceCall(call, instance_of);
 }
 
-
 // TODO(srdjan): Apply optimizations as in ReplaceWithInstanceOf (TestCids).
 void JitOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeCastOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* instantiator_type_args = call->ArgumentAt(1);
   Definition* function_type_args = call->ArgumentAt(2);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value());
   ASSERT(!type.IsMalformedOrMalbounded());
   const ICData& unary_checks =
@@ skipping 20 matching lines @@
       return;
     }
   }
   AssertAssignableInstr* assert_as = new (Z) AssertAssignableInstr(
       call->token_pos(), new (Z) Value(left),
       new (Z) Value(instantiator_type_args), new (Z) Value(function_type_args),
       type, Symbols::InTypeCast(), call->deopt_id());
   ReplaceCall(call, assert_as);
 }
 
-
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void JitOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   if (!instr->HasICData() || (instr->ic_data()->NumberOfUsedChecks() == 0)) {
     return;
   }
   const Token::Kind op_kind = instr->token_kind();
 
   // Type test is special as it always gets converted into inlined code.
   if (Token::IsTypeTestOperator(op_kind)) {
@@ skipping 96 matching lines @@
     StaticCallInstr* call = StaticCallInstr::FromCall(Z, instr, target);
     instr->ReplaceWith(call, current_iterator());
   } else {
     PolymorphicInstanceCallInstr* call =
         new (Z) PolymorphicInstanceCallInstr(instr, targets,
                                              /* 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:
     case MethodRecognizer::kFloat32x4Splat:
     case MethodRecognizer::kFloat32x4Constructor:
     case MethodRecognizer::kFloat32x4FromFloat64x2:
@@ skipping 62 matching lines @@
           }
         }
       }
       break;
     }
     default:
       break;
   }
 }
 
-
 void JitOptimizer::VisitStoreInstanceField(StoreInstanceFieldInstr* instr) {
   if (instr->IsUnboxedStore()) {
     // Determine if this field should be unboxed based on the usage of getter
     // and setter functions: The heuristic requires that the setter has a
     // usage count of at least 1/kGetterSetterRatio of the getter usage count.
     // This is to avoid unboxing fields where the setter is never or rarely
     // executed.
     const Field& field = instr->field();
     const String& field_name = String::Handle(Z, field.name());
     const Class& owner = Class::Handle(Z, field.Owner());
@@ skipping 33 matching lines @@
       }
       ASSERT(field.IsOriginal());
       field.set_is_unboxing_candidate(false);
       field.DeoptimizeDependentCode();
     } else {
       flow_graph()->parsed_function().AddToGuardedFields(&field);
     }
   }
 }
 
-
 void JitOptimizer::VisitAllocateContext(AllocateContextInstr* instr) {
   // Replace generic allocation with a sequence of inlined allocation and
   // explicit initializing stores.
   AllocateUninitializedContextInstr* replacement =
       new AllocateUninitializedContextInstr(instr->token_pos(),
                                             instr->num_context_variables());
   instr->ReplaceWith(replacement, current_iterator());
 
   StoreInstanceFieldInstr* store = new (Z)
       StoreInstanceFieldInstr(Context::parent_offset(), new Value(replacement),
@@ skipping 10 matching lines @@
         new Value(flow_graph_->constant_null()), kNoStoreBarrier,
         instr->token_pos());
     // Storing into uninitialized memory; remember to prevent dead store
     // elimination and ensure proper GC barrier.
     store->set_is_initialization(true);
     flow_graph_->InsertAfter(cursor, store, NULL, FlowGraph::kEffect);
     cursor = store;
   }
 }
 
-
 void JitOptimizer::VisitLoadCodeUnits(LoadCodeUnitsInstr* instr) {
 // TODO(zerny): Use kUnboxedUint32 once it is fully supported/optimized.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_ARM)
   if (!instr->can_pack_into_smi()) instr->set_representation(kUnboxedMint);
 #endif
 }
 
-
 bool JitOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
                                            const ICData& unary_ic_data) {
   ASSERT(!unary_ic_data.NumberOfChecksIs(0) &&
          (unary_ic_data.NumArgsTested() == 1));
   if (I->type_checks()) {
     // Checked mode setters are inlined like normal methods by conventional
     // inlining.
     return false;
   }
 
@@ skipping 19 matching lines @@
       String::Handle(Z, Field::NameFromSetter(instr->function_name()));
   const Field& field = Field::ZoneHandle(Z, GetField(class_id, field_name));
   ASSERT(!field.IsNull());
 
   if (flow_graph()->InstanceCallNeedsClassCheck(instr,
                                                 RawFunction::kImplicitSetter)) {
     AddReceiverCheck(instr);
   }
   if (field.guarded_cid() != kDynamicCid) {
     ASSERT(I->use_field_guards());
-    InsertBefore(
-        instr, new (Z) GuardFieldClassInstr(new (Z) Value(instr->ArgumentAt(1)),
-                                            field, instr->deopt_id()),
-        instr->env(), FlowGraph::kEffect);
+    InsertBefore(instr,
+                 new (Z)
+                     GuardFieldClassInstr(new (Z) Value(instr->ArgumentAt(1)),
+                                          field, instr->deopt_id()),
+                 instr->env(), FlowGraph::kEffect);
   }
 
   if (field.needs_length_check()) {
     ASSERT(I->use_field_guards());
-    InsertBefore(instr, new (Z) GuardFieldLengthInstr(
-                            new (Z) Value(instr->ArgumentAt(1)), field,
-                            instr->deopt_id()),
+    InsertBefore(instr,
+                 new (Z)
+                     GuardFieldLengthInstr(new (Z) Value(instr->ArgumentAt(1)),
+                                           field, instr->deopt_id()),
                  instr->env(), FlowGraph::kEffect);
   }
 
   // Field guard was detached.
   StoreInstanceFieldInstr* store = new (Z)
       StoreInstanceFieldInstr(field, new (Z) Value(instr->ArgumentAt(0)),
                               new (Z) Value(instr->ArgumentAt(1)),
                               kEmitStoreBarrier, instr->token_pos());
 
   if (store->IsUnboxedStore()) {
     flow_graph()->parsed_function().AddToGuardedFields(&field);
   }
 
   // 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