clang-format runtime/vm

runtime/vm/constant_propagator.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/constant_propagator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, remove_redundant_phis, true, "Remove redundant phis.");
-DEFINE_FLAG(bool, trace_constant_propagation, false,
-    "Print constant propagation and useless code elimination.");
+DEFINE_FLAG(bool,
+            trace_constant_propagation,
+            false,
+            "Print constant propagation and useless code elimination.");
 
 // Quick access to the current zone and isolate.
 #define I (isolate())
 #define Z (graph_->zone())
 
 
 ConstantPropagator::ConstantPropagator(
     FlowGraph* graph,
     const GrowableArray<BlockEntryInstr*>& ignored)
     : FlowGraphVisitor(ignored),
       graph_(graph),
       unknown_(Object::unknown_constant()),
       non_constant_(Object::non_constant()),
-      reachable_(new(Z) BitVector(
-          Z, graph->preorder().length())),
-      marked_phis_(new(Z) BitVector(
-          Z, graph->max_virtual_register_number())),
+      reachable_(new (Z) BitVector(Z, graph->preorder().length())),
+      marked_phis_(new (Z) BitVector(Z, graph->max_virtual_register_number())),
       block_worklist_(),
       definition_worklist_(graph, 10) {}
 
 
 void ConstantPropagator::Optimize(FlowGraph* graph) {
   GrowableArray<BlockEntryInstr*> ignored;
   ConstantPropagator cp(graph, ignored);
   cp.Analyze();
   cp.Transform();
 }
@@ skipping 180 matching lines @@
       }
     }
   }
 }
 
 
 // --------------------------------------------------------------------------
 // Analysis of non-definition instructions.  They do not have values so they
 // cannot have constant values.
 void ConstantPropagator::VisitCheckStackOverflow(
-    CheckStackOverflowInstr* instr) { }
+    CheckStackOverflowInstr* instr) {}
 
 
-void ConstantPropagator::VisitCheckClass(CheckClassInstr* instr) { }
+void ConstantPropagator::VisitCheckClass(CheckClassInstr* instr) {}
 
 
-void ConstantPropagator::VisitCheckClassId(CheckClassIdInstr* instr) { }
+void ConstantPropagator::VisitCheckClassId(CheckClassIdInstr* instr) {}
 
 
-void ConstantPropagator::VisitGuardFieldClass(GuardFieldClassInstr* instr) { }
+void ConstantPropagator::VisitGuardFieldClass(GuardFieldClassInstr* instr) {}
 
 
-void ConstantPropagator::VisitGuardFieldLength(GuardFieldLengthInstr* instr) { }
+void ConstantPropagator::VisitGuardFieldLength(GuardFieldLengthInstr* instr) {}
 
 
-void ConstantPropagator::VisitCheckSmi(CheckSmiInstr* instr) { }
+void ConstantPropagator::VisitCheckSmi(CheckSmiInstr* instr) {}
 
 
 void ConstantPropagator::VisitGenericCheckBound(GenericCheckBoundInstr* instr) {
 }
 
 
-void ConstantPropagator::VisitCheckEitherNonSmi(
-    CheckEitherNonSmiInstr* instr) { }
+void ConstantPropagator::VisitCheckEitherNonSmi(CheckEitherNonSmiInstr* instr) {
+}
 
 
-void ConstantPropagator::VisitCheckArrayBound(CheckArrayBoundInstr* instr) { }
+void ConstantPropagator::VisitCheckArrayBound(CheckArrayBoundInstr* instr) {}
 
 
 void ConstantPropagator::VisitDeoptimize(DeoptimizeInstr* instr) {
   // TODO(vegorov) remove all code after DeoptimizeInstr as dead.
 }
 
-void ConstantPropagator::VisitGrowRegExpStack(GrowRegExpStackInstr* instr) { }
+void ConstantPropagator::VisitGrowRegExpStack(GrowRegExpStackInstr* instr) {}
 
 Definition* ConstantPropagator::UnwrapPhi(Definition* defn) {
   if (defn->IsPhi()) {
     JoinEntryInstr* block = defn->AsPhi()->block();
 
     Definition* input = NULL;
     for (intptr_t i = 0; i < defn->InputCount(); ++i) {
       if (reachable_->Contains(block->PredecessorAt(i)->preorder_number())) {
         if (input == NULL) {
           input = defn->InputAt(i)->definition();
@@ skipping 20 matching lines @@
 // Analysis of definitions.  Compute the constant value.  If it has changed
 // and the definition has input uses, add the definition to the definition
 // worklist so that the used can be processed.
 void ConstantPropagator::VisitPhi(PhiInstr* instr) {
   // Compute the join over all the reachable predecessor values.
   JoinEntryInstr* block = instr->block();
   Object& value = Object::ZoneHandle(Z, Unknown());
   for (intptr_t pred_idx = 0; pred_idx < instr->InputCount(); ++pred_idx) {
     if (reachable_->Contains(
             block->PredecessorAt(pred_idx)->preorder_number())) {
-      Join(&value,
-           instr->InputAt(pred_idx)->definition()->constant_value());
+      Join(&value, instr->InputAt(pred_idx)->definition()->constant_value());
     }
   }
   if (!SetValue(instr, value) &&
       marked_phis_->Contains(instr->ssa_temp_index())) {
     marked_phis_->Remove(instr->ssa_temp_index());
     definition_worklist_.Add(instr);
   }
 }
 
 
 void ConstantPropagator::VisitRedefinition(RedefinitionInstr* instr) {
   // Ensure that we never remove redefinition of a constant unless we are also
   // are guaranteed to fold away code paths that correspond to non-matching
   // class ids. Otherwise LICM might potentially hoist incorrect code.
   const Object& value = instr->value()->definition()->constant_value();
-  if (IsConstant(value) &&
-      !Field::IsExternalizableCid(value.GetClassId())) {
+  if (IsConstant(value) && !Field::IsExternalizableCid(value.GetClassId())) {
     SetValue(instr, value);
   } else {
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitParameter(ParameterInstr* instr) {
   SetValue(instr, non_constant_);
 }
@@ skipping 80 matching lines @@
 
 void ConstantPropagator::VisitIfThenElse(IfThenElseInstr* instr) {
   instr->comparison()->Accept(this);
   const Object& value = instr->comparison()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     ASSERT(!value.IsNull());
     ASSERT(value.IsBool());
     bool result = Bool::Cast(value).value();
-    SetValue(instr,
-             Smi::Handle(Z, Smi::New(
-                 result ? instr->if_true() : instr->if_false())));
+    SetValue(instr, Smi::Handle(Z, Smi::New(result ? instr->if_true()
+                                                   : instr->if_false())));
   }
 }
 
 
 void ConstantPropagator::VisitStrictCompare(StrictCompareInstr* instr) {
   Definition* left_defn = instr->left()->definition();
   Definition* right_defn = instr->right()->definition();
 
   Definition* unwrapped_left_defn = UnwrapPhi(left_defn);
   Definition* unwrapped_right_defn = UnwrapPhi(right_defn);
@@ skipping 42 matching lines @@
     SetValue(instr, Bool::Get(result));
   }
 }
 
 
 static bool CompareIntegers(Token::Kind kind,
                             const Integer& left,
                             const Integer& right) {
   const int result = left.CompareWith(right);
   switch (kind) {
-    case Token::kEQ: return (result == 0);
-    case Token::kNE: return (result != 0);
-    case Token::kLT: return (result < 0);
-    case Token::kGT: return (result > 0);
-    case Token::kLTE: return (result <= 0);
-    case Token::kGTE: return (result >= 0);
+    case Token::kEQ:
+      return (result == 0);
+    case Token::kNE:
+      return (result != 0);
+    case Token::kLT:
+      return (result < 0);
+    case Token::kGT:
+      return (result > 0);
+    case Token::kLTE:
+      return (result <= 0);
+    case Token::kGTE:
+      return (result >= 0);
     default:
       UNREACHABLE();
       return false;
   }
 }
 
 
 // Comparison instruction that is equivalent to the (left & right) == 0
 // comparison pattern.
 void ConstantPropagator::VisitTestSmi(TestSmiInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     // BitOp does not work on Bigints.
-    if (left.IsInteger() && right.IsInteger() &&
-        !left.IsBigint() && !right.IsBigint()) {
+    if (left.IsInteger() && right.IsInteger() && !left.IsBigint() &&
+        !right.IsBigint()) {
       const bool result = CompareIntegers(
           instr->kind(),
           Integer::Handle(Z, Integer::Cast(left).BitOp(Token::kBIT_AND,
                                                        Integer::Cast(right))),
           Smi::Handle(Z, Smi::New(0)));
       SetValue(instr, result ? Bool::True() : Bool::False());
     } else {
       SetValue(instr, non_constant_);
     }
   }
@@ skipping 26 matching lines @@
       return;
     }
   }
 
   const Object& left = left_defn->constant_value();
   const Object& right = right_defn->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     if (left.IsInteger() && right.IsInteger()) {
-      const bool result = CompareIntegers(instr->kind(),
-                                          Integer::Cast(left),
+      const bool result = CompareIntegers(instr->kind(), Integer::Cast(left),
                                           Integer::Cast(right));
       SetValue(instr, Bool::Get(result));
     } else if (left.IsString() && right.IsString()) {
       const bool result = String::Cast(left).Equals(String::Cast(right));
       SetValue(instr, Bool::Get((instr->kind() == Token::kEQ) == result));
     } else {
       SetValue(instr, non_constant_);
     }
   }
 }
 
 
 void ConstantPropagator::VisitRelationalOp(RelationalOpInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     if (left.IsInteger() && right.IsInteger()) {
-      const bool result = CompareIntegers(instr->kind(),
-                                          Integer::Cast(left),
+      const bool result = CompareIntegers(instr->kind(), Integer::Cast(left),
                                           Integer::Cast(right));
       SetValue(instr, Bool::Get(result));
     } else if (left.IsDouble() && right.IsDouble()) {
       // TODO(srdjan): Implement.
       SetValue(instr, non_constant_);
     } else {
       SetValue(instr, non_constant_);
     }
   }
 }
@@ skipping 55 matching lines @@
     if (!index_obj.IsSmi()) {
       // Should not occur.
       SetValue(instr, non_constant_);
       return;
     }
     const intptr_t index = Smi::Cast(index_obj).Value();
     if (index >= 0) {
       if (array_obj.IsString()) {
         const String& str = String::Cast(array_obj);
         if (str.Length() > index) {
-          SetValue(instr, Smi::Handle(Z,
-              Smi::New(static_cast<intptr_t>(str.CharAt(index)))));
+          SetValue(instr,
+                   Smi::Handle(
+                       Z, Smi::New(static_cast<intptr_t>(str.CharAt(index)))));
           return;
         }
       } else if (array_obj.IsArray()) {
         const Array& a = Array::Cast(array_obj);
         if ((a.Length() > index) && a.IsImmutable()) {
           Instance& result = Instance::Handle(Z);
           result ^= a.At(index);
           SetValue(instr, result);
           return;
         }
@@ skipping 81 matching lines @@
     } else {
       SetValue(instr, non_constant_);
     }
   } else if (IsConstant(value)) {
     if (value.IsInstance()) {
       const Instance& instance = Instance::Cast(value);
       const AbstractType& checked_type = instr->type();
       if (instr->instantiator_type_arguments()->BindsToConstantNull()) {
         const TypeArguments& checked_type_arguments = TypeArguments::Handle();
         Error& bound_error = Error::Handle();
-        bool is_instance = instance.IsInstanceOf(checked_type,
-                                                 checked_type_arguments,
-                                                 &bound_error);
+        bool is_instance = instance.IsInstanceOf(
+            checked_type, checked_type_arguments, &bound_error);
         // Can only have bound error with generics.
         ASSERT(bound_error.IsNull());
-        SetValue(instr, Bool::Get(instr->negate_result()
-                                  ? !is_instance : is_instance));
+        SetValue(instr, Bool::Get(instr->negate_result() ? !is_instance
+                                                         : is_instance));
         return;
       }
     }
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitCreateArray(CreateArrayInstr* instr) {
   SetValue(instr, non_constant_);
@@ skipping 26 matching lines @@
     }
   }
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitLoadField(LoadFieldInstr* instr) {
   Value* instance = instr->instance();
   if ((instr->recognized_kind() == MethodRecognizer::kObjectArrayLength) &&
       instance->definition()->OriginalDefinition()->IsCreateArray()) {
-    Value* num_elements = instance->definition()->OriginalDefinition()
-        ->AsCreateArray()->num_elements();
+    Value* num_elements = instance->definition()
+                              ->OriginalDefinition()
+                              ->AsCreateArray()
+                              ->num_elements();
     if (num_elements->BindsToConstant() &&
         num_elements->BoundConstant().IsSmi()) {
       intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
       const Object& result = Smi::ZoneHandle(Z, Smi::New(length));
       SetValue(instr, result);
       return;
     }
   }
 
   if (instr->IsImmutableLengthLoad()) {
     ConstantInstr* constant =
         instance->definition()->OriginalDefinition()->AsConstant();
     if (constant != NULL) {
       if (constant->value().IsString()) {
-        SetValue(instr, Smi::ZoneHandle(Z,
-            Smi::New(String::Cast(constant->value()).Length())));
+        SetValue(instr,
+                 Smi::ZoneHandle(
+                     Z, Smi::New(String::Cast(constant->value()).Length())));
         return;
       }
       if (constant->value().IsArray()) {
-        SetValue(instr, Smi::ZoneHandle(Z,
-            Smi::New(Array::Cast(constant->value()).Length())));
+        SetValue(instr,
+                 Smi::ZoneHandle(
+                     Z, Smi::New(Array::Cast(constant->value()).Length())));
         return;
       }
       if (constant->value().IsTypedData()) {
-        SetValue(instr, Smi::ZoneHandle(Z,
-            Smi::New(TypedData::Cast(constant->value()).Length())));
+        SetValue(instr,
+                 Smi::ZoneHandle(
+                     Z, Smi::New(TypedData::Cast(constant->value()).Length())));
         return;
       }
     }
   }
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitInstantiateType(InstantiateTypeInstr* instr) {
-  const Object& object =
-      instr->instantiator()->definition()->constant_value();
+  const Object& object = instr->instantiator()->definition()->constant_value();
   if (IsNonConstant(object)) {
     SetValue(instr, non_constant_);
     return;
   }
   if (IsConstant(object)) {
     if (instr->type().IsTypeParameter()) {
       if (object.IsNull()) {
         SetValue(instr, Object::dynamic_type());
         return;
       }
       // We could try to instantiate the type parameter and return it if no
       // malformed error is reported.
     }
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitInstantiateTypeArguments(
     InstantiateTypeArgumentsInstr* instr) {
-  const Object& object =
-      instr->instantiator()->definition()->constant_value();
+  const Object& object = instr->instantiator()->definition()->constant_value();
   if (IsNonConstant(object)) {
     SetValue(instr, non_constant_);
     return;
   }
   if (IsConstant(object)) {
     const intptr_t len = instr->type_arguments().Length();
-    if (instr->type_arguments().IsRawInstantiatedRaw(len) &&
-        object.IsNull()) {
+    if (instr->type_arguments().IsRawInstantiatedRaw(len) && object.IsNull()) {
       SetValue(instr, object);
       return;
     }
     if (instr->type_arguments().IsUninstantiatedIdentity() ||
         instr->type_arguments().CanShareInstantiatorTypeArguments(
             instr->instantiator_class())) {
       SetValue(instr, object);
       return;
     }
     SetValue(instr, non_constant_);
@@ skipping 87 matching lines @@
 void ConstantPropagator::VisitUnboxInt64(UnboxInt64Instr* instr) {
   // TODO(kmillikin): Handle unbox operation.
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnaryIntegerOp(UnaryIntegerOpInstr* unary_op) {
   const Object& value = unary_op->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
     const Integer& value_int = Integer::Cast(value);
-    const Integer& result =
-        Integer::Handle(Z, unary_op->Evaluate(value_int));
+    const Integer& result = Integer::Handle(Z, unary_op->Evaluate(value_int));
     if (!result.IsNull()) {
       SetValue(unary_op, Integer::ZoneHandle(Z, result.raw()));
       return;
     }
   }
 
   SetValue(unary_op, non_constant_);
 }
 
 
@@ skipping 14 matching lines @@
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle unary operations.
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitSmiToDouble(SmiToDoubleInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
-    SetValue(instr, Double::Handle(Z,
-        Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
+    SetValue(instr,
+             Double::Handle(Z, Double::New(Integer::Cast(value).AsDoubleValue(),
+                                           Heap::kOld)));
   } else if (!IsUnknown(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitMintToDouble(MintToDoubleInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
-    SetValue(instr, Double::Handle(Z,
-        Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
+    SetValue(instr,
+             Double::Handle(Z, Double::New(Integer::Cast(value).AsDoubleValue(),
+                                           Heap::kOld)));
   } else if (!IsUnknown(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitInt32ToDouble(Int32ToDoubleInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
-    SetValue(instr, Double::Handle(Z,
-        Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
+    SetValue(instr,
+             Double::Handle(Z, Double::New(Integer::Cast(value).AsDoubleValue(),
+                                           Heap::kOld)));
   } else if (!IsUnknown(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitDoubleToInteger(DoubleToIntegerInstr* instr) {
   // TODO(kmillikin): Handle conversion.
   SetValue(instr, non_constant_);
 }
@@ skipping 67 matching lines @@
   return value.IsInteger() || value.IsDouble();
 }
 
 
 static double ToDouble(const Object& value) {
   return value.IsInteger() ? Integer::Cast(value).AsDoubleValue()
                            : Double::Cast(value).value();
 }
 
 
-void ConstantPropagator::VisitBinaryDoubleOp(
-    BinaryDoubleOpInstr* instr) {
+void ConstantPropagator::VisitBinaryDoubleOp(BinaryDoubleOpInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (left.IsInteger() && right.IsInteger()) {
     SetValue(instr, non_constant_);
   } else if (IsIntegerOrDouble(left) && IsIntegerOrDouble(right)) {
     const double left_val = ToDouble(left);
     const double right_val = ToDouble(right);
     double result_val = 0.0;
@@ skipping 38 matching lines @@
       }
       default:
         UNREACHABLE();
     }
   } else {
     SetValue(instr, non_constant_);
   }
 }
 
 
-void ConstantPropagator::VisitBinaryFloat32x4Op(
-    BinaryFloat32x4OpInstr* instr) {
+void ConstantPropagator::VisitBinaryFloat32x4Op(BinaryFloat32x4OpInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     // TODO(kmillikin): Handle binary operation.
     SetValue(instr, non_constant_);
   }
 }
 
@@ skipping 126 matching lines @@
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat64x2ToFloat32x4(
     Float64x2ToFloat32x4Instr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitFloat64x2Zero(
-    Float64x2ZeroInstr* instr) {
+void ConstantPropagator::VisitFloat64x2Zero(Float64x2ZeroInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
-void ConstantPropagator::VisitFloat64x2Splat(
-    Float64x2SplatInstr* instr) {
+void ConstantPropagator::VisitFloat64x2Splat(Float64x2SplatInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitFloat64x2Constructor(
     Float64x2ConstructorInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
@@ skipping 26 matching lines @@
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     // TODO(srdjan): Handle min and max.
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitCaseInsensitiveCompareUC16(
-    CaseInsensitiveCompareUC16Instr *instr) {
+    CaseInsensitiveCompareUC16Instr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnbox(UnboxInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle conversion.
@@ skipping 66 matching lines @@
     } else {
       BlockEntryInstr* block = block_worklist_.RemoveLast();
       block->Accept(this);
     }
   }
 }
 
 
 static bool IsEmptyBlock(BlockEntryInstr* block) {
   return block->next()->IsGoto() &&
-      (!block->IsJoinEntry() || (block->AsJoinEntry()->phis() == NULL)) &&
-      !block->IsIndirectEntry();
+         (!block->IsJoinEntry() || (block->AsJoinEntry()->phis() == NULL)) &&
+         !block->IsIndirectEntry();
 }
 
 
 // Traverses a chain of empty blocks and returns the first reachable non-empty
 // block that is not dominated by the start block. The empty blocks are added
 // to the supplied bit vector.
-static BlockEntryInstr* FindFirstNonEmptySuccessor(
-    TargetEntryInstr* block,
-    BitVector* empty_blocks) {
+static BlockEntryInstr* FindFirstNonEmptySuccessor(TargetEntryInstr* block,
+                                                   BitVector* empty_blocks) {
   BlockEntryInstr* current = block;
   while (IsEmptyBlock(current) && block->Dominates(current)) {
     ASSERT(!block->IsJoinEntry() || (block->AsJoinEntry()->phis() == NULL));
     empty_blocks->Add(current->preorder_number());
     current = current->next()->AsGoto()->successor();
   }
   return current;
 }
 
 
 void ConstantPropagator::EliminateRedundantBranches() {
   // Canonicalize branches that have no side-effects and where true- and
   // false-targets are the same.
   bool changed = false;
-  BitVector* empty_blocks = new(Z) BitVector(Z,
-      graph_->preorder().length());
-  for (BlockIterator b = graph_->postorder_iterator();
-       !b.Done();
-       b.Advance()) {
+  BitVector* empty_blocks = new (Z) BitVector(Z, graph_->preorder().length());
+  for (BlockIterator b = graph_->postorder_iterator(); !b.Done(); b.Advance()) {
     BlockEntryInstr* block = b.Current();
     BranchInstr* branch = block->last_instruction()->AsBranch();
     empty_blocks->Clear();
     if ((branch != NULL) && branch->Effects().IsNone()) {
       ASSERT(branch->previous() != NULL);  // Not already eliminated.
       BlockEntryInstr* if_true =
           FindFirstNonEmptySuccessor(branch->true_successor(), empty_blocks);
       BlockEntryInstr* if_false =
           FindFirstNonEmptySuccessor(branch->false_successor(), empty_blocks);
       if (if_true == if_false) {
         // Replace the branch with a jump to the common successor.
         // Drop the comparison, which does not have side effects
         JoinEntryInstr* join = if_true->AsJoinEntry();
         if (join->phis() == NULL) {
-          GotoInstr* jump = new(Z) GotoInstr(if_true->AsJoinEntry());
+          GotoInstr* jump = new (Z) GotoInstr(if_true->AsJoinEntry());
           jump->InheritDeoptTarget(Z, branch);
 
           Instruction* previous = branch->previous();
           branch->set_previous(NULL);
           previous->LinkTo(jump);
 
           // Remove uses from branch and all the empty blocks that
           // are now unreachable.
           branch->UnuseAllInputs();
           for (BitVector::Iterator it(empty_blocks); !it.Done(); it.Advance()) {
@@ skipping 25 matching lines @@
 void ConstantPropagator::Transform() {
   if (FLAG_trace_constant_propagation &&
       FlowGraphPrinter::ShouldPrint(graph_->function())) {
     FlowGraphPrinter::PrintGraph("Before CP", graph_);
   }
 
   // We will recompute dominators, block ordering, block ids, block last
   // instructions, previous pointers, predecessors, etc. after eliminating
   // unreachable code.  We do not maintain those properties during the
   // transformation.
-  for (BlockIterator b = graph_->reverse_postorder_iterator();
-       !b.Done();
+  for (BlockIterator b = graph_->reverse_postorder_iterator(); !b.Done();
        b.Advance()) {
     BlockEntryInstr* block = b.Current();
     if (!reachable_->Contains(block->preorder_number())) {
       if (FLAG_trace_constant_propagation &&
           FlowGraphPrinter::ShouldPrint(graph_->function())) {
         THR_Print("Unreachable B%" Pd "\n", block->block_id());
       }
       // Remove all uses in unreachable blocks.
       block->ClearAllInstructions();
       continue;
@@ skipping 48 matching lines @@
           }
         }
       }
     }
 
     for (ForwardInstructionIterator i(block); !i.Done(); i.Advance()) {
       Definition* defn = i.Current()->AsDefinition();
       // Replace constant-valued instructions without observable side
       // effects.  Do this for smis only to avoid having to copy other
       // objects into the heap's old generation.
-      if ((defn != NULL) &&
-          IsConstant(defn->constant_value()) &&
+      if ((defn != NULL) && IsConstant(defn->constant_value()) &&
           (defn->constant_value().IsSmi() || defn->constant_value().IsOld()) &&
-          !defn->IsConstant() &&
-          !defn->IsPushArgument() &&
-          !defn->IsStoreIndexed() &&
-          !defn->IsStoreInstanceField() &&
+          !defn->IsConstant() && !defn->IsPushArgument() &&
+          !defn->IsStoreIndexed() && !defn->IsStoreInstanceField() &&
           !defn->IsStoreStaticField()) {
         if (FLAG_trace_constant_propagation &&
             FlowGraphPrinter::ShouldPrint(graph_->function())) {
-          THR_Print("Constant v%" Pd " = %s\n",
-                    defn->ssa_temp_index(),
+          THR_Print("Constant v%" Pd " = %s\n", defn->ssa_temp_index(),
                     defn->constant_value().ToCString());
         }
         ConstantInstr* constant = graph_->GetConstant(defn->constant_value());
         defn->ReplaceUsesWith(constant);
         i.RemoveCurrentFromGraph();
       }
     }
 
     // Replace branches where one target is unreachable with jumps.
     BranchInstr* branch = block->last_instruction()->AsBranch();
     if (branch != NULL) {
       TargetEntryInstr* if_true = branch->true_successor();
       TargetEntryInstr* if_false = branch->false_successor();
       JoinEntryInstr* join = NULL;
       Instruction* next = NULL;
 
       if (!reachable_->Contains(if_true->preorder_number())) {
         ASSERT(reachable_->Contains(if_false->preorder_number()));
         ASSERT(if_false->parallel_move() == NULL);
         ASSERT(if_false->loop_info() == NULL);
-        join = new(Z) JoinEntryInstr(if_false->block_id(),
-                                     if_false->try_index());
+        join =
+            new (Z) JoinEntryInstr(if_false->block_id(), if_false->try_index());
         join->InheritDeoptTarget(Z, if_false);
         if_false->UnuseAllInputs();
         next = if_false->next();
       } else if (!reachable_->Contains(if_false->preorder_number())) {
         ASSERT(if_true->parallel_move() == NULL);
         ASSERT(if_true->loop_info() == NULL);
-        join = new(Z) JoinEntryInstr(if_true->block_id(),
-                                     if_true->try_index());
+        join =
+            new (Z) JoinEntryInstr(if_true->block_id(), if_true->try_index());
         join->InheritDeoptTarget(Z, if_true);
         if_true->UnuseAllInputs();
         next = if_true->next();
       }
 
       if (join != NULL) {
         // Replace the branch with a jump to the reachable successor.
         // Drop the comparison, which does not have side effects as long
         // as it is a strict compare (the only one we can determine is
         // constant with the current analysis).
-        GotoInstr* jump = new(Z) GotoInstr(join);
+        GotoInstr* jump = new (Z) GotoInstr(join);
         jump->InheritDeoptTarget(Z, branch);
 
         Instruction* previous = branch->previous();
         branch->set_previous(NULL);
         previous->LinkTo(jump);
 
         // Replace the false target entry with the new join entry. We will
         // recompute the dominators after this pass.
         join->LinkTo(next);
         branch->UnuseAllInputs();
       }
     }
   }
 
   graph_->DiscoverBlocks();
   graph_->MergeBlocks();
   GrowableArray<BitVector*> dominance_frontier;
   graph_->ComputeDominators(&dominance_frontier);
 
   if (FLAG_trace_constant_propagation &&
       FlowGraphPrinter::ShouldPrint(graph_->function())) {
     FlowGraphPrinter::PrintGraph("After CP", graph_);
   }
 }
 
 }  // namespace dart