clang-format runtime/vm

runtime/vm/flow_graph.cc

 // Copyright (c) 2012, 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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.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/growable_array.h"
 #include "vm/object_store.h"
 
 namespace dart {
 
 #if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_IA32)
 DEFINE_FLAG(bool, trace_smi_widening, false, "Trace Smi->Int32 widening pass.");
 #endif
 DEFINE_FLAG(bool, prune_dead_locals, true, "optimize dead locals away");
 DECLARE_FLAG(bool, verify_compiler);
 
 
 FlowGraph::FlowGraph(const ParsedFunction& parsed_function,
                      GraphEntryInstr* graph_entry,
                      intptr_t max_block_id)
-  : thread_(Thread::Current()),
-    parent_(),
-    current_ssa_temp_index_(0),
-    max_block_id_(max_block_id),
-    parsed_function_(parsed_function),
-    num_copied_params_(parsed_function.num_copied_params()),
-    num_non_copied_params_(parsed_function.num_non_copied_params()),
-    graph_entry_(graph_entry),
-    preorder_(),
-    postorder_(),
-    reverse_postorder_(),
-    optimized_block_order_(),
-    constant_null_(NULL),
-    constant_dead_(NULL),
-    constant_empty_context_(NULL),
-    block_effects_(NULL),
-    licm_allowed_(true),
-    loop_headers_(NULL),
-    loop_invariant_loads_(NULL),
-    deferred_prefixes_(parsed_function.deferred_prefixes()),
-    captured_parameters_(new(zone()) BitVector(zone(), variable_count())),
-    inlining_id_(-1) {
+    : thread_(Thread::Current()),
+      parent_(),
+      current_ssa_temp_index_(0),
+      max_block_id_(max_block_id),
+      parsed_function_(parsed_function),
+      num_copied_params_(parsed_function.num_copied_params()),
+      num_non_copied_params_(parsed_function.num_non_copied_params()),
+      graph_entry_(graph_entry),
+      preorder_(),
+      postorder_(),
+      reverse_postorder_(),
+      optimized_block_order_(),
+      constant_null_(NULL),
+      constant_dead_(NULL),
+      constant_empty_context_(NULL),
+      block_effects_(NULL),
+      licm_allowed_(true),
+      loop_headers_(NULL),
+      loop_invariant_loads_(NULL),
+      deferred_prefixes_(parsed_function.deferred_prefixes()),
+      captured_parameters_(new (zone()) BitVector(zone(), variable_count())),
+      inlining_id_(-1) {
   DiscoverBlocks();
 }
 
 
-void FlowGraph::EnsureSSATempIndex(Definition* defn,
-                                   Definition* replacement) {
-  if ((replacement->ssa_temp_index() == -1) &&
-      (defn->ssa_temp_index() != -1)) {
+void FlowGraph::EnsureSSATempIndex(Definition* defn, Definition* replacement) {
+  if ((replacement->ssa_temp_index() == -1) && (defn->ssa_temp_index() != -1)) {
     AllocateSSAIndexes(replacement);
   }
 }
 
 
 void FlowGraph::ReplaceCurrentInstruction(ForwardInstructionIterator* iterator,
                                           Instruction* current,
                                           Instruction* replacement) {
   Definition* current_defn = current->AsDefinition();
   if ((replacement != NULL) && (current_defn != NULL)) {
@@ skipping 24 matching lines @@
     }
   }
   iterator->RemoveCurrentFromGraph();
 }
 
 
 void FlowGraph::AddToDeferredPrefixes(
     ZoneGrowableArray<const LibraryPrefix*>* from) {
   ZoneGrowableArray<const LibraryPrefix*>* to = deferred_prefixes();
   for (intptr_t i = 0; i < from->length(); i++) {
-    const  LibraryPrefix* prefix = (*from)[i];
+    const LibraryPrefix* prefix = (*from)[i];
     for (intptr_t j = 0; j < to->length(); j++) {
       if ((*to)[j]->raw() == prefix->raw()) {
         return;
       }
     }
     to->Add(prefix);
   }
 }
 
 
 bool FlowGraph::ShouldReorderBlocks(const Function& function,
                                     bool is_optimized) {
-  return is_optimized
-      && FLAG_reorder_basic_blocks
-      && !function.is_intrinsic();
+  return is_optimized && FLAG_reorder_basic_blocks && !function.is_intrinsic();
 }
 
 
 GrowableArray<BlockEntryInstr*>* FlowGraph::CodegenBlockOrder(
     bool is_optimized) {
-  return ShouldReorderBlocks(function(), is_optimized)
-      ? &optimized_block_order_
-      : &reverse_postorder_;
+  return ShouldReorderBlocks(function(), is_optimized) ? &optimized_block_order_
+                                                       : &reverse_postorder_;
 }
 
 
 ConstantInstr* FlowGraph::GetConstant(const Object& object) {
   ConstantInstr* constant = constant_instr_pool_.LookupValue(object);
   if (constant == NULL) {
     // Otherwise, allocate and add it to the pool.
-    constant = new(zone()) ConstantInstr(
-        Object::ZoneHandle(zone(), object.raw()));
+    constant =
+        new (zone()) ConstantInstr(Object::ZoneHandle(zone(), object.raw()));
     constant->set_ssa_temp_index(alloc_ssa_temp_index());
 
     AddToInitialDefinitions(constant);
     constant_instr_pool_.Insert(constant);
   }
   return constant;
 }
 
 
 void FlowGraph::AddToInitialDefinitions(Definition* defn) {
@@ skipping 42 matching lines @@
   }
   return prev->AppendInstruction(instr);
 }
 
 
 // A wrapper around block entries including an index of the next successor to
 // be read.
 class BlockTraversalState {
  public:
   explicit BlockTraversalState(BlockEntryInstr* block)
-    : block_(block),
-      next_successor_ix_(block->last_instruction()->SuccessorCount() - 1) { }
+      : block_(block),
+        next_successor_ix_(block->last_instruction()->SuccessorCount() - 1) {}
 
   bool HasNextSuccessor() const { return next_successor_ix_ >= 0; }
   BlockEntryInstr* NextSuccessor() {
     ASSERT(HasNextSuccessor());
     return block_->last_instruction()->SuccessorAt(next_successor_ix_--);
   }
 
   BlockEntryInstr* block() const { return block_; }
 
  private:
@@ skipping 10 matching lines @@
   // Initialize state.
   preorder_.Clear();
   postorder_.Clear();
   reverse_postorder_.Clear();
   parent_.Clear();
 
   GrowableArray<BlockTraversalState> block_stack;
   graph_entry_->DiscoverBlock(NULL, &preorder_, &parent_);
   block_stack.Add(BlockTraversalState(graph_entry_));
   while (!block_stack.is_empty()) {
-    BlockTraversalState &state = block_stack.Last();
+    BlockTraversalState& state = block_stack.Last();
     BlockEntryInstr* block = state.block();
     if (state.HasNextSuccessor()) {
       // Process successors one-by-one.
       BlockEntryInstr* succ = state.NextSuccessor();
       if (succ->DiscoverBlock(block, &preorder_, &parent_)) {
         block_stack.Add(BlockTraversalState(succ));
       }
     } else {
       // All successors have been processed, pop the current block entry node
       // and add it to the postorder list.
@@ skipping 13 matching lines @@
 
   // Block effects are using postorder numbering. Discard computed information.
   block_effects_ = NULL;
   loop_headers_ = NULL;
   loop_invariant_loads_ = NULL;
 }
 
 
 void FlowGraph::MergeBlocks() {
   bool changed = false;
-  BitVector* merged = new(zone()) BitVector(zone(), postorder().length());
-  for (BlockIterator block_it = reverse_postorder_iterator();
-       !block_it.Done();
+  BitVector* merged = new (zone()) BitVector(zone(), postorder().length());
+  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
     if (block->IsGraphEntry()) continue;
     if (merged->Contains(block->postorder_number())) continue;
 
     Instruction* last = block->last_instruction();
     BlockEntryInstr* successor = NULL;
-    while ((!last->IsIndirectGoto()) &&
-           (last->SuccessorCount() == 1) &&
+    while ((!last->IsIndirectGoto()) && (last->SuccessorCount() == 1) &&
            (!last->SuccessorAt(0)->IsIndirectEntry()) &&
            (last->SuccessorAt(0)->PredecessorCount() == 1) &&
            (block->try_index() == last->SuccessorAt(0)->try_index())) {
       successor = last->SuccessorAt(0);
       ASSERT(last->IsGoto());
 
       // Remove environment uses and unlink goto and block entry.
       successor->UnuseAllInputs();
       last->previous()->LinkTo(successor->next());
       last->UnuseAllInputs();
 
       last = successor->last_instruction();
       merged->Add(successor->postorder_number());
       changed = true;
       if (FLAG_trace_optimization) {
-        OS::Print("Merged blocks B%" Pd " and B%" Pd "\n",
-                  block->block_id(),
+        OS::Print("Merged blocks B%" Pd " and B%" Pd "\n", block->block_id(),
                   successor->block_id());
       }
     }
     // The new block inherits the block id of the last successor to maintain
     // the order of phi inputs at its successors consistent with block ids.
     if (successor != NULL) {
       block->set_block_id(successor->block_id());
     }
   }
   // Recompute block order after changes were made.
@@ skipping 11 matching lines @@
   return count;
 }
 
 
 static void VerifyUseListsInInstruction(Instruction* instr) {
   ASSERT(instr != NULL);
   ASSERT(!instr->IsJoinEntry());
   for (intptr_t i = 0; i < instr->InputCount(); ++i) {
     Value* use = instr->InputAt(i);
     ASSERT(use->definition() != NULL);
-    ASSERT((use->definition() != instr) ||
-           use->definition()->IsPhi() ||
+    ASSERT((use->definition() != instr) || use->definition()->IsPhi() ||
            use->definition()->IsMaterializeObject());
     ASSERT(use->instruction() == instr);
     ASSERT(use->use_index() == i);
     ASSERT(!FLAG_verify_compiler ||
            (1 == MembershipCount(use, use->definition()->input_use_list())));
   }
   if (instr->env() != NULL) {
     intptr_t use_index = 0;
     for (Environment::DeepIterator it(instr->env()); !it.Done(); it.Advance()) {
       Value* use = it.CurrentValue();
@@ skipping 38 matching lines @@
       ASSERT(instr->IsBlockEntry() ||
              (instr->IsPhi() && instr->AsPhi()->is_alive()) ||
              (instr->previous() != NULL));
       prev = curr;
       curr = curr->next_use();
     }
   }
 }
 
 void FlowGraph::ComputeIsReceiverRecursive(
-    PhiInstr* phi, GrowableArray<PhiInstr*>* unmark) const {
+    PhiInstr* phi,
+    GrowableArray<PhiInstr*>* unmark) const {
   if (phi->is_receiver() != PhiInstr::kUnknownReceiver) return;
   phi->set_is_receiver(PhiInstr::kReceiver);
   for (intptr_t i = 0; i < phi->InputCount(); ++i) {
     Definition* def = phi->InputAt(i)->definition();
     if (def->IsParameter() && (def->AsParameter()->index() == 0)) continue;
     if (!def->IsPhi()) {
       phi->set_is_receiver(PhiInstr::kNotReceiver);
       break;
     }
     ComputeIsReceiverRecursive(def->AsPhi(), unmark);
@@ skipping 46 matching lines @@
 bool FlowGraph::InstanceCallNeedsClassCheck(InstanceCallInstr* call,
                                             RawFunction::Kind kind) const {
   if (!FLAG_use_cha_deopt && !isolate()->all_classes_finalized()) {
     // Even if class or function are private, lazy class finalization
     // may later add overriding methods.
     return true;
   }
   Definition* callee_receiver = call->ArgumentAt(0);
   ASSERT(callee_receiver != NULL);
   if (function().IsDynamicFunction() && IsReceiver(callee_receiver)) {
-    const String& name = (kind == RawFunction::kMethodExtractor)
-        ? String::Handle(zone(), Field::NameFromGetter(call->function_name()))
-        : call->function_name();
+    const String& name =
+        (kind == RawFunction::kMethodExtractor)
+            ? String::Handle(zone(),
+                             Field::NameFromGetter(call->function_name()))
+            : call->function_name();
     const Class& cls = Class::Handle(zone(), function().Owner());
     intptr_t subclass_count = 0;
     if (!thread()->cha()->HasOverride(cls, name, &subclass_count)) {
       if (FLAG_trace_cha) {
-        THR_Print("  **(CHA) Instance call needs no check, "
+        THR_Print(
+            "  **(CHA) Instance call needs no check, "
             "no overrides of '%s' '%s'\n",
             name.ToCString(), cls.ToCString());
       }
       thread()->cha()->AddToGuardedClasses(cls, subclass_count);
       return false;
     }
   }
   return true;
 }
 
 
-
 bool FlowGraph::VerifyUseLists() {
   // Verify the initial definitions.
   for (intptr_t i = 0; i < graph_entry_->initial_definitions()->length(); ++i) {
     VerifyUseListsInInstruction((*graph_entry_->initial_definitions())[i]);
   }
 
   // Verify phis in join entries and the instructions in each block.
   for (intptr_t i = 0; i < preorder_.length(); ++i) {
     BlockEntryInstr* entry = preorder_[i];
     JoinEntryInstr* join = entry->AsJoinEntry();
     if (join != NULL) {
       for (PhiIterator it(join); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
         ASSERT(phi != NULL);
         VerifyUseListsInInstruction(phi);
       }
     }
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       VerifyUseListsInInstruction(it.Current());
     }
   }
   return true;  // Return true so we can ASSERT validation.
 }
 
 
 LivenessAnalysis::LivenessAnalysis(
-  intptr_t variable_count,
-  const GrowableArray<BlockEntryInstr*>& postorder)
+    intptr_t variable_count,
+    const GrowableArray<BlockEntryInstr*>& postorder)
     : zone_(Thread::Current()->zone()),
       variable_count_(variable_count),
       postorder_(postorder),
       live_out_(postorder.length()),
       kill_(postorder.length()),
-      live_in_(postorder.length()) {
-}
+      live_in_(postorder.length()) {}
 
 
 bool LivenessAnalysis::UpdateLiveOut(const BlockEntryInstr& block) {
   BitVector* live_out = live_out_[block.postorder_number()];
   bool changed = false;
   Instruction* last = block.last_instruction();
   ASSERT(last != NULL);
   for (intptr_t i = 0; i < last->SuccessorCount(); i++) {
     BlockEntryInstr* succ = last->SuccessorAt(i);
     ASSERT(succ != NULL);
@@ skipping 30 matching lines @@
         changed = true;
       }
     }
   } while (changed);
 }
 
 
 void LivenessAnalysis::Analyze() {
   const intptr_t block_count = postorder_.length();
   for (intptr_t i = 0; i < block_count; i++) {
-    live_out_.Add(new(zone()) BitVector(zone(), variable_count_));
-    kill_.Add(new(zone()) BitVector(zone(), variable_count_));
-    live_in_.Add(new(zone()) BitVector(zone(), variable_count_));
+    live_out_.Add(new (zone()) BitVector(zone(), variable_count_));
+    kill_.Add(new (zone()) BitVector(zone(), variable_count_));
+    live_in_.Add(new (zone()) BitVector(zone(), variable_count_));
   }
 
   ComputeInitialSets();
   ComputeLiveInAndLiveOutSets();
 }
 
 
 static void PrintBitVector(const char* tag, BitVector* v) {
   OS::Print("%s:", tag);
   for (BitVector::Iterator it(v); !it.Done(); it.Advance()) {
@@ skipping 23 matching lines @@
 }
 
 
 // Computes liveness information for local variables.
 class VariableLivenessAnalysis : public LivenessAnalysis {
  public:
   explicit VariableLivenessAnalysis(FlowGraph* flow_graph)
       : LivenessAnalysis(flow_graph->variable_count(), flow_graph->postorder()),
         flow_graph_(flow_graph),
         num_non_copied_params_(flow_graph->num_non_copied_params()),
-        assigned_vars_() { }
+        assigned_vars_() {}
 
   // For every block (in preorder) compute and return set of variables that
   // have new assigned values flowing out of that block.
   const GrowableArray<BitVector*>& ComputeAssignedVars() {
     // We can't directly return kill_ because it uses postorder numbering while
     // SSA construction uses preorder numbering internally.
     // We have to permute postorder into preorder.
     assigned_vars_.Clear();
 
     const intptr_t block_count = flow_graph_->preorder().length();
@@ skipping 52 matching lines @@
 
   const FlowGraph* flow_graph_;
   const intptr_t num_non_copied_params_;
   GrowableArray<BitVector*> assigned_vars_;
 };
 
 
 void VariableLivenessAnalysis::ComputeInitialSets() {
   const intptr_t block_count = postorder_.length();
 
-  BitVector* last_loads = new(zone()) BitVector(zone(), variable_count_);
+  BitVector* last_loads = new (zone()) BitVector(zone(), variable_count_);
   for (intptr_t i = 0; i < block_count; i++) {
     BlockEntryInstr* block = postorder_[i];
 
     BitVector* kill = kill_[i];
     BitVector* live_in = live_in_[i];
     last_loads->Clear();
 
     // There is an implicit use (load-local) of every local variable at each
     // call inside a try{} block and every call has an implicit control-flow
     // to the catch entry. As an approximation we mark all locals as live
@@ skipping 50 matching lines @@
   ASSERT((next_virtual_register_number == 0) || (inlining_parameters != NULL));
   current_ssa_temp_index_ = next_virtual_register_number;
   GrowableArray<BitVector*> dominance_frontier;
   ComputeDominators(&dominance_frontier);
 
   VariableLivenessAnalysis variable_liveness(this);
   variable_liveness.Analyze();
 
   GrowableArray<PhiInstr*> live_phis;
 
-  InsertPhis(preorder_,
-             variable_liveness.ComputeAssignedVars(),
-             dominance_frontier,
-             &live_phis);
+  InsertPhis(preorder_, variable_liveness.ComputeAssignedVars(),
+             dominance_frontier, &live_phis);
 
 
   // Rename uses to reference inserted phis where appropriate.
   // Collect phis that reach a non-environment use.
   Rename(&live_phis, &variable_liveness, inlining_parameters);
 
   // Propagate alive mark transitively from alive phis and then remove
   // non-live ones.
   RemoveDeadPhis(&live_phis);
 }
@@ skipping 13 matching lines @@
   // that eliminates a pass by using nearest-common ancestor (NCA) to
   // compute immediate dominators from semidominators.  It also removes a
   // level of indirection in the link-eval forest data structure.
   //
   // The algorithm is described in Georgiadis, Tarjan, and Werneck's
   // "Finding Dominators in Practice".
   // See http://www.cs.princeton.edu/~rwerneck/dominators/ .
 
   // All arrays are maps between preorder basic-block numbers.
   intptr_t size = parent_.length();
-  GrowableArray<intptr_t> idom(size);  // Immediate dominator.
-  GrowableArray<intptr_t> semi(size);  // Semidominator.
+  GrowableArray<intptr_t> idom(size);   // Immediate dominator.
+  GrowableArray<intptr_t> semi(size);   // Semidominator.
   GrowableArray<intptr_t> label(size);  // Label for link-eval forest.
 
   // 1. First pass: compute semidominators as in Lengauer-Tarjan.
   // Semidominators are computed from a depth-first spanning tree and are an
   // approximation of immediate dominators.
 
   // Use a link-eval data structure with path compression.  Implement path
   // compression in place by mutating the parent array.  Each block has a
   // label, which is the minimum block number on the compressed path.
 
   // Initialize idom, semi, and label used by SEMI-NCA.  Initialize the
   // dominance frontier output array.
   for (intptr_t i = 0; i < size; ++i) {
     idom.Add(parent_[i]);
     semi.Add(i);
     label.Add(i);
-    dominance_frontier->Add(new(zone()) BitVector(zone(), size));
+    dominance_frontier->Add(new (zone()) BitVector(zone(), size));
   }
 
   // Loop over the blocks in reverse preorder (not including the graph
   // entry).  Clear the dominated blocks in the graph entry in case
   // ComputeDominators is used to recompute them.
   preorder_[0]->ClearDominatedBlocks();
   for (intptr_t block_index = size - 1; block_index >= 1; --block_index) {
     // Loop over the predecessors.
     BlockEntryInstr* block = preorder_[block_index];
     // Clear the immediately dominated blocks in case ComputeDominators is
@@ skipping 58 matching lines @@
   intptr_t next_index = (*parent)[current_index];
   if (next_index > start_index) {
     CompressPath(start_index, next_index, parent, label);
     (*label)[current_index] =
         Utils::Minimum((*label)[current_index], (*label)[next_index]);
     (*parent)[current_index] = (*parent)[next_index];
   }
 }
 
 
-void FlowGraph::InsertPhis(
-    const GrowableArray<BlockEntryInstr*>& preorder,
-    const GrowableArray<BitVector*>& assigned_vars,
-    const GrowableArray<BitVector*>& dom_frontier,
-    GrowableArray<PhiInstr*>* live_phis) {
+void FlowGraph::InsertPhis(const GrowableArray<BlockEntryInstr*>& preorder,
+                           const GrowableArray<BitVector*>& assigned_vars,
+                           const GrowableArray<BitVector*>& dom_frontier,
+                           GrowableArray<PhiInstr*>* live_phis) {
   const intptr_t block_count = preorder.length();
   // Map preorder block number to the highest variable index that has a phi
   // in that block.  Use it to avoid inserting multiple phis for the same
   // variable.
   GrowableArray<intptr_t> has_already(block_count);
   // Map preorder block number to the highest variable index for which the
   // block went on the worklist.  Use it to avoid adding the same block to
   // the worklist more than once for the same variable.
   GrowableArray<intptr_t> work(block_count);
 
   // Initialize has_already and work.
   for (intptr_t block_index = 0; block_index < block_count; ++block_index) {
     has_already.Add(-1);
     work.Add(-1);
   }
 
   // Insert phis for each variable in turn.
   GrowableArray<BlockEntryInstr*> worklist;
   for (intptr_t var_index = 0; var_index < variable_count(); ++var_index) {
-    const bool always_live = !FLAG_prune_dead_locals ||
-        (var_index == CurrentContextEnvIndex());
+    const bool always_live =
+        !FLAG_prune_dead_locals || (var_index == CurrentContextEnvIndex());
     // Add to the worklist each block containing an assignment.
     for (intptr_t block_index = 0; block_index < block_count; ++block_index) {
       if (assigned_vars[block_index]->Contains(var_index)) {
         work[block_index] = var_index;
         worklist.Add(preorder[block_index]);
       }
     }
 
     while (!worklist.is_empty()) {
       BlockEntryInstr* current = worklist.RemoveLast();
       // Ensure a phi for each block in the dominance frontier of current.
       for (BitVector::Iterator it(dom_frontier[current->preorder_number()]);
-           !it.Done();
-           it.Advance()) {
+           !it.Done(); it.Advance()) {
         int index = it.Current();
         if (has_already[index] < var_index) {
           BlockEntryInstr* block = preorder[index];
           ASSERT(block->IsJoinEntry());
-          PhiInstr* phi = block->AsJoinEntry()->InsertPhi(var_index,
-                                                          variable_count());
+          PhiInstr* phi =
+              block->AsJoinEntry()->InsertPhi(var_index, variable_count());
           if (always_live) {
             phi->mark_alive();
             live_phis->Add(phi);
           }
           has_already[index] = var_index;
           if (work[index] < var_index) {
             work[index] = var_index;
             worklist.Add(block);
           }
         }
       }
     }
   }
 }
 
 
 void FlowGraph::Rename(GrowableArray<PhiInstr*>* live_phis,
                        VariableLivenessAnalysis* variable_liveness,
                        ZoneGrowableArray<Definition*>* inlining_parameters) {
   GraphEntryInstr* entry = graph_entry();
 
   // Initial renaming environment.
   GrowableArray<Definition*> env(variable_count());
 
   // Add global constants to the initial definitions.
   constant_null_ = GetConstant(Object::ZoneHandle());
   constant_dead_ = GetConstant(Symbols::OptimizedOut());
-  constant_empty_context_ = GetConstant(Context::Handle(
-      isolate()->object_store()->empty_context()));
+  constant_empty_context_ =
+      GetConstant(Context::Handle(isolate()->object_store()->empty_context()));
 
   // Add parameters to the initial definitions and renaming environment.
   if (inlining_parameters != NULL) {
     // Use known parameters.
     ASSERT(parameter_count() == inlining_parameters->length());
     for (intptr_t i = 0; i < parameter_count(); ++i) {
       Definition* defn = (*inlining_parameters)[i];
       AllocateSSAIndexes(defn);
       AddToInitialDefinitions(defn);
       env.Add(defn);
     }
   } else {
     // Create new parameters.  For functions compiled for OSR, the locals
     // are unknown and so treated like parameters.
     intptr_t count = IsCompiledForOsr() ? variable_count() : parameter_count();
     for (intptr_t i = 0; i < count; ++i) {
-      ParameterInstr* param = new(zone()) ParameterInstr(i, entry);
+      ParameterInstr* param = new (zone()) ParameterInstr(i, entry);
       param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
       AddToInitialDefinitions(param);
       env.Add(param);
     }
   }
 
   // Initialize all locals in the renaming environment  For OSR, the locals have
   // already been handled as parameters.
   if (!IsCompiledForOsr()) {
     for (intptr_t i = parameter_count(); i < variable_count(); ++i) {
@@ skipping 18 matching lines @@
     // on entry to the catch.
     entry->set_fixed_slot_count(num_stack_locals() + num_copied_params());
   }
   RenameRecursive(entry, &env, live_phis, variable_liveness);
 }
 
 
 void FlowGraph::AttachEnvironment(Instruction* instr,
                                   GrowableArray<Definition*>* env) {
   Environment* deopt_env =
-      Environment::From(zone(),
-                        *env,
-                        num_non_copied_params_,
-                        parsed_function_);
+      Environment::From(zone(), *env, num_non_copied_params_, parsed_function_);
   if (instr->IsClosureCall()) {
-    deopt_env = deopt_env->DeepCopy(zone(),
-                                    deopt_env->Length() - instr->InputCount());
+    deopt_env =
+        deopt_env->DeepCopy(zone(), deopt_env->Length() - instr->InputCount());
   }
   instr->SetEnvironment(deopt_env);
   for (Environment::DeepIterator it(deopt_env); !it.Done(); it.Advance()) {
     Value* use = it.CurrentValue();
     use->definition()->AddEnvUse(use);
   }
   if (instr->CanDeoptimize()) {
     instr->env()->set_deopt_id(instr->deopt_id());
   }
 }
@@ skipping 20 matching lines @@
             // more redundant phis.
             phi->mark_alive();
             live_phis->Add(phi);
           }
         }
       }
     }
   } else if (block_entry->IsCatchBlockEntry()) {
     // Add real definitions for all locals and parameters.
     for (intptr_t i = 0; i < env->length(); ++i) {
-      ParameterInstr* param = new(zone()) ParameterInstr(i, block_entry);
+      ParameterInstr* param = new (zone()) ParameterInstr(i, block_entry);
       param->set_ssa_temp_index(alloc_ssa_temp_index());  // New SSA temp.
       (*env)[i] = param;
       block_entry->AsCatchBlockEntry()->initial_definitions()->Add(param);
     }
   }
 
   // Prune non-live variables at block entry by replacing their environment
   // slots with null.
   BitVector* live_in = variable_liveness->GetLiveInSet(block_entry);
   for (intptr_t i = 0; i < variable_count(); i++) {
     // TODO(fschneider): Make sure that live_in always contains the
     // CurrentContext variable to avoid the special case here.
-    if (FLAG_prune_dead_locals &&
-        !live_in->Contains(i) &&
+    if (FLAG_prune_dead_locals && !live_in->Contains(i) &&
         (i != CurrentContextEnvIndex())) {
       (*env)[i] = constant_dead();
     }
   }
 
   // Attach environment to the block entry.
   AttachEnvironment(block_entry, env);
 
   // 2. Process normal instructions.
   for (ForwardInstructionIterator it(block_entry); !it.Done(); it.Advance()) {
@@ skipping 10 matching lines @@
     // For each use of a LoadLocal, StoreLocal, DropTemps or Constant: Replace
     // it with the renamed value.
     for (intptr_t i = current->InputCount() - 1; i >= 0; --i) {
       Value* v = current->InputAt(i);
       // Update expression stack.
       ASSERT(env->length() > variable_count());
 
       Definition* reaching_defn = env->RemoveLast();
       Definition* input_defn = v->definition();
       if (input_defn != reaching_defn) {
-        ASSERT(input_defn->IsLoadLocal() ||
-               input_defn->IsStoreLocal() ||
-               input_defn->IsDropTemps() ||
-               input_defn->IsConstant());
+        ASSERT(input_defn->IsLoadLocal() || input_defn->IsStoreLocal() ||
+               input_defn->IsDropTemps() || input_defn->IsConstant());
         // Assert we are not referencing nulls in the initial environment.
         ASSERT(reaching_defn->ssa_temp_index() != -1);
         v->set_definition(reaching_defn);
         input_defn = reaching_defn;
       }
       input_defn->AddInputUse(v);
     }
 
     // Drop pushed arguments for calls.
     for (intptr_t j = 0; j < current->ArgumentCount(); j++) {
       env->RemoveLast();
     }
 
     // 2b. Handle LoadLocal, StoreLocal, DropTemps and Constant.
     Definition* definition = current->AsDefinition();
     if (definition != NULL) {
       LoadLocalInstr* load = definition->AsLoadLocal();
       StoreLocalInstr* store = definition->AsStoreLocal();
       DropTempsInstr* drop = definition->AsDropTemps();
       ConstantInstr* constant = definition->AsConstant();
-      if ((load != NULL) ||
-          (store != NULL) ||
-          (drop != NULL) ||
+      if ((load != NULL) || (store != NULL) || (drop != NULL) ||
           (constant != NULL)) {
         Definition* result = NULL;
         if (store != NULL) {
           // Update renaming environment.
           intptr_t index = store->local().BitIndexIn(num_non_copied_params_);
           result = store->value()->definition();
 
           if (!FLAG_prune_dead_locals ||
               variable_liveness->IsStoreAlive(block_entry, store)) {
             (*env)[index] = result;
@@ skipping 74 matching lines @@
       block_entry->last_instruction()->SuccessorAt(0)->IsJoinEntry()) {
     JoinEntryInstr* successor =
         block_entry->last_instruction()->SuccessorAt(0)->AsJoinEntry();
     intptr_t pred_index = successor->IndexOfPredecessor(block_entry);
     ASSERT(pred_index >= 0);
     if (successor->phis() != NULL) {
       for (intptr_t i = 0; i < successor->phis()->length(); ++i) {
         PhiInstr* phi = (*successor->phis())[i];
         if (phi != NULL) {
           // Rename input operand.
-          Value* use = new(zone()) Value((*env)[i]);
+          Value* use = new (zone()) Value((*env)[i]);
           phi->SetInputAt(pred_index, use);
         }
       }
     }
   }
 }
 
 
 void FlowGraph::RemoveDeadPhis(GrowableArray<PhiInstr*>* live_phis) {
   // Augment live_phis with those that have implicit real used at
   // potentially throwing instructions if there is a try-catch in this graph.
   if (graph_entry()->SuccessorCount() > 1) {
     for (BlockIterator it(postorder_iterator()); !it.Done(); it.Advance()) {
       JoinEntryInstr* join = it.Current()->AsJoinEntry();
       if (join == NULL) continue;
       for (PhiIterator phi_it(join); !phi_it.Done(); phi_it.Advance()) {
         PhiInstr* phi = phi_it.Current();
-        if (phi == NULL ||
-            phi->is_alive() ||
-            (phi->input_use_list() != NULL) ||
+        if (phi == NULL || phi->is_alive() || (phi->input_use_list() != NULL) ||
             (phi->env_use_list() == NULL)) {
           continue;
         }
-        for (Value::Iterator it(phi->env_use_list());
-             !it.Done();
+        for (Value::Iterator it(phi->env_use_list()); !it.Done();
              it.Advance()) {
           Value* use = it.Current();
           if (use->instruction()->MayThrow() &&
               use->instruction()->GetBlock()->InsideTryBlock()) {
             live_phis->Add(phi);
             phi->mark_alive();
             break;
           }
         }
       }
@@ skipping 14 matching lines @@
 
   for (BlockIterator it(postorder_iterator()); !it.Done(); it.Advance()) {
     JoinEntryInstr* join = it.Current()->AsJoinEntry();
     if (join != NULL) join->RemoveDeadPhis(constant_dead());
   }
 }
 
 
 void FlowGraph::RemoveRedefinitions() {
   // Remove redefinition instructions inserted to inhibit hoisting.
-  for (BlockIterator block_it = reverse_postorder_iterator();
-       !block_it.Done();
+  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
     for (ForwardInstructionIterator instr_it(block_it.Current());
-         !instr_it.Done();
-         instr_it.Advance()) {
+         !instr_it.Done(); instr_it.Advance()) {
       RedefinitionInstr* redefinition = instr_it.Current()->AsRedefinition();
       if (redefinition != NULL) {
         Definition* original;
         do {
           original = redefinition->value()->definition();
         } while (original->IsRedefinition());
         redefinition->ReplaceUsesWith(original);
         instr_it.RemoveCurrentFromGraph();
       }
     }
   }
 }
 
 
 // Find the natural loop for the back edge m->n and attach loop information
 // to block n (loop header). The algorithm is described in "Advanced Compiler
 // Design & Implementation" (Muchnick) p192.
 BitVector* FlowGraph::FindLoop(BlockEntryInstr* m, BlockEntryInstr* n) const {
   GrowableArray<BlockEntryInstr*> stack;
-  BitVector* loop = new(zone()) BitVector(zone(), preorder_.length());
+  BitVector* loop = new (zone()) BitVector(zone(), preorder_.length());
 
   loop->Add(n->preorder_number());
   if (n != m) {
     loop->Add(m->preorder_number());
     stack.Add(m);
   }
 
   while (!stack.is_empty()) {
     BlockEntryInstr* p = stack.RemoveLast();
     for (intptr_t i = 0; i < p->PredecessorCount(); ++i) {
       BlockEntryInstr* q = p->PredecessorAt(i);
       if (!loop->Contains(q->preorder_number())) {
         loop->Add(q->preorder_number());
         stack.Add(q);
       }
     }
   }
   return loop;
 }
 
 
 ZoneGrowableArray<BlockEntryInstr*>* FlowGraph::ComputeLoops() const {
   ZoneGrowableArray<BlockEntryInstr*>* loop_headers =
-      new(zone()) ZoneGrowableArray<BlockEntryInstr*>();
+      new (zone()) ZoneGrowableArray<BlockEntryInstr*>();
 
-  for (BlockIterator it = postorder_iterator();
-       !it.Done();
-       it.Advance()) {
+  for (BlockIterator it = postorder_iterator(); !it.Done(); it.Advance()) {
     BlockEntryInstr* block = it.Current();
     for (intptr_t i = 0; i < block->PredecessorCount(); ++i) {
       BlockEntryInstr* pred = block->PredecessorAt(i);
       if (block->Dominates(pred)) {
         if (FLAG_trace_optimization) {
           OS::Print("Back edge B%" Pd " -> B%" Pd "\n", pred->block_id(),
                     block->block_id());
         }
         BitVector* loop_info = FindLoop(pred, block);
         // Loops that share the same loop header are treated as one loop.
@@ skipping 10 matching lines @@
           block->set_loop_info(loop_info);
           loop_headers->Add(block);
         }
       }
     }
   }
   if (FLAG_trace_optimization) {
     for (intptr_t i = 0; i < loop_headers->length(); ++i) {
       BlockEntryInstr* header = (*loop_headers)[i];
       OS::Print("Loop header B%" Pd "\n", header->block_id());
-      for (BitVector::Iterator it(header->loop_info());
-           !it.Done();
+      for (BitVector::Iterator it(header->loop_info()); !it.Done();
            it.Advance()) {
         OS::Print("  B%" Pd "\n", preorder_[it.Current()]->block_id());
       }
     }
   }
   return loop_headers;
 }
 
 
 intptr_t FlowGraph::InstructionCount() const {
   intptr_t size = 0;
   // Iterate each block, skipping the graph entry.
   for (intptr_t i = 1; i < preorder_.length(); ++i) {
-    for (ForwardInstructionIterator it(preorder_[i]);
-         !it.Done();
+    for (ForwardInstructionIterator it(preorder_[i]); !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 void FlowGraph::ComputeBlockEffects() {
-  block_effects_ = new(zone()) BlockEffects(this);
+  block_effects_ = new (zone()) BlockEffects(this);
 }
 
 
 BlockEffects::BlockEffects(FlowGraph* flow_graph)
     : available_at_(flow_graph->postorder().length()) {
   // We are tracking a single effect.
   ASSERT(EffectSet::kLastEffect == 1);
   Zone* zone = flow_graph->zone();
   const intptr_t block_count = flow_graph->postorder().length();
 
   // Set of blocks that contain side-effects.
-  BitVector* kill = new(zone) BitVector(zone, block_count);
+  BitVector* kill = new (zone) BitVector(zone, block_count);
 
   // Per block available-after sets. Block A is available after the block B if
   // and only if A is either equal to B or A is available at B and B contains no
   // side-effects. Initially we consider all blocks available after all other
   // blocks.
   GrowableArray<BitVector*> available_after(block_count);
 
   // Discover all blocks with side-effects.
-  for (BlockIterator it = flow_graph->postorder_iterator();
-       !it.Done();
+  for (BlockIterator it = flow_graph->postorder_iterator(); !it.Done();
        it.Advance()) {
     available_at_.Add(NULL);
     available_after.Add(NULL);
 
     BlockEntryInstr* block = it.Current();
-    for (ForwardInstructionIterator it(block);
-         !it.Done();
-         it.Advance()) {
+    for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       if (!it.Current()->Effects().IsNone()) {
         kill->Add(block->postorder_number());
         break;
       }
     }
   }
 
-  BitVector* temp = new(zone) BitVector(zone, block_count);
+  BitVector* temp = new (zone) BitVector(zone, block_count);
 
   // Recompute available-at based on predecessors' available-after until the fix
   // point is reached.
   bool changed;
   do {
     changed = false;
 
     for (BlockIterator it = flow_graph->reverse_postorder_iterator();
-         !it.Done();
-         it.Advance()) {
+         !it.Done(); it.Advance()) {
       BlockEntryInstr* block = it.Current();
       const intptr_t block_num = block->postorder_number();
 
       if (block->IsGraphEntry()) {
         temp->Clear();  // Nothing is live-in into graph entry.
       } else {
         // Available-at is an intersection of all predecessors' available-after
         // sets.
         temp->SetAll();
         for (intptr_t i = 0; i < block->PredecessorCount(); i++) {
           const intptr_t pred = block->PredecessorAt(i)->postorder_number();
           if (available_after[pred] != NULL) {
             temp->Intersect(available_after[pred]);
           }
         }
       }
 
       BitVector* current = available_at_[block_num];
       if ((current == NULL) || !current->Equals(*temp)) {
         // Available-at changed: update it and recompute available-after.
         if (available_at_[block_num] == NULL) {
           current = available_at_[block_num] =
-              new(zone) BitVector(zone, block_count);
-          available_after[block_num] =
-              new(zone) BitVector(zone, block_count);
+              new (zone) BitVector(zone, block_count);
+          available_after[block_num] = new (zone) BitVector(zone, block_count);
           // Block is always available after itself.
           available_after[block_num]->Add(block_num);
         }
         current->CopyFrom(temp);
         if (!kill->Contains(block_num)) {
           available_after[block_num]->CopyFrom(temp);
           // Block is always available after itself.
           available_after[block_num]->Add(block_num);
         }
         changed = true;
       }
     }
   } while (changed);
 }
 
 
 bool BlockEffects::IsAvailableAt(Instruction* instr,
                                  BlockEntryInstr* block) const {
   return (instr->Dependencies().IsNone()) ||
-      IsSideEffectFreePath(instr->GetBlock(), block);
+         IsSideEffectFreePath(instr->GetBlock(), block);
 }
 
 
 bool BlockEffects::CanBeMovedTo(Instruction* instr,
                                 BlockEntryInstr* block) const {
   return (instr->Dependencies().IsNone()) ||
-      IsSideEffectFreePath(block, instr->GetBlock());
+         IsSideEffectFreePath(block, instr->GetBlock());
 }
 
 
 bool BlockEffects::IsSideEffectFreePath(BlockEntryInstr* from,
                                         BlockEntryInstr* to) const {
   return available_at_[to->postorder_number()]->Contains(
       from->postorder_number());
 }
 
 
 // Quick access to the current zone.
 #define Z (zone())
 
 
 void FlowGraph::ConvertUse(Value* use, Representation from_rep) {
   const Representation to_rep =
       use->instruction()->RequiredInputRepresentation(use->use_index());
   if (from_rep == to_rep || to_rep == kNoRepresentation) {
     return;
   }
-  InsertConversion(from_rep, to_rep, use, /*is_environment_use=*/ false);
+  InsertConversion(from_rep, to_rep, use, /*is_environment_use=*/false);
 }
 
 
 static bool IsUnboxedInteger(Representation rep) {
-  return (rep == kUnboxedInt32) ||
-         (rep == kUnboxedUint32) ||
+  return (rep == kUnboxedInt32) || (rep == kUnboxedUint32) ||
          (rep == kUnboxedMint);
 }
 
 
 static bool ShouldInlineSimd() {
   return FlowGraphCompiler::SupportsUnboxedSimd128();
 }
 
 
 static bool CanUnboxDouble() {
@@ skipping 18 matching lines @@
     // For phis conversions have to be inserted in the predecessor.
     insert_before =
         phi->block()->PredecessorAt(use->use_index())->last_instruction();
     deopt_target = NULL;
   } else {
     deopt_target = insert_before = use->instruction();
   }
 
   Definition* converted = NULL;
   if (IsUnboxedInteger(from) && IsUnboxedInteger(to)) {
-    const intptr_t deopt_id = (to == kUnboxedInt32) && (deopt_target != NULL) ?
-      deopt_target->DeoptimizationTarget() : Thread::kNoDeoptId;
-    converted = new(Z) UnboxedIntConverterInstr(from,
-                                                to,
-                                                use->CopyWithType(),
-                                                deopt_id);
+    const intptr_t deopt_id = (to == kUnboxedInt32) && (deopt_target != NULL)
+                                  ? deopt_target->DeoptimizationTarget()
+                                  : Thread::kNoDeoptId;
+    converted = new (Z)
+        UnboxedIntConverterInstr(from, to, use->CopyWithType(), deopt_id);
   } else if ((from == kUnboxedInt32) && (to == kUnboxedDouble)) {
     converted = new Int32ToDoubleInstr(use->CopyWithType());
-  } else if ((from == kUnboxedMint) &&
-             (to == kUnboxedDouble) &&
+  } else if ((from == kUnboxedMint) && (to == kUnboxedDouble) &&
              CanConvertUnboxedMintToDouble()) {
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Thread::kNoDeoptId;
+    const intptr_t deopt_id = (deopt_target != NULL)
+                                  ? deopt_target->DeoptimizationTarget()
+                                  : Thread::kNoDeoptId;
     ASSERT(CanUnboxDouble());
     converted = new MintToDoubleInstr(use->CopyWithType(), deopt_id);
   } else if ((from == kTagged) && Boxing::Supports(to)) {
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Thread::kNoDeoptId;
+    const intptr_t deopt_id = (deopt_target != NULL)
+                                  ? deopt_target->DeoptimizationTarget()
+                                  : Thread::kNoDeoptId;
     converted = UnboxInstr::Create(to, use->CopyWithType(), deopt_id);
   } else if ((to == kTagged) && Boxing::Supports(from)) {
     converted = BoxInstr::Create(from, use->CopyWithType());
   } else {
     // We have failed to find a suitable conversion instruction.
     // Insert two "dummy" conversion instructions with the correct
     // "from" and "to" representation. The inserted instructions will
     // trigger a deoptimization if executed. See #12417 for a discussion.
-    const intptr_t deopt_id = (deopt_target != NULL) ?
-        deopt_target->DeoptimizationTarget() : Thread::kNoDeoptId;
+    const intptr_t deopt_id = (deopt_target != NULL)
+                                  ? deopt_target->DeoptimizationTarget()
+                                  : Thread::kNoDeoptId;
     ASSERT(Boxing::Supports(from));
     ASSERT(Boxing::Supports(to));
     Definition* boxed = BoxInstr::Create(from, use->CopyWithType());
     use->BindTo(boxed);
     InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
-    converted = UnboxInstr::Create(to, new(Z) Value(boxed), deopt_id);
+    converted = UnboxInstr::Create(to, new (Z) Value(boxed), deopt_id);
   }
   ASSERT(converted != NULL);
   InsertBefore(insert_before, converted, use->instruction()->env(),
                FlowGraph::kValue);
   if (is_environment_use) {
     use->BindToEnvironment(converted);
   } else {
     use->BindTo(converted);
   }
 
   if ((to == kUnboxedInt32) && (phi != NULL)) {
     // Int32 phis are unboxed optimistically. Ensure that unboxing
     // has deoptimization target attached from the goto instruction.
     CopyDeoptTarget(converted, insert_before);
   }
 }
 
 
 void FlowGraph::ConvertEnvironmentUse(Value* use, Representation from_rep) {
   const Representation to_rep = kTagged;
   if (from_rep == to_rep) {
     return;
   }
-  InsertConversion(from_rep, to_rep, use, /*is_environment_use=*/ true);
+  InsertConversion(from_rep, to_rep, use, /*is_environment_use=*/true);
 }
 
 
 void FlowGraph::InsertConversionsFor(Definition* def) {
   const Representation from_rep = def->representation();
 
-  for (Value::Iterator it(def->input_use_list());
-       !it.Done();
-       it.Advance()) {
+  for (Value::Iterator it(def->input_use_list()); !it.Done(); it.Advance()) {
     ConvertUse(it.Current(), from_rep);
   }
 
   if (graph_entry()->SuccessorCount() > 1) {
-    for (Value::Iterator it(def->env_use_list());
-         !it.Done();
-         it.Advance()) {
+    for (Value::Iterator it(def->env_use_list()); !it.Done(); it.Advance()) {
       Value* use = it.Current();
       if (use->instruction()->MayThrow() &&
           use->instruction()->GetBlock()->InsideTryBlock()) {
         // Environment uses at calls inside try-blocks must be converted to
         // tagged representation.
         ConvertEnvironmentUse(it.Current(), from_rep);
       }
     }
   }
 }
@@ skipping 18 matching lines @@
         unboxed = kUnboxedInt32x4;
       }
       break;
     case kFloat64x2Cid:
       if (ShouldInlineSimd()) {
         unboxed = kUnboxedFloat64x2;
       }
       break;
   }
 
-  if ((kSmiBits < 32) &&
-      (unboxed == kTagged) &&
-      phi->Type()->IsInt() &&
+  if ((kSmiBits < 32) && (unboxed == kTagged) && phi->Type()->IsInt() &&
       RangeUtils::Fits(phi->range(), RangeBoundary::kRangeBoundaryInt64)) {
     // On 32-bit platforms conservatively unbox phis that:
     //   - are proven to be of type Int;
     //   - fit into 64bits range;
     //   - have either constants or Box() operations as inputs;
     //   - have at least one Box() operation as an input;
     //   - are used in at least 1 Unbox() operation.
     bool should_unbox = false;
     for (intptr_t i = 0; i < phi->InputCount(); i++) {
       Definition* input = phi->InputAt(i)->definition();
       if (input->IsBox() &&
           RangeUtils::Fits(input->range(),
                            RangeBoundary::kRangeBoundaryInt64)) {
         should_unbox = true;
       } else if (!input->IsConstant()) {
         should_unbox = false;
         break;
       }
     }
 
     if (should_unbox) {
       // We checked inputs. Check if phi is used in at least one unbox
       // operation.
       bool has_unboxed_use = false;
-      for (Value* use = phi->input_use_list();
-           use != NULL;
+      for (Value* use = phi->input_use_list(); use != NULL;
            use = use->next_use()) {
         Instruction* instr = use->instruction();
         if (instr->IsUnbox()) {
           has_unboxed_use = true;
           break;
         } else if (IsUnboxedInteger(
-            instr->RequiredInputRepresentation(use->use_index()))) {
+                       instr->RequiredInputRepresentation(use->use_index()))) {
           has_unboxed_use = true;
           break;
         }
       }
 
       if (!has_unboxed_use) {
         should_unbox = false;
       }
     }
 
     if (should_unbox) {
       unboxed =
           RangeUtils::Fits(phi->range(), RangeBoundary::kRangeBoundaryInt32)
-          ? kUnboxedInt32 : kUnboxedMint;
+              ? kUnboxedInt32
+              : kUnboxedMint;
     }
   }
 
   phi->set_representation(unboxed);
 }
 
 
 void FlowGraph::SelectRepresentations() {
   // Conservatively unbox all phis that were proven to be of Double,
   // Float32x4, or Int32x4 type.
-  for (BlockIterator block_it = reverse_postorder_iterator();
-       !block_it.Done();
+  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
     JoinEntryInstr* join_entry = block_it.Current()->AsJoinEntry();
     if (join_entry != NULL) {
       for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
         UnboxPhi(phi);
       }
     }
   }
 
   // Process all instructions and insert conversions where needed.
   // Visit incoming parameters and constants.
-  for (intptr_t i = 0;
-       i < graph_entry()->initial_definitions()->length();
+  for (intptr_t i = 0; i < graph_entry()->initial_definitions()->length();
        i++) {
     InsertConversionsFor((*graph_entry()->initial_definitions())[i]);
   }
 
-  for (BlockIterator block_it = reverse_postorder_iterator();
-       !block_it.Done();
+  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
     BlockEntryInstr* entry = block_it.Current();
     JoinEntryInstr* join_entry = entry->AsJoinEntry();
     if (join_entry != NULL) {
       for (PhiIterator it(join_entry); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
         ASSERT(phi != NULL);
         ASSERT(phi->is_alive());
         InsertConversionsFor(phi);
       }
     }
     CatchBlockEntryInstr* catch_entry = entry->AsCatchBlockEntry();
     if (catch_entry != NULL) {
-      for (intptr_t i = 0;
-           i < catch_entry->initial_definitions()->length();
+      for (intptr_t i = 0; i < catch_entry->initial_definitions()->length();
            i++) {
         InsertConversionsFor((*catch_entry->initial_definitions())[i]);
       }
     }
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Definition* def = it.Current()->AsDefinition();
       if (def != NULL) {
         InsertConversionsFor(def);
       }
     }
   }
 }
 
 
 #if defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_IA32)
 // Smi widening pass is only meaningful on platforms where Smi
 // is smaller than 32bit. For now only support it on ARM and ia32.
 static bool CanBeWidened(BinarySmiOpInstr* smi_op) {
-  return BinaryInt32OpInstr::IsSupported(smi_op->op_kind(),
-                                         smi_op->left(),
+  return BinaryInt32OpInstr::IsSupported(smi_op->op_kind(), smi_op->left(),
                                          smi_op->right());
 }
 
 
 static bool BenefitsFromWidening(BinarySmiOpInstr* smi_op) {
   // TODO(vegorov): when shifts with non-constants shift count are supported
   // add them here as we save untagging for the count.
   switch (smi_op->op_kind()) {
     case Token::kMUL:
     case Token::kSHR:
       // For kMUL we save untagging of the argument for kSHR
       // we save tagging of the result.
       return true;
 
     default:
       return false;
   }
 }
 
 
 void FlowGraph::WidenSmiToInt32() {
   GrowableArray<BinarySmiOpInstr*> candidates;
 
   // Step 1. Collect all instructions that potentially benefit from widening of
   // their operands (or their result) into int32 range.
-  for (BlockIterator block_it = reverse_postorder_iterator();
-       !block_it.Done();
+  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
     for (ForwardInstructionIterator instr_it(block_it.Current());
-         !instr_it.Done();
-         instr_it.Advance()) {
+         !instr_it.Done(); instr_it.Advance()) {
       BinarySmiOpInstr* smi_op = instr_it.Current()->AsBinarySmiOp();
-      if ((smi_op != NULL) &&
-          smi_op->HasSSATemp() &&
-          BenefitsFromWidening(smi_op) &&
-          CanBeWidened(smi_op)) {
+      if ((smi_op != NULL) && smi_op->HasSSATemp() &&
+          BenefitsFromWidening(smi_op) && CanBeWidened(smi_op)) {
         candidates.Add(smi_op);
       }
     }
   }
 
   if (candidates.is_empty()) {
     return;
   }
 
   // Step 2. For each block in the graph compute which loop it belongs to.
   // We will use this information later during computation of the widening's
   // gain: we are going to assume that only conversion occuring inside the
   // same loop should be counted against the gain, all other conversions
   // can be hoisted and thus cost nothing compared to the loop cost itself.
   const ZoneGrowableArray<BlockEntryInstr*>& loop_headers = LoopHeaders();
 
   GrowableArray<intptr_t> loops(preorder().length());
   for (intptr_t i = 0; i < preorder().length(); i++) {
     loops.Add(-1);
   }
 
   for (intptr_t loop_id = 0; loop_id < loop_headers.length(); ++loop_id) {
     for (BitVector::Iterator loop_it(loop_headers[loop_id]->loop_info());
-         !loop_it.Done();
-         loop_it.Advance()) {
+         !loop_it.Done(); loop_it.Advance()) {
       loops[loop_it.Current()] = loop_id;
     }
   }
 
   // Step 3. For each candidate transitively collect all other BinarySmiOpInstr
   // and PhiInstr that depend on it and that it depends on and count amount of
   // untagging operations that we save in assumption that this whole graph of
   // values is using kUnboxedInt32 representation instead of kTagged.
   // Convert those graphs that have positive gain to kUnboxedInt32.
 
   // BitVector containing SSA indexes of all processed definitions. Used to skip
   // those candidates that belong to dependency graph of another candidate.
-  BitVector* processed =
-      new(Z) BitVector(Z, current_ssa_temp_index());
+  BitVector* processed = new (Z) BitVector(Z, current_ssa_temp_index());
 
   // Worklist used to collect dependency graph.
   DefinitionWorklist worklist(this, candidates.length());
   for (intptr_t i = 0; i < candidates.length(); i++) {
     BinarySmiOpInstr* op = candidates[i];
     if (op->WasEliminated() || processed->Contains(op->ssa_temp_index())) {
       continue;
     }
 
     if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
@@ skipping 18 matching lines @@
         if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
           THR_Print("^ [%" Pd "] (o) %s\n", gain, defn->ToCString());
         }
       }
 
       const intptr_t defn_loop = loops[defn->GetBlock()->preorder_number()];
 
       // Process all inputs.
       for (intptr_t k = 0; k < defn->InputCount(); k++) {
         Definition* input = defn->InputAt(k)->definition();
-        if (input->IsBinarySmiOp() &&
-            CanBeWidened(input->AsBinarySmiOp())) {
+        if (input->IsBinarySmiOp() && CanBeWidened(input->AsBinarySmiOp())) {
           worklist.Add(input);
         } else if (input->IsPhi() && (input->Type()->ToCid() == kSmiCid)) {
           worklist.Add(input);
         } else if (input->IsBinaryMintOp()) {
           // Mint operation produces untagged result. We avoid tagging.
           gain++;
           if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("^ [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         } else if (defn_loop == loops[input->GetBlock()->preorder_number()] &&
                    (input->Type()->ToCid() == kSmiCid)) {
           // Input comes from the same loop, is known to be smi and requires
           // untagging.
           // TODO(vegorov) this heuristic assumes that values that are not
           // known to be smi have to be checked and this check can be
           // coalesced with untagging. Start coalescing them.
           gain--;
           if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("v [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         }
       }
 
       // Process all uses.
-      for (Value* use = defn->input_use_list();
-           use != NULL;
+      for (Value* use = defn->input_use_list(); use != NULL;
            use = use->next_use()) {
         Instruction* instr = use->instruction();
         Definition* use_defn = instr->AsDefinition();
         if (use_defn == NULL) {
           // We assume that tagging before returning or pushing argument costs
           // very little compared to the cost of the return/call itself.
           if (!instr->IsReturn() && !instr->IsPushArgument()) {
             gain--;
             if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
-              THR_Print("v [%" Pd "] (u) %s\n",
-                        gain,
+              THR_Print("v [%" Pd "] (u) %s\n", gain,
                         use->instruction()->ToCString());
             }
           }
           continue;
         } else if (use_defn->IsBinarySmiOp() &&
                    CanBeWidened(use_defn->AsBinarySmiOp())) {
           worklist.Add(use_defn);
         } else if (use_defn->IsPhi() &&
                    use_defn->AsPhi()->Type()->ToCid() == kSmiCid) {
           worklist.Add(use_defn);
         } else if (use_defn->IsBinaryMintOp()) {
           // BinaryMintOp requires untagging of its inputs.
           // Converting kUnboxedInt32 to kUnboxedMint is essentially zero cost
           // sign extension operation.
           gain++;
           if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
-            THR_Print("^ [%" Pd "] (u) %s\n",
-                      gain,
+            THR_Print("^ [%" Pd "] (u) %s\n", gain,
                       use->instruction()->ToCString());
           }
         } else if (defn_loop == loops[instr->GetBlock()->preorder_number()]) {
           gain--;
           if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
-            THR_Print("v [%" Pd "] (u) %s\n",
-                      gain,
+            THR_Print("v [%" Pd "] (u) %s\n", gain,
                       use->instruction()->ToCString());
           }
         }
       }
     }
 
     processed->AddAll(worklist.contains_vector());
 
     if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
       THR_Print("~ %s gain %" Pd "\n", op->ToCString(), gain);
     }
 
     if (gain > 0) {
       // We have positive gain from widening. Convert all BinarySmiOpInstr into
       // BinaryInt32OpInstr and set representation of all phis to kUnboxedInt32.
       for (intptr_t j = 0; j < worklist.definitions().length(); j++) {
         Definition* defn = worklist.definitions()[j];
         ASSERT(defn->IsPhi() || defn->IsBinarySmiOp());
 
         if (defn->IsBinarySmiOp()) {
           BinarySmiOpInstr* smi_op = defn->AsBinarySmiOp();
-          BinaryInt32OpInstr* int32_op = new(Z) BinaryInt32OpInstr(
-            smi_op->op_kind(),
-            smi_op->left()->CopyWithType(),
-            smi_op->right()->CopyWithType(),
-            smi_op->DeoptimizationTarget());
+          BinaryInt32OpInstr* int32_op = new (Z) BinaryInt32OpInstr(
+              smi_op->op_kind(), smi_op->left()->CopyWithType(),
+              smi_op->right()->CopyWithType(), smi_op->DeoptimizationTarget());
 
           smi_op->ReplaceWith(int32_op, NULL);
         } else if (defn->IsPhi()) {
           defn->AsPhi()->set_representation(kUnboxedInt32);
           ASSERT(defn->Type()->IsInt());
         }
       }
     }
   }
 }
 #else
 void FlowGraph::WidenSmiToInt32() {
   // TODO(vegorov) ideally on 64-bit platforms we would like to narrow smi
   // operations to 32-bit where it saves tagging and untagging and allows
   // to use shorted (and faster) instructions. But we currently don't
   // save enough range information in the ICData to drive this decision.
 }
 #endif
 
 
 void FlowGraph::EliminateEnvironments() {
   // After this pass we can no longer perform LICM and hoist instructions
   // that can deoptimize.
 
   disallow_licm();
-  for (BlockIterator block_it = reverse_postorder_iterator();
-       !block_it.Done();
+  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
     if (!block->IsCatchBlockEntry()) {
       block->RemoveEnvironment();
     }
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
       if (!current->CanDeoptimize() &&
           (!current->MayThrow() || !current->GetBlock()->InsideTryBlock())) {
         // Instructions that can throw need an environment for optimized
         // try-catch.
         // TODO(srdjan): --source-lines needs deopt environments to get at
         // the code for this instruction, however, leaving the environment
         // changes code.
         current->RemoveEnvironment();
       }
     }
   }
 }
 
 
 bool FlowGraph::Canonicalize() {
   bool changed = false;
 
-  for (BlockIterator block_it = reverse_postorder_iterator();
-       !block_it.Done();
+  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
-    for (ForwardInstructionIterator it(block_it.Current());
-         !it.Done();
+    for (ForwardInstructionIterator it(block_it.Current()); !it.Done();
          it.Advance()) {
       Instruction* current = it.Current();
       if (current->HasUnmatchedInputRepresentations()) {
         // Can't canonicalize this instruction until all conversions for its
         // inputs are inserted.
         continue;
       }
 
       Instruction* replacement = current->Canonicalize(this);
 
@@ skipping 10 matching lines @@
 }
 
 
 // Optimize (a << b) & c pattern: if c is a positive Smi or zero, then the
 // shift can be a truncating Smi shift-left and result is always Smi.
 // Merging occurs only per basic-block.
 void FlowGraph::TryOptimizePatterns() {
   if (!FLAG_truncating_left_shift) return;
   GrowableArray<BinarySmiOpInstr*> div_mod_merge;
   GrowableArray<InvokeMathCFunctionInstr*> sin_cos_merge;
-  for (BlockIterator block_it = reverse_postorder_iterator();
-       !block_it.Done();
+  for (BlockIterator block_it = reverse_postorder_iterator(); !block_it.Done();
        block_it.Advance()) {
     // Merging only per basic-block.
     div_mod_merge.Clear();
     sin_cos_merge.Clear();
     ForwardInstructionIterator it(block_it.Current());
     for (; !it.Done(); it.Advance()) {
       if (it.Current()->IsBinarySmiOp()) {
         BinarySmiOpInstr* binop = it.Current()->AsBinarySmiOp();
         if (binop->op_kind() == Token::kBIT_AND) {
-          OptimizeLeftShiftBitAndSmiOp(&it,
-                                       binop,
-                                       binop->left()->definition(),
+          OptimizeLeftShiftBitAndSmiOp(&it, binop, binop->left()->definition(),
                                        binop->right()->definition());
         } else if ((binop->op_kind() == Token::kTRUNCDIV) ||
                    (binop->op_kind() == Token::kMOD)) {
           if (binop->HasUses()) {
             div_mod_merge.Add(binop);
           }
         }
       } else if (it.Current()->IsBinaryMintOp()) {
         BinaryMintOpInstr* mintop = it.Current()->AsBinaryMintOp();
         if (mintop->op_kind() == Token::kBIT_AND) {
-          OptimizeLeftShiftBitAndSmiOp(&it,
-                                       mintop,
+          OptimizeLeftShiftBitAndSmiOp(&it, mintop,
                                        mintop->left()->definition(),
                                        mintop->right()->definition());
         }
       } else if (it.Current()->IsInvokeMathCFunction()) {
         InvokeMathCFunctionInstr* math_unary =
             it.Current()->AsInvokeMathCFunction();
         if ((math_unary->recognized_kind() == MethodRecognizer::kMathSin) ||
             (math_unary->recognized_kind() == MethodRecognizer::kMathCos)) {
           if (math_unary->HasUses()) {
             sin_cos_merge.Add(math_unary);
@@ skipping 47 matching lines @@
   if ((smi_shift_left == NULL) && (bit_and_instr->InputAt(1)->IsSingleUse())) {
     smi_shift_left = AsSmiShiftLeftInstruction(right_instr);
   }
   if (smi_shift_left == NULL) return;
 
   // Pattern recognized.
   smi_shift_left->mark_truncating();
   ASSERT(bit_and_instr->IsBinarySmiOp() || bit_and_instr->IsBinaryMintOp());
   if (bit_and_instr->IsBinaryMintOp()) {
     // Replace Mint op with Smi op.
-    BinarySmiOpInstr* smi_op = new(Z) BinarySmiOpInstr(
-        Token::kBIT_AND,
-        new(Z) Value(left_instr),
-        new(Z) Value(right_instr),
+    BinarySmiOpInstr* smi_op = new (Z) BinarySmiOpInstr(
+        Token::kBIT_AND, new (Z) Value(left_instr), new (Z) Value(right_instr),
         Thread::kNoDeoptId);  // BIT_AND cannot deoptimize.
     bit_and_instr->ReplaceWith(smi_op, current_iterator);
   }
 }
 
 
 // Dart:
 //  var x = d % 10;
 //  var y = d ~/ 10;
 //  var z = x + y;
@@ skipping 18 matching lines @@
   }
   for (intptr_t i = 0; i < merge_candidates->length(); i++) {
     BinarySmiOpInstr* curr_instr = (*merge_candidates)[i];
     if (curr_instr == NULL) {
       // Instruction was merged already.
       continue;
     }
     ASSERT((curr_instr->op_kind() == Token::kTRUNCDIV) ||
            (curr_instr->op_kind() == Token::kMOD));
     // Check if there is kMOD/kTRUNDIV binop with same inputs.
-    const Token::Kind other_kind = (curr_instr->op_kind() == Token::kTRUNCDIV) ?
-        Token::kMOD : Token::kTRUNCDIV;
+    const Token::Kind other_kind = (curr_instr->op_kind() == Token::kTRUNCDIV)
+                                       ? Token::kMOD
+                                       : Token::kTRUNCDIV;
     Definition* left_def = curr_instr->left()->definition();
     Definition* right_def = curr_instr->right()->definition();
     for (intptr_t k = i + 1; k < merge_candidates->length(); k++) {
       BinarySmiOpInstr* other_binop = (*merge_candidates)[k];
       // 'other_binop' can be NULL if it was already merged.
-      if ((other_binop != NULL) &&
-          (other_binop->op_kind() == other_kind) &&
+      if ((other_binop != NULL) && (other_binop->op_kind() == other_kind) &&
           (other_binop->left()->definition() == left_def) &&
           (other_binop->right()->definition() == right_def)) {
         (*merge_candidates)[k] = NULL;  // Clear it.
         ASSERT(curr_instr->HasUses());
         AppendExtractNthOutputForMerged(
-            curr_instr,
-            MergedMathInstr::OutputIndexOf(curr_instr->op_kind()),
+            curr_instr, MergedMathInstr::OutputIndexOf(curr_instr->op_kind()),
             kTagged, kSmiCid);
         ASSERT(other_binop->HasUses());
         AppendExtractNthOutputForMerged(
-            other_binop,
-            MergedMathInstr::OutputIndexOf(other_binop->op_kind()),
+            other_binop, MergedMathInstr::OutputIndexOf(other_binop->op_kind()),
             kTagged, kSmiCid);
 
-        ZoneGrowableArray<Value*>* args = new(Z) ZoneGrowableArray<Value*>(2);
-        args->Add(new(Z) Value(curr_instr->left()->definition()));
-        args->Add(new(Z) Value(curr_instr->right()->definition()));
+        ZoneGrowableArray<Value*>* args = new (Z) ZoneGrowableArray<Value*>(2);
+        args->Add(new (Z) Value(curr_instr->left()->definition()));
+        args->Add(new (Z) Value(curr_instr->right()->definition()));
 
         // Replace with TruncDivMod.
-        MergedMathInstr* div_mod = new(Z) MergedMathInstr(
-            args,
-            curr_instr->deopt_id(),
-            MergedMathInstr::kTruncDivMod);
+        MergedMathInstr* div_mod = new (Z) MergedMathInstr(
+            args, curr_instr->deopt_id(), MergedMathInstr::kTruncDivMod);
         curr_instr->ReplaceWith(div_mod, NULL);
         other_binop->ReplaceUsesWith(div_mod);
         other_binop->RemoveFromGraph();
         // Only one merge possible. Because canonicalization happens later,
         // more candidates are possible.
         // TODO(srdjan): Allow merging of trunc-div/mod into truncDivMod.
         break;
       }
     }
   }
@@ skipping 15 matching lines @@
     InvokeMathCFunctionInstr* curr_instr = (*merge_candidates)[i];
     if (curr_instr == NULL) {
       // Instruction was merged already.
       continue;
     }
     const MethodRecognizer::Kind kind = curr_instr->recognized_kind();
     ASSERT((kind == MethodRecognizer::kMathSin) ||
            (kind == MethodRecognizer::kMathCos));
     // Check if there is sin/cos binop with same inputs.
     const MethodRecognizer::Kind other_kind =
-        (kind == MethodRecognizer::kMathSin)
-        ? MethodRecognizer::kMathCos : MethodRecognizer::kMathSin;
+        (kind == MethodRecognizer::kMathSin) ? MethodRecognizer::kMathCos
+                                             : MethodRecognizer::kMathSin;
     Definition* def = curr_instr->InputAt(0)->definition();
     for (intptr_t k = i + 1; k < merge_candidates->length(); k++) {
       InvokeMathCFunctionInstr* other_op = (*merge_candidates)[k];
       // 'other_op' can be NULL if it was already merged.
       if ((other_op != NULL) && (other_op->recognized_kind() == other_kind) &&
           (other_op->InputAt(0)->definition() == def)) {
         (*merge_candidates)[k] = NULL;  // Clear it.
         ASSERT(curr_instr->HasUses());
         AppendExtractNthOutputForMerged(curr_instr,
                                         MergedMathInstr::OutputIndexOf(kind),
                                         kUnboxedDouble, kDoubleCid);
         ASSERT(other_op->HasUses());
         AppendExtractNthOutputForMerged(
-            other_op,
-            MergedMathInstr::OutputIndexOf(other_kind),
+            other_op, MergedMathInstr::OutputIndexOf(other_kind),
             kUnboxedDouble, kDoubleCid);
-        ZoneGrowableArray<Value*>* args = new(Z) ZoneGrowableArray<Value*>(1);
-        args->Add(new(Z) Value(curr_instr->InputAt(0)->definition()));
+        ZoneGrowableArray<Value*>* args = new (Z) ZoneGrowableArray<Value*>(1);
+        args->Add(new (Z) Value(curr_instr->InputAt(0)->definition()));
         // Replace with SinCos.
-        MergedMathInstr* sin_cos =
-            new(Z) MergedMathInstr(args,
-                                   curr_instr->DeoptimizationTarget(),
-                                   MergedMathInstr::kSinCos);
+        MergedMathInstr* sin_cos = new (Z) MergedMathInstr(
+            args, curr_instr->DeoptimizationTarget(), MergedMathInstr::kSinCos);
         curr_instr->ReplaceWith(sin_cos, NULL);
         other_op->ReplaceUsesWith(sin_cos);
         other_op->RemoveFromGraph();
         // Only one merge possible. Because canonicalization happens later,
         // more candidates are possible.
         // TODO(srdjan): Allow merging of sin/cos into sincos.
         break;
       }
     }
   }
 }
 
 
 void FlowGraph::AppendExtractNthOutputForMerged(Definition* instr,
                                                 intptr_t index,
                                                 Representation rep,
                                                 intptr_t cid) {
   ExtractNthOutputInstr* extract =
-      new(Z) ExtractNthOutputInstr(new(Z) Value(instr), index, rep, cid);
+      new (Z) ExtractNthOutputInstr(new (Z) Value(instr), index, rep, cid);
   instr->ReplaceUsesWith(extract);
   InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
 
-
-
 }  // namespace dart