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

runtime/vm/redundancy_elimination.cc

 // Copyright (c) 2016, 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/redundancy_elimination.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
 
-
 DEFINE_FLAG(bool, dead_store_elimination, true, "Eliminate dead stores");
 DEFINE_FLAG(bool, load_cse, true, "Use redundant load elimination.");
 DEFINE_FLAG(bool,
             trace_load_optimization,
             false,
             "Print live sets for load optimization pass.");
 
 // Quick access to the current zone.
 #define Z (zone())
 
-
 class CSEInstructionMap : public ValueObject {
  public:
   // Right now CSE and LICM track a single effect: possible externalization of
   // strings.
   // Other effects like modifications of fields are tracked in a separate load
   // forwarding pass via Alias structure.
   COMPILE_ASSERT(EffectSet::kLastEffect == 1);
 
   CSEInstructionMap() : independent_(), dependent_() {}
   explicit CSEInstructionMap(const CSEInstructionMap& other)
@@ skipping 26 matching lines @@
 
   // All computations that are not affected by any side-effect.
   // Majority of computations are not affected by anything and will be in
   // this map.
   Map independent_;
 
   // All computations that are affected by side effect.
   Map dependent_;
 };
 
-
 // Place describes an abstract location (e.g. field) that IR can load
 // from or store to.
 //
 // Places are also used to describe wild-card locations also known as aliases,
 // that essentially represent sets of places that alias each other. Places A
 // and B are said to alias each other if store into A can affect load from B.
 //
 // We distinguish the following aliases:
 //
 //   - for fields
@@ skipping 239 matching lines @@
   // For example for X[9|kInt8] and target size kInt32 we would return
   // X[8|kInt32].
   Place ToLargerElement(ElementSize to) const {
     ASSERT(kind() == kConstantIndexed);
     ASSERT(element_size() != kNoSize);
     ASSERT(element_size() < to);
     return Place(ElementSizeBits::update(to, flags_), instance_,
                  RoundByteOffset(to, index_constant_));
   }
 
-
   intptr_t id() const { return id_; }
 
   Kind kind() const { return KindBits::decode(flags_); }
 
   Representation representation() const {
     return RepresentationBits::decode(flags_);
   }
 
   Definition* instance() const {
     ASSERT(DependsOnInstance());
@@ skipping 231 matching lines @@
     intptr_t raw_selector_;
     const Field* field_;
     intptr_t offset_in_bytes_;
     intptr_t index_constant_;
     Definition* index_;
   };
 
   intptr_t id_;
 };
 
-
 class ZonePlace : public ZoneAllocated {
  public:
   explicit ZonePlace(const Place& place) : place_(place) {}
 
   Place* place() { return &place_; }
 
  private:
   Place place_;
 };
 
-
 Place* Place::Wrap(Zone* zone, const Place& place, intptr_t id) {
   Place* wrapped = (new (zone) ZonePlace(place))->place();
   wrapped->id_ = id;
   return wrapped;
 }
 
-
 // Correspondence between places connected through outgoing phi moves on the
 // edge that targets join.
 class PhiPlaceMoves : public ZoneAllocated {
  public:
   // Record a move from the place with id |from| to the place with id |to| at
   // the given block.
   void CreateOutgoingMove(Zone* zone,
                           BlockEntryInstr* block,
                           intptr_t from,
                           intptr_t to) {
@@ skipping 25 matching lines @@
 
   MovesList GetOutgoingMoves(BlockEntryInstr* block) const {
     const intptr_t block_num = block->preorder_number();
     return (block_num < moves_.length()) ? moves_[block_num] : NULL;
   }
 
  private:
   GrowableArray<ZoneGrowableArray<Move>*> moves_;
 };
 
-
 // A map from aliases to a set of places sharing the alias. Additionally
 // carries a set of places that can be aliased by side-effects, essentially
 // those that are affected by calls.
 class AliasedSet : public ZoneAllocated {
  public:
   AliasedSet(Zone* zone,
              DirectChainedHashMap<PointerKeyValueTrait<Place> >* places_map,
              ZoneGrowableArray<Place*>* places,
              PhiPlaceMoves* phi_moves)
       : zone_(zone),
@@ skipping 468 matching lines @@
   GrowableArray<Definition*> aliasing_worklist_;
 
   // List of definitions that had their identity set to Aliased. At the end
   // of load optimization their identity will be rolled back to Unknown to
   // avoid treating them as Aliased at later stages without checking first
   // as optimizations can potentially eliminate instructions leading to
   // aliasing.
   GrowableArray<Definition*> identity_rollback_;
 };
 
-
 static Definition* GetStoredValue(Instruction* instr) {
   if (instr->IsStoreIndexed()) {
     return instr->AsStoreIndexed()->value()->definition();
   }
 
   StoreInstanceFieldInstr* store_instance_field = instr->AsStoreInstanceField();
   if (store_instance_field != NULL) {
     return store_instance_field->value()->definition();
   }
 
   StoreStaticFieldInstr* store_static_field = instr->AsStoreStaticField();
   if (store_static_field != NULL) {
     return store_static_field->value()->definition();
   }
 
   UNREACHABLE();  // Should only be called for supported store instructions.
   return NULL;
 }
 
-
 static bool IsPhiDependentPlace(Place* place) {
   return ((place->kind() == Place::kField) ||
           (place->kind() == Place::kVMField)) &&
          (place->instance() != NULL) && place->instance()->IsPhi();
 }
 
-
 // For each place that depends on a phi ensure that equivalent places
 // corresponding to phi input are numbered and record outgoing phi moves
 // for each block which establish correspondence between phi dependent place
 // and phi input's place that is flowing in.
 static PhiPlaceMoves* ComputePhiMoves(
     DirectChainedHashMap<PointerKeyValueTrait<Place> >* map,
     ZoneGrowableArray<Place*>* places) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   PhiPlaceMoves* phi_moves = new (zone) PhiPlaceMoves();
@@ skipping 25 matching lines @@
         }
         phi_moves->CreateOutgoingMove(zone, block->PredecessorAt(j),
                                       result->id(), place->id());
       }
     }
   }
 
   return phi_moves;
 }
 
-
 enum CSEMode { kOptimizeLoads, kOptimizeStores };
 
-
 static AliasedSet* NumberPlaces(
     FlowGraph* graph,
     DirectChainedHashMap<PointerKeyValueTrait<Place> >* map,
     CSEMode mode) {
   // Loads representing different expression ids will be collected and
   // used to build per offset kill sets.
   Zone* zone = graph->zone();
   ZoneGrowableArray<Place*>* places = new (zone) ZoneGrowableArray<Place*>(10);
 
   bool has_loads = false;
@@ skipping 32 matching lines @@
   if ((mode == kOptimizeStores) && !has_stores) {
     return NULL;
   }
 
   PhiPlaceMoves* phi_moves = ComputePhiMoves(map, places);
 
   // Build aliasing sets mapping aliases to loads.
   return new (zone) AliasedSet(zone, map, places, phi_moves);
 }
 
-
 // Load instructions handled by load elimination.
 static bool IsLoadEliminationCandidate(Instruction* instr) {
   return instr->IsLoadField() || instr->IsLoadIndexed() ||
          instr->IsLoadStaticField();
 }
 
-
 static bool IsLoopInvariantLoad(ZoneGrowableArray<BitVector*>* sets,
                                 intptr_t loop_header_index,
                                 Instruction* instr) {
   return IsLoadEliminationCandidate(instr) && (sets != NULL) &&
          instr->HasPlaceId() && ((*sets)[loop_header_index] != NULL) &&
          (*sets)[loop_header_index]->Contains(instr->place_id());
 }
 
-
 LICM::LICM(FlowGraph* flow_graph) : flow_graph_(flow_graph) {
   ASSERT(flow_graph->is_licm_allowed());
 }
 
-
 void LICM::Hoist(ForwardInstructionIterator* it,
                  BlockEntryInstr* pre_header,
                  Instruction* current) {
   if (current->IsCheckClass()) {
     current->AsCheckClass()->set_licm_hoisted(true);
   } else if (current->IsCheckSmi()) {
     current->AsCheckSmi()->set_licm_hoisted(true);
   } else if (current->IsCheckEitherNonSmi()) {
     current->AsCheckEitherNonSmi()->set_licm_hoisted(true);
   } else if (current->IsCheckArrayBound()) {
@@ skipping 12 matching lines @@
     it->RemoveCurrentFromGraph();
   } else {
     current->RemoveFromGraph();
   }
   GotoInstr* last = pre_header->last_instruction()->AsGoto();
   // Using kind kEffect will not assign a fresh ssa temporary index.
   flow_graph()->InsertBefore(last, current, last->env(), FlowGraph::kEffect);
   current->CopyDeoptIdFrom(*last);
 }
 
-
 void LICM::TrySpecializeSmiPhi(PhiInstr* phi,
                                BlockEntryInstr* header,
                                BlockEntryInstr* pre_header) {
   if (phi->Type()->ToCid() == kSmiCid) {
     return;
   }
 
   // Check if there is only a single kDynamicCid input to the phi that
   // comes from the pre-header.
   const intptr_t kNotFound = -1;
@@ skipping 29 matching lines @@
 
   // Host CheckSmi instruction and make this phi smi one.
   Hoist(NULL, pre_header, check);
 
   // Replace value we are checking with phi's input.
   check->value()->BindTo(phi->InputAt(non_smi_input)->definition());
 
   phi->UpdateType(CompileType::FromCid(kSmiCid));
 }
 
-
 void LICM::OptimisticallySpecializeSmiPhis() {
   if (!flow_graph()->function().allows_hoisting_check_class() ||
       FLAG_precompiled_mode) {
     // Do not hoist any: Either deoptimized on a hoisted check,
     // or compiling precompiled code where we can't do optimistic
     // hoisting of checks.
     return;
   }
 
   const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
       flow_graph()->LoopHeaders();
 
   for (intptr_t i = 0; i < loop_headers.length(); ++i) {
     JoinEntryInstr* header = loop_headers[i]->AsJoinEntry();
     // Skip loop that don't have a pre-header block.
     BlockEntryInstr* pre_header = header->ImmediateDominator();
     if (pre_header == NULL) continue;
 
     for (PhiIterator it(header); !it.Done(); it.Advance()) {
       TrySpecializeSmiPhi(it.Current(), header, pre_header);
     }
   }
 }
 
-
 void LICM::Optimize() {
   if (!flow_graph()->function().allows_hoisting_check_class()) {
     // Do not hoist any.
     return;
   }
 
   const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
       flow_graph()->LoopHeaders();
 
   ZoneGrowableArray<BitVector*>* loop_invariant_loads =
@@ skipping 28 matching lines @@
             // TODO(fschneider): Enable hoisting of Assert-instructions
             // if it safe to do.
             Hoist(&it, pre_header, current);
           }
         }
       }
     }
   }
 }
 
-
 class LoadOptimizer : public ValueObject {
  public:
   LoadOptimizer(FlowGraph* graph, AliasedSet* aliased_set)
       : graph_(graph),
         aliased_set_(aliased_set),
         in_(graph_->preorder().length()),
         out_(graph_->preorder().length()),
         gen_(graph_->preorder().length()),
         kill_(graph_->preorder().length()),
         exposed_values_(graph_->preorder().length()),
@@ skipping 375 matching lines @@
          !block_it.Done(); block_it.Advance()) {
       BlockEntryInstr* block = block_it.Current();
 
       const bool can_merge_eagerly = CanMergeEagerly(block);
 
       const intptr_t preorder_number = block->preorder_number();
 
       ZoneGrowableArray<Definition*>* block_out_values =
           out_values_[preorder_number];
 
-
       // If OUT set has changed then we have new values available out of
       // the block. Compute these values creating phi where necessary.
       for (BitVector::Iterator it(out_[preorder_number]); !it.Done();
            it.Advance()) {
         const intptr_t place_id = it.Current();
 
         if (block_out_values == NULL) {
           out_values_[preorder_number] = block_out_values =
               CreateBlockOutValues();
         }
@@ skipping 492 matching lines @@
   // List of phis generated during ComputeOutValues and ForwardLoads.
   // Some of these phis might be redundant and thus a separate pass is
   // needed to emit only non-redundant ones.
   GrowableArray<PhiInstr*> phis_;
 
   // Auxiliary worklist used by redundant phi elimination.
   GrowableArray<PhiInstr*> worklist_;
   GrowableArray<Definition*> congruency_worklist_;
   BitVector* in_worklist_;
 
-
   // True if any load was eliminated.
   bool forwarded_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadOptimizer);
 };
 
-
 bool DominatorBasedCSE::Optimize(FlowGraph* graph) {
   bool changed = false;
   if (FLAG_load_cse) {
     changed = LoadOptimizer::OptimizeGraph(graph) || changed;
   }
 
   CSEInstructionMap map;
   changed = OptimizeRecursive(graph, graph->graph_entry(), &map) || changed;
 
   return changed;
 }
 
-
 bool DominatorBasedCSE::OptimizeRecursive(FlowGraph* graph,
                                           BlockEntryInstr* block,
                                           CSEInstructionMap* map) {
   bool changed = false;
   for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
     Instruction* current = it.Current();
     if (current->AllowsCSE()) {
       Instruction* replacement = map->Lookup(current);
       if ((replacement != NULL) &&
           graph->block_effects()->IsAvailableAt(replacement, block)) {
@@ skipping 26 matching lines @@
       CSEInstructionMap child_map(*map);
       changed = OptimizeRecursive(graph, child, &child_map) || changed;
     } else {
       // Reuse map for the last child.
       changed = OptimizeRecursive(graph, child, map) || changed;
     }
   }
   return changed;
 }
 
-
 class StoreOptimizer : public LivenessAnalysis {
  public:
   StoreOptimizer(FlowGraph* graph,
                  AliasedSet* aliased_set,
                  DirectChainedHashMap<PointerKeyValueTrait<Place> >* map)
       : LivenessAnalysis(aliased_set->max_place_id(), graph->postorder()),
         graph_(graph),
         map_(map),
         aliased_set_(aliased_set),
         exposed_stores_(graph_->postorder().length()) {
@@ skipping 186 matching lines @@
   // Mapping between field offsets in words and expression ids of loads from
   // that offset.
   AliasedSet* aliased_set_;
 
   // Per block list of downward exposed stores.
   GrowableArray<ZoneGrowableArray<Instruction*>*> exposed_stores_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreOptimizer);
 };
 
-
 void DeadStoreElimination::Optimize(FlowGraph* graph) {
   if (FLAG_dead_store_elimination) {
     StoreOptimizer::OptimizeGraph(graph);
   }
 }
 
-
 enum SafeUseCheck { kOptimisticCheck, kStrictCheck };
 
 // Check if the use is safe for allocation sinking. Allocation sinking
 // candidates can only be used at store instructions:
 //
 //     - any store into the allocation candidate itself is unconditionally safe
 //       as it just changes the rematerialization state of this candidate;
 //     - store into another object is only safe if another object is allocation
 //       candidate.
 //
@@ skipping 21 matching lines @@
       return instance->IsAllocateObject() &&
              ((check_type == kOptimisticCheck) ||
               instance->Identity().IsAllocationSinkingCandidate());
     }
     return true;
   }
 
   return false;
 }
 
-
 // Right now we are attempting to sink allocation only into
 // deoptimization exit. So candidate should only be used in StoreInstanceField
 // instructions that write into fields of the allocated object.
 // We do not support materialization of the object that has type arguments.
 static bool IsAllocationSinkingCandidate(Definition* alloc,
                                          SafeUseCheck check_type) {
   for (Value* use = alloc->input_use_list(); use != NULL;
        use = use->next_use()) {
     if (!IsSafeUse(use, check_type)) {
       if (FLAG_support_il_printer && FLAG_trace_optimization) {
         THR_Print("use of %s at %s is unsafe for allocation sinking\n",
                   alloc->ToCString(), use->instruction()->ToCString());
       }
       return false;
     }
   }
 
   return true;
 }
 
-
 // If the given use is a store into an object then return an object we are
 // storing into.
 static Definition* StoreInto(Value* use) {
   StoreInstanceFieldInstr* store = use->instruction()->AsStoreInstanceField();
   if (store != NULL) {
     return store->instance()->definition();
   }
 
   return NULL;
 }
 
-
 // Remove the given allocation from the graph. It is not observable.
 // If deoptimization occurs the object will be materialized.
 void AllocationSinking::EliminateAllocation(Definition* alloc) {
   ASSERT(IsAllocationSinkingCandidate(alloc, kStrictCheck));
 
   if (FLAG_trace_optimization) {
     THR_Print("removing allocation from the graph: v%" Pd "\n",
               alloc->ssa_temp_index());
   }
 
@@ skipping 14 matching lines @@
   ASSERT(alloc->input_use_list() == NULL);
   alloc->RemoveFromGraph();
   if (alloc->ArgumentCount() > 0) {
     ASSERT(alloc->ArgumentCount() == 1);
     for (intptr_t i = 0; i < alloc->ArgumentCount(); ++i) {
       alloc->PushArgumentAt(i)->RemoveFromGraph();
     }
   }
 }
 
-
 // Find allocation instructions that can be potentially eliminated and
 // rematerialized at deoptimization exits if needed. See IsSafeUse
 // for the description of algorithm used below.
 void AllocationSinking::CollectCandidates() {
   // Optimistically collect all potential candidates.
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done(); block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       {
@@ skipping 43 matching lines @@
 
       if (j != i) {
         candidates_[j] = alloc;
       }
       j++;
     }
   }
   candidates_.TruncateTo(j);
 }
 
-
 // If materialization references an allocation sinking candidate then replace
 // this reference with a materialization which should have been computed for
 // this side-exit. CollectAllExits should have collected this exit.
 void AllocationSinking::NormalizeMaterializations() {
   for (intptr_t i = 0; i < candidates_.length(); i++) {
     Definition* alloc = candidates_[i];
 
     Value* next_use;
     for (Value* use = alloc->input_use_list(); use != NULL; use = next_use) {
       next_use = use->next_use();
       if (use->instruction()->IsMaterializeObject()) {
         use->BindTo(MaterializationFor(alloc, use->instruction()));
       }
     }
   }
 }
 
-
 // We transitively insert materializations at each deoptimization exit that
 // might see the given allocation (see ExitsCollector). Some of this
 // materializations are not actually used and some fail to compute because
 // they are inserted in the block that is not dominated by the allocation.
 // Remove them unused materializations from the graph.
 void AllocationSinking::RemoveUnusedMaterializations() {
   intptr_t j = 0;
   for (intptr_t i = 0; i < materializations_.length(); i++) {
     MaterializeObjectInstr* mat = materializations_[i];
     if ((mat->input_use_list() == NULL) && (mat->env_use_list() == NULL)) {
@@ skipping 13 matching lines @@
     } else {
       if (j != i) {
         materializations_[j] = mat;
       }
       j++;
     }
   }
   materializations_.TruncateTo(j);
 }
 
-
 // Some candidates might stop being eligible for allocation sinking after
 // the load forwarding because they flow into phis that load forwarding
 // inserts. Discover such allocations and remove them from the list
 // of allocation sinking candidates undoing all changes that we did
 // in preparation for sinking these allocations.
 void AllocationSinking::DiscoverFailedCandidates() {
   // Transitively unmark all candidates that are not strictly valid.
   bool changed;
   do {
     changed = false;
@@ skipping 65 matching lines @@
         }
         k++;
       }
     }
     materializations_.TruncateTo(k);
   }
 
   candidates_.TruncateTo(j);
 }
 
-
 void AllocationSinking::Optimize() {
   CollectCandidates();
 
   // Insert MaterializeObject instructions that will describe the state of the
   // object at all deoptimization points. Each inserted materialization looks
   // like this (where v_0 is allocation that we are going to eliminate):
   //   v_1     <- LoadField(v_0, field_1)
   //           ...
   //   v_N     <- LoadField(v_0, field_N)
   //   v_{N+1} <- MaterializeObject(field_1 = v_1, ..., field_N = v_{N})
@@ skipping 32 matching lines @@
     MaterializeObjectInstr* mat = materializations_[i];
     for (intptr_t j = 0; j < mat->InputCount(); j++) {
       Definition* defn = mat->InputAt(j)->definition();
       if (defn->IsBox()) {
         mat->InputAt(j)->BindTo(defn->InputAt(0)->definition());
       }
     }
   }
 }
 
-
 // Remove materializations from the graph. Register allocator will treat them
 // as part of the environment not as a real instruction.
 void AllocationSinking::DetachMaterializations() {
   for (intptr_t i = 0; i < materializations_.length(); i++) {
     materializations_[i]->previous()->LinkTo(materializations_[i]->next());
   }
 }
 
-
 // Add a field/offset to the list of fields if it is not yet present there.
 static bool AddSlot(ZoneGrowableArray<const Object*>* slots,
                     const Object& slot) {
   ASSERT(slot.IsSmi() || slot.IsField());
   ASSERT(!slot.IsField() || Field::Cast(slot).IsOriginal());
   for (intptr_t i = 0; i < slots->length(); i++) {
     if ((*slots)[i]->raw() == slot.raw()) {
       return false;
     }
   }
   slots->Add(&slot);
   return true;
 }
 
-
 // Find deoptimization exit for the given materialization assuming that all
 // materializations are emitted right before the instruction which is a
 // deoptimization exit.
 static Instruction* ExitForMaterialization(MaterializeObjectInstr* mat) {
   while (mat->next()->IsMaterializeObject()) {
     mat = mat->next()->AsMaterializeObject();
   }
   return mat->next();
 }
 
-
 // Given the deoptimization exit find first materialization that was inserted
 // before it.
 static Instruction* FirstMaterializationAt(Instruction* exit) {
   while (exit->previous()->IsMaterializeObject()) {
     exit = exit->previous();
   }
   return exit;
 }
 
-
 // Given the allocation and deoptimization exit try to find MaterializeObject
 // instruction corresponding to this allocation at this exit.
 MaterializeObjectInstr* AllocationSinking::MaterializationFor(
     Definition* alloc,
     Instruction* exit) {
   if (exit->IsMaterializeObject()) {
     exit = ExitForMaterialization(exit->AsMaterializeObject());
   }
 
   for (MaterializeObjectInstr* mat = exit->previous()->AsMaterializeObject();
        mat != NULL; mat = mat->previous()->AsMaterializeObject()) {
     if (mat->allocation() == alloc) {
       return mat;
     }
   }
 
   return NULL;
 }
 
-
 // Insert MaterializeObject instruction for the given allocation before
 // the given instruction that can deoptimize.
 void AllocationSinking::CreateMaterializationAt(
     Instruction* exit,
     Definition* alloc,
     const ZoneGrowableArray<const Object*>& slots) {
   ZoneGrowableArray<Value*>* values =
       new (Z) ZoneGrowableArray<Value*>(slots.length());
 
   // All loads should be inserted before the first materialization so that
@@ skipping 45 matching lines @@
   // This will allow us to discover it when we are looking for deoptimization
   // exits for another allocation that potentially flows into this one.
   Value* val = new (Z) Value(alloc);
   val->set_instruction(mat);
   alloc->AddEnvUse(val);
 
   // Record inserted materialization.
   materializations_.Add(mat);
 }
 
-
 // Add given instruction to the list of the instructions if it is not yet
 // present there.
 template <typename T>
 void AddInstruction(GrowableArray<T*>* list, T* value) {
   ASSERT(!value->IsGraphEntry());
   for (intptr_t i = 0; i < list->length(); i++) {
     if ((*list)[i] == value) {
       return;
     }
   }
   list->Add(value);
 }
 
-
 // Transitively collect all deoptimization exits that might need this allocation
 // rematerialized. It is not enough to collect only environment uses of this
 // allocation because it can flow into other objects that will be
 // dematerialized and that are referenced by deopt environments that
 // don't contain this allocation explicitly.
 void AllocationSinking::ExitsCollector::Collect(Definition* alloc) {
   for (Value* use = alloc->env_use_list(); use != NULL; use = use->next_use()) {
     if (use->instruction()->IsMaterializeObject()) {
       AddInstruction(&exits_, ExitForMaterialization(
                                   use->instruction()->AsMaterializeObject()));
     } else {
       AddInstruction(&exits_, use->instruction());
     }
   }
 
   // Check if this allocation is stored into any other allocation sinking
   // candidate and put it on worklist so that we conservatively collect all
   // exits for that candidate as well because they potentially might see
   // this object.
   for (Value* use = alloc->input_use_list(); use != NULL;
        use = use->next_use()) {
     Definition* obj = StoreInto(use);
     if ((obj != NULL) && (obj != alloc)) {
       AddInstruction(&worklist_, obj);
     }
   }
 }
 
-
 void AllocationSinking::ExitsCollector::CollectTransitively(Definition* alloc) {
   exits_.TruncateTo(0);
   worklist_.TruncateTo(0);
 
   worklist_.Add(alloc);
 
   // Note: worklist potentially will grow while we are iterating over it.
   // We are not removing allocations from the worklist not to waste space on
   // the side maintaining BitVector of already processed allocations: worklist
   // is expected to be very small thus linear search in it is just as efficient
   // as a bitvector.
   for (intptr_t i = 0; i < worklist_.length(); i++) {
     Collect(worklist_[i]);
   }
 }
 
-
 void AllocationSinking::InsertMaterializations(Definition* alloc) {
   // Collect all fields that are written for this instance.
   ZoneGrowableArray<const Object*>* slots =
       new (Z) ZoneGrowableArray<const Object*>(5);
 
   for (Value* use = alloc->input_use_list(); use != NULL;
        use = use->next_use()) {
     StoreInstanceFieldInstr* store = use->instruction()->AsStoreInstanceField();
     if ((store != NULL) && (store->instance()->definition() == alloc)) {
       if (!store->field().IsNull()) {
@@ skipping 14 matching lines @@
 
   // Collect all instructions that mention this object in the environment.
   exits_collector_.CollectTransitively(alloc);
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(exits_collector_.exits()[i], alloc, *slots);
   }
 }
 
-
 void TryCatchAnalyzer::Optimize(FlowGraph* flow_graph) {
   // For every catch-block: Iterate over all call instructions inside the
   // corresponding try-block and figure out for each environment value if it
   // is the same constant at all calls. If yes, replace the initial definition
   // at the catch-entry with this constant.
   const GrowableArray<CatchBlockEntryInstr*>& catch_entries =
       flow_graph->graph_entry()->catch_entries();
   intptr_t base = kFirstLocalSlotFromFp + flow_graph->num_non_copied_params();
   for (intptr_t catch_idx = 0; catch_idx < catch_entries.length();
        ++catch_idx) {
@@ skipping 52 matching lines @@
         ConstantInstr* copy =
             new (flow_graph->zone()) ConstantInstr(orig->value());
         copy->set_ssa_temp_index(flow_graph->alloc_ssa_temp_index());
         old->ReplaceUsesWith(copy);
         (*idefs)[j] = copy;
       }
     }
   }
 }
 
-
 // Returns true iff this definition is used in a non-phi instruction.
 static bool HasRealUse(Definition* def) {
   // Environment uses are real (non-phi) uses.
   if (def->env_use_list() != NULL) return true;
 
   for (Value::Iterator it(def->input_use_list()); !it.Done(); it.Advance()) {
     if (!it.Current()->instruction()->IsPhi()) return true;
   }
   return false;
 }
 
-
 void DeadCodeElimination::EliminateDeadPhis(FlowGraph* flow_graph) {
   GrowableArray<PhiInstr*> live_phis;
   for (BlockIterator b = flow_graph->postorder_iterator(); !b.Done();
        b.Advance()) {
     JoinEntryInstr* join = b.Current()->AsJoinEntry();
     if (join != NULL) {
       for (PhiIterator it(join); !it.Done(); it.Advance()) {
         PhiInstr* phi = it.Current();
         // Phis that have uses and phis inside try blocks are
         // marked as live.
@@ skipping 52 matching lines @@
       }
       if (to_index == 0) {
         join->phis_ = NULL;
       } else {
         join->phis_->TruncateTo(to_index);
       }
     }
   }
 }
 
-
 }  // namespace dart