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

runtime/vm/aot_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.
 
 #include "vm/aot_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 29 matching lines @@
 // Quick access to the current isolate and zone.
 #define I (isolate())
 #define Z (zone())
 
 #ifdef DART_PRECOMPILER
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
-
 static bool CanUnboxDouble() {
   return FlowGraphCompiler::SupportsUnboxedDoubles();
 }
 
-
 static bool CanConvertUnboxedMintToDouble() {
   return FlowGraphCompiler::CanConvertUnboxedMintToDouble();
 }
 
-
 // Returns named function that is a unique dynamic target, i.e.,
 // - the target is identified by its name alone, since it occurs only once.
 // - target's class has no subclasses, and neither is subclassed, i.e.,
 //   the receiver type can be only the function's class.
 // Returns Function::null() if there is no unique dynamic target for
 // given 'fname'. 'fname' must be a symbol.
 static void GetUniqueDynamicTarget(Isolate* isolate,
                                    const String& fname,
                                    Object* function) {
   UniqueFunctionsSet functions_set(
       isolate->object_store()->unique_dynamic_targets());
   ASSERT(fname.IsSymbol());
   *function = functions_set.GetOrNull(fname);
   ASSERT(functions_set.Release().raw() ==
          isolate->object_store()->unique_dynamic_targets());
 }
 
-
 AotOptimizer::AotOptimizer(Precompiler* precompiler,
                            FlowGraph* flow_graph,
                            bool use_speculative_inlining,
                            GrowableArray<intptr_t>* inlining_black_list)
     : FlowGraphVisitor(flow_graph->reverse_postorder()),
       precompiler_(precompiler),
       flow_graph_(flow_graph),
       use_speculative_inlining_(use_speculative_inlining),
       inlining_black_list_(inlining_black_list),
       has_unique_no_such_method_(false) {
   ASSERT(!use_speculative_inlining || (inlining_black_list != NULL));
   Function& target_function = Function::Handle();
   if (isolate()->object_store()->unique_dynamic_targets() != Array::null()) {
     GetUniqueDynamicTarget(isolate(), Symbols::NoSuchMethod(),
                            &target_function);
     has_unique_no_such_method_ = !target_function.IsNull();
   }
 }
 
-
 // Optimize instance calls using ICData.
 void AotOptimizer::ApplyICData() {
   VisitBlocks();
 }
 
-
 bool AotOptimizer::RecognizeRuntimeTypeGetter(InstanceCallInstr* call) {
   if ((precompiler_ == NULL) || !precompiler_->get_runtime_type_is_unique()) {
     return false;
   }
 
   if (call->function_name().raw() != Symbols::GetRuntimeType().raw()) {
     return false;
   }
 
   // There is only a single function Object.get:runtimeType that can be invoked
   // by this call. Convert dynamic invocation to a static one.
   const Class& cls = Class::Handle(Z, I->object_store()->object_class());
   const Function& function =
       Function::Handle(Z, call->ResolveForReceiverClass(cls));
   ASSERT(!function.IsNull());
   const Function& target = Function::ZoneHandle(Z, function.raw());
   StaticCallInstr* static_call = StaticCallInstr::FromCall(Z, call, target);
   static_call->set_result_cid(kTypeCid);
   call->ReplaceWith(static_call, current_iterator());
   return true;
 }
 
-
 // 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 AotOptimizer::ApplyClassIds() {
   ASSERT(current_iterator_ == NULL);
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
     ForwardInstructionIterator it(block_it.Current());
     current_iterator_ = &it;
     for (; !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
       if (instr->IsInstanceCall()) {
         InstanceCallInstr* call = instr->AsInstanceCall();
         if (call->HasICData()) {
           if (TryCreateICData(call)) {
             VisitInstanceCall(call);
           }
         }
       }
     }
     current_iterator_ = NULL;
   }
 }
 
-
 // TODO(srdjan): Test/support other number types as well.
 static bool IsNumberCid(intptr_t cid) {
   return (cid == kSmiCid) || (cid == kDoubleCid);
 }
 
-
 bool AotOptimizer::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;
   }
   GrowableArray<intptr_t> class_ids(call->ic_data()->NumArgsTested());
   const intptr_t receiver_idx = call->FirstParamIndex();
   ASSERT(call->ic_data()->NumArgsTested() <=
@@ skipping 102 matching lines @@
           }
         }
         return true;
       }
     }
   }
 
   return false;
 }
 
-
 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 AotOptimizer::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 AotOptimizer::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 AotOptimizer::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 AotOptimizer::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 AotOptimizer::TryReplaceWithIndexedOp(InstanceCallInstr* call,
                                            const ICData* unary_checks) {
   // Check for monomorphic IC data.
   ASSERT(unary_checks->NumberOfChecks() > 0);
   if (unary_checks->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 AotOptimizer::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;
 }
 
-
 static bool IsGetRuntimeType(Definition* defn) {
   StaticCallInstr* call = defn->AsStaticCall();
   return (call != NULL) && (call->function().recognized_kind() ==
                             MethodRecognizer::kObjectRuntimeType);
 }
 
-
 // Recognize a.runtimeType == b.runtimeType and fold it into
 // Object._haveSameRuntimeType(a, b).
 // Note: this optimization is not speculative.
 bool AotOptimizer::TryReplaceWithHaveSameRuntimeType(InstanceCallInstr* call) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
@@ skipping 23 matching lines @@
                         Object::null_array(),  // argument_names
                         args, call->deopt_id(), call->CallCount());
     static_call->set_result_cid(kBoolCid);
     ReplaceCall(call, static_call);
     return true;
   }
 
   return false;
 }
 
-
 bool AotOptimizer::TryReplaceWithEqualityOp(InstanceCallInstr* call,
                                             Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* const left = call->ArgumentAt(0);
   Definition* const right = call->ArgumentAt(1);
 
@@ skipping 16 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 22 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 AotOptimizer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
                                               Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
@@ skipping 14 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 AotOptimizer::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 94 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 AotOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
                                          Token::Kind op_kind) {
   ASSERT(call->type_args_len() == 0);
   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()),
@@ skipping 11 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* AotOptimizer::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()) {
       return field.raw();
     }
     cls = cls.SuperClass();
   }
   return Field::null();
 }
 
-
 bool AotOptimizer::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 16 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 AotOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
                                            Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* const left = call->ArgumentAt(0);
   Definition* const right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, /* arg_number = */ 0);
   AddChecksForArgNr(call, right, /* arg_number = */ 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 AotOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
                                          Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* const left = call->ArgumentAt(0);
   Definition* const right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, /* arg_number = */ 0);
   AddChecksForArgNr(call, right, /* arg_number = */ 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 AotOptimizer::InlineFloat64x2BinaryOp(InstanceCallInstr* call,
                                            Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->type_args_len() == 0);
   ASSERT(call->ArgumentCount() == 2);
   Definition* const left = call->ArgumentAt(0);
   Definition* const right = call->ArgumentAt(1);
   // Type check left and right.
   AddChecksForArgNr(call, left, /* arg_number = */ 0);
   AddChecksForArgNr(call, right, /* arg_number = */ 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 AotOptimizer::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 AotOptimizer::ReplaceWithMathCFunction(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   ASSERT(call->type_args_len() == 0);
   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 AotOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfUsedChecks() != 1) {
     // No type feedback collected or multiple receivers/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' has less than
 // (ic_data.NumberOfChecks() * 2) entries
 // An instance-of test returning all same results can be converted to a class
 // check.
 RawBool* AotOptimizer::InstanceOfAsBool(
     const ICData& ic_data,
     const AbstractType& type,
@@ 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 AotOptimizer::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 24 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 AotOptimizer::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);
   ASSERT(call->type_args_len() == 0);
   if (call->ArgumentCount() == 2) {
     instantiator_type_args = flow_graph()->constant_null();
@@ skipping 97 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 AotOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeCastOperator(call->token_kind()));
   ASSERT(call->type_args_len() == 0);
   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());
@@ skipping 142 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);
 }
 
-
 bool AotOptimizer::IsAllowedForInlining(intptr_t call_deopt_id) {
   if (!use_speculative_inlining_) return false;
   for (intptr_t i = 0; i < inlining_black_list_->length(); ++i) {
     if ((*inlining_black_list_)[i] == call_deopt_id) return false;
   }
   return true;
 }
 
-
 static bool HasLikelySmiOperand(InstanceCallInstr* instr) {
   ASSERT(instr->type_args_len() == 0);
   // Phis with at least one known smi are // guessed to be likely smi as well.
   for (intptr_t i = 0; i < instr->ArgumentCount(); ++i) {
     PhiInstr* phi = instr->ArgumentAt(i)->AsPhi();
     if (phi != NULL) {
       for (intptr_t j = 0; j < phi->InputCount(); ++j) {
         if (phi->InputAt(j)->Type()->ToCid() == kSmiCid) return true;
       }
     }
   }
   // If all of the inputs are known smis or the result of CheckedSmiOp,
   // we guess the operand to be likely smi.
   for (intptr_t i = 0; i < instr->ArgumentCount(); ++i) {
     if (!instr->ArgumentAt(i)->IsCheckedSmiOp()) return false;
   }
   return true;
 }
 
-
 bool AotOptimizer::TryInlineFieldAccess(InstanceCallInstr* call) {
   const Token::Kind op_kind = call->token_kind();
   if ((op_kind == Token::kGET) && TryInlineInstanceGetter(call)) {
     return true;
   }
 
   const ICData& unary_checks =
       ICData::Handle(Z, call->ic_data()->AsUnaryClassChecks());
   if (!unary_checks.NumberOfChecksIs(0) && (op_kind == Token::kSET) &&
       TryInlineInstanceSetter(call, unary_checks)) {
     return true;
   }
 
   return false;
 }
 
-
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void AotOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   ASSERT(FLAG_precompiled_mode);
   // TODO(srdjan): Investigate other attempts, as they are not allowed to
   // deoptimize.
 
   // Type test is special as it always gets converted into inlined code.
   const Token::Kind op_kind = instr->token_kind();
   if (Token::IsTypeTestOperator(op_kind)) {
@@ skipping 253 matching lines @@
     // deoptimization is allowed.
     CallTargets* targets = CallTargets::Create(Z, *instr->ic_data());
     PolymorphicInstanceCallInstr* call =
         new (Z) PolymorphicInstanceCallInstr(instr, *targets,
                                              /* complete = */ false);
     instr->ReplaceWith(call, current_iterator());
     return;
   }
 }
 
-
 void AotOptimizer::VisitPolymorphicInstanceCall(
     PolymorphicInstanceCallInstr* call) {
   const intptr_t receiver_cid =
       call->PushArgumentAt(0)->value()->Type()->ToCid();
   if (receiver_cid != kDynamicCid) {
     const Class& receiver_class =
         Class::Handle(Z, isolate()->class_table()->At(receiver_cid));
     const Function& function = Function::ZoneHandle(
         Z, call->instance_call()->ResolveForReceiverClass(receiver_class));
     if (!function.IsNull()) {
       // Only one target. Replace by static call.
       StaticCallInstr* new_call = StaticCallInstr::FromCall(Z, call, function);
       call->ReplaceWith(new_call, current_iterator());
     }
   }
 }
 
-
 void AotOptimizer::VisitStaticCall(StaticCallInstr* call) {
   if (!IsAllowedForInlining(call->deopt_id())) {
     // Inlining disabled after a speculative inlining attempt.
     return;
   }
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   switch (recognized_kind) {
     case MethodRecognizer::kObjectConstructor:
     case MethodRecognizer::kObjectArrayAllocate:
@@ skipping 65 matching lines @@
           }
         }
       }
       break;
     }
     default:
       break;
   }
 }
 
-
 void AotOptimizer::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 AotOptimizer::TryInlineInstanceSetter(InstanceCallInstr* instr,
                                            const ICData& unary_ic_data) {
   ASSERT((unary_ic_data.NumberOfChecks() > 0) &&
          (unary_ic_data.NumArgsTested() == 1));
   if (I->type_checks()) {
     // Checked mode setters are inlined like normal methods by conventional
     // inlining.
     return false;
   }
 
@@ skipping 34 matching lines @@
   // No unboxed stores in precompiled code.
   ASSERT(!store->IsUnboxedStore());
 
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
-
 void AotOptimizer::ReplaceArrayBoundChecks() {
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
     ForwardInstructionIterator it(block_it.Current());
     current_iterator_ = &it;
     for (; !it.Done(); it.Advance()) {
       CheckArrayBoundInstr* check = it.Current()->AsCheckArrayBound();
       if (check != NULL) {
         GenericCheckBoundInstr* new_check = new (Z) GenericCheckBoundInstr(
             new (Z) Value(check->length()->definition()),
             new (Z) Value(check->index()->definition()), check->deopt_id());
         flow_graph_->InsertBefore(check, new_check, check->env(),
                                   FlowGraph::kEffect);
         current_iterator()->RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart