clang-format runtime/vm

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 11 matching lines @@
 #include "vm/regexp_assembler_ir.h"
 #include "vm/resolver.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 #include "vm/il_printer.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, propagate_ic_data, true,
-    "Propagate IC data from unoptimized to optimized IC calls.");
-DEFINE_FLAG(bool, two_args_smi_icd, true,
-    "Generate special IC stubs for two args Smi operations");
-DEFINE_FLAG(bool, unbox_numeric_fields, !USING_DBC,
-    "Support unboxed double and float32x4 fields.");
+DEFINE_FLAG(bool,
+            propagate_ic_data,
+            true,
+            "Propagate IC data from unoptimized to optimized IC calls.");
+DEFINE_FLAG(bool,
+            two_args_smi_icd,
+            true,
+            "Generate special IC stubs for two args Smi operations");
+DEFINE_FLAG(bool,
+            unbox_numeric_fields,
+            !USING_DBC,
+            "Support unboxed double and float32x4 fields.");
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, support_externalizable_strings);
 
 
 #if defined(DEBUG)
 void Instruction::CheckField(const Field& field) const {
   ASSERT(field.IsZoneHandle());
   ASSERT(!Compiler::IsBackgroundCompilation() || !field.IsOriginal());
 }
 #endif  // DEBUG
 
 
 Definition::Definition(intptr_t deopt_id)
     : Instruction(deopt_id),
       range_(NULL),
       type_(NULL),
       temp_index_(-1),
       ssa_temp_index_(-1),
       input_use_list_(NULL),
       env_use_list_(NULL),
-      constant_value_(NULL) {
-}
+      constant_value_(NULL) {}
 
 
 // A value in the constant propagation lattice.
 //    - non-constant sentinel
 //    - a constant (any non-sentinel value)
 //    - unknown sentinel
 Object& Definition::constant_value() {
   if (constant_value_ == NULL) {
     constant_value_ = &Object::ZoneHandle(ConstantPropagator::Unknown());
   }
@@ skipping 113 matching lines @@
     }
   }
   return true;
 }
 
 
 static bool AreAllChecksImmutable(const ICData& checks) {
   const intptr_t len = checks.NumberOfChecks();
   for (intptr_t i = 0; i < len; i++) {
     if (checks.IsUsedAt(i)) {
-      if (Field::IsExternalizableCid(
-              checks.GetReceiverClassIdAt(i))) {
+      if (Field::IsExternalizableCid(checks.GetReceiverClassIdAt(i))) {
         return false;
       }
     }
   }
   return true;
 }
 
 
 EffectSet CheckClassInstr::Dependencies() const {
   // Externalization of strings via the API can change the class-id.
-  return !AreAllChecksImmutable(unary_checks()) ?
-      EffectSet::Externalization() : EffectSet::None();
+  return !AreAllChecksImmutable(unary_checks()) ? EffectSet::Externalization()
+                                                : EffectSet::None();
 }
 
 
 EffectSet CheckClassIdInstr::Dependencies() const {
   // Externalization of strings via the API can change the class-id.
-  return Field::IsExternalizableCid(cid_) ?
-      EffectSet::Externalization() : EffectSet::None();
+  return Field::IsExternalizableCid(cid_) ? EffectSet::Externalization()
+                                          : EffectSet::None();
 }
 
 
 bool CheckClassInstr::DeoptIfNull() const {
   if (unary_checks().NumberOfChecks() != 1) {
     return false;
   }
   CompileType* in_type = value()->Type();
   const intptr_t cid = unary_checks().GetCidAt(0);
   // Performance check: use CheckSmiInstr instead.
@@ skipping 46 matching lines @@
 
 
 bool CheckClassInstr::IsDenseMask(intptr_t mask) {
   // Returns true if the mask is a continuos sequence of ones in its binary
   // representation (i.e. no holes)
   return mask == -1 || Utils::IsPowerOfTwo(mask + 1);
 }
 
 
 bool LoadFieldInstr::IsUnboxedLoad() const {
-  return FLAG_unbox_numeric_fields
-      && (field() != NULL)
-      && FlowGraphCompiler::IsUnboxedField(*field());
+  return FLAG_unbox_numeric_fields && (field() != NULL) &&
+         FlowGraphCompiler::IsUnboxedField(*field());
 }
 
 
 bool LoadFieldInstr::IsPotentialUnboxedLoad() const {
-  return FLAG_unbox_numeric_fields
-      && (field() != NULL)
-      && FlowGraphCompiler::IsPotentialUnboxedField(*field());
+  return FLAG_unbox_numeric_fields && (field() != NULL) &&
+         FlowGraphCompiler::IsPotentialUnboxedField(*field());
 }
 
 
 Representation LoadFieldInstr::representation() const {
   if (IsUnboxedLoad()) {
     const intptr_t cid = field()->UnboxedFieldCid();
     switch (cid) {
       case kDoubleCid:
         return kUnboxedDouble;
       case kFloat32x4Cid:
         return kUnboxedFloat32x4;
       case kFloat64x2Cid:
         return kUnboxedFloat64x2;
       default:
         UNREACHABLE();
     }
   }
   return kTagged;
 }
 
 
 bool StoreInstanceFieldInstr::IsUnboxedStore() const {
-  return FLAG_unbox_numeric_fields
-      && !field().IsNull()
-      && FlowGraphCompiler::IsUnboxedField(field());
+  return FLAG_unbox_numeric_fields && !field().IsNull() &&
+         FlowGraphCompiler::IsUnboxedField(field());
 }
 
 
 bool StoreInstanceFieldInstr::IsPotentialUnboxedStore() const {
-  return FLAG_unbox_numeric_fields
-      && !field().IsNull()
-      && FlowGraphCompiler::IsPotentialUnboxedField(field());
+  return FLAG_unbox_numeric_fields && !field().IsNull() &&
+         FlowGraphCompiler::IsPotentialUnboxedField(field());
 }
 
 
 Representation StoreInstanceFieldInstr::RequiredInputRepresentation(
-  intptr_t index) const {
+    intptr_t index) const {
   ASSERT((index == 0) || (index == 1));
   if ((index == 1) && IsUnboxedStore()) {
     const intptr_t cid = field().UnboxedFieldCid();
     switch (cid) {
       case kDoubleCid:
         return kUnboxedDouble;
       case kFloat32x4Cid:
         return kUnboxedFloat32x4;
       case kFloat64x2Cid:
         return kUnboxedFloat64x2;
@@ skipping 21 matching lines @@
   // This predicate has to be commutative for DominatorBasedCSE to work.
   // TODO(fschneider): Eliminate more asserts with subtype relation.
   return dst_type().raw() == other_assert->dst_type().raw();
 }
 
 
 bool StrictCompareInstr::AttributesEqual(Instruction* other) const {
   StrictCompareInstr* other_op = other->AsStrictCompare();
   ASSERT(other_op != NULL);
   return ComparisonInstr::AttributesEqual(other) &&
-    (needs_number_check() == other_op->needs_number_check());
+         (needs_number_check() == other_op->needs_number_check());
 }
 
 
 bool MathMinMaxInstr::AttributesEqual(Instruction* other) const {
   MathMinMaxInstr* other_op = other->AsMathMinMax();
   ASSERT(other_op != NULL);
   return (op_kind() == other_op->op_kind()) &&
-      (result_cid() == other_op->result_cid());
+         (result_cid() == other_op->result_cid());
 }
 
 
 bool BinaryIntegerOpInstr::AttributesEqual(Instruction* other) const {
   ASSERT(other->tag() == tag());
   BinaryIntegerOpInstr* other_op = other->AsBinaryIntegerOp();
   return (op_kind() == other_op->op_kind()) &&
-      (can_overflow() == other_op->can_overflow()) &&
-      (is_truncating() == other_op->is_truncating());
+         (can_overflow() == other_op->can_overflow()) &&
+         (is_truncating() == other_op->is_truncating());
 }
 
 
 EffectSet LoadFieldInstr::Dependencies() const {
   return immutable_ ? EffectSet::None() : EffectSet::All();
 }
 
 
 bool LoadFieldInstr::AttributesEqual(Instruction* other) const {
   LoadFieldInstr* other_load = other->AsLoadField();
   ASSERT(other_load != NULL);
   if (field() != NULL) {
     return (other_load->field() != NULL) &&
-        (field()->raw() == other_load->field()->raw());
+           (field()->raw() == other_load->field()->raw());
   }
   return (other_load->field() == NULL) &&
-      (offset_in_bytes() == other_load->offset_in_bytes());
+         (offset_in_bytes() == other_load->offset_in_bytes());
 }
 
 
 Instruction* InitStaticFieldInstr::Canonicalize(FlowGraph* flow_graph) {
   const bool is_initialized =
       (field_.StaticValue() != Object::sentinel().raw()) &&
       (field_.StaticValue() != Object::transition_sentinel().raw());
   // When precompiling, the fact that a field is currently initialized does not
   // make it safe to omit code that checks if the field needs initialization
   // because the field will be reset so it starts uninitialized in the process
   // running the precompiled code. We must be prepared to reinitialize fields.
   return is_initialized && !FLAG_fields_may_be_reset ? NULL : this;
 }
 
 
 EffectSet LoadStaticFieldInstr::Dependencies() const {
   return (StaticField().is_final() && !FLAG_fields_may_be_reset)
-      ? EffectSet::None() : EffectSet::All();
+             ? EffectSet::None()
+             : EffectSet::All();
 }
 
 
 bool LoadStaticFieldInstr::AttributesEqual(Instruction* other) const {
   LoadStaticFieldInstr* other_load = other->AsLoadStaticField();
   ASSERT(other_load != NULL);
   // Assert that the field is initialized.
   ASSERT(StaticField().StaticValue() != Object::sentinel().raw());
   ASSERT(StaticField().StaticValue() != Object::transition_sentinel().raw());
   return StaticField().raw() == other_load->StaticField().raw();
 }
 
 
 const Field& LoadStaticFieldInstr::StaticField() const {
   Field& field = Field::ZoneHandle();
   field ^= field_value()->BoundConstant().raw();
   return field;
 }
 
 
 ConstantInstr::ConstantInstr(const Object& value, TokenPosition token_pos)
-    : value_(value),
-      token_pos_(token_pos) {
+    : value_(value), token_pos_(token_pos) {
   // Check that the value is not an incorrect Integer representation.
   ASSERT(!value.IsBigint() || !Bigint::Cast(value).FitsIntoSmi());
   ASSERT(!value.IsBigint() || !Bigint::Cast(value).FitsIntoInt64());
   ASSERT(!value.IsMint() || !Smi::IsValid(Mint::Cast(value).AsInt64Value()));
   ASSERT(!value.IsField() || Field::Cast(value).IsOriginal());
 }
 
 
 bool ConstantInstr::AttributesEqual(Instruction* other) const {
   ConstantInstr* other_constant = other->AsConstant();
@@ skipping 41 matching lines @@
                                  intptr_t osr_id)
     : BlockEntryInstr(0, CatchClauseNode::kInvalidTryIndex),
       parsed_function_(parsed_function),
       normal_entry_(normal_entry),
       catch_entries_(),
       indirect_entries_(),
       initial_definitions_(),
       osr_id_(osr_id),
       entry_count_(0),
       spill_slot_count_(0),
-      fixed_slot_count_(0) {
-}
+      fixed_slot_count_(0) {}
 
 
 ConstantInstr* GraphEntryInstr::constant_null() {
   ASSERT(initial_definitions_.length() > 0);
   for (intptr_t i = 0; i < initial_definitions_.length(); ++i) {
     ConstantInstr* defn = initial_definitions_[i]->AsConstant();
     if (defn != NULL && defn->value().IsNull()) return defn;
   }
   UNREACHABLE();
   return NULL;
@@ skipping 11 matching lines @@
 
 
 bool GraphEntryInstr::IsCompiledForOsr() const {
   return osr_id_ != Compiler::kNoOSRDeoptId;
 }
 
 
 // ==== Support for visiting flow graphs.
 
 #define DEFINE_ACCEPT(ShortName)                                               \
-void ShortName##Instr::Accept(FlowGraphVisitor* visitor) {                     \
-  visitor->Visit##ShortName(this);                                             \
-}
+  void ShortName##Instr::Accept(FlowGraphVisitor* visitor) {                   \
+    visitor->Visit##ShortName(this);                                           \
+  }
 
 FOR_EACH_INSTRUCTION(DEFINE_ACCEPT)
 
 #undef DEFINE_ACCEPT
 
 
 void Instruction::SetEnvironment(Environment* deopt_env) {
   intptr_t use_index = 0;
   for (Environment::DeepIterator it(deopt_env); !it.Done(); it.Advance()) {
     Value* use = it.CurrentValue();
@@ skipping 64 matching lines @@
   }
   return tail;
 }
 
 
 BlockEntryInstr* Instruction::GetBlock() {
   // TODO(fschneider): Implement a faster way to get the block of an
   // instruction.
   ASSERT(previous() != NULL);
   Instruction* result = previous();
-  while (!result->IsBlockEntry()) result = result->previous();
+  while (!result->IsBlockEntry())
+    result = result->previous();
   return result->AsBlockEntry();
 }
 
 
 void ForwardInstructionIterator::RemoveCurrentFromGraph() {
   current_ = current_->RemoveFromGraph(true);  // Set current_ to previous.
 }
 
 
 void BackwardInstructionIterator::RemoveCurrentFromGraph() {
@@ skipping 11 matching lines @@
     current_iterator_ = &it;
     for (; !it.Done(); it.Advance()) {
       it.Current()->Accept(this);
     }
     current_iterator_ = NULL;
   }
 }
 
 
 bool Value::NeedsStoreBuffer() {
-  if (Type()->IsNull() ||
-      (Type()->ToNullableCid() == kSmiCid) ||
+  if (Type()->IsNull() || (Type()->ToNullableCid() == kSmiCid) ||
       (Type()->ToNullableCid() == kBoolCid)) {
     return false;
   }
 
   return !BindsToConstant();
 }
 
 
 void JoinEntryInstr::AddPredecessor(BlockEntryInstr* predecessor) {
   // Require the predecessors to be sorted by block_id to make managing
@@ skipping 118 matching lines @@
     it.CurrentValue()->RemoveFromUseList();
   }
 }
 
 
 void Instruction::InheritDeoptTargetAfter(FlowGraph* flow_graph,
                                           Definition* call,
                                           Definition* result) {
   ASSERT(call->env() != NULL);
   deopt_id_ = Thread::ToDeoptAfter(call->deopt_id_);
-  call->env()->DeepCopyAfterTo(flow_graph->zone(),
-                               this,
-                               call->ArgumentCount(),
-                               flow_graph->constant_dead(),
-                               result != NULL ? result
-                                              : flow_graph->constant_dead());
+  call->env()->DeepCopyAfterTo(
+      flow_graph->zone(), this, call->ArgumentCount(),
+      flow_graph->constant_dead(),
+      result != NULL ? result : flow_graph->constant_dead());
   env()->set_deopt_id(deopt_id_);
 }
 
 
 void Instruction::InheritDeoptTarget(Zone* zone, Instruction* other) {
   ASSERT(other->env() != NULL);
   CopyDeoptIdFrom(*other);
   other->env()->DeepCopyTo(zone, this);
   env()->set_deopt_id(deopt_id_);
 }
@@ skipping 103 matching lines @@
   // Detect that a block has been visited as part of the current
   // DiscoverBlocks (we can call DiscoverBlocks multiple times).  The block
   // will be 'marked' by (1) having a preorder number in the range of the
   // preorder array and (2) being in the preorder array at that index.
   intptr_t i = block->preorder_number();
   return (i >= 0) && (i < preorder->length()) && ((*preorder)[i] == block);
 }
 
 
 // Base class implementation used for JoinEntry and TargetEntry.
-bool BlockEntryInstr::DiscoverBlock(
-    BlockEntryInstr* predecessor,
-    GrowableArray<BlockEntryInstr*>* preorder,
-    GrowableArray<intptr_t>* parent) {
+bool BlockEntryInstr::DiscoverBlock(BlockEntryInstr* predecessor,
+                                    GrowableArray<BlockEntryInstr*>* preorder,
+                                    GrowableArray<intptr_t>* parent) {
   // If this block has a predecessor (i.e., is not the graph entry) we can
   // assume the preorder array is non-empty.
   ASSERT((predecessor == NULL) || !preorder->is_empty());
   // Blocks with a single predecessor cannot have been reached before.
   ASSERT(IsJoinEntry() || !IsMarked(this, preorder));
 
   // 1. If the block has already been reached, add current_block as a
   // basic-block predecessor and we are done.
   if (IsMarked(this, preorder)) {
     ASSERT(predecessor != NULL);
@@ skipping 64 matching lines @@
 
       GotoInstr* goto_join = new GotoInstr(AsJoinEntry());
       goto_join->CopyDeoptIdFrom(*parent);
       graph_entry->normal_entry()->LinkTo(goto_join);
       return true;
     }
   }
 
   // Recursively search the successors.
   for (intptr_t i = instr->SuccessorCount() - 1; i >= 0; --i) {
-    if (instr->SuccessorAt(i)->PruneUnreachable(graph_entry,
-                                                instr,
-                                                osr_id,
+    if (instr->SuccessorAt(i)->PruneUnreachable(graph_entry, instr, osr_id,
                                                 block_marks)) {
       return true;
     }
   }
   return false;
 }
 
 
 bool BlockEntryInstr::Dominates(BlockEntryInstr* other) const {
   // TODO(fschneider): Make this faster by e.g. storing dominators for each
@@ skipping 62 matching lines @@
     if ((join->phis() == NULL) || (old_index == new_index)) return;
     // Otherwise, reorder the predecessor uses in each phi.
     for (PhiIterator it(join); !it.Done(); it.Advance()) {
       PhiInstr* phi = it.Current();
       ASSERT(phi != NULL);
       ASSERT(pred_count == phi->InputCount());
       // Save the predecessor use.
       Value* pred_use = phi->InputAt(old_index);
       // Move uses between old and new.
       intptr_t step = (old_index < new_index) ? 1 : -1;
-      for (intptr_t use_idx = old_index;
-           use_idx != new_index;
+      for (intptr_t use_idx = old_index; use_idx != new_index;
            use_idx += step) {
         phi->SetInputAt(use_idx, phi->InputAt(use_idx + step));
       }
       // Write the predecessor use.
       phi->SetInputAt(new_index, pred_use);
     }
   }
 }
 
 
 void BlockEntryInstr::ClearAllInstructions() {
   JoinEntryInstr* join = this->AsJoinEntry();
   if (join != NULL) {
     for (PhiIterator it(join); !it.Done(); it.Advance()) {
       it.Current()->UnuseAllInputs();
     }
   }
   UnuseAllInputs();
-  for (ForwardInstructionIterator it(this);
-       !it.Done();
-       it.Advance()) {
+  for (ForwardInstructionIterator it(this); !it.Done(); it.Advance()) {
     it.Current()->UnuseAllInputs();
   }
 }
 
 
 PhiInstr* JoinEntryInstr::InsertPhi(intptr_t var_index, intptr_t var_count) {
   // Lazily initialize the array of phis.
   // Currently, phis are stored in a sparse array that holds the phi
   // for variable with index i at position i.
   // TODO(fschneider): Store phis in a more compact way.
@@ skipping 100 matching lines @@
   return successor();
 }
 
 
 void Instruction::Goto(JoinEntryInstr* entry) {
   LinkTo(new GotoInstr(entry));
 }
 
 
 bool UnboxedIntConverterInstr::CanDeoptimize() const {
-  return (to() == kUnboxedInt32) &&
-      !is_truncating() &&
-      !RangeUtils::Fits(value()->definition()->range(),
-                        RangeBoundary::kRangeBoundaryInt32);
+  return (to() == kUnboxedInt32) && !is_truncating() &&
+         !RangeUtils::Fits(value()->definition()->range(),
+                           RangeBoundary::kRangeBoundaryInt32);
 }
 
 
 bool UnboxInt32Instr::CanDeoptimize() const {
   const intptr_t value_cid = value()->Type()->ToCid();
   if (value_cid == kSmiCid) {
-    return (kSmiBits > 32) &&
-        !is_truncating() &&
-        !RangeUtils::Fits(value()->definition()->range(),
-                          RangeBoundary::kRangeBoundaryInt32);
+    return (kSmiBits > 32) && !is_truncating() &&
+           !RangeUtils::Fits(value()->definition()->range(),
+                             RangeBoundary::kRangeBoundaryInt32);
   } else if (value_cid == kMintCid) {
     return !is_truncating() &&
-        !RangeUtils::Fits(value()->definition()->range(),
-                          RangeBoundary::kRangeBoundaryInt32);
+           !RangeUtils::Fits(value()->definition()->range(),
+                             RangeBoundary::kRangeBoundaryInt32);
   } else if (is_truncating() && value()->definition()->IsBoxInteger()) {
     return false;
   } else if ((kSmiBits < 32) && value()->Type()->IsInt()) {
     // Note: we don't support truncation of Bigint values.
     return !RangeUtils::Fits(value()->definition()->range(),
                              RangeBoundary::kRangeBoundaryInt32);
   } else {
     return true;
   }
 }
@@ skipping 16 matching lines @@
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       return false;
 
     case Token::kSHR:
       return false;
 
     case Token::kSHL:
       return can_overflow() ||
-          !RangeUtils::IsPositive(right()->definition()->range());
+             !RangeUtils::IsPositive(right()->definition()->range());
 
     case Token::kMOD: {
       UNREACHABLE();
     }
 
     default:
       return can_overflow();
   }
 }
 
 
 bool BinarySmiOpInstr::CanDeoptimize() const {
   switch (op_kind()) {
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR:
       return false;
 
     case Token::kSHR:
       return !RangeUtils::IsPositive(right()->definition()->range());
 
     case Token::kSHL:
       return can_overflow() ||
-          !RangeUtils::IsPositive(right()->definition()->range());
+             !RangeUtils::IsPositive(right()->definition()->range());
 
     case Token::kMOD: {
       Range* right_range = this->right()->definition()->range();
       return (right_range == NULL) || right_range->Overlaps(0, 0);
     }
     default:
       return can_overflow();
   }
 }
 
@@ skipping 17 matching lines @@
     case kUnboxedMint:
       return 64;
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
 
 static int64_t RepresentationMask(Representation r) {
-  return static_cast<int64_t>(
-      static_cast<uint64_t>(-1) >> (64 - RepresentationBits(r)));
+  return static_cast<int64_t>(static_cast<uint64_t>(-1) >>
+                              (64 - RepresentationBits(r)));
 }
 
 
 static bool ToIntegerConstant(Value* value, int64_t* result) {
   if (!value->BindsToConstant()) {
     UnboxInstr* unbox = value->definition()->AsUnbox();
     if (unbox != NULL) {
       switch (unbox->representation()) {
         case kUnboxedDouble:
         case kUnboxedMint:
@@ skipping 26 matching lines @@
     return true;
   } else if (constant.IsMint()) {
     *result = Mint::Cast(constant).value();
     return true;
   }
 
   return false;
 }
 
 
-static Definition* CanonicalizeCommutativeDoubleArithmetic(
-    Token::Kind op,
-    Value* left,
-    Value* right) {
+static Definition* CanonicalizeCommutativeDoubleArithmetic(Token::Kind op,
+                                                           Value* left,
+                                                           Value* right) {
   int64_t left_value;
   if (!ToIntegerConstant(left, &left_value)) {
     return NULL;
   }
 
   // Can't apply 0.0 * x -> 0.0 equivalence to double operation because
   // 0.0 * NaN is NaN not 0.0.
   // Can't apply 0.0 + x -> x to double because 0.0 + (-0.0) is 0.0 not -0.0.
   switch (op) {
     case Token::kMUL:
@@ skipping 15 matching lines @@
 
   return NULL;
 }
 
 
 Definition* DoubleToFloatInstr::Canonicalize(FlowGraph* flow_graph) {
 #ifdef DEBUG
   // Must only be used in Float32 StoreIndexedInstr or FloatToDoubleInstr or
   // Phis introduce by load forwarding.
   ASSERT(env_use_list() == NULL);
-  for (Value* use = input_use_list();
-       use != NULL;
-       use = use->next_use()) {
+  for (Value* use = input_use_list(); use != NULL; use = use->next_use()) {
     ASSERT(use->instruction()->IsPhi() ||
            use->instruction()->IsFloatToDouble() ||
            (use->instruction()->IsStoreIndexed() &&
             (use->instruction()->AsStoreIndexed()->class_id() ==
              kTypedDataFloat32ArrayCid)));
   }
 #endif
   if (!HasUses()) return NULL;
   if (value()->definition()->IsFloatToDouble()) {
     // F2D(D2F(v)) == v.
@@ skipping 18 matching lines @@
     return result;
   }
 
   result = CanonicalizeCommutativeDoubleArithmetic(op_kind(), right(), left());
   if (result != NULL) {
     return result;
   }
 
   if ((op_kind() == Token::kMUL) &&
       (left()->definition() == right()->definition())) {
-    MathUnaryInstr* math_unary =
-        new MathUnaryInstr(MathUnaryInstr::kDoubleSquare,
-                           new Value(left()->definition()),
-                           DeoptimizationTarget());
+    MathUnaryInstr* math_unary = new MathUnaryInstr(
+        MathUnaryInstr::kDoubleSquare, new Value(left()->definition()),
+        DeoptimizationTarget());
     flow_graph->InsertBefore(this, math_unary, env(), FlowGraph::kValue);
     return math_unary;
   }
 
   return this;
 }
 
 
 Definition* DoubleTestOpInstr::Canonicalize(FlowGraph* flow_graph) {
   return HasUses() ? this : NULL;
@@ skipping 125 matching lines @@
 }
 
 
 RawInteger* UnaryIntegerOpInstr::Evaluate(const Integer& value) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Integer& result = Integer::Handle(zone);
 
   switch (op_kind()) {
     case Token::kNEGATE:
-      result = value.ArithmeticOp(Token::kMUL,
-                                  Smi::Handle(zone, Smi::New(-1)),
+      result = value.ArithmeticOp(Token::kMUL, Smi::Handle(zone, Smi::New(-1)),
                                   Heap::kOld);
       break;
 
     case Token::kBIT_NOT:
       if (value.IsSmi()) {
         result = Integer::New(~Smi::Cast(value).Value());
       } else if (value.IsMint()) {
         result = Integer::New(~Mint::Cast(value).value());
       }
       break;
@@ skipping 23 matching lines @@
   Zone* zone = thread->zone();
   Integer& result = Integer::Handle(zone);
 
   switch (op_kind()) {
     case Token::kTRUNCDIV:
     case Token::kMOD:
       // Check right value for zero.
       if (right.IsSmi() && right.AsInt64Value() == 0) {
         break;  // Will throw.
       }
-      // Fall through.
+    // Fall through.
     case Token::kADD:
     case Token::kSUB:
     case Token::kMUL: {
       result = left.ArithmeticOp(op_kind(), right, Heap::kOld);
       break;
     }
     case Token::kSHL:
     case Token::kSHR:
       if (left.IsSmi() && right.IsSmi() && (Smi::Cast(right).Value() >= 0)) {
-        result = Smi::Cast(left).ShiftOp(op_kind(),
-                                         Smi::Cast(right),
-                                         Heap::kOld);
+        result =
+            Smi::Cast(left).ShiftOp(op_kind(), Smi::Cast(right), Heap::kOld);
       }
       break;
     case Token::kBIT_AND:
     case Token::kBIT_OR:
     case Token::kBIT_XOR: {
       result = left.BitOp(op_kind(), right, Heap::kOld);
       break;
     }
     case Token::kDIV:
       break;
@@ skipping 18 matching lines @@
   }
 
   return result.raw();
 }
 
 
 Definition* BinaryIntegerOpInstr::CreateConstantResult(FlowGraph* flow_graph,
                                                        const Integer& result) {
   Definition* result_defn = flow_graph->GetConstant(result);
   if (representation() != kTagged) {
-    result_defn = UnboxInstr::Create(representation(),
-                                     new Value(result_defn),
+    result_defn = UnboxInstr::Create(representation(), new Value(result_defn),
                                      GetDeoptId());
     flow_graph->InsertBefore(this, result_defn, env(), FlowGraph::kValue);
   }
   return result_defn;
 }
 
 
 Definition* CheckedSmiOpInstr::Canonicalize(FlowGraph* flow_graph) {
   if ((left()->Type()->ToCid() == kSmiCid) &&
       (right()->Type()->ToCid() == kSmiCid)) {
     Definition* replacement = NULL;
     // Operations that can't deoptimize are specialized here: These include
     // bit-wise operators and comparisons. Other arithmetic operations can
     // overflow or divide by 0 and can't be specialized unless we have extra
     // range information.
     switch (op_kind()) {
       case Token::kBIT_AND:
       case Token::kBIT_OR:
       case Token::kBIT_XOR:
-        replacement =
-            new BinarySmiOpInstr(op_kind(),
-                                 new Value(left()->definition()),
-                                 new Value(right()->definition()),
-                                 Thread::kNoDeoptId);
+        replacement = new BinarySmiOpInstr(
+            op_kind(), new Value(left()->definition()),
+            new Value(right()->definition()), Thread::kNoDeoptId);
       default:
         break;
     }
     if (replacement != NULL) {
       flow_graph->InsertBefore(this, replacement, env(), FlowGraph::kValue);
       return replacement;
     }
   }
   return this;
 }
 
 
-ComparisonInstr* CheckedSmiComparisonInstr::CopyWithNewOperands(
-    Value* left, Value* right) {
+ComparisonInstr* CheckedSmiComparisonInstr::CopyWithNewOperands(Value* left,
+                                                                Value* right) {
   UNREACHABLE();
   return NULL;
 }
 
 
 Definition* CheckedSmiComparisonInstr::Canonicalize(FlowGraph* flow_graph) {
   if ((left()->Type()->ToCid() == kSmiCid) &&
       (right()->Type()->ToCid() == kSmiCid)) {
     Definition* replacement = NULL;
     if (Token::IsRelationalOperator(kind())) {
-      replacement = new RelationalOpInstr(token_pos(), kind(),
-                                          new Value(left()->definition()),
-                                          new Value(right()->definition()),
-                                          kSmiCid,
-                                          Thread::kNoDeoptId);
+      replacement = new RelationalOpInstr(
+          token_pos(), kind(), new Value(left()->definition()),
+          new Value(right()->definition()), kSmiCid, Thread::kNoDeoptId);
     } else if (Token::IsEqualityOperator(kind())) {
-      replacement = new EqualityCompareInstr(token_pos(), kind(),
-                                             new Value(left()->definition()),
-                                             new Value(right()->definition()),
-                                             kSmiCid,
-                                             Thread::kNoDeoptId);
+      replacement = new EqualityCompareInstr(
+          token_pos(), kind(), new Value(left()->definition()),
+          new Value(right()->definition()), kSmiCid, Thread::kNoDeoptId);
     }
     if (replacement != NULL) {
       flow_graph->InsertBefore(this, replacement, env(), FlowGraph::kValue);
       return replacement;
     }
   }
   return this;
 }
 
 
 Definition* BinaryIntegerOpInstr::Canonicalize(FlowGraph* flow_graph) {
   // If both operands are constants evaluate this expression. Might
   // occur due to load forwarding after constant propagation pass
   // have already been run.
-  if (left()->BindsToConstant() &&
-      left()->BoundConstant().IsInteger() &&
-      right()->BindsToConstant() &&
-      right()->BoundConstant().IsInteger()) {
-    const Integer& result = Integer::Handle(
-        Evaluate(Integer::Cast(left()->BoundConstant()),
-                 Integer::Cast(right()->BoundConstant())));
+  if (left()->BindsToConstant() && left()->BoundConstant().IsInteger() &&
+      right()->BindsToConstant() && right()->BoundConstant().IsInteger()) {
+    const Integer& result =
+        Integer::Handle(Evaluate(Integer::Cast(left()->BoundConstant()),
+                                 Integer::Cast(right()->BoundConstant())));
     if (!result.IsNull()) {
       return CreateConstantResult(flow_graph, result);
     }
   }
 
-  if (left()->BindsToConstant() &&
-      !right()->BindsToConstant() &&
+  if (left()->BindsToConstant() && !right()->BindsToConstant() &&
       IsCommutative(op_kind())) {
     Value* l = left();
     Value* r = right();
     SetInputAt(0, r);
     SetInputAt(1, l);
   }
 
   int64_t rhs;
   if (!ToIntegerConstant(right(), &rhs)) {
     return this;
@@ skipping 17 matching lines @@
 
   switch (op_kind()) {
     case Token::kMUL:
       if (rhs == 1) {
         return left()->definition();
       } else if (rhs == 0) {
         return right()->definition();
       } else if (rhs == 2) {
         ConstantInstr* constant_1 =
             flow_graph->GetConstant(Smi::Handle(Smi::New(1)));
-        BinaryIntegerOpInstr* shift =
-            BinaryIntegerOpInstr::Make(representation(),
-                                       Token::kSHL,
-                                       left()->CopyWithType(),
-                                       new Value(constant_1),
-                                       GetDeoptId(),
-                                       can_overflow(),
-                                       is_truncating(),
-                                       range());
+        BinaryIntegerOpInstr* shift = BinaryIntegerOpInstr::Make(
+            representation(), Token::kSHL, left()->CopyWithType(),
+            new Value(constant_1), GetDeoptId(), can_overflow(),
+            is_truncating(), range());
         if (shift != NULL) {
           flow_graph->InsertBefore(this, shift, env(), FlowGraph::kValue);
           return shift;
         }
       }
 
       break;
     case Token::kADD:
       if (rhs == 0) {
         return left()->definition();
@@ skipping 10 matching lines @@
       if (rhs == 0) {
         return left()->definition();
       } else if (rhs == range_mask) {
         return right()->definition();
       }
       break;
     case Token::kBIT_XOR:
       if (rhs == 0) {
         return left()->definition();
       } else if (rhs == range_mask) {
-        UnaryIntegerOpInstr* bit_not =
-            UnaryIntegerOpInstr::Make(representation(),
-                                      Token::kBIT_NOT,
-                                      left()->CopyWithType(),
-                                      GetDeoptId(),
-                                      range());
+        UnaryIntegerOpInstr* bit_not = UnaryIntegerOpInstr::Make(
+            representation(), Token::kBIT_NOT, left()->CopyWithType(),
+            GetDeoptId(), range());
         if (bit_not != NULL) {
           flow_graph->InsertBefore(this, bit_not, env(), FlowGraph::kValue);
           return bit_not;
         }
       }
       break;
 
     case Token::kSUB:
       if (rhs == 0) {
         return left()->definition();
       }
       break;
 
     case Token::kTRUNCDIV:
       if (rhs == 1) {
         return left()->definition();
       } else if (rhs == -1) {
-        UnaryIntegerOpInstr* negation =
-            UnaryIntegerOpInstr::Make(representation(),
-                                      Token::kNEGATE,
-                                      left()->CopyWithType(),
-                                      GetDeoptId(),
-                                      range());
+        UnaryIntegerOpInstr* negation = UnaryIntegerOpInstr::Make(
+            representation(), Token::kNEGATE, left()->CopyWithType(),
+            GetDeoptId(), range());
         if (negation != NULL) {
           flow_graph->InsertBefore(this, negation, env(), FlowGraph::kValue);
           return negation;
         }
       }
       break;
 
     case Token::kSHR:
       if (rhs == 0) {
         return left()->definition();
@@ skipping 153 matching lines @@
       value()->Type()->IsAssignableTo(dst_type())) {
     return value()->definition();
   }
 
   // For uninstantiated target types: If the instantiator type arguments
   // are constant, instantiate the target type here.
   if (dst_type().IsInstantiated()) return this;
 
   ConstantInstr* constant_type_args =
       instantiator_type_arguments()->definition()->AsConstant();
-  if (constant_type_args != NULL &&
-      !constant_type_args->value().IsNull() &&
+  if (constant_type_args != NULL && !constant_type_args->value().IsNull() &&
       constant_type_args->value().IsTypeArguments()) {
     const TypeArguments& instantiator_type_args =
         TypeArguments::Cast(constant_type_args->value());
     Error& bound_error = Error::Handle();
-    AbstractType& new_dst_type = AbstractType::Handle(
-        dst_type().InstantiateFrom(
+    AbstractType& new_dst_type =
+        AbstractType::Handle(dst_type().InstantiateFrom(
             instantiator_type_args, &bound_error, NULL, NULL, Heap::kOld));
     if (new_dst_type.IsMalformedOrMalbounded() || !bound_error.IsNull()) {
       return this;
     }
     if (new_dst_type.IsTypeRef()) {
       new_dst_type = TypeRef::Cast(new_dst_type).type();
     }
     new_dst_type = new_dst_type.Canonicalize();
     set_dst_type(new_dst_type);
 
-    if (new_dst_type.IsDynamicType() ||
-        new_dst_type.IsObjectType() ||
+    if (new_dst_type.IsDynamicType() || new_dst_type.IsObjectType() ||
         (FLAG_eliminate_type_checks &&
          value()->Type()->IsAssignableTo(new_dst_type))) {
       return value()->definition();
     }
 
     ConstantInstr* null_constant = flow_graph->constant_null();
     instantiator_type_arguments()->BindTo(null_constant);
   }
   return this;
 }
 
 
 Definition* InstantiateTypeArgumentsInstr::Canonicalize(FlowGraph* flow_graph) {
   return (Isolate::Current()->type_checks() || HasUses()) ? this : NULL;
 }
 
 
 LocationSummary* DebugStepCheckInstr::MakeLocationSummary(Zone* zone,
                                                           bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 0;
-  LocationSummary* locs = new(zone) LocationSummary(
-      zone, kNumInputs, kNumTemps, LocationSummary::kCall);
+  LocationSummary* locs = new (zone)
+      LocationSummary(zone, kNumInputs, kNumTemps, LocationSummary::kCall);
   return locs;
 }
 
 
 Instruction* DebugStepCheckInstr::Canonicalize(FlowGraph* flow_graph) {
   return NULL;
 }
 
 
 static bool HasTryBlockUse(Value* use_list) {
@@ skipping 60 matching lines @@
         break;
       case kUnboxedUint32:
         replacement = new BoxUint32Instr(conv->value()->CopyWithType());
         break;
       default:
         UNREACHABLE();
         break;
     }
 
     if (replacement != this) {
-      flow_graph->InsertBefore(this,
-                               replacement,
-                               NULL,
-                               FlowGraph::kValue);
+      flow_graph->InsertBefore(this, replacement, NULL, FlowGraph::kValue);
     }
 
     return replacement;
   }
 
   return this;
 }
 
 
 Definition* UnboxInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!HasUses() && !CanDeoptimize()) return NULL;
 
   // Fold away Unbox<rep>(Box<rep>(v)).
   BoxInstr* box_defn = value()->definition()->AsBox();
   if ((box_defn != NULL) &&
       (box_defn->from_representation() == representation())) {
     return box_defn->value()->definition();
   }
 
   if ((representation() == kUnboxedDouble) && value()->BindsToConstant()) {
     UnboxedConstantInstr* uc = NULL;
 
     const Object& val = value()->BoundConstant();
     if (val.IsSmi()) {
-      const Double& double_val = Double::ZoneHandle(flow_graph->zone(),
+      const Double& double_val = Double::ZoneHandle(
+          flow_graph->zone(),
           Double::NewCanonical(Smi::Cast(val).AsDoubleValue()));
       uc = new UnboxedConstantInstr(double_val, kUnboxedDouble);
     } else if (val.IsDouble()) {
       uc = new UnboxedConstantInstr(val, kUnboxedDouble);
     }
 
     if (uc != NULL) {
       flow_graph->InsertBefore(this, uc, NULL, FlowGraph::kValue);
       return uc;
     }
   }
 
   return this;
 }
 
 
 Definition* UnboxIntegerInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!HasUses() && !CanDeoptimize()) return NULL;
 
   // Fold away UnboxInteger<rep_to>(BoxInteger<rep_from>(v)).
   BoxIntegerInstr* box_defn = value()->definition()->AsBoxInteger();
   if (box_defn != NULL) {
     Representation from_representation =
         box_defn->value()->definition()->representation();
     if (from_representation == representation()) {
       return box_defn->value()->definition();
     } else {
       UnboxedIntConverterInstr* converter = new UnboxedIntConverterInstr(
-          from_representation,
-          representation(),
+          from_representation, representation(),
           box_defn->value()->CopyWithType(),
-          (representation() == kUnboxedInt32) ?
-              GetDeoptId() : Thread::kNoDeoptId);
+          (representation() == kUnboxedInt32) ? GetDeoptId()
+                                              : Thread::kNoDeoptId);
       // TODO(vegorov): marking resulting converter as truncating when
       // unboxing can't deoptimize is a workaround for the missing
       // deoptimization environment when we insert converter after
       // EliminateEnvironments and there is a mismatch between predicates
       // UnboxIntConverterInstr::CanDeoptimize and UnboxInt32::CanDeoptimize.
       if ((representation() == kUnboxedInt32) &&
           (is_truncating() || !CanDeoptimize())) {
         converter->mark_truncating();
       }
       flow_graph->InsertBefore(this, converter, env(), FlowGraph::kValue);
       return converter;
     }
   }
 
   return this;
 }
 
 
 Definition* UnboxInt32Instr::Canonicalize(FlowGraph* flow_graph) {
   Definition* replacement = UnboxIntegerInstr::Canonicalize(flow_graph);
   if (replacement != this) {
     return replacement;
   }
 
   ConstantInstr* c = value()->definition()->AsConstant();
   if ((c != NULL) && c->value().IsSmi()) {
     if (!is_truncating() && (kSmiBits > 32)) {
       // Check that constant fits into 32-bit integer.
-      const int64_t value =
-          static_cast<int64_t>(Smi::Cast(c->value()).Value());
+      const int64_t value = static_cast<int64_t>(Smi::Cast(c->value()).Value());
       if (!Utils::IsInt(32, value)) {
         return this;
       }
     }
 
     UnboxedConstantInstr* uc =
         new UnboxedConstantInstr(c->value(), kUnboxedInt32);
     if (c->range() != NULL) {
       uc->set_range(*c->range());
     }
     flow_graph->InsertBefore(this, uc, NULL, FlowGraph::kValue);
     return uc;
   }
 
   return this;
 }
 
 
 Definition* UnboxedIntConverterInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!HasUses()) return NULL;
 
   UnboxedIntConverterInstr* box_defn =
       value()->definition()->AsUnboxedIntConverter();
   if ((box_defn != NULL) && (box_defn->representation() == from())) {
     if (box_defn->from() == to()) {
       return box_defn->value()->definition();
     }
 
     UnboxedIntConverterInstr* converter = new UnboxedIntConverterInstr(
-        box_defn->from(),
-        representation(),
-        box_defn->value()->CopyWithType(),
+        box_defn->from(), representation(), box_defn->value()->CopyWithType(),
         (to() == kUnboxedInt32) ? GetDeoptId() : Thread::kNoDeoptId);
     if ((representation() == kUnboxedInt32) && is_truncating()) {
       converter->mark_truncating();
     }
     flow_graph->InsertBefore(this, converter, env(), FlowGraph::kValue);
     return converter;
   }
 
   UnboxInt64Instr* unbox_defn = value()->definition()->AsUnboxInt64();
-  if (unbox_defn != NULL &&
-      (from() == kUnboxedMint) &&
-      (to() == kUnboxedInt32) &&
-      unbox_defn->HasOnlyInputUse(value())) {
+  if (unbox_defn != NULL && (from() == kUnboxedMint) &&
+      (to() == kUnboxedInt32) && unbox_defn->HasOnlyInputUse(value())) {
     // TODO(vegorov): there is a duplication of code between UnboxedIntCoverter
     // and code path that unboxes Mint into Int32. We should just schedule
     // these instructions close to each other instead of fusing them.
     Definition* replacement =
         new UnboxInt32Instr(is_truncating() ? UnboxInt32Instr::kTruncate
                                             : UnboxInt32Instr::kNoTruncation,
-                            unbox_defn->value()->CopyWithType(),
-                            GetDeoptId());
-    flow_graph->InsertBefore(this,
-                             replacement,
-                             env(),
-                             FlowGraph::kValue);
+                            unbox_defn->value()->CopyWithType(), GetDeoptId());
+    flow_graph->InsertBefore(this, replacement, env(), FlowGraph::kValue);
     return replacement;
   }
 
   return this;
 }
 
 
 Definition* BooleanNegateInstr::Canonicalize(FlowGraph* flow_graph) {
   Definition* defn = value()->definition();
-  if (defn->IsComparison() &&
-      defn->HasOnlyUse(value()) &&
+  if (defn->IsComparison() && defn->HasOnlyUse(value()) &&
       defn->Type()->ToCid() == kBoolCid) {
     defn->AsComparison()->NegateComparison();
     return defn;
   }
   return this;
 }
 
 
 static bool MayBeBoxableNumber(intptr_t cid) {
-  return (cid == kDynamicCid) ||
-         (cid == kMintCid) ||
-         (cid == kBigintCid) ||
+  return (cid == kDynamicCid) || (cid == kMintCid) || (cid == kBigintCid) ||
          (cid == kDoubleCid);
 }
 
 
 static bool MaybeNumber(CompileType* type) {
-  ASSERT(Type::Handle(Type::Number()).IsMoreSpecificThan(
-             Type::Handle(Type::Number()), NULL, NULL, Heap::kOld));
-  return type->ToAbstractType()->IsDynamicType()
-      || type->ToAbstractType()->IsObjectType()
-      || type->ToAbstractType()->IsTypeParameter()
-      || type->IsMoreSpecificThan(Type::Handle(Type::Number()));
+  ASSERT(Type::Handle(Type::Number())
+             .IsMoreSpecificThan(Type::Handle(Type::Number()), NULL, NULL,
+                                 Heap::kOld));
+  return type->ToAbstractType()->IsDynamicType() ||
+         type->ToAbstractType()->IsObjectType() ||
+         type->ToAbstractType()->IsTypeParameter() ||
+         type->IsMoreSpecificThan(Type::Handle(Type::Number()));
 }
 
 
 // Returns a replacement for a strict comparison and signals if the result has
 // to be negated.
 static Definition* CanonicalizeStrictCompare(StrictCompareInstr* compare,
                                              bool* negated,
                                              bool is_branch) {
   // Use propagated cid and type information to eliminate number checks.
   // If one of the inputs is not a boxable number (Mint, Double, Bigint), or
   // is not a subtype of num, no need for number checks.
   if (compare->needs_number_check()) {
     if (!MayBeBoxableNumber(compare->left()->Type()->ToCid()) ||
-        !MayBeBoxableNumber(compare->right()->Type()->ToCid()))  {
+        !MayBeBoxableNumber(compare->right()->Type()->ToCid())) {
       compare->set_needs_number_check(false);
     } else if (!MaybeNumber(compare->left()->Type()) ||
                !MaybeNumber(compare->right()->Type())) {
       compare->set_needs_number_check(false);
     }
   }
   *negated = false;
   PassiveObject& constant = PassiveObject::Handle();
   Value* other = NULL;
   if (compare->right()->BindsToConstant()) {
     constant = compare->right()->BoundConstant().raw();
     other = compare->left();
   } else if (compare->left()->BindsToConstant()) {
     constant = compare->left()->BoundConstant().raw();
     other = compare->right();
   } else {
     return compare;
   }
 
   const bool can_merge = is_branch || (other->Type()->ToCid() == kBoolCid);
   Definition* other_defn = other->definition();
   Token::Kind kind = compare->kind();
   // Handle e === true.
-  if ((kind == Token::kEQ_STRICT) &&
-      (constant.raw() == Bool::True().raw()) &&
+  if ((kind == Token::kEQ_STRICT) && (constant.raw() == Bool::True().raw()) &&
       can_merge) {
     return other_defn;
   }
   // Handle e !== false.
-  if ((kind == Token::kNE_STRICT) &&
-      (constant.raw() == Bool::False().raw()) &&
+  if ((kind == Token::kNE_STRICT) && (constant.raw() == Bool::False().raw()) &&
       can_merge) {
     return other_defn;
   }
   // Handle e !== true.
-  if ((kind == Token::kNE_STRICT) &&
-      (constant.raw() == Bool::True().raw()) &&
-      other_defn->IsComparison() &&
-      can_merge &&
+  if ((kind == Token::kNE_STRICT) && (constant.raw() == Bool::True().raw()) &&
+      other_defn->IsComparison() && can_merge &&
       other_defn->HasOnlyUse(other)) {
     *negated = true;
     return other_defn;
   }
   // Handle e === false.
-  if ((kind == Token::kEQ_STRICT) &&
-      (constant.raw() == Bool::False().raw()) &&
-      other_defn->IsComparison() &&
-      can_merge &&
+  if ((kind == Token::kEQ_STRICT) && (constant.raw() == Bool::False().raw()) &&
+      other_defn->IsComparison() && can_merge &&
       other_defn->HasOnlyUse(other)) {
     *negated = true;
     return other_defn;
   }
   return compare;
 }
 
 
 static bool BindsToGivenConstant(Value* v, intptr_t expected) {
-  return v->BindsToConstant() &&
-      v->BoundConstant().IsSmi() &&
-      (Smi::Cast(v->BoundConstant()).Value() == expected);
+  return v->BindsToConstant() && v->BoundConstant().IsSmi() &&
+         (Smi::Cast(v->BoundConstant()).Value() == expected);
 }
 
 
 // Recognize patterns (a & b) == 0 and (a & 2^n) != 2^n.
 static bool RecognizeTestPattern(Value* left, Value* right, bool* negate) {
   if (!right->BindsToConstant() || !right->BoundConstant().IsSmi()) {
     return false;
   }
 
   const intptr_t value = Smi::Cast(right->BoundConstant()).Value();
   if ((value != 0) && !Utils::IsPowerOfTwo(value)) {
     return false;
   }
 
 
   BinarySmiOpInstr* mask_op = left->definition()->AsBinarySmiOp();
-  if ((mask_op == NULL) ||
-      (mask_op->op_kind() != Token::kBIT_AND) ||
+  if ((mask_op == NULL) || (mask_op->op_kind() != Token::kBIT_AND) ||
       !mask_op->HasOnlyUse(left)) {
     return false;
   }
 
   if (value == 0) {
     // Recognized (a & b) == 0 pattern.
     *negate = false;
     return true;
   }
 
   // Recognize
   if (BindsToGivenConstant(mask_op->left(), value) ||
       BindsToGivenConstant(mask_op->right(), value)) {
     // Recognized (a & 2^n) == 2^n pattern. It's equivalent to (a & 2^n) != 0
     // so we need to negate original comparison.
     *negate = true;
     return true;
   }
 
   return false;
 }
 
 
 Instruction* BranchInstr::Canonicalize(FlowGraph* flow_graph) {
   Zone* zone = flow_graph->zone();
   // Only handle strict-compares.
   if (comparison()->IsStrictCompare()) {
     bool negated = false;
-    Definition* replacement =
-        CanonicalizeStrictCompare(comparison()->AsStrictCompare(),
-                                  &negated, /* is_branch = */ true);
+    Definition* replacement = CanonicalizeStrictCompare(
+        comparison()->AsStrictCompare(), &negated, /* is_branch = */ true);
     if (replacement == comparison()) {
       return this;
     }
     ComparisonInstr* comp = replacement->AsComparison();
-    if ((comp == NULL) ||
-        comp->CanDeoptimize() ||
+    if ((comp == NULL) || comp->CanDeoptimize() ||
         comp->HasUnmatchedInputRepresentations()) {
       return this;
     }
 
     // Replace the comparison if the replacement is used at this branch,
     // and has exactly one use.
     Value* use = comp->input_use_list();
     if ((use->instruction() == this) && comp->HasOnlyUse(use)) {
       if (negated) {
         comp->NegateComparison();
@@ skipping 12 matching lines @@
       // Clear the comparison's temp index and ssa temp index since the
       // value of the comparison is not used outside the branch anymore.
       ASSERT(comp->input_use_list() == NULL);
       comp->ClearSSATempIndex();
       comp->ClearTempIndex();
     }
   } else if (comparison()->IsEqualityCompare() &&
              comparison()->operation_cid() == kSmiCid) {
     BinarySmiOpInstr* bit_and = NULL;
     bool negate = false;
-    if (RecognizeTestPattern(comparison()->left(),
-                             comparison()->right(),
+    if (RecognizeTestPattern(comparison()->left(), comparison()->right(),
                              &negate)) {
       bit_and = comparison()->left()->definition()->AsBinarySmiOp();
-    } else if (RecognizeTestPattern(comparison()->right(),
-                                    comparison()->left(),
+    } else if (RecognizeTestPattern(comparison()->right(), comparison()->left(),
                                     &negate)) {
       bit_and = comparison()->right()->definition()->AsBinarySmiOp();
     }
     if (bit_and != NULL) {
       if (FLAG_trace_optimization) {
         OS::Print("Merging test smi v%" Pd "\n", bit_and->ssa_temp_index());
       }
       TestSmiInstr* test = new TestSmiInstr(
           comparison()->token_pos(),
           negate ? Token::NegateComparison(comparison()->kind())
                  : comparison()->kind(),
-          bit_and->left()->Copy(zone),
-          bit_and->right()->Copy(zone));
+          bit_and->left()->Copy(zone), bit_and->right()->Copy(zone));
       ASSERT(!CanDeoptimize());
       RemoveEnvironment();
       flow_graph->CopyDeoptTarget(this, bit_and);
       SetComparison(test);
       bit_and->RemoveFromGraph();
     }
   }
   return this;
 }
 
@@ skipping 17 matching lines @@
     return this;
   }
 
   return unary_checks().HasReceiverClassId(value_cid) ? NULL : this;
 }
 
 
 Instruction* CheckClassIdInstr::Canonicalize(FlowGraph* flow_graph) {
   if (value()->BindsToConstant()) {
     const Object& constant_value = value()->BoundConstant();
-    if (constant_value.IsSmi() &&
-        Smi::Cast(constant_value).Value() == cid_) {
+    if (constant_value.IsSmi() && Smi::Cast(constant_value).Value() == cid_) {
       return NULL;
     }
   }
   return this;
 }
 
 
 Definition* TestCidsInstr::Canonicalize(FlowGraph* flow_graph) {
   CompileType* in_type = left()->Type();
   intptr_t cid = in_type->ToCid();
   if (cid == kDynamicCid) return this;
 
   const ZoneGrowableArray<intptr_t>& data = cid_results();
   const intptr_t true_result = (kind() == Token::kIS) ? 1 : 0;
   for (intptr_t i = 0; i < data.length(); i += 2) {
     if (data[i] == cid) {
       return (data[i + 1] == true_result)
-          ? flow_graph->GetConstant(Bool::True())
-          : flow_graph->GetConstant(Bool::False());
+                 ? flow_graph->GetConstant(Bool::True())
+                 : flow_graph->GetConstant(Bool::False());
     }
   }
 
   // TODO(sra): Handle misses if the instruction is not deoptimizing.
   // TODO(sra): Handle nullable input, possibly canonicalizing to a compare
   // against `null`.
   return this;
 }
 
 
@@ skipping 30 matching lines @@
   StaticCallInstr* call = value()->definition()->AsStaticCall();
   if (call == NULL) {
     return this;
   }
 
   ConstantInstr* length = NULL;
   if (call->is_known_list_constructor() &&
       LoadFieldInstr::IsFixedLengthArrayCid(call->Type()->ToCid())) {
     length = call->ArgumentAt(1)->AsConstant();
   }
-  if ((length != NULL) &&
-      length->value().IsSmi() &&
+  if ((length != NULL) && length->value().IsSmi() &&
       Smi::Cast(length->value()).Value() == expected_length) {
     return NULL;  // Expected length matched.
   }
 
   return this;
 }
 
 
 Instruction* CheckSmiInstr::Canonicalize(FlowGraph* flow_graph) {
-  return (value()->Type()->ToCid() == kSmiCid) ?  NULL : this;
+  return (value()->Type()->ToCid() == kSmiCid) ? NULL : this;
 }
 
 
 Instruction* CheckEitherNonSmiInstr::Canonicalize(FlowGraph* flow_graph) {
   if ((left()->Type()->ToCid() == kDoubleCid) ||
       (right()->Type()->ToCid() == kDoubleCid)) {
     return NULL;  // Remove from the graph.
   }
   return this;
 }
@@ skipping 21 matching lines @@
       return NULL;
   }
 }
 
 
 UnboxInstr* UnboxInstr::Create(Representation to,
                                Value* value,
                                intptr_t deopt_id) {
   switch (to) {
     case kUnboxedInt32:
-      return new UnboxInt32Instr(
-          UnboxInt32Instr::kNoTruncation, value, deopt_id);
+      return new UnboxInt32Instr(UnboxInt32Instr::kNoTruncation, value,
+                                 deopt_id);
 
     case kUnboxedUint32:
       return new UnboxUint32Instr(value, deopt_id);
 
     case kUnboxedMint:
       return new UnboxInt64Instr(value, deopt_id);
 
     case kUnboxedDouble:
     case kUnboxedFloat32x4:
     case kUnboxedFloat64x2:
@@ skipping 42 matching lines @@
 LocationSummary* JoinEntryInstr::MakeLocationSummary(Zone* zone,
                                                      bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void JoinEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
-    compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
-                                   GetDeoptId(),
+    compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt, GetDeoptId(),
                                    TokenPosition::kNoSource);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
 LocationSummary* TargetEntryInstr::MakeLocationSummary(Zone* zone,
                                                        bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void TargetEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   __ Bind(compiler->GetJumpLabel(this));
   if (!compiler->is_optimizing()) {
 #if !defined(TARGET_ARCH_DBC)
     // TODO(vegorov) re-enable edge counters on DBC if we consider them
     // beneficial for the quality of the optimized bytecode.
     if (compiler->NeedsEdgeCounter(this)) {
       compiler->EmitEdgeCounter(preorder_number());
     }
 #endif
 
     // The deoptimization descriptor points after the edge counter code for
     // uniformity with ARM and MIPS, where we can reuse pattern matching
     // code that matches backwards from the end of the pattern.
-    compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt,
-                                   GetDeoptId(),
+    compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt, GetDeoptId(),
                                    TokenPosition::kNoSource);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 }
 
 
 void IndirectGotoInstr::ComputeOffsetTable() {
   if (GetBlock()->offset() < 0) {
@@ skipping 23 matching lines @@
       offset = ientry->offset();
     }
 
     ASSERT(offset > 0);
     offsets_.SetInt32(i * element_size, offset);
   }
 }
 
 
 LocationSummary* IndirectEntryInstr::MakeLocationSummary(
-    Zone* zone, bool optimizing) const {
+    Zone* zone,
+    bool optimizing) const {
   return JoinEntryInstr::MakeLocationSummary(zone, optimizing);
 }
 
 
 void IndirectEntryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   JoinEntryInstr::EmitNativeCode(compiler);
 }
 
 
 LocationSummary* PhiInstr::MakeLocationSummary(Zone* zone,
@@ skipping 59 matching lines @@
   return NULL;
 }
 
 
 void ConstraintInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
 LocationSummary* MaterializeObjectInstr::MakeLocationSummary(
-    Zone* zone, bool optimizing) const {
+    Zone* zone,
+    bool optimizing) const {
   UNREACHABLE();
   return NULL;
 }
 
 
 void MaterializeObjectInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNREACHABLE();
 }
 
 
@@ skipping 23 matching lines @@
 
 void CurrentContextInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   // Only appears in initial definitions, never in normal code.
   UNREACHABLE();
 }
 
 
 LocationSummary* DropTempsInstr::MakeLocationSummary(Zone* zone,
                                                      bool optimizing) const {
   return (InputCount() == 1)
-      ? LocationSummary::Make(zone,
-                              1,
-                              Location::SameAsFirstInput(),
-                              LocationSummary::kNoCall)
-      : LocationSummary::Make(zone,
-                              0,
-                              Location::NoLocation(),
-                              LocationSummary::kNoCall);
+             ? LocationSummary::Make(zone, 1, Location::SameAsFirstInput(),
+                                     LocationSummary::kNoCall)
+             : LocationSummary::Make(zone, 0, Location::NoLocation(),
+                                     LocationSummary::kNoCall);
 }
 
 
 void DropTempsInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
 #if defined(TARGET_ARCH_DBC)
   // On DBC the action of poping the TOS value and then pushing it
   // after all intermediates are poped is folded into a special
   // bytecode (DropR). On other architectures this is handled by
   // instruction prologue/epilogues.
   ASSERT(!compiler->is_optimizing());
   if ((InputCount() != 0) && HasTemp()) {
     __ DropR(num_temps());
   } else {
     __ Drop(num_temps() + ((InputCount() != 0) ? 1 : 0));
   }
 #else
   ASSERT(!compiler->is_optimizing());
   // Assert that register assignment is correct.
   ASSERT((InputCount() == 0) || (locs()->out(0).reg() == locs()->in(0).reg()));
   __ Drop(num_temps());
 #endif  // defined(TARGET_ARCH_DBC)
 }
 
 
 StrictCompareInstr::StrictCompareInstr(TokenPosition token_pos,
                                        Token::Kind kind,
                                        Value* left,
                                        Value* right,
                                        bool needs_number_check)
-    : TemplateComparison(token_pos,
-                         kind,
-                         Thread::Current()->GetNextDeoptId()),
+    : TemplateComparison(token_pos, kind, Thread::Current()->GetNextDeoptId()),
       needs_number_check_(needs_number_check) {
   ASSERT((kind == Token::kEQ_STRICT) || (kind == Token::kNE_STRICT));
   SetInputAt(0, left);
   SetInputAt(1, right);
 }
 
 
 LocationSummary* InstanceCallInstr::MakeLocationSummary(Zone* zone,
                                                         bool optimizing) const {
   return MakeCallSummary(zone);
 }
 
 
 // DBC does not use specialized inline cache stubs for smi operations.
 #if !defined(TARGET_ARCH_DBC)
 static const StubEntry* TwoArgsSmiOpInlineCacheEntry(Token::Kind kind) {
   if (!FLAG_two_args_smi_icd) {
     return 0;
   }
   switch (kind) {
-    case Token::kADD: return StubCode::SmiAddInlineCache_entry();
-    case Token::kSUB: return StubCode::SmiSubInlineCache_entry();
-    case Token::kEQ:  return StubCode::SmiEqualInlineCache_entry();
-    default:          return NULL;
+    case Token::kADD:
+      return StubCode::SmiAddInlineCache_entry();
+    case Token::kSUB:
+      return StubCode::SmiSubInlineCache_entry();
+    case Token::kEQ:
+      return StubCode::SmiEqualInlineCache_entry();
+    default:
+      return NULL;
   }
 }
 #else
-static void TryFastPathSmiOp(
-    FlowGraphCompiler* compiler, ICData* call_ic_data, const String& name) {
+static void TryFastPathSmiOp(FlowGraphCompiler* compiler,
+                             ICData* call_ic_data,
+                             const String& name) {
   if (!FLAG_two_args_smi_icd) {
     return;
   }
   if (name.raw() == Symbols::Plus().raw()) {
     if (call_ic_data->AddSmiSmiCheckForFastSmiStubs()) {
       __ AddTOS();
     }
   } else if (name.raw() == Symbols::Minus().raw()) {
     if (call_ic_data->AddSmiSmiCheckForFastSmiStubs()) {
       __ SubTOS();
     }
   } else if (name.raw() == Symbols::EqualOperator().raw()) {
     if (call_ic_data->AddSmiSmiCheckForFastSmiStubs()) {
       __ EqualTOS();
     }
   } else if (name.raw() == Symbols::LAngleBracket().raw()) {
     if (call_ic_data->AddSmiSmiCheckForFastSmiStubs()) {
-     __ LessThanTOS();
+      __ LessThanTOS();
     }
   } else if (name.raw() == Symbols::RAngleBracket().raw()) {
     if (call_ic_data->AddSmiSmiCheckForFastSmiStubs()) {
       __ GreaterThanTOS();
     }
   } else if (name.raw() == Symbols::BitAnd().raw()) {
     if (call_ic_data->AddSmiSmiCheckForFastSmiStubs()) {
       __ BitAndTOS();
     }
   } else if (name.raw() == Symbols::BitOr().raw()) {
     if (call_ic_data->AddSmiSmiCheckForFastSmiStubs()) {
       __ BitOrTOS();
     }
   } else if (name.raw() == Symbols::Star().raw()) {
     if (call_ic_data->AddSmiSmiCheckForFastSmiStubs()) {
       __ MulTOS();
     }
   }
 }
 #endif
 
 
 void InstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Zone* zone = compiler->zone();
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing() ||
       (ic_data() == NULL)) {
-    const Array& arguments_descriptor =
-        Array::Handle(zone, ArgumentsDescriptor::New(ArgumentCount(),
-                                                     argument_names()));
+    const Array& arguments_descriptor = Array::Handle(
+        zone, ArgumentsDescriptor::New(ArgumentCount(), argument_names()));
     call_ic_data = compiler->GetOrAddInstanceCallICData(
         deopt_id(), function_name(), arguments_descriptor,
         checked_argument_count());
   } else {
     call_ic_data = &ICData::ZoneHandle(zone, ic_data()->raw());
   }
 
 #if !defined(TARGET_ARCH_DBC)
   if (compiler->is_optimizing() && HasICData()) {
     ASSERT(HasICData());
     if (ic_data()->NumberOfUsedChecks() > 0) {
       const ICData& unary_ic_data =
           ICData::ZoneHandle(zone, ic_data()->AsUnaryClassChecks());
-      compiler->GenerateInstanceCall(deopt_id(),
-                                     token_pos(),
-                                     ArgumentCount(),
-                                     locs(),
-                                     unary_ic_data);
+      compiler->GenerateInstanceCall(deopt_id(), token_pos(), ArgumentCount(),
+                                     locs(), unary_ic_data);
     } else {
       // Call was not visited yet, use original ICData in order to populate it.
-      compiler->GenerateInstanceCall(deopt_id(),
-                                     token_pos(),
-                                     ArgumentCount(),
-                                     locs(),
-                                     *call_ic_data);
+      compiler->GenerateInstanceCall(deopt_id(), token_pos(), ArgumentCount(),
+                                     locs(), *call_ic_data);
     }
   } else {
     // Unoptimized code.
     ASSERT(!HasICData());
     bool is_smi_two_args_op = false;
     const StubEntry* stub_entry = TwoArgsSmiOpInlineCacheEntry(token_kind());
     if (stub_entry != NULL) {
       // We have a dedicated inline cache stub for this operation, add an
       // an initial Smi/Smi check with count 0.
       is_smi_two_args_op = call_ic_data->AddSmiSmiCheckForFastSmiStubs();
     }
     if (is_smi_two_args_op) {
       ASSERT(ArgumentCount() == 2);
       compiler->EmitInstanceCall(*stub_entry, *call_ic_data, ArgumentCount(),
                                  deopt_id(), token_pos(), locs());
     } else {
-      compiler->GenerateInstanceCall(deopt_id(),
-                                     token_pos(),
-                                     ArgumentCount(),
-                                     locs(),
-                                     *call_ic_data);
+      compiler->GenerateInstanceCall(deopt_id(), token_pos(), ArgumentCount(),
+                                     locs(), *call_ic_data);
     }
   }
 #else
   ICData* original_ic_data = &ICData::ZoneHandle(call_ic_data->Original());
 
   // Emit smi fast path instruction. If fast-path succeeds it skips the next
   // instruction otherwise it falls through. Only attempt in unoptimized code
   // because TryFastPathSmiOp will update original_ic_data.
   if (!compiler->is_optimizing()) {
     TryFastPathSmiOp(compiler, original_ic_data, function_name());
@@ skipping 12 matching lines @@
       if (compiler->is_optimizing()) {
         __ InstanceCall2Opt(ArgumentCount(), call_ic_data_kidx);
       } else {
         __ InstanceCall2(ArgumentCount(), call_ic_data_kidx);
       }
       break;
     default:
       UNIMPLEMENTED();
       break;
   }
-  compiler->AddCurrentDescriptor(RawPcDescriptors::kIcCall,
-                                 deopt_id(),
+  compiler->AddCurrentDescriptor(RawPcDescriptors::kIcCall, deopt_id(),
                                  token_pos());
   compiler->RecordAfterCall(this);
 
   if (compiler->is_optimizing()) {
     __ PopLocal(locs()->out(0).reg());
   }
 #endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 bool PolymorphicInstanceCallInstr::HasSingleRecognizedTarget() const {
   if (FLAG_precompiled_mode && with_checks()) return false;
 
   return ic_data().HasOneTarget() &&
-      (MethodRecognizer::RecognizeKind(
-          Function::Handle(ic_data().GetTargetAt(0))) !=
-       MethodRecognizer::kUnknown);
+         (MethodRecognizer::RecognizeKind(Function::Handle(
+              ic_data().GetTargetAt(0))) != MethodRecognizer::kUnknown);
 }
 
 
 // DBC does not support optimizing compiler and thus doesn't emit
 // PolymorphicInstanceCallInstr.
 #if !defined(TARGET_ARCH_DBC)
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   ASSERT(ic_data().NumArgsTested() == 1);
   if (!with_checks()) {
     ASSERT(ic_data().HasOneTarget());
     const Function& target = Function::ZoneHandle(ic_data().GetTargetAt(0));
-    compiler->GenerateStaticCall(deopt_id(),
-                                 instance_call()->token_pos(),
-                                 target,
-                                 instance_call()->ArgumentCount(),
-                                 instance_call()->argument_names(),
-                                 locs(),
+    compiler->GenerateStaticCall(deopt_id(), instance_call()->token_pos(),
+                                 target, instance_call()->ArgumentCount(),
+                                 instance_call()->argument_names(), locs(),
                                  ICData::Handle());
     return;
   }
 
-  compiler->EmitPolymorphicInstanceCall(ic_data(),
-                                        instance_call()->ArgumentCount(),
-                                        instance_call()->argument_names(),
-                                        deopt_id(),
-                                        instance_call()->token_pos(),
-                                        locs(),
-                                        complete());
+  compiler->EmitPolymorphicInstanceCall(
+      ic_data(), instance_call()->ArgumentCount(),
+      instance_call()->argument_names(), deopt_id(),
+      instance_call()->token_pos(), locs(), complete());
 }
 #endif
 
 
 RawType* PolymorphicInstanceCallInstr::ComputeRuntimeType(
     const ICData& ic_data) {
   bool is_string = true;
   bool is_integer = true;
   bool is_double = true;
 
@@ skipping 55 matching lines @@
 LocationSummary* StaticCallInstr::MakeLocationSummary(Zone* zone,
                                                       bool optimizing) const {
   return MakeCallSummary(zone);
 }
 
 
 void StaticCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const ICData* call_ic_data = NULL;
   if (!FLAG_propagate_ic_data || !compiler->is_optimizing() ||
       (ic_data() == NULL)) {
-    const Array& arguments_descriptor =
-        Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
-                                               argument_names()));
+    const Array& arguments_descriptor = Array::Handle(
+        ArgumentsDescriptor::New(ArgumentCount(), argument_names()));
     MethodRecognizer::Kind recognized_kind =
         MethodRecognizer::RecognizeKind(function());
     int num_args_checked = 0;
     switch (recognized_kind) {
       case MethodRecognizer::kDoubleFromInteger:
       case MethodRecognizer::kMathMin:
       case MethodRecognizer::kMathMax:
         num_args_checked = 2;
         break;
       default:
         break;
     }
-    call_ic_data = compiler->GetOrAddStaticCallICData(deopt_id(),
-                                                      function(),
-                                                      arguments_descriptor,
-                                                      num_args_checked);
+    call_ic_data = compiler->GetOrAddStaticCallICData(
+        deopt_id(), function(), arguments_descriptor, num_args_checked);
   } else {
     call_ic_data = &ICData::ZoneHandle(ic_data()->raw());
   }
 
 #if !defined(TARGET_ARCH_DBC)
-  compiler->GenerateStaticCall(deopt_id(),
-                               token_pos(),
-                               function(),
-                               ArgumentCount(),
-                               argument_names(),
-                               locs(),
+  compiler->GenerateStaticCall(deopt_id(), token_pos(), function(),
+                               ArgumentCount(), argument_names(), locs(),
                                *call_ic_data);
 #else
   const Array& arguments_descriptor =
-      (ic_data() == NULL) ?
-        Array::Handle(ArgumentsDescriptor::New(ArgumentCount(),
-                                               argument_names())) :
-        Array::Handle(ic_data()->arguments_descriptor());
+      (ic_data() == NULL) ? Array::Handle(ArgumentsDescriptor::New(
+                                ArgumentCount(), argument_names()))
+                          : Array::Handle(ic_data()->arguments_descriptor());
   const intptr_t argdesc_kidx = __ AddConstant(arguments_descriptor);
 
   if (compiler->is_optimizing()) {
     __ PushConstant(function());
     __ StaticCall(ArgumentCount(), argdesc_kidx);
-    compiler->AddCurrentDescriptor(RawPcDescriptors::kOther,
-        deopt_id(), token_pos());
+    compiler->AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id(),
+                                   token_pos());
     compiler->RecordAfterCall(this);
     __ PopLocal(locs()->out(0).reg());
   } else {
     const intptr_t ic_data_kidx = __ AddConstant(*call_ic_data);
     __ PushConstant(ic_data_kidx);
     __ IndirectStaticCall(ArgumentCount(), argdesc_kidx);
     compiler->AddCurrentDescriptor(RawPcDescriptors::kUnoptStaticCall,
-        deopt_id(), token_pos());
+                                   deopt_id(), token_pos());
     compiler->RecordAfterCall(this);
   }
 #endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 void AssertAssignableInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  compiler->GenerateAssertAssignable(token_pos(),
-                                     deopt_id(),
-                                     dst_type(),
-                                     dst_name(),
-                                     locs());
+  compiler->GenerateAssertAssignable(token_pos(), deopt_id(), dst_type(),
+                                     dst_name(), locs());
 
-  // DBC does not use LocationSummaries in the same way as other architectures.
+// DBC does not use LocationSummaries in the same way as other architectures.
 #if !defined(TARGET_ARCH_DBC)
   ASSERT(locs()->in(0).reg() == locs()->out(0).reg());
 #endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 LocationSummary* DeoptimizeInstr::MakeLocationSummary(Zone* zone,
                                                       bool opt) const {
-  return new(zone) LocationSummary(zone, 0, 0, LocationSummary::kNoCall);
+  return new (zone) LocationSummary(zone, 0, 0, LocationSummary::kNoCall);
 }
 
 
 void DeoptimizeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
 #if !defined(TARGET_ARCH_DBC)
   __ Jump(compiler->AddDeoptStub(deopt_id(), deopt_reason_));
 #else
   compiler->EmitDeopt(deopt_id(), deopt_reason_);
 #endif
 }
 
 
 Environment* Environment::From(Zone* zone,
                                const GrowableArray<Definition*>& definitions,
                                intptr_t fixed_parameter_count,
                                const ParsedFunction& parsed_function) {
   Environment* env =
-      new(zone) Environment(definitions.length(),
-                               fixed_parameter_count,
-                               Thread::kNoDeoptId,
-                               parsed_function,
-                               NULL);
+      new (zone) Environment(definitions.length(), fixed_parameter_count,
+                             Thread::kNoDeoptId, parsed_function, NULL);
   for (intptr_t i = 0; i < definitions.length(); ++i) {
-    env->values_.Add(new(zone) Value(definitions[i]));
+    env->values_.Add(new (zone) Value(definitions[i]));
   }
   return env;
 }
 
 
 Environment* Environment::DeepCopy(Zone* zone, intptr_t length) const {
   ASSERT(length <= values_.length());
-  Environment* copy = new(zone) Environment(
-      length,
-      fixed_parameter_count_,
-      deopt_id_,
-      parsed_function_,
-      (outer_ == NULL) ? NULL : outer_->DeepCopy(zone));
+  Environment* copy = new (zone)
+      Environment(length, fixed_parameter_count_, deopt_id_, parsed_function_,
+                  (outer_ == NULL) ? NULL : outer_->DeepCopy(zone));
   if (locations_ != NULL) {
     Location* new_locations = zone->Alloc<Location>(length);
     copy->set_locations(new_locations);
   }
   for (intptr_t i = 0; i < length; ++i) {
     copy->values_.Add(values_[i]->Copy(zone));
     if (locations_ != NULL) {
       copy->locations_[i] = locations_[i].Copy();
     }
   }
@@ skipping 20 matching lines @@
                                   Instruction* instr,
                                   intptr_t argc,
                                   Definition* dead,
                                   Definition* result) const {
   for (Environment::DeepIterator it(instr->env()); !it.Done(); it.Advance()) {
     it.CurrentValue()->RemoveFromUseList();
   }
 
   Environment* copy = DeepCopy(zone, values_.length() - argc);
   for (intptr_t i = 0; i < argc; i++) {
-    copy->values_.Add(new(zone) Value(dead));
+    copy->values_.Add(new (zone) Value(dead));
   }
-  copy->values_.Add(new(zone) Value(result));
+  copy->values_.Add(new (zone) Value(result));
 
   instr->SetEnvironment(copy);
   for (Environment::DeepIterator it(copy); !it.Done(); it.Advance()) {
     Value* value = it.CurrentValue();
     value->definition()->AddEnvUse(value);
   }
 }
 
 
 // Copies the environment as outer on an inlined instruction and updates the
@@ skipping 17 matching lines @@
 
 ComparisonInstr* DoubleTestOpInstr::CopyWithNewOperands(Value* new_left,
                                                         Value* new_right) {
   UNREACHABLE();
   return NULL;
 }
 
 
 ComparisonInstr* EqualityCompareInstr::CopyWithNewOperands(Value* new_left,
                                                            Value* new_right) {
-  return new EqualityCompareInstr(token_pos(),
-                                  kind(),
-                                  new_left,
-                                  new_right,
-                                  operation_cid(),
-                                  deopt_id());
+  return new EqualityCompareInstr(token_pos(), kind(), new_left, new_right,
+                                  operation_cid(), deopt_id());
 }
 
 
 ComparisonInstr* RelationalOpInstr::CopyWithNewOperands(Value* new_left,
                                                         Value* new_right) {
-  return new RelationalOpInstr(token_pos(),
-                               kind(),
-                               new_left,
-                               new_right,
-                               operation_cid(),
-                               deopt_id());
+  return new RelationalOpInstr(token_pos(), kind(), new_left, new_right,
+                               operation_cid(), deopt_id());
 }
 
 
 ComparisonInstr* StrictCompareInstr::CopyWithNewOperands(Value* new_left,
                                                          Value* new_right) {
-  return new StrictCompareInstr(token_pos(),
-                                kind(),
-                                new_left,
-                                new_right,
+  return new StrictCompareInstr(token_pos(), kind(), new_left, new_right,
                                 needs_number_check());
 }
 
 
-
 ComparisonInstr* TestSmiInstr::CopyWithNewOperands(Value* new_left,
                                                    Value* new_right) {
   return new TestSmiInstr(token_pos(), kind(), new_left, new_right);
 }
 
 
-
 ComparisonInstr* TestCidsInstr::CopyWithNewOperands(Value* new_left,
                                                     Value* new_right) {
-  return new TestCidsInstr(token_pos(),
-                           kind(),
-                           new_left,
-                           cid_results(),
+  return new TestCidsInstr(token_pos(), kind(), new_left, cid_results(),
                            deopt_id());
 }
 
 
 bool TestCidsInstr::AttributesEqual(Instruction* other) const {
   TestCidsInstr* other_instr = other->AsTestCids();
   if (!ComparisonInstr::AttributesEqual(other)) {
     return false;
   }
   if (cid_results().length() != other_instr->cid_results().length()) {
@@ skipping 16 matching lines @@
 
 
 bool IfThenElseInstr::Supports(ComparisonInstr* comparison,
                                Value* v1,
                                Value* v2) {
 #if !defined(TARGET_ARCH_DBC)
   bool is_smi_result = BindsToSmiConstant(v1) && BindsToSmiConstant(v2);
   if (comparison->IsStrictCompare()) {
     // Strict comparison with number checks calls a stub and is not supported
     // by if-conversion.
-    return is_smi_result
-        && !comparison->AsStrictCompare()->needs_number_check();
+    return is_smi_result &&
+           !comparison->AsStrictCompare()->needs_number_check();
   }
   if (comparison->operation_cid() != kSmiCid) {
     // Non-smi comparisons are not supported by if-conversion.
     return false;
   }
   return is_smi_result;
 #else
   return false;
 #endif  // !defined(TARGET_ARCH_DBC)
 }
 
 
 bool PhiInstr::IsRedundant() const {
   ASSERT(InputCount() > 1);
   Definition* first = InputAt(0)->definition();
   for (intptr_t i = 1; i < InputCount(); ++i) {
     Definition* def = InputAt(i)->definition();
     if (def != first) return false;
   }
   return true;
 }
 
 
 bool CheckArrayBoundInstr::IsFixedLengthArrayType(intptr_t cid) {
   return LoadFieldInstr::IsFixedLengthArrayCid(cid);
 }
 
 
 Instruction* CheckArrayBoundInstr::Canonicalize(FlowGraph* flow_graph) {
-  return IsRedundant(RangeBoundary::FromDefinition(length()->definition())) ?
-      NULL : this;
+  return IsRedundant(RangeBoundary::FromDefinition(length()->definition()))
+             ? NULL
+             : this;
 }
 
 
 intptr_t CheckArrayBoundInstr::LengthOffsetFor(intptr_t class_id) {
   if (RawObject::IsExternalTypedDataClassId(class_id)) {
     return ExternalTypedData::length_offset();
   }
   if (RawObject::IsTypedDataClassId(class_id)) {
     return TypedData::length_offset();
   }
@@ skipping 13 matching lines @@
 }
 
 
 const Function& StringInterpolateInstr::CallFunction() const {
   if (function_.IsNull()) {
     const int kNumberOfArguments = 1;
     const Array& kNoArgumentNames = Object::null_array();
     const Class& cls =
         Class::Handle(Library::LookupCoreClass(Symbols::StringBase()));
     ASSERT(!cls.IsNull());
-    function_ =
-        Resolver::ResolveStatic(
-            cls,
-            Library::PrivateCoreLibName(Symbols::Interpolate()),
-            kNumberOfArguments,
-            kNoArgumentNames);
+    function_ = Resolver::ResolveStatic(
+        cls, Library::PrivateCoreLibName(Symbols::Interpolate()),
+        kNumberOfArguments, kNoArgumentNames);
   }
   ASSERT(!function_.IsNull());
   return function_;
 }
 
 
 // Replace StringInterpolateInstr with a constant string if all inputs are
 // constant of [string, number, boolean, null].
 // Leave the CreateArrayInstr and StoreIndexedInstr in the stream in case
 // deoptimization occurs.
@@ skipping 18 matching lines @@
     return this;
   }
   const intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   GrowableHandlePtrArray<const String> pieces(zone, length);
   for (intptr_t i = 0; i < length; i++) {
     pieces.Add(Object::null_string());
   }
 
-  for (Value::Iterator it(create_array->input_use_list());
-       !it.Done();
+  for (Value::Iterator it(create_array->input_use_list()); !it.Done();
        it.Advance()) {
     Instruction* curr = it.Current()->instruction();
     if (curr == this) continue;
 
     StoreIndexedInstr* store = curr->AsStoreIndexed();
     if (!store->index()->BindsToConstant() ||
         !store->index()->BoundConstant().IsSmi()) {
       return this;
     }
     intptr_t store_index = Smi::Cast(store->index()->BoundConstant()).Value();
     ASSERT(store_index < length);
     ASSERT(store != NULL);
     if (store->value()->definition()->IsConstant()) {
       ASSERT(store->index()->BindsToConstant());
       const Object& obj = store->value()->definition()->AsConstant()->value();
       // TODO(srdjan): Verify if any other types should be converted as well.
       if (obj.IsString()) {
         pieces.SetAt(store_index, String::Cast(obj));
       } else if (obj.IsSmi()) {
         const char* cstr = obj.ToCString();
         pieces.SetAt(store_index,
-            String::Handle(zone, String::New(cstr, Heap::kOld)));
+                     String::Handle(zone, String::New(cstr, Heap::kOld)));
       } else if (obj.IsBool()) {
-        pieces.SetAt(store_index,
-            Bool::Cast(obj).value() ? Symbols::True() : Symbols::False());
+        pieces.SetAt(store_index, Bool::Cast(obj).value() ? Symbols::True()
+                                                          : Symbols::False());
       } else if (obj.IsNull()) {
         pieces.SetAt(store_index, Symbols::Null());
       } else {
         return this;
       }
     } else {
       return this;
     }
   }
 
-  const String& concatenated = String::ZoneHandle(zone,
-      Symbols::FromConcatAll(thread, pieces));
+  const String& concatenated =
+      String::ZoneHandle(zone, Symbols::FromConcatAll(thread, pieces));
   return flow_graph->GetConstant(concatenated);
 }
 
 
 static AlignmentType StrengthenAlignment(intptr_t cid,
                                          AlignmentType alignment) {
   switch (cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
@@ skipping 27 matching lines @@
     : TemplateDefinition(deopt_id),
       index_scale_(index_scale),
       class_id_(class_id),
       alignment_(StrengthenAlignment(class_id, alignment)),
       token_pos_(token_pos) {
   SetInputAt(0, array);
   SetInputAt(1, index);
 }
 
 
-
 StoreIndexedInstr::StoreIndexedInstr(Value* array,
                                      Value* index,
                                      Value* value,
                                      StoreBarrierType emit_store_barrier,
                                      intptr_t index_scale,
                                      intptr_t class_id,
                                      AlignmentType alignment,
                                      intptr_t deopt_id,
                                      TokenPosition token_pos)
     : TemplateDefinition(deopt_id),
@@ skipping 47 matching lines @@
     case MethodRecognizer::kMathDoublePow:
     case MethodRecognizer::kMathAtan2:
       return 2;
     default:
       UNREACHABLE();
   }
   return 0;
 }
 
 // Use expected function signatures to help MSVC compiler resolve overloading.
-typedef double (*UnaryMathCFunction) (double x);
-typedef double (*BinaryMathCFunction) (double x, double y);
+typedef double (*UnaryMathCFunction)(double x);
+typedef double (*BinaryMathCFunction)(double x, double y);
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcPow, 2, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<BinaryMathCFunction>(&pow)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcPow,
+    2,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<BinaryMathCFunction>(&pow)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(DartModulo, 2, true /* is_float */,
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    DartModulo,
+    2,
+    true /* is_float */,
     reinterpret_cast<RuntimeFunction>(
         static_cast<BinaryMathCFunction>(&DartModulo)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcAtan2, 2, true /* is_float */,
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcAtan2,
+    2,
+    true /* is_float */,
     reinterpret_cast<RuntimeFunction>(
         static_cast<BinaryMathCFunction>(&atan2_ieee)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcFloor, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&floor)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcFloor,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&floor)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcCeil, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&ceil)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcCeil,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&ceil)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcTrunc, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&trunc)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcTrunc,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&trunc)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcRound, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&round)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcRound,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&round)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcCos, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&cos)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcCos,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&cos)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcSin, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&sin)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcSin,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&sin)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcAsin, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&asin)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcAsin,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&asin)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcAcos, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&acos)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcAcos,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&acos)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcTan, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&tan)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcTan,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&tan)));
 
-DEFINE_RAW_LEAF_RUNTIME_ENTRY(LibcAtan, 1, true /* is_float */,
-    reinterpret_cast<RuntimeFunction>(
-        static_cast<UnaryMathCFunction>(&atan)));
+DEFINE_RAW_LEAF_RUNTIME_ENTRY(
+    LibcAtan,
+    1,
+    true /* is_float */,
+    reinterpret_cast<RuntimeFunction>(static_cast<UnaryMathCFunction>(&atan)));
 
 
 const RuntimeEntry& InvokeMathCFunctionInstr::TargetFunction() const {
   switch (recognized_kind_) {
     case MethodRecognizer::kDoubleTruncate:
       return kLibcTruncRuntimeEntry;
     case MethodRecognizer::kDoubleRound:
       return kLibcRoundRuntimeEntry;
     case MethodRecognizer::kDoubleFloor:
       return kLibcFloorRuntimeEntry;
@@ skipping 19 matching lines @@
       return kLibcAtan2RuntimeEntry;
     default:
       UNREACHABLE();
   }
   return kLibcPowRuntimeEntry;
 }
 
 
 const char* MathUnaryInstr::KindToCString(MathUnaryKind kind) {
   switch (kind) {
-    case kIllegal:       return "illegal";
-    case kSqrt:          return "sqrt";
-    case kDoubleSquare:  return "double-square";
+    case kIllegal:
+      return "illegal";
+    case kSqrt:
+      return "sqrt";
+    case kDoubleSquare:
+      return "double-square";
   }
   UNREACHABLE();
   return "";
 }
 
 
 const RuntimeEntry& CaseInsensitiveCompareUC16Instr::TargetFunction() const {
   return kCaseInsensitiveCompareUC16RuntimeEntry;
 }
 
 
 MergedMathInstr::MergedMathInstr(ZoneGrowableArray<Value*>* inputs,
                                  intptr_t deopt_id,
                                  MergedMathInstr::Kind kind)
-    : PureDefinition(deopt_id),
-      inputs_(inputs),
-      kind_(kind) {
+    : PureDefinition(deopt_id), inputs_(inputs), kind_(kind) {
   ASSERT(inputs_->length() == InputCountFor(kind_));
   for (intptr_t i = 0; i < inputs_->length(); ++i) {
     ASSERT((*inputs)[i] != NULL);
     (*inputs)[i]->set_instruction(this);
     (*inputs)[i]->set_use_index(i);
   }
 }
 
 
 intptr_t MergedMathInstr::OutputIndexOf(MethodRecognizer::Kind kind) {
   switch (kind) {
-    case MethodRecognizer::kMathSin: return 1;
-    case MethodRecognizer::kMathCos: return 0;
-    default: UNIMPLEMENTED(); return -1;
+    case MethodRecognizer::kMathSin:
+      return 1;
+    case MethodRecognizer::kMathCos:
+      return 0;
+    default:
+      UNIMPLEMENTED();
+      return -1;
   }
 }
 
 
 intptr_t MergedMathInstr::OutputIndexOf(Token::Kind token) {
   switch (token) {
-    case Token::kTRUNCDIV: return 0;
-    case Token::kMOD: return 1;
-    default: UNIMPLEMENTED(); return -1;
+    case Token::kTRUNCDIV:
+      return 0;
+    case Token::kMOD:
+      return 1;
+    default:
+      UNIMPLEMENTED();
+      return -1;
   }
 }
 
 
 void NativeCallInstr::SetupNative() {
   Zone* zone = Thread::Current()->zone();
   const Class& cls = Class::Handle(zone, function().Owner());
   const Library& library = Library::Handle(zone, cls.library());
   const int num_params =
       NativeArguments::ParameterCountForResolution(function());
   bool auto_setup_scope = true;
   NativeFunction native_function = NativeEntry::ResolveNative(
       library, native_name(), num_params, &auto_setup_scope);
   if (native_function == NULL) {
-    Report::MessageF(Report::kError,
-                     Script::Handle(function().script()),
-                     function().token_pos(),
-                     Report::AtLocation,
+    Report::MessageF(Report::kError, Script::Handle(function().script()),
+                     function().token_pos(), Report::AtLocation,
                      "native function '%s' (%" Pd " arguments) cannot be found",
-                     native_name().ToCString(),
-                     function().NumParameters());
+                     native_name().ToCString(), function().NumParameters());
   }
   set_native_c_function(native_function);
   function().SetIsNativeAutoSetupScope(auto_setup_scope);
   Dart_NativeEntryResolver resolver = library.native_entry_resolver();
   bool is_bootstrap_native = Bootstrap::IsBootstapResolver(resolver);
   set_is_bootstrap_native(is_bootstrap_native);
 }
 
 #undef __
 
 }  // namespace dart