clang-format runtime/vm

runtime/vm/flow_graph_range_analysis.cc

 // Copyright (c) 2014, 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/flow_graph_range_analysis.h"
 
 #include "vm/bit_vector.h"
 #include "vm/il_printer.h"
 
 namespace dart {
 
-DEFINE_FLAG(bool, array_bounds_check_elimination, true,
-    "Eliminate redundant bounds checks.");
+DEFINE_FLAG(bool,
+            array_bounds_check_elimination,
+            true,
+            "Eliminate redundant bounds checks.");
 DEFINE_FLAG(bool, trace_range_analysis, false, "Trace range analysis progress");
-DEFINE_FLAG(bool, trace_integer_ir_selection, false,
-    "Print integer IR selection optimization pass.");
+DEFINE_FLAG(bool,
+            trace_integer_ir_selection,
+            false,
+            "Print integer IR selection optimization pass.");
 DECLARE_FLAG(bool, trace_constant_propagation);
 
 // Quick access to the locally defined isolate() and zone() methods.
 #define I (isolate())
 #define Z (zone())
 
 void RangeAnalysis::Analyze() {
   CollectValues();
   InsertConstraints();
   DiscoverSimpleInductionVariables();
@@ skipping 47 matching lines @@
 class InductionVariableInfo : public ZoneAllocated {
  public:
   InductionVariableInfo(PhiInstr* phi,
                         Definition* initial_value,
                         BinarySmiOpInstr* increment,
                         ConstraintInstr* limit)
       : phi_(phi),
         initial_value_(initial_value),
         increment_(increment),
         limit_(limit),
-        bound_(NULL) { }
+        bound_(NULL) {}
 
   PhiInstr* phi() const { return phi_; }
   Definition* initial_value() const { return initial_value_; }
   BinarySmiOpInstr* increment() const { return increment_; }
 
   // Outermost constraint that constrains this induction variable into
   // [-inf, X] range.
   ConstraintInstr* limit() const { return limit_; }
 
   // Induction variable from the same join block that has limiting constraint.
   PhiInstr* bound() const { return bound_; }
   void set_bound(PhiInstr* bound) { bound_ = bound; }
 
  private:
   PhiInstr* phi_;
   Definition* initial_value_;
   BinarySmiOpInstr* increment_;
   ConstraintInstr* limit_;
 
   PhiInstr* bound_;
 };
 
 
 static ConstraintInstr* FindBoundingConstraint(PhiInstr* phi,
                                                Definition* defn) {
   ConstraintInstr* limit = NULL;
-  for (ConstraintInstr* constraint = defn->AsConstraint();
-       constraint != NULL;
+  for (ConstraintInstr* constraint = defn->AsConstraint(); constraint != NULL;
        constraint = constraint->value()->definition()->AsConstraint()) {
     if (constraint->target() == NULL) {
       continue;  // Only interested in non-artifical constraints.
     }
 
     Range* constraining_range = constraint->constraint();
     if (constraining_range->min().Equals(RangeBoundary::MinSmi()) &&
         (constraining_range->max().IsSymbol() &&
          phi->IsDominatedBy(constraining_range->max().symbol()))) {
       limit = constraint;
@@ skipping 10 matching lines @@
   }
 
   if (phi->InputCount() != 2) {
     return NULL;
   }
 
   BitVector* loop_info = phi->block()->loop_info();
 
   const intptr_t backedge_idx =
       loop_info->Contains(phi->block()->PredecessorAt(0)->preorder_number())
-          ? 0 : 1;
+          ? 0
+          : 1;
 
-  Definition* initial_value =
-      phi->InputAt(1 - backedge_idx)->definition();
+  Definition* initial_value = phi->InputAt(1 - backedge_idx)->definition();
 
   BinarySmiOpInstr* increment =
-      UnwrapConstraint(phi->InputAt(backedge_idx)->definition())->
-          AsBinarySmiOp();
+      UnwrapConstraint(phi->InputAt(backedge_idx)->definition())
+          ->AsBinarySmiOp();
 
-  if ((increment != NULL) &&
-      (increment->op_kind() == Token::kADD) &&
+  if ((increment != NULL) && (increment->op_kind() == Token::kADD) &&
       (UnwrapConstraint(increment->left()->definition()) == phi) &&
       increment->right()->BindsToConstant() &&
       increment->right()->BoundConstant().IsSmi() &&
       (Smi::Cast(increment->right()->BoundConstant()).Value() == 1)) {
     return new InductionVariableInfo(
-        phi,
-        initial_value,
-        increment,
+        phi, initial_value, increment,
         FindBoundingConstraint(phi, increment->left()->definition()));
   }
 
   return NULL;
 }
 
 
 void RangeAnalysis::DiscoverSimpleInductionVariables() {
   GrowableArray<InductionVariableInfo*> loop_variables;
 
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
-       !block_it.Done();
-       block_it.Advance()) {
+       !block_it.Done(); block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
 
     JoinEntryInstr* join = block->AsJoinEntry();
     if (join != NULL && join->loop_info() != NULL) {
       loop_variables.Clear();
 
       for (PhiIterator phi_it(join); !phi_it.Done(); phi_it.Advance()) {
         PhiInstr* current = phi_it.Current();
 
         InductionVariableInfo* info = DetectSimpleInductionVariable(current);
         if (info != NULL) {
           if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
             THR_Print("Simple loop variable: %s bound <%s>\n",
-                       current->ToCString(),
-                       info->limit() != NULL ?
-                           info->limit()->ToCString() : "?");
+                      current->ToCString(),
+                      info->limit() != NULL ? info->limit()->ToCString() : "?");
           }
 
           loop_variables.Add(info);
         }
       }
     }
 
     InductionVariableInfo* bound = NULL;
     for (intptr_t i = 0; i < loop_variables.length(); i++) {
       if (loop_variables[i]->limit() != NULL) {
@@ skipping 17 matching lines @@
   const GrowableArray<Definition*>& initial =
       *flow_graph_->graph_entry()->initial_definitions();
   for (intptr_t i = 0; i < initial.length(); ++i) {
     Definition* current = initial[i];
     if (IsIntegerDefinition(current)) {
       values_.Add(current);
     }
   }
 
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
-       !block_it.Done();
-       block_it.Advance()) {
+       !block_it.Done(); block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
 
 
     if (block->IsGraphEntry() || block->IsCatchBlockEntry()) {
-      const GrowableArray<Definition*>& initial = block->IsGraphEntry()
-          ? *block->AsGraphEntry()->initial_definitions()
-          : *block->AsCatchBlockEntry()->initial_definitions();
+      const GrowableArray<Definition*>& initial =
+          block->IsGraphEntry()
+              ? *block->AsGraphEntry()->initial_definitions()
+              : *block->AsCatchBlockEntry()->initial_definitions();
       for (intptr_t i = 0; i < initial.length(); ++i) {
         Definition* current = initial[i];
         if (IsIntegerDefinition(current)) {
           values_.Add(current);
         }
       }
     }
 
     JoinEntryInstr* join = block->AsJoinEntry();
     if (join != NULL) {
       for (PhiIterator phi_it(join); !phi_it.Done(); phi_it.Advance()) {
         PhiInstr* current = phi_it.Current();
         if (current->Type()->IsInt()) {
           values_.Add(current);
         }
       }
     }
 
-    for (ForwardInstructionIterator instr_it(block);
-         !instr_it.Done();
+    for (ForwardInstructionIterator instr_it(block); !instr_it.Done();
          instr_it.Advance()) {
       Instruction* current = instr_it.Current();
       Definition* defn = current->AsDefinition();
       if (defn != NULL) {
         if (defn->HasSSATemp() && IsIntegerDefinition(defn)) {
           values_.Add(defn);
           if (defn->IsBinaryMintOp()) {
             binary_mint_ops_.Add(defn->AsBinaryMintOp());
           } else if (defn->IsShiftMintOp()) {
             shift_mint_ops_.Add(defn->AsShiftMintOp());
@@ skipping 31 matching lines @@
     return false;
   }
 
   return dom_block->Dominates(use_block);
 }
 
 
 void RangeAnalysis::RenameDominatedUses(Definition* def,
                                         Instruction* dom,
                                         Definition* other) {
-  for (Value::Iterator it(def->input_use_list());
-       !it.Done();
-       it.Advance()) {
+  for (Value::Iterator it(def->input_use_list()); !it.Done(); it.Advance()) {
     Value* use = it.Current();
 
     // Skip dead phis.
     PhiInstr* phi = use->instruction()->AsPhi();
     ASSERT((phi == NULL) || phi->is_alive());
     if (IsDominatedUse(dom, use)) {
       use->BindTo(other);
     }
   }
 }
 
 
 // For a comparison operation return an operation for the equivalent flipped
 // comparison: a (op) b === b (op') a.
 static Token::Kind FlipComparison(Token::Kind op) {
   switch (op) {
-    case Token::kEQ: return Token::kEQ;
-    case Token::kNE: return Token::kNE;
-    case Token::kLT: return Token::kGT;
-    case Token::kGT: return Token::kLT;
-    case Token::kLTE: return Token::kGTE;
-    case Token::kGTE: return Token::kLTE;
+    case Token::kEQ:
+      return Token::kEQ;
+    case Token::kNE:
+      return Token::kNE;
+    case Token::kLT:
+      return Token::kGT;
+    case Token::kGT:
+      return Token::kLT;
+    case Token::kLTE:
+      return Token::kGTE;
+    case Token::kGTE:
+      return Token::kLTE;
     default:
       UNREACHABLE();
       return Token::kILLEGAL;
   }
 }
 
 
 // Given a boundary (right operand) and a comparison operation return
 // a symbolic range constraint for the left operand of the comparison assuming
 // that it evaluated to true.
 // For example for the comparison a < b symbol a is constrained with range
 // [Smi::kMinValue, b - 1].
 Range* RangeAnalysis::ConstraintSmiRange(Token::Kind op, Definition* boundary) {
   switch (op) {
     case Token::kEQ:
-      return new(Z) Range(RangeBoundary::FromDefinition(boundary),
-                          RangeBoundary::FromDefinition(boundary));
+      return new (Z) Range(RangeBoundary::FromDefinition(boundary),
+                           RangeBoundary::FromDefinition(boundary));
     case Token::kNE:
-      return new(Z) Range(Range::Full(RangeBoundary::kRangeBoundarySmi));
+      return new (Z) Range(Range::Full(RangeBoundary::kRangeBoundarySmi));
     case Token::kLT:
-      return new(Z) Range(RangeBoundary::MinSmi(),
-                          RangeBoundary::FromDefinition(boundary, -1));
+      return new (Z) Range(RangeBoundary::MinSmi(),
+                           RangeBoundary::FromDefinition(boundary, -1));
     case Token::kGT:
-      return new(Z) Range(RangeBoundary::FromDefinition(boundary, 1),
-                          RangeBoundary::MaxSmi());
+      return new (Z) Range(RangeBoundary::FromDefinition(boundary, 1),
+                           RangeBoundary::MaxSmi());
     case Token::kLTE:
-      return new(Z) Range(RangeBoundary::MinSmi(),
-                          RangeBoundary::FromDefinition(boundary));
+      return new (Z) Range(RangeBoundary::MinSmi(),
+                           RangeBoundary::FromDefinition(boundary));
     case Token::kGTE:
-      return new(Z) Range(RangeBoundary::FromDefinition(boundary),
-                          RangeBoundary::MaxSmi());
+      return new (Z) Range(RangeBoundary::FromDefinition(boundary),
+                           RangeBoundary::MaxSmi());
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 ConstraintInstr* RangeAnalysis::InsertConstraintFor(Value* use,
                                                     Definition* defn,
                                                     Range* constraint_range,
                                                     Instruction* after) {
   // No need to constrain constants.
   if (defn->IsConstant()) return NULL;
 
   // Check if the value is already constrained to avoid inserting duplicated
   // constraints.
   ConstraintInstr* constraint = after->next()->AsConstraint();
   while (constraint != NULL) {
     if ((constraint->value()->definition() == defn) &&
         constraint->constraint()->Equals(constraint_range)) {
       return NULL;
     }
     constraint = constraint->next()->AsConstraint();
   }
 
-  constraint = new(Z) ConstraintInstr(
-      use->CopyWithType(), constraint_range);
+  constraint = new (Z) ConstraintInstr(use->CopyWithType(), constraint_range);
 
   flow_graph_->InsertAfter(after, constraint, NULL, FlowGraph::kValue);
   RenameDominatedUses(defn, constraint, constraint);
   constraints_.Add(constraint);
   return constraint;
 }
 
 
 bool RangeAnalysis::ConstrainValueAfterBranch(Value* use, Definition* defn) {
   BranchInstr* branch = use->instruction()->AsBranch();
   RelationalOpInstr* rel_op = branch->comparison()->AsRelationalOp();
   if ((rel_op != NULL) && (rel_op->operation_cid() == kSmiCid)) {
     // Found comparison of two smis. Constrain defn at true and false
     // successors using the other operand as a boundary.
     Definition* boundary;
     Token::Kind op_kind;
     if (use->use_index() == 0) {  // Left operand.
       boundary = rel_op->InputAt(1)->definition();
       op_kind = rel_op->kind();
     } else {
       ASSERT(use->use_index() == 1);  // Right operand.
       boundary = rel_op->InputAt(0)->definition();
       // InsertConstraintFor assumes that defn is left operand of a
       // comparison if it is right operand flip the comparison.
       op_kind = FlipComparison(rel_op->kind());
     }
 
     // Constrain definition at the true successor.
     ConstraintInstr* true_constraint =
-        InsertConstraintFor(use,
-                            defn,
-                            ConstraintSmiRange(op_kind, boundary),
+        InsertConstraintFor(use, defn, ConstraintSmiRange(op_kind, boundary),
                             branch->true_successor());
     if (true_constraint != NULL) {
       true_constraint->set_target(branch->true_successor());
     }
 
     // Constrain definition with a negated condition at the false successor.
-    ConstraintInstr* false_constraint =
-        InsertConstraintFor(
-            use,
-            defn,
-            ConstraintSmiRange(Token::NegateComparison(op_kind), boundary),
-            branch->false_successor());
+    ConstraintInstr* false_constraint = InsertConstraintFor(
+        use, defn,
+        ConstraintSmiRange(Token::NegateComparison(op_kind), boundary),
+        branch->false_successor());
     if (false_constraint != NULL) {
       false_constraint->set_target(branch->false_successor());
     }
 
     return true;
   }
 
   return false;
 }
 
 
 void RangeAnalysis::InsertConstraintsFor(Definition* defn) {
-  for (Value* use = defn->input_use_list();
-       use != NULL;
+  for (Value* use = defn->input_use_list(); use != NULL;
        use = use->next_use()) {
     if (use->instruction()->IsBranch()) {
       if (ConstrainValueAfterBranch(use, defn)) {
         Value* other_value = use->instruction()->InputAt(1 - use->use_index());
         if (!IsIntegerDefinition(other_value->definition())) {
           ConstrainValueAfterBranch(other_value, other_value->definition());
         }
       }
     } else if (use->instruction()->IsCheckArrayBound()) {
       ConstrainValueAfterCheckArrayBound(use, defn);
     }
   }
 }
 
 
-void RangeAnalysis::ConstrainValueAfterCheckArrayBound(
-    Value* use,
-    Definition* defn) {
+void RangeAnalysis::ConstrainValueAfterCheckArrayBound(Value* use,
+                                                       Definition* defn) {
   CheckArrayBoundInstr* check = use->instruction()->AsCheckArrayBound();
   intptr_t use_index = use->use_index();
 
   Range* constraint_range = NULL;
   if (use_index == CheckArrayBoundInstr::kIndexPos) {
     Definition* length = check->length()->definition();
-    constraint_range = new(Z) Range(
-        RangeBoundary::FromConstant(0),
-        RangeBoundary::FromDefinition(length, -1));
+    constraint_range = new (Z) Range(RangeBoundary::FromConstant(0),
+                                     RangeBoundary::FromDefinition(length, -1));
   } else {
     ASSERT(use_index == CheckArrayBoundInstr::kLengthPos);
     Definition* index = check->index()->definition();
-    constraint_range = new(Z) Range(
-        RangeBoundary::FromDefinition(index, 1),
-        RangeBoundary::MaxSmi());
+    constraint_range = new (Z)
+        Range(RangeBoundary::FromDefinition(index, 1), RangeBoundary::MaxSmi());
   }
   InsertConstraintFor(use, defn, constraint_range, check);
 }
 
 
 void RangeAnalysis::InsertConstraints() {
   for (intptr_t i = 0; i < values_.length(); i++) {
     InsertConstraintsFor(values_[i]);
   }
 
@@ skipping 44 matching lines @@
   }
 
   return range;
 }
 
 
 static bool AreEqualDefinitions(Definition* a, Definition* b) {
   a = UnwrapConstraint(a);
   b = UnwrapConstraint(b);
   return (a == b) ||
-      (a->AllowsCSE() &&
-       a->Dependencies().IsNone() &&
-       b->AllowsCSE() &&
-       b->Dependencies().IsNone() &&
-       a->Equals(b));
+         (a->AllowsCSE() && a->Dependencies().IsNone() && b->AllowsCSE() &&
+          b->Dependencies().IsNone() && a->Equals(b));
 }
 
 
 static bool DependOnSameSymbol(const RangeBoundary& a, const RangeBoundary& b) {
   return a.IsSymbol() && b.IsSymbol() &&
-      AreEqualDefinitions(a.symbol(), b.symbol());
+         AreEqualDefinitions(a.symbol(), b.symbol());
 }
 
 
 // Given the current range of a phi and a newly computed range check
 // if it is growing towards negative infinity, if it does widen it to
 // MinSmi.
 static RangeBoundary WidenMin(const Range* range,
                               const Range* new_range,
                               RangeBoundary::RangeSize size) {
   RangeBoundary min = range->min();
   RangeBoundary new_min = new_range->min();
 
   if (min.IsSymbol()) {
     if (min.LowerBound().Overflowed(size)) {
       return RangeBoundary::MinConstant(size);
     } else if (DependOnSameSymbol(min, new_min)) {
-      return min.offset() <= new_min.offset() ?
-          min : RangeBoundary::MinConstant(size);
+      return min.offset() <= new_min.offset()
+                 ? min
+                 : RangeBoundary::MinConstant(size);
     } else if (min.UpperBound(size) <= new_min.LowerBound(size)) {
       return min;
     }
   }
 
   min = Range::ConstantMin(range, size);
   new_min = Range::ConstantMin(new_range, size);
 
-  return (min.ConstantValue() <= new_min.ConstantValue()) ?
-      min : RangeBoundary::MinConstant(size);
+  return (min.ConstantValue() <= new_min.ConstantValue())
+             ? min
+             : RangeBoundary::MinConstant(size);
 }
 
 // Given the current range of a phi and a newly computed range check
 // if it is growing towards positive infinity, if it does widen it to
 // MaxSmi.
 static RangeBoundary WidenMax(const Range* range,
                               const Range* new_range,
                               RangeBoundary::RangeSize size) {
   RangeBoundary max = range->max();
   RangeBoundary new_max = new_range->max();
 
   if (max.IsSymbol()) {
     if (max.UpperBound().Overflowed(size)) {
       return RangeBoundary::MaxConstant(size);
     } else if (DependOnSameSymbol(max, new_max)) {
-      return max.offset() >= new_max.offset() ?
-          max : RangeBoundary::MaxConstant(size);
+      return max.offset() >= new_max.offset()
+                 ? max
+                 : RangeBoundary::MaxConstant(size);
     } else if (max.LowerBound(size) >= new_max.UpperBound(size)) {
       return max;
     }
   }
 
   max = Range::ConstantMax(range, size);
   new_max = Range::ConstantMax(new_range, size);
 
-  return (max.ConstantValue() >= new_max.ConstantValue()) ?
-      max : RangeBoundary::MaxConstant(size);
+  return (max.ConstantValue() >= new_max.ConstantValue())
+             ? max
+             : RangeBoundary::MaxConstant(size);
 }
 
 
 // Given the current range of a phi and a newly computed range check
 // if we can perform narrowing: use newly computed minimum to improve precision
 // of the computed range. We do it only if current minimum was widened and is
 // equal to MinSmi.
 // Newly computed minimum is expected to be greater or equal than old one as
 // we are running after widening phase.
 static RangeBoundary NarrowMin(const Range* range,
@@ skipping 21 matching lines @@
   const RangeBoundary new_max = Range::ConstantMax(new_range, size);
   if (max.ConstantValue() < new_max.ConstantValue()) return range->max();
 
   // TODO(vegorov): consider using positive infinity to indicate widened bound.
   return range->max().IsMaximumOrAbove(size) ? new_range->max() : range->max();
 }
 
 
 char RangeAnalysis::OpPrefix(JoinOperator op) {
   switch (op) {
-    case WIDEN: return 'W';
-    case NARROW: return 'N';
-    case NONE: return 'I';
+    case WIDEN:
+      return 'W';
+    case NARROW:
+      return 'N';
+    case NONE:
+      return 'I';
   }
   UNREACHABLE();
   return ' ';
 }
 
 
 static RangeBoundary::RangeSize RangeSizeForPhi(Definition* phi) {
   ASSERT(phi->IsPhi());
   if (phi->Type()->ToCid() == kSmiCid) {
     return RangeBoundary::kRangeBoundarySmi;
@@ skipping 22 matching lines @@
                       WidenMax(defn->range(), &range, size));
       } else if (op == NARROW) {
         range = Range(NarrowMin(defn->range(), &range, size),
                       NarrowMax(defn->range(), &range, size));
       }
     }
 
     if (!range.Equals(defn->range())) {
 #ifndef PRODUCT
       if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
-        THR_Print("%c [%" Pd "] %s:  %s => %s\n",
-                  OpPrefix(op),
-                  iteration,
-                  defn->ToCString(),
-                  Range::ToCString(defn->range()),
+        THR_Print("%c [%" Pd "] %s:  %s => %s\n", OpPrefix(op), iteration,
+                  defn->ToCString(), Range::ToCString(defn->range()),
                   Range::ToCString(&range));
       }
 #endif  // !PRODUCT
       defn->set_range(range);
       return true;
     }
   }
 
   return false;
 }
 
 
 void RangeAnalysis::CollectDefinitions(BitVector* set) {
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
-       !block_it.Done();
-       block_it.Advance()) {
+       !block_it.Done(); block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
 
     JoinEntryInstr* join = block->AsJoinEntry();
     if (join != NULL) {
       for (PhiIterator it(join); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
         if (set->Contains(phi->ssa_temp_index())) {
           definitions_.Add(phi);
         }
       }
     }
 
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Definition* defn = it.Current()->AsDefinition();
-      if ((defn != NULL) &&
-          defn->HasSSATemp() &&
+      if ((defn != NULL) && defn->HasSSATemp() &&
           set->Contains(defn->ssa_temp_index())) {
         definitions_.Add(defn);
       }
     }
   }
 }
 
 
 void RangeAnalysis::Iterate(JoinOperator op, intptr_t max_iterations) {
   // TODO(vegorov): switch to worklist if this becomes performance bottleneck.
@@ skipping 12 matching lines @@
   } while (changed && (iteration < max_iterations));
 }
 
 
 void RangeAnalysis::InferRanges() {
   if (FLAG_trace_range_analysis) {
     FlowGraphPrinter::PrintGraph("Range Analysis (BEFORE)", flow_graph_);
   }
   Zone* zone = flow_graph_->zone();
   // Initialize bitvector for quick filtering of int values.
-  BitVector* set = new(zone) BitVector(zone,
-      flow_graph_->current_ssa_temp_index());
+  BitVector* set =
+      new (zone) BitVector(zone, flow_graph_->current_ssa_temp_index());
   for (intptr_t i = 0; i < values_.length(); i++) {
     set->Add(values_[i]->ssa_temp_index());
   }
   for (intptr_t i = 0; i < constraints_.length(); i++) {
     set->Add(constraints_[i]->ssa_temp_index());
   }
 
   // Collect integer definitions (including constraints) in the reverse
   // postorder. This improves convergence speed compared to iterating
   // values_ and constraints_ array separately.
@@ skipping 71 matching lines @@
   explicit Scheduler(FlowGraph* flow_graph)
       : flow_graph_(flow_graph),
         loop_headers_(flow_graph->LoopHeaders()),
         pre_headers_(loop_headers_.length()) {
     for (intptr_t i = 0; i < loop_headers_.length(); i++) {
       pre_headers_.Add(loop_headers_[i]->ImmediateDominator());
     }
   }
 
   // Clear the list of emitted instructions.
-  void Start() {
-    emitted_.Clear();
-  }
+  void Start() { emitted_.Clear(); }
 
   // Given the floating instruction attempt to schedule it into one of the
   // loop preheaders that dominates given post_dominator instruction.
   // Some of the instruction inputs can potentially be unscheduled as well.
   // Returns NULL is the scheduling fails (e.g. inputs are not invariant for
   // any loop containing post_dominator).
   // Resulting schedule should be equivalent to one obtained by inserting
   // instructions right before post_dominator and running CSE and LICM passes.
-  template<typename T>
+  template <typename T>
   T* Emit(T* instruction, Instruction* post_dominator) {
     return static_cast<T*>(EmitRecursively(instruction, post_dominator));
   }
 
   // Undo all insertions recorded in the list of emitted instructions.
   void Rollback() {
     for (intptr_t i = emitted_.length() - 1; i >= 0; i--) {
       emitted_[i]->RemoveFromGraph();
     }
     emitted_.Clear();
   }
 
  private:
-  typedef DirectChainedHashMap<PointerKeyValueTrait<Instruction> >  Map;
+  typedef DirectChainedHashMap<PointerKeyValueTrait<Instruction> > Map;
 
-  Instruction* EmitRecursively(Instruction* instruction,
-                               Instruction* sink) {
+  Instruction* EmitRecursively(Instruction* instruction, Instruction* sink) {
     // Schedule all unscheduled inputs and unwrap all constrained inputs.
     for (intptr_t i = 0; i < instruction->InputCount(); i++) {
       Definition* defn = instruction->InputAt(i)->definition();
 
       // Instruction is not in the graph yet which means that none of
       // its input uses should be recorded at defn's use chains.
       // Verify this assumption to ensure that we are not going to
       // leave use-lists in an inconsistent state when we start
       // rewriting inputs via set_definition.
       ASSERT(instruction->InputAt(i)->IsSingleUse() &&
              !defn->HasOnlyInputUse(instruction->InputAt(i)));
 
       if (!defn->HasSSATemp()) {
         Definition* scheduled = Emit(defn, sink);
         if (scheduled == NULL) {
           return NULL;
         }
         instruction->InputAt(i)->set_definition(scheduled);
       } else if (defn->IsConstraint()) {
         instruction->InputAt(i)->set_definition(UnwrapConstraint(defn));
       }
     }
 
     // Attempt to find equivalent instruction that was already scheduled.
     // If the instruction is still in the graph (it could have been
     // un-scheduled by a rollback action) and it dominates the sink - use it.
     Instruction* emitted = map_.LookupValue(instruction);
-    if (emitted != NULL &&
-        !emitted->WasEliminated() &&
+    if (emitted != NULL && !emitted->WasEliminated() &&
         sink->IsDominatedBy(emitted)) {
       return emitted;
     }
 
     // Attempt to find suitable pre-header. Iterate loop headers backwards to
     // attempt scheduling into the outermost loop first.
     for (intptr_t i = loop_headers_.length() - 1; i >= 0; i--) {
       BlockEntryInstr* header = loop_headers_[i];
       BlockEntryInstr* pre_header = pre_headers_[i];
 
@@ skipping 20 matching lines @@
         EmitTo(pre_header, instruction);
         return instruction;
       }
     }
 
     return NULL;
   }
 
   void EmitTo(BlockEntryInstr* block, Instruction* instr) {
     GotoInstr* last = block->last_instruction()->AsGoto();
-    flow_graph_->InsertBefore(last,
-                              instr,
-                              last->env(),
-                              instr->IsDefinition() ? FlowGraph::kValue
-                                                    : FlowGraph::kEffect);
+    flow_graph_->InsertBefore(
+        last, instr, last->env(),
+        instr->IsDefinition() ? FlowGraph::kValue : FlowGraph::kEffect);
     instr->CopyDeoptIdFrom(*last);
     instr->env()->set_deopt_id(instr->deopt_id_);
 
     map_.Insert(instr);
     emitted_.Add(instr);
   }
 
   FlowGraph* flow_graph_;
   Map map_;
   const ZoneGrowableArray<BlockEntryInstr*>& loop_headers_;
   GrowableArray<BlockEntryInstr*> pre_headers_;
   GrowableArray<Instruction*> emitted_;
 };
 
 
 // If bounds check 0 <= index < length is not redundant we attempt to
 // replace it with a sequence of checks that guarantee
 //
 //           0 <= LowerBound(index) < UpperBound(index) < length
 //
 // and hoist all of those checks out of the enclosing loop.
 //
 // Upper/Lower bounds are symbolic arithmetic expressions with +, -, *
 // operations.
 class BoundsCheckGeneralizer {
  public:
-  BoundsCheckGeneralizer(RangeAnalysis* range_analysis,
-                         FlowGraph* flow_graph)
+  BoundsCheckGeneralizer(RangeAnalysis* range_analysis, FlowGraph* flow_graph)
       : range_analysis_(range_analysis),
         flow_graph_(flow_graph),
-        scheduler_(flow_graph) { }
+        scheduler_(flow_graph) {}
 
   void TryGeneralize(CheckArrayBoundInstr* check,
                      const RangeBoundary& array_length) {
     Definition* upper_bound =
         ConstructUpperBound(check->index()->definition(), check);
     if (upper_bound == UnwrapConstraint(check->index()->definition())) {
       // Unable to construct upper bound for the index.
       if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
         THR_Print("Failed to construct upper bound for %s index\n",
                   check->ToCString());
@@ skipping 15 matching lines @@
     range_analysis_->AssignRangesRecursively(upper_bound);
 
     // We are going to constrain any symbols participating in + and * operations
     // to guarantee that they are positive. Find all symbols that need
     // constraining. If there is a subtraction subexpression with non-positive
     // range give up on generalization for simplicity.
     GrowableArray<Definition*> non_positive_symbols;
     if (!FindNonPositiveSymbols(&non_positive_symbols, upper_bound)) {
 #ifndef PRODUCT
       if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
-        THR_Print("Failed to generalize %s index to %s"
-                  " (can't ensure positivity)\n",
-                  check->ToCString(),
-                  IndexBoundToCString(upper_bound));
+        THR_Print(
+            "Failed to generalize %s index to %s"
+            " (can't ensure positivity)\n",
+            check->ToCString(), IndexBoundToCString(upper_bound));
       }
 #endif  // !PRODUCT
       return;
     }
 
     // Check that we can statically prove that lower bound of the index is
     // non-negative under the assumption that all potentially non-positive
     // symbols are positive.
     GrowableArray<ConstraintInstr*> positive_constraints(
         non_positive_symbols.length());
-    Range* positive_range = new Range(
-        RangeBoundary::FromConstant(0),
-        RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundarySmi));
+    Range* positive_range =
+        new Range(RangeBoundary::FromConstant(0),
+                  RangeBoundary::MaxConstant(RangeBoundary::kRangeBoundarySmi));
     for (intptr_t i = 0; i < non_positive_symbols.length(); i++) {
       Definition* symbol = non_positive_symbols[i];
-      positive_constraints.Add(new ConstraintInstr(
-          new Value(symbol),
-          positive_range));
+      positive_constraints.Add(
+          new ConstraintInstr(new Value(symbol), positive_range));
     }
 
     Definition* lower_bound =
-      ConstructLowerBound(check->index()->definition(), check);
+        ConstructLowerBound(check->index()->definition(), check);
     // No need to simplify lower bound before applying constraints as
     // we are not going to emit it.
     lower_bound = ApplyConstraints(lower_bound, check, &positive_constraints);
     range_analysis_->AssignRangesRecursively(lower_bound);
 
     if (!RangeUtils::IsPositive(lower_bound->range())) {
-      // Can't prove that lower bound is positive even with additional checks
-      // against potentially non-positive symbols. Give up.
+// Can't prove that lower bound is positive even with additional checks
+// against potentially non-positive symbols. Give up.
 #ifndef PRODUCT
       if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
-        THR_Print("Failed to generalize %s index to %s"
-                  " (lower bound is not positive)\n",
-                  check->ToCString(),
-                  IndexBoundToCString(upper_bound));
+        THR_Print(
+            "Failed to generalize %s index to %s"
+            " (lower bound is not positive)\n",
+            check->ToCString(), IndexBoundToCString(upper_bound));
       }
 #endif  // !PRODUCT
       return;
     }
 
 #ifndef PRODUCT
     if (FLAG_support_il_printer && FLAG_trace_range_analysis) {
-      THR_Print("For %s computed index bounds [%s, %s]\n",
-                check->ToCString(),
+      THR_Print("For %s computed index bounds [%s, %s]\n", check->ToCString(),
                 IndexBoundToCString(lower_bound),
                 IndexBoundToCString(upper_bound));
     }
 #endif  // !PRODUCT
 
     // At this point we know that 0 <= index < UpperBound(index) under
     // certain preconditions. Start by emitting this preconditions.
     scheduler_.Start();
 
     ConstantInstr* max_smi =
         flow_graph_->GetConstant(Smi::Handle(Smi::New(Smi::kMaxValue)));
     for (intptr_t i = 0; i < non_positive_symbols.length(); i++) {
       CheckArrayBoundInstr* precondition = new CheckArrayBoundInstr(
-          new Value(max_smi),
-          new Value(non_positive_symbols[i]),
+          new Value(max_smi), new Value(non_positive_symbols[i]),
           Thread::kNoDeoptId);
       precondition->mark_generalized();
       precondition = scheduler_.Emit(precondition, check);
       if (precondition == NULL) {
         if (FLAG_trace_range_analysis) {
           THR_Print("  => failed to insert positivity constraint\n");
         }
         scheduler_.Rollback();
         return;
       }
     }
 
     CheckArrayBoundInstr* new_check = new CheckArrayBoundInstr(
-          new Value(UnwrapConstraint(check->length()->definition())),
-          new Value(upper_bound),
-          Thread::kNoDeoptId);
+        new Value(UnwrapConstraint(check->length()->definition())),
+        new Value(upper_bound), Thread::kNoDeoptId);
     new_check->mark_generalized();
     if (new_check->IsRedundant(array_length)) {
       if (FLAG_trace_range_analysis) {
         THR_Print("  => generalized check is redundant\n");
       }
       RemoveGeneralizedCheck(check);
       return;
     }
 
     new_check = scheduler_.Emit(new_check, check);
     if (new_check != NULL) {
       if (FLAG_trace_range_analysis) {
         THR_Print("  => generalized check was hoisted into B%" Pd "\n",
                   new_check->GetBlock()->block_id());
       }
       RemoveGeneralizedCheck(check);
     } else {
       if (FLAG_trace_range_analysis) {
         THR_Print("  => generalized check can't be hoisted\n");
       }
       scheduler_.Rollback();
     }
   }
 
   static void RemoveGeneralizedCheck(CheckArrayBoundInstr* check) {
-    BinarySmiOpInstr* binary_op =
-        check->index()->definition()->AsBinarySmiOp();
+    BinarySmiOpInstr* binary_op = check->index()->definition()->AsBinarySmiOp();
     if (binary_op != NULL) {
       binary_op->set_can_overflow(false);
     }
     check->RemoveFromGraph();
   }
 
  private:
   BinarySmiOpInstr* MakeBinaryOp(Token::Kind op_kind,
                                  Definition* left,
                                  Definition* right) {
-    return new BinarySmiOpInstr(op_kind,
-                                new Value(left),
-                                new Value(right),
+    return new BinarySmiOpInstr(op_kind, new Value(left), new Value(right),
                                 Thread::kNoDeoptId);
   }
 
 
   BinarySmiOpInstr* MakeBinaryOp(Token::Kind op_kind,
                                  Definition* left,
                                  intptr_t right) {
     ConstantInstr* constant_right =
         flow_graph_->GetConstant(Smi::Handle(Smi::New(right)));
     return MakeBinaryOp(op_kind, left, constant_right);
   }
 
   Definition* RangeBoundaryToDefinition(const RangeBoundary& bound) {
     Definition* symbol = UnwrapConstraint(bound.symbol());
     if (bound.offset() == 0) {
       return symbol;
     } else {
       return MakeBinaryOp(Token::kADD, symbol, bound.offset());
     }
   }
 
-  typedef Definition* (BoundsCheckGeneralizer::*PhiBoundFunc)(
-      PhiInstr*, Instruction*);
+  typedef Definition* (BoundsCheckGeneralizer::*PhiBoundFunc)(PhiInstr*,
+                                                              Instruction*);
 
   // Construct symbolic lower bound for a value at the given point.
   Definition* ConstructLowerBound(Definition* value, Instruction* point) {
     return ConstructBound(&BoundsCheckGeneralizer::InductionVariableLowerBound,
-                          value,
-                          point);
+                          value, point);
   }
 
   // Construct symbolic upper bound for a value at the given point.
   Definition* ConstructUpperBound(Definition* value, Instruction* point) {
     return ConstructBound(&BoundsCheckGeneralizer::InductionVariableUpperBound,
-                          value,
-                          point);
+                          value, point);
   }
 
   // Construct symbolic bound for a value at the given point:
   //
   //   1. if value is an induction variable use its bounds;
   //   2. if value is addition or multiplication construct bounds for left
   //      and right hand sides separately and use addition/multiplication
   //      of bounds as a bound (addition and multiplication are monotone
   //      operations for both operands);
   //   3. if value is a substraction then construct bound for the left hand
@@ skipping 10 matching lines @@
       if (phi->induction_variable_info() != NULL) {
         return (this->*phi_bound_func)(phi, point);
       }
     } else if (value->IsBinarySmiOp()) {
       BinarySmiOpInstr* bin_op = value->AsBinarySmiOp();
       if ((bin_op->op_kind() == Token::kADD) ||
           (bin_op->op_kind() == Token::kMUL) ||
           (bin_op->op_kind() == Token::kSUB)) {
         Definition* new_left =
             ConstructBound(phi_bound_func, bin_op->left()->definition(), point);
-        Definition* new_right = (bin_op->op_kind() != Token::kSUB)
-            ? ConstructBound(phi_bound_func,
-                             bin_op->right()->definition(),
-                             point)
-            : UnwrapConstraint(bin_op->right()->definition());
+        Definition* new_right =
+            (bin_op->op_kind() != Token::kSUB)
+                ? ConstructBound(phi_bound_func, bin_op->right()->definition(),
+                                 point)
+                : UnwrapConstraint(bin_op->right()->definition());
 
         if ((new_left != UnwrapConstraint(bin_op->left()->definition())) ||
             (new_right != UnwrapConstraint(bin_op->right()->definition()))) {
           return MakeBinaryOp(bin_op->op_kind(), new_left, new_right);
         }
       }
     }
 
     return value;
   }
 
-  Definition* InductionVariableUpperBound(PhiInstr* phi,
-                                          Instruction* point) {
+  Definition* InductionVariableUpperBound(PhiInstr* phi, Instruction* point) {
     const InductionVariableInfo& info = *phi->induction_variable_info();
     if (info.bound() == phi) {
       if (point->IsDominatedBy(info.limit())) {
         // Given induction variable
         //
         //          x <- phi(x0, x + 1)
         //
         // and a constraint x <= M that dominates the given
         // point we conclude that M is an upper bound for x.
         return RangeBoundaryToDefinition(info.limit()->constraint()->max());
       }
     } else {
       const InductionVariableInfo& bound_info =
           *info.bound()->induction_variable_info();
       if (point->IsDominatedBy(bound_info.limit())) {
         // Given two induction variables
         //
         //          x <- phi(x0, x + 1)
         //          y <- phi(y0, y + 1)
         //
         // and a constraint x <= M that dominates the given
         // point we can conclude that
         //
         //          y <= y0 + (M - x0)
         //
-        Definition* limit = RangeBoundaryToDefinition(
-            bound_info.limit()->constraint()->max());
-        BinarySmiOpInstr* loop_length =
-            MakeBinaryOp(Token::kSUB,
-                         ConstructUpperBound(limit, point),
-                         ConstructLowerBound(bound_info.initial_value(),
-                                             point));
+        Definition* limit =
+            RangeBoundaryToDefinition(bound_info.limit()->constraint()->max());
+        BinarySmiOpInstr* loop_length = MakeBinaryOp(
+            Token::kSUB, ConstructUpperBound(limit, point),
+            ConstructLowerBound(bound_info.initial_value(), point));
         return MakeBinaryOp(Token::kADD,
                             ConstructUpperBound(info.initial_value(), point),
                             loop_length);
       }
     }
 
     return phi;
   }
 
-  Definition* InductionVariableLowerBound(PhiInstr* phi,
-                                          Instruction* point) {
+  Definition* InductionVariableLowerBound(PhiInstr* phi, Instruction* point) {
     // Given induction variable
     //
     //          x <- phi(x0, x + 1)
     //
     // we can conclude that LowerBound(x) == x0.
     const InductionVariableInfo& info = *phi->induction_variable_info();
     return ConstructLowerBound(info.initial_value(), point);
   }
 
   // Try to re-associate binary operations in the floating DAG of operations
@@ skipping 103 matching lines @@
       ASSERT(right != NULL);
 
       const bool left_changed = (left != binary_op->left()->definition());
       const bool right_changed = (right != binary_op->right()->definition());
       if (left_changed || right_changed) {
         if (!(*defn)->HasSSATemp()) {
           if (left_changed) binary_op->left()->set_definition(left);
           if (right_changed) binary_op->right()->set_definition(right);
           *defn = binary_op;
         } else {
-          *defn = MakeBinaryOp(binary_op->op_kind(),
-                               UnwrapConstraint(left),
+          *defn = MakeBinaryOp(binary_op->op_kind(), UnwrapConstraint(left),
                                UnwrapConstraint(right));
         }
       }
 
       if ((c != 0) && (constant == NULL)) {
         *defn = MakeBinaryOp(Token::kADD, *defn, c);
       }
     } else if ((*defn)->IsConstant()) {
       ConstantInstr* constant_defn = (*defn)->AsConstant();
       if ((constant != NULL) && constant_defn->value().IsSmi()) {
@@ skipping 30 matching lines @@
       }
 
       if (binary_op->op_kind() == Token::kSUB) {
         // For addition and multiplication it's enough to ensure that
         // lhs and rhs are positive to guarantee that defn as whole is
         // positive. This does not work for substraction so just give up.
         return false;
       }
 
       return FindNonPositiveSymbols(symbols, binary_op->left()->definition()) &&
-        FindNonPositiveSymbols(symbols, binary_op->right()->definition());
+             FindNonPositiveSymbols(symbols, binary_op->right()->definition());
     }
     UNREACHABLE();
     return false;
   }
 
   // Find innermost constraint for the given definition dominating given
   // instruction.
   static Definition* FindInnermostConstraint(Definition* defn,
                                              Instruction* post_dominator) {
-    for (Value* use = defn->input_use_list();
-         use != NULL;
+    for (Value* use = defn->input_use_list(); use != NULL;
          use = use->next_use()) {
       ConstraintInstr* constraint = use->instruction()->AsConstraint();
       if ((constraint != NULL) && post_dominator->IsDominatedBy(constraint)) {
         return FindInnermostConstraint(constraint, post_dominator);
       }
     }
     return defn;
   }
 
   // Replace symbolic parts of the boundary with respective constraints
@@ skipping 12 matching lines @@
           ConstraintInstr* constraint = (*constraints)[i];
           if (constraint->value()->definition() == defn) {
             return constraint;
           }
         }
       }
       return defn;
     }
 
     for (intptr_t i = 0; i < defn->InputCount(); i++) {
-      defn->InputAt(i)->set_definition(
-          ApplyConstraints(defn->InputAt(i)->definition(),
-                           post_dominator,
-                           constraints));
+      defn->InputAt(i)->set_definition(ApplyConstraints(
+          defn->InputAt(i)->definition(), post_dominator, constraints));
     }
 
     return defn;
   }
 
 #ifndef PRODUCT
   static void PrettyPrintIndexBoundRecursively(BufferFormatter* f,
                                                Definition* index_bound) {
     BinarySmiOpInstr* binary_op = index_bound->AsBinarySmiOp();
     if (binary_op != NULL) {
@@ skipping 26 matching lines @@
 };
 
 
 void RangeAnalysis::EliminateRedundantBoundsChecks() {
   if (FLAG_array_bounds_check_elimination) {
     const Function& function = flow_graph_->function();
     // Generalization only if we have not deoptimized on a generalized
     // check earlier, or we're compiling precompiled code (no
     // optimistic hoisting of checks possible)
     const bool try_generalization =
-        function.allows_bounds_check_generalization() &&
-        !FLAG_precompiled_mode;
+        function.allows_bounds_check_generalization() && !FLAG_precompiled_mode;
 
     BoundsCheckGeneralizer generalizer(this, flow_graph_);
 
     for (intptr_t i = 0; i < bounds_checks_.length(); i++) {
       CheckArrayBoundInstr* check = bounds_checks_[i];
       RangeBoundary array_length =
           RangeBoundary::FromDefinition(check->length()->definition());
       if (check->IsRedundant(array_length)) {
         check->RemoveFromGraph();
       } else if (try_generalization) {
@@ skipping 53 matching lines @@
     }
     constraints_[i]->ReplaceUsesWith(def);
     constraints_[i]->RemoveFromGraph();
   }
 }
 
 
 static void NarrowBinaryMintOp(BinaryMintOpInstr* mint_op) {
   if (RangeUtils::Fits(mint_op->range(), RangeBoundary::kRangeBoundaryInt32) &&
       RangeUtils::Fits(mint_op->left()->definition()->range(),
-                  RangeBoundary::kRangeBoundaryInt32) &&
+                       RangeBoundary::kRangeBoundaryInt32) &&
       RangeUtils::Fits(mint_op->right()->definition()->range(),
-                  RangeBoundary::kRangeBoundaryInt32) &&
-      BinaryInt32OpInstr::IsSupported(mint_op->op_kind(),
-                                      mint_op->left(),
+                       RangeBoundary::kRangeBoundaryInt32) &&
+      BinaryInt32OpInstr::IsSupported(mint_op->op_kind(), mint_op->left(),
                                       mint_op->right())) {
-    BinaryInt32OpInstr* int32_op =
-        new BinaryInt32OpInstr(mint_op->op_kind(),
-                               mint_op->left()->CopyWithType(),
-                               mint_op->right()->CopyWithType(),
-                               mint_op->DeoptimizationTarget());
+    BinaryInt32OpInstr* int32_op = new BinaryInt32OpInstr(
+        mint_op->op_kind(), mint_op->left()->CopyWithType(),
+        mint_op->right()->CopyWithType(), mint_op->DeoptimizationTarget());
     int32_op->set_range(*mint_op->range());
     int32_op->set_can_overflow(false);
     mint_op->ReplaceWith(int32_op, NULL);
   }
 }
 
 
 static void NarrowShiftMintOp(ShiftMintOpInstr* mint_op) {
   if (RangeUtils::Fits(mint_op->range(), RangeBoundary::kRangeBoundaryInt32) &&
       RangeUtils::Fits(mint_op->left()->definition()->range(),
-                  RangeBoundary::kRangeBoundaryInt32) &&
+                       RangeBoundary::kRangeBoundaryInt32) &&
       RangeUtils::Fits(mint_op->right()->definition()->range(),
-                  RangeBoundary::kRangeBoundaryInt32) &&
-      BinaryInt32OpInstr::IsSupported(mint_op->op_kind(),
-                                      mint_op->left(),
+                       RangeBoundary::kRangeBoundaryInt32) &&
+      BinaryInt32OpInstr::IsSupported(mint_op->op_kind(), mint_op->left(),
                                       mint_op->right())) {
-    BinaryInt32OpInstr* int32_op =
-        new BinaryInt32OpInstr(mint_op->op_kind(),
-                               mint_op->left()->CopyWithType(),
-                               mint_op->right()->CopyWithType(),
-                               mint_op->DeoptimizationTarget());
+    BinaryInt32OpInstr* int32_op = new BinaryInt32OpInstr(
+        mint_op->op_kind(), mint_op->left()->CopyWithType(),
+        mint_op->right()->CopyWithType(), mint_op->DeoptimizationTarget());
     int32_op->set_range(*mint_op->range());
     int32_op->set_can_overflow(false);
     mint_op->ReplaceWith(int32_op, NULL);
   }
 }
 
 
 void RangeAnalysis::NarrowMintToInt32() {
   for (intptr_t i = 0; i < binary_mint_ops_.length(); i++) {
     NarrowBinaryMintOp(binary_mint_ops_[i]);
   }
 
   for (intptr_t i = 0; i < shift_mint_ops_.length(); i++) {
     NarrowShiftMintOp(shift_mint_ops_[i]);
   }
 }
 
 
 IntegerInstructionSelector::IntegerInstructionSelector(FlowGraph* flow_graph)
     : flow_graph_(flow_graph) {
   ASSERT(flow_graph_ != NULL);
   zone_ = flow_graph_->zone();
   selected_uint32_defs_ =
-      new(zone_) BitVector(zone_, flow_graph_->current_ssa_temp_index());
+      new (zone_) BitVector(zone_, flow_graph_->current_ssa_temp_index());
 }
 
 
 void IntegerInstructionSelector::Select() {
   if (FLAG_trace_integer_ir_selection) {
     THR_Print("---- starting integer ir selection -------\n");
   }
   FindPotentialUint32Definitions();
   FindUint32NarrowingDefinitions();
   Propagate();
   ReplaceInstructions();
   if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
     THR_Print("---- after integer ir selection -------\n");
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 }
 
 
 bool IntegerInstructionSelector::IsPotentialUint32Definition(Definition* def) {
   // TODO(johnmccutchan): Consider Smi operations, to avoid unnecessary tagging
   // & untagged of intermediate results.
   // TODO(johnmccutchan): Consider phis.
-  return def->IsBoxInt64() ||
-         def->IsUnboxInt64() ||
-         def->IsBinaryMintOp() ||
-         def->IsShiftMintOp()  ||
-         def->IsUnaryMintOp();
+  return def->IsBoxInt64() || def->IsUnboxInt64() || def->IsBinaryMintOp() ||
+         def->IsShiftMintOp() || def->IsUnaryMintOp();
 }
 
 
 void IntegerInstructionSelector::FindPotentialUint32Definitions() {
   if (FLAG_trace_integer_ir_selection) {
     THR_Print("++++ Finding potential Uint32 definitions:\n");
   }
 
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
-       !block_it.Done();
-       block_it.Advance()) {
+       !block_it.Done(); block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
 
-    for (ForwardInstructionIterator instr_it(block);
-         !instr_it.Done();
+    for (ForwardInstructionIterator instr_it(block); !instr_it.Done();
          instr_it.Advance()) {
       Instruction* current = instr_it.Current();
       Definition* defn = current->AsDefinition();
       if ((defn != NULL) && defn->HasSSATemp()) {
         if (IsPotentialUint32Definition(defn)) {
           if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
-           THR_Print("Adding %s\n", current->ToCString());
+            THR_Print("Adding %s\n", current->ToCString());
           }
           potential_uint32_defs_.Add(defn);
         }
       }
     }
   }
 }
 
 
 // BinaryMintOp masks and stores into unsigned typed arrays that truncate the
@@ skipping 29 matching lines @@
       if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
         THR_Print("Adding %s\n", defn->ToCString());
       }
       selected_uint32_defs_->Add(defn->ssa_temp_index());
     }
   }
 }
 
 
 bool IntegerInstructionSelector::AllUsesAreUint32Narrowing(Value* list_head) {
-  for (Value::Iterator it(list_head);
-       !it.Done();
-       it.Advance()) {
+  for (Value::Iterator it(list_head); !it.Done(); it.Advance()) {
     Value* use = it.Current();
     Definition* defn = use->instruction()->AsDefinition();
-    if ((defn == NULL) ||
-        !defn->HasSSATemp() ||
+    if ((defn == NULL) || !defn->HasSSATemp() ||
         !selected_uint32_defs_->Contains(defn->ssa_temp_index())) {
       return false;
     }
   }
   return true;
 }
 
 
 bool IntegerInstructionSelector::CanBecomeUint32(Definition* def) {
   ASSERT(IsPotentialUint32Definition(def));
@@ skipping 66 matching lines @@
   // Should only see mint definitions.
   ASSERT(IsPotentialUint32Definition(def));
   // Should not see constant instructions.
   ASSERT(!def->IsConstant());
   if (def->IsBinaryMintOp()) {
     BinaryMintOpInstr* op = def->AsBinaryMintOp();
     Token::Kind op_kind = op->op_kind();
     Value* left = op->left()->CopyWithType();
     Value* right = op->right()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
-    return new(Z) BinaryUint32OpInstr(op_kind, left, right, deopt_id);
+    return new (Z) BinaryUint32OpInstr(op_kind, left, right, deopt_id);
   } else if (def->IsBoxInt64()) {
     Value* value = def->AsBoxInt64()->value()->CopyWithType();
-    return new(Z) BoxUint32Instr(value);
+    return new (Z) BoxUint32Instr(value);
   } else if (def->IsUnboxInt64()) {
     UnboxInstr* unbox = def->AsUnboxInt64();
     Value* value = unbox->value()->CopyWithType();
     intptr_t deopt_id = unbox->DeoptimizationTarget();
-    return new(Z) UnboxUint32Instr(value, deopt_id);
+    return new (Z) UnboxUint32Instr(value, deopt_id);
   } else if (def->IsUnaryMintOp()) {
     UnaryMintOpInstr* op = def->AsUnaryMintOp();
     Token::Kind op_kind = op->op_kind();
     Value* value = op->value()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
-    return new(Z) UnaryUint32OpInstr(op_kind, value, deopt_id);
+    return new (Z) UnaryUint32OpInstr(op_kind, value, deopt_id);
   } else if (def->IsShiftMintOp()) {
     ShiftMintOpInstr* op = def->AsShiftMintOp();
     Token::Kind op_kind = op->op_kind();
     Value* left = op->left()->CopyWithType();
     Value* right = op->right()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
-    return new(Z) ShiftUint32OpInstr(op_kind, left, right, deopt_id);
+    return new (Z) ShiftUint32OpInstr(op_kind, left, right, deopt_id);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void IntegerInstructionSelector::ReplaceInstructions() {
   if (FLAG_trace_integer_ir_selection) {
     THR_Print("++++ Replacing instructions:\n");
   }
   for (intptr_t i = 0; i < potential_uint32_defs_.length(); i++) {
     Definition* defn = potential_uint32_defs_[i];
     if (!selected_uint32_defs_->Contains(defn->ssa_temp_index())) {
       // Not a candidate.
       continue;
     }
     Definition* replacement = ConstructReplacementFor(defn);
     ASSERT(replacement != NULL);
     if (FLAG_support_il_printer && FLAG_trace_integer_ir_selection) {
       THR_Print("Replacing %s with %s\n", defn->ToCString(),
-                                          replacement->ToCString());
+                replacement->ToCString());
     }
     if (!Range::IsUnknown(defn->range())) {
       replacement->set_range(*defn->range());
     }
     defn->ReplaceWith(replacement, NULL);
     ASSERT(flow_graph_->VerifyUseLists());
   }
 }
 
 
 RangeBoundary RangeBoundary::FromDefinition(Definition* defn, int64_t offs) {
   if (defn->IsConstant() && defn->AsConstant()->value().IsSmi()) {
     return FromConstant(Smi::Cast(defn->AsConstant()->value()).Value() + offs);
   }
   return RangeBoundary(kSymbol, reinterpret_cast<intptr_t>(defn), offs);
 }
 
 
 RangeBoundary RangeBoundary::LowerBound() const {
   if (IsInfinity()) {
     return NegativeInfinity();
   }
   if (IsConstant()) return *this;
   return Add(Range::ConstantMinSmi(symbol()->range()),
-             RangeBoundary::FromConstant(offset_),
-             NegativeInfinity());
+             RangeBoundary::FromConstant(offset_), NegativeInfinity());
 }
 
 
 RangeBoundary RangeBoundary::UpperBound() const {
   if (IsInfinity()) {
     return PositiveInfinity();
   }
   if (IsConstant()) return *this;
 
   return Add(Range::ConstantMaxSmi(symbol()->range()),
-             RangeBoundary::FromConstant(offset_),
-             PositiveInfinity());
+             RangeBoundary::FromConstant(offset_), PositiveInfinity());
 }
 
 
 RangeBoundary RangeBoundary::Add(const RangeBoundary& a,
                                  const RangeBoundary& b,
                                  const RangeBoundary& overflow) {
   if (a.IsInfinity() || b.IsInfinity()) return overflow;
 
   ASSERT(a.IsConstant() && b.IsConstant());
   if (Utils::WillAddOverflow(a.ConstantValue(), b.ConstantValue())) {
@@ skipping 72 matching lines @@
 
 
 RangeBoundary RangeBoundary::Shl(const RangeBoundary& value_boundary,
                                  int64_t shift_count,
                                  const RangeBoundary& overflow) {
   ASSERT(value_boundary.IsConstant());
   ASSERT(shift_count >= 0);
   int64_t limit = 64 - shift_count;
   int64_t value = value_boundary.ConstantValue();
 
-  if ((value == 0) ||
-      (shift_count == 0) ||
+  if ((value == 0) || (shift_count == 0) ||
       ((limit > 0) && Utils::IsInt(static_cast<int>(limit), value))) {
     // Result stays in 64 bit range.
     int64_t result = value << shift_count;
     return RangeBoundary(result);
   }
 
   return overflow;
 }
 
 
@@ skipping 126 matching lines @@
 }
 
 
 RangeBoundary RangeBoundary::JoinMin(RangeBoundary a,
                                      RangeBoundary b,
                                      RangeBoundary::RangeSize size) {
   if (a.Equals(b)) {
     return b;
   }
 
-  if (CanonicalizeForComparison(&a,
-                                &b,
-                                &CanonicalizeMinBoundary,
+  if (CanonicalizeForComparison(&a, &b, &CanonicalizeMinBoundary,
                                 RangeBoundary::NegativeInfinity())) {
     return (a.offset() <= b.offset()) ? a : b;
   }
 
   const int64_t inf_a = a.LowerBound(size);
   const int64_t inf_b = b.LowerBound(size);
   const int64_t sup_a = a.UpperBound(size);
   const int64_t sup_b = b.UpperBound(size);
 
   if ((sup_a <= inf_b) && !a.LowerBound().Overflowed(size)) {
     return a;
   } else if ((sup_b <= inf_a) && !b.LowerBound().Overflowed(size)) {
     return b;
   } else {
     return RangeBoundary::FromConstant(Utils::Minimum(inf_a, inf_b));
   }
 }
 
 
 RangeBoundary RangeBoundary::JoinMax(RangeBoundary a,
                                      RangeBoundary b,
                                      RangeBoundary::RangeSize size) {
   if (a.Equals(b)) {
     return b;
   }
 
-  if (CanonicalizeForComparison(&a,
-                                &b,
-                                &CanonicalizeMaxBoundary,
+  if (CanonicalizeForComparison(&a, &b, &CanonicalizeMaxBoundary,
                                 RangeBoundary::PositiveInfinity())) {
     return (a.offset() >= b.offset()) ? a : b;
   }
 
   const int64_t inf_a = a.LowerBound(size);
   const int64_t inf_b = b.LowerBound(size);
   const int64_t sup_a = a.UpperBound(size);
   const int64_t sup_b = b.UpperBound(size);
 
   if ((sup_a <= inf_b) && !b.UpperBound().Overflowed(size)) {
@@ skipping 13 matching lines @@
   if (a.Equals(b)) {
     return a;
   }
 
   if (a.IsMinimumOrBelow(RangeBoundary::kRangeBoundarySmi)) {
     return b;
   } else if (b.IsMinimumOrBelow(RangeBoundary::kRangeBoundarySmi)) {
     return a;
   }
 
-  if (CanonicalizeForComparison(&a,
-                                &b,
-                                &CanonicalizeMinBoundary,
+  if (CanonicalizeForComparison(&a, &b, &CanonicalizeMinBoundary,
                                 RangeBoundary::NegativeInfinity())) {
     return (a.offset() >= b.offset()) ? a : b;
   }
 
   const int64_t inf_a = a.SmiLowerBound();
   const int64_t inf_b = b.SmiLowerBound();
 
   return (inf_a >= inf_b) ? a : b;
 }
 
 
 RangeBoundary RangeBoundary::IntersectionMax(RangeBoundary a, RangeBoundary b) {
   ASSERT(!a.IsNegativeInfinity() && !b.IsNegativeInfinity());
   ASSERT(!a.IsUnknown() && !b.IsUnknown());
 
   if (a.Equals(b)) {
     return a;
   }
 
   if (a.IsMaximumOrAbove(RangeBoundary::kRangeBoundarySmi)) {
     return b;
   } else if (b.IsMaximumOrAbove(RangeBoundary::kRangeBoundarySmi)) {
     return a;
   }
 
-  if (CanonicalizeForComparison(&a,
-                                &b,
-                                &CanonicalizeMaxBoundary,
+  if (CanonicalizeForComparison(&a, &b, &CanonicalizeMaxBoundary,
                                 RangeBoundary::PositiveInfinity())) {
     return (a.offset() <= b.offset()) ? a : b;
   }
 
   const int64_t sup_a = a.SmiUpperBound();
   const int64_t sup_b = b.SmiUpperBound();
 
   return (sup_a <= sup_b) ? a : b;
 }
 
 
 int64_t RangeBoundary::ConstantValue() const {
   ASSERT(IsConstant());
   return value_;
 }
 
 
 bool Range::IsPositive() const {
   return OnlyGreaterThanOrEqualTo(0);
 }
 
 
 bool Range::OnlyLessThanOrEqualTo(int64_t val) const {
   const RangeBoundary upper_bound = max().UpperBound();
   return !upper_bound.IsPositiveInfinity() &&
-      (upper_bound.ConstantValue() <= val);
+         (upper_bound.ConstantValue() <= val);
 }
 
 
 bool Range::OnlyGreaterThanOrEqualTo(int64_t val) const {
   const RangeBoundary lower_bound = min().LowerBound();
   return !lower_bound.IsNegativeInfinity() &&
-      (lower_bound.ConstantValue() >= val);
+         (lower_bound.ConstantValue() >= val);
 }
 
 
 // Inclusive.
 bool Range::IsWithin(int64_t min_int, int64_t max_int) const {
-  return OnlyGreaterThanOrEqualTo(min_int) &&
-      OnlyLessThanOrEqualTo(max_int);
+  return OnlyGreaterThanOrEqualTo(min_int) && OnlyLessThanOrEqualTo(max_int);
 }
 
 
 bool Range::Overlaps(int64_t min_int, int64_t max_int) const {
   RangeBoundary lower = min().LowerBound();
   RangeBoundary upper = max().UpperBound();
-  const int64_t this_min = lower.IsNegativeInfinity() ?
-      RangeBoundary::kMin : lower.ConstantValue();
-  const int64_t this_max = upper.IsPositiveInfinity() ?
-      RangeBoundary::kMax : upper.ConstantValue();
+  const int64_t this_min =
+      lower.IsNegativeInfinity() ? RangeBoundary::kMin : lower.ConstantValue();
+  const int64_t this_max =
+      upper.IsPositiveInfinity() ? RangeBoundary::kMax : upper.ConstantValue();
   if ((this_min <= min_int) && (min_int <= this_max)) return true;
   if ((this_min <= max_int) && (max_int <= this_max)) return true;
   if ((min_int < this_min) && (max_int > this_max)) return true;
   return false;
 }
 
 
 bool Range::IsUnsatisfiable() const {
   // Infinity case: [+inf, ...] || [..., -inf]
   if (min().IsPositiveInfinity() || max().IsNegativeInfinity()) {
@@ skipping 26 matching lines @@
   RangeBoundary left_max = Range::ConstantMax(left);
   RangeBoundary left_min = Range::ConstantMin(left);
   // A negative shift count always deoptimizes (and throws), so the minimum
   // shift count is zero.
   int64_t right_max = Utils::Maximum(Range::ConstantMax(right).ConstantValue(),
                                      static_cast<int64_t>(0));
   int64_t right_min = Utils::Maximum(Range::ConstantMin(right).ConstantValue(),
                                      static_cast<int64_t>(0));
 
   *result_min = RangeBoundary::Shl(
-      left_min,
-      left_min.ConstantValue() > 0 ? right_min : right_max,
-      left_min.ConstantValue() > 0
-          ? RangeBoundary::PositiveInfinity()
-          : RangeBoundary::NegativeInfinity());
+      left_min, left_min.ConstantValue() > 0 ? right_min : right_max,
+      left_min.ConstantValue() > 0 ? RangeBoundary::PositiveInfinity()
+                                   : RangeBoundary::NegativeInfinity());
 
   *result_max = RangeBoundary::Shl(
-      left_max,
-      left_max.ConstantValue() > 0 ? right_max : right_min,
-      left_max.ConstantValue() > 0
-          ? RangeBoundary::PositiveInfinity()
-          : RangeBoundary::NegativeInfinity());
+      left_max, left_max.ConstantValue() > 0 ? right_max : right_min,
+      left_max.ConstantValue() > 0 ? RangeBoundary::PositiveInfinity()
+                                   : RangeBoundary::NegativeInfinity());
 }
 
 
 void Range::Shr(const Range* left,
                 const Range* right,
                 RangeBoundary* result_min,
                 RangeBoundary* result_max) {
   RangeBoundary left_max = Range::ConstantMax(left);
   RangeBoundary left_min = Range::ConstantMin(left);
   // A negative shift count always deoptimizes (and throws), so the minimum
   // shift count is zero.
   int64_t right_max = Utils::Maximum(Range::ConstantMax(right).ConstantValue(),
                                      static_cast<int64_t>(0));
   int64_t right_min = Utils::Maximum(Range::ConstantMin(right).ConstantValue(),
                                      static_cast<int64_t>(0));
 
   *result_min = RangeBoundary::Shr(
-      left_min,
-      left_min.ConstantValue() > 0 ? right_max : right_min);
+      left_min, left_min.ConstantValue() > 0 ? right_max : right_min);
 
   *result_max = RangeBoundary::Shr(
-      left_max,
-      left_max.ConstantValue() > 0 ? right_min : right_max);
+      left_max, left_max.ConstantValue() > 0 ? right_min : right_max);
 }
 
 
 void Range::And(const Range* left_range,
                 const Range* right_range,
                 RangeBoundary* result_min,
                 RangeBoundary* result_max) {
   ASSERT(left_range != NULL);
   ASSERT(right_range != NULL);
   ASSERT(result_min != NULL);
@@ skipping 19 matching lines @@
   const int64_t min = Range::ConstantMin(range).ConstantValue();
   const int64_t max = Range::ConstantMax(range).ConstantValue();
   return Utils::Maximum(Utils::BitLength(min), Utils::BitLength(max));
 }
 
 
 void Range::BitwiseOp(const Range* left_range,
                       const Range* right_range,
                       RangeBoundary* result_min,
                       RangeBoundary* result_max) {
-  const int bitsize =
-      Utils::Maximum(BitSize(left_range), BitSize(right_range));
+  const int bitsize = Utils::Maximum(BitSize(left_range), BitSize(right_range));
 
   if (left_range->IsPositive() && right_range->IsPositive()) {
     *result_min = RangeBoundary::FromConstant(0);
   } else {
-    *result_min = RangeBoundary::FromConstant(
-        static_cast<int64_t>(-1) << bitsize);
+    *result_min =
+        RangeBoundary::FromConstant(static_cast<int64_t>(-1) << bitsize);
   }
 
-  *result_max = RangeBoundary::FromConstant(
-      (static_cast<uint64_t>(1) << bitsize) - 1);
+  *result_max =
+      RangeBoundary::FromConstant((static_cast<uint64_t>(1) << bitsize) - 1);
 }
 
 
 static bool IsArrayLength(Definition* defn) {
   if (defn == NULL) {
     return false;
   }
   LoadFieldInstr* load = UnwrapConstraint(defn)->AsLoadField();
   return (load != NULL) && load->IsImmutableLengthLoad();
 }
 
 
 void Range::Add(const Range* left_range,
                 const Range* right_range,
                 RangeBoundary* result_min,
                 RangeBoundary* result_max,
                 Definition* left_defn) {
   ASSERT(left_range != NULL);
   ASSERT(right_range != NULL);
   ASSERT(result_min != NULL);
   ASSERT(result_max != NULL);
 
-  RangeBoundary left_min =
-    IsArrayLength(left_defn) ?
-        RangeBoundary::FromDefinition(left_defn) : left_range->min();
+  RangeBoundary left_min = IsArrayLength(left_defn)
+                               ? RangeBoundary::FromDefinition(left_defn)
+                               : left_range->min();
 
-  RangeBoundary left_max =
-    IsArrayLength(left_defn) ?
-        RangeBoundary::FromDefinition(left_defn) : left_range->max();
+  RangeBoundary left_max = IsArrayLength(left_defn)
+                               ? RangeBoundary::FromDefinition(left_defn)
+                               : left_range->max();
 
   if (!RangeBoundary::SymbolicAdd(left_min, right_range->min(), result_min)) {
     *result_min = RangeBoundary::Add(left_range->min().LowerBound(),
                                      right_range->min().LowerBound(),
                                      RangeBoundary::NegativeInfinity());
   }
   if (!RangeBoundary::SymbolicAdd(left_max, right_range->max(), result_max)) {
     *result_max = RangeBoundary::Add(right_range->max().UpperBound(),
                                      left_range->max().UpperBound(),
                                      RangeBoundary::PositiveInfinity());
   }
 }
 
 
 void Range::Sub(const Range* left_range,
                 const Range* right_range,
                 RangeBoundary* result_min,
                 RangeBoundary* result_max,
                 Definition* left_defn) {
   ASSERT(left_range != NULL);
   ASSERT(right_range != NULL);
   ASSERT(result_min != NULL);
   ASSERT(result_max != NULL);
 
-  RangeBoundary left_min =
-    IsArrayLength(left_defn) ?
-        RangeBoundary::FromDefinition(left_defn) : left_range->min();
+  RangeBoundary left_min = IsArrayLength(left_defn)
+                               ? RangeBoundary::FromDefinition(left_defn)
+                               : left_range->min();
 
-  RangeBoundary left_max =
-    IsArrayLength(left_defn) ?
-        RangeBoundary::FromDefinition(left_defn) : left_range->max();
+  RangeBoundary left_max = IsArrayLength(left_defn)
+                               ? RangeBoundary::FromDefinition(left_defn)
+                               : left_range->max();
 
   if (!RangeBoundary::SymbolicSub(left_min, right_range->max(), result_min)) {
     *result_min = RangeBoundary::Sub(left_range->min().LowerBound(),
-                              right_range->max().UpperBound(),
-                              RangeBoundary::NegativeInfinity());
+                                     right_range->max().UpperBound(),
+                                     RangeBoundary::NegativeInfinity());
   }
   if (!RangeBoundary::SymbolicSub(left_max, right_range->min(), result_max)) {
     *result_max = RangeBoundary::Sub(left_range->max().UpperBound(),
                                      right_range->min().LowerBound(),
                                      RangeBoundary::PositiveInfinity());
   }
 }
 
 
 void Range::Mul(const Range* left_range,
@@ skipping 266 matching lines @@
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 void PhiInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   const RangeBoundary::RangeSize size = RangeSizeForPhi(this);
   for (intptr_t i = 0; i < InputCount(); i++) {
     Value* input = InputAt(i);
-    Join(range,
-         input->definition(),
-         GetInputRange(analysis, size, input),
+    Join(range, input->definition(), GetInputRange(analysis, size, input),
          size);
   }
 
   BlockEntryInstr* phi_block = GetBlock();
-  range->set_min(EnsureAcyclicSymbol(
-      phi_block, range->min(), RangeBoundary::MinSmi()));
-  range->set_max(EnsureAcyclicSymbol(
-      phi_block, range->max(), RangeBoundary::MaxSmi()));
+  range->set_min(
+      EnsureAcyclicSymbol(phi_block, range->min(), RangeBoundary::MinSmi()));
+  range->set_max(
+      EnsureAcyclicSymbol(phi_block, range->max(), RangeBoundary::MaxSmi()));
 }
 
 
 void ConstantInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   if (value_.IsSmi()) {
     int64_t value = Smi::Cast(value_).Value();
     *range = Range(RangeBoundary::FromConstant(value),
                    RangeBoundary::FromConstant(value));
   } else if (value_.IsMint()) {
     int64_t value = Mint::Cast(value_).value();
@@ skipping 43 matching lines @@
       *range = Range(RangeBoundary::FromConstant(0),
                      RangeBoundary::FromConstant(String::kMaxElements));
       break;
 
     default:
       Definition::InferRange(analysis, range);
   }
 }
 
 
-
 void LoadIndexedInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   switch (class_id()) {
     case kTypedDataInt8ArrayCid:
       *range = Range(RangeBoundary::FromConstant(-128),
                      RangeBoundary::FromConstant(127));
       break;
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
@@ skipping 44 matching lines @@
     default:
       UNREACHABLE();
       break;
   }
 }
 
 
 void IfThenElseInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   const intptr_t min = Utils::Minimum(if_true_, if_false_);
   const intptr_t max = Utils::Maximum(if_true_, if_false_);
-  *range = Range(RangeBoundary::FromConstant(min),
-                 RangeBoundary::FromConstant(max));
+  *range =
+      Range(RangeBoundary::FromConstant(min), RangeBoundary::FromConstant(max));
 }
 
 
 static RangeBoundary::RangeSize RepresentationToRangeSize(Representation r) {
   switch (r) {
     case kTagged:
       return RangeBoundary::kRangeBoundarySmi;
     case kUnboxedInt32:
       return RangeBoundary::kRangeBoundaryInt32;
     case kUnboxedMint:
       return RangeBoundary::kRangeBoundaryInt64;
     default:
       UNREACHABLE();
       return RangeBoundary::kRangeBoundarySmi;
   }
 }
 
 
 void BinaryIntegerOpInstr::InferRangeHelper(const Range* left_range,
                                             const Range* right_range,
                                             Range* range) {
   // TODO(vegorov): canonicalize BinaryIntegerOp to always have constant on the
   // right and a non-constant on the left.
   if (Range::IsUnknown(left_range) || Range::IsUnknown(right_range)) {
     return;
   }
 
-  Range::BinaryOp(op_kind(),
-                  left_range,
-                  right_range,
-                  left()->definition(),
+  Range::BinaryOp(op_kind(), left_range, right_range, left()->definition(),
                   range);
   ASSERT(!Range::IsUnknown(range));
 
   const RangeBoundary::RangeSize range_size =
       RepresentationToRangeSize(representation());
 
   // Calculate overflowed status before clamping if operation is
   // not truncating.
   if (!is_truncating()) {
     set_can_overflow(!range->Fits(range_size));
   }
 
   range->Clamp(range_size);
 }
 
 
 void BinarySmiOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   // TODO(vegorov) completely remove this once GetSmiRange is eliminated.
   InferRangeHelper(analysis->GetSmiRange(left()),
-                   analysis->GetSmiRange(right()),
-                   range);
+                   analysis->GetSmiRange(right()), range);
 }
 
 
 void BinaryInt32OpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   InferRangeHelper(analysis->GetSmiRange(left()),
-                   analysis->GetSmiRange(right()),
-                   range);
+                   analysis->GetSmiRange(right()), range);
 }
 
 
 void BinaryMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   InferRangeHelper(left()->definition()->range(),
-                   right()->definition()->range(),
-                   range);
+                   right()->definition()->range(), range);
 }
 
 
 void ShiftMintOpInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   InferRangeHelper(left()->definition()->range(),
-                   right()->definition()->range(),
-                   range);
+                   right()->definition()->range(), range);
 }
 
 
 void BoxIntegerInstr::InferRange(RangeAnalysis* analysis, Range* range) {
   const Range* value_range = value()->definition()->range();
   if (!Range::IsUnknown(value_range)) {
     *range = *value_range;
   }
 }
 
@@ skipping 47 matching lines @@
     *range = *value_range;
   } else if (!value()->definition()->IsMintDefinition() &&
              (value()->definition()->Type()->ToCid() != kSmiCid)) {
     *range = Range::Full(RangeBoundary::kRangeBoundaryInt64);
   }
 }
 
 
 void UnboxedIntConverterInstr::InferRange(RangeAnalysis* analysis,
                                           Range* range) {
-  ASSERT((from() == kUnboxedInt32) ||
-         (from() == kUnboxedMint) ||
+  ASSERT((from() == kUnboxedInt32) || (from() == kUnboxedMint) ||
          (from() == kUnboxedUint32));
-  ASSERT((to() == kUnboxedInt32) ||
-         (to() == kUnboxedMint) ||
+  ASSERT((to() == kUnboxedInt32) || (to() == kUnboxedMint) ||
          (to() == kUnboxedUint32));
   const Range* value_range = value()->definition()->range();
   if (Range::IsUnknown(value_range)) {
     return;
   }
 
   if (to() == kUnboxedUint32) {
     // TODO(vegorov): improve range information for unboxing to Uint32.
-    *range = Range(
-        RangeBoundary::FromConstant(0),
-        RangeBoundary::FromConstant(static_cast<int64_t>(kMaxUint32)));
+    *range =
+        Range(RangeBoundary::FromConstant(0),
+              RangeBoundary::FromConstant(static_cast<int64_t>(kMaxUint32)));
   } else {
     *range = *value_range;
     if (to() == kUnboxedInt32) {
       range->Clamp(RangeBoundary::kRangeBoundaryInt32);
     }
   }
 }
 
 
 bool CheckArrayBoundInstr::IsRedundant(const RangeBoundary& length) {
@@ skipping 44 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart