Address review comments for r39595.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 4607 matching lines @@
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 #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.
 
-class DefinitionWorklist {
+class DefinitionWorklist : public ValueObject {
  public:
   DefinitionWorklist(FlowGraph* flow_graph,
                      intptr_t initial_capacity)
       : defs_(initial_capacity),
-        contains_(new BitVector(flow_graph->current_ssa_temp_index())) {
+        contains_vector_(new BitVector(flow_graph->current_ssa_temp_index())) {
   }
 
   void Add(Definition* defn) {
     if (!Contains(defn)) {
       defs_.Add(defn);
-      contains_->Add(defn->ssa_temp_index());
+      contains_vector_->Add(defn->ssa_temp_index());
     }
   }
 
   bool Contains(Definition* defn) const {
     return (defn->ssa_temp_index() >= 0) &&
-        contains_->Contains(defn->ssa_temp_index());
+        contains_vector_->Contains(defn->ssa_temp_index());
   }
 
   const GrowableArray<Definition*>& definitions() const { return defs_; }
-  BitVector* contains() const { return contains_; }
+  BitVector* contains_vector() const { return contains_vector_; }
 
   void Clear() {
     defs_.TruncateTo(0);
-    contains_->Clear();
+    contains_vector_->Clear();
   }
 
  private:
   GrowableArray<Definition*> defs_;
-  BitVector* contains_;
+  BitVector* contains_vector_;
 };
 
 
 static bool CanBeWidened(BinarySmiOpInstr* smi_op) {
   return BinaryInt32OpInstr::IsSupported(smi_op->op_kind(),
                                          smi_op->left(),
                                          smi_op->right());
 }
 
 
@@ skipping 18 matching lines @@
 
   // Step 1. Collect all instructions that potentially benefit from widening of
   // their operands (or their result) into int32 range.
   for (BlockIterator block_it = flow_graph_->reverse_postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     for (ForwardInstructionIterator instr_it(block_it.Current());
          !instr_it.Done();
          instr_it.Advance()) {
       BinarySmiOpInstr* smi_op = instr_it.Current()->AsBinarySmiOp();
-      if (smi_op != NULL &&
+      if ((smi_op != NULL) &&
           BenefitsFromWidening(smi_op) &&
           CanBeWidened(smi_op)) {
         candidates.Add(smi_op);
       }
     }
   }
 
-  if (candidates.length() == 0) {
+  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 =
-    flow_graph()->loop_headers();
+      flow_graph()->loop_headers();
 
   GrowableArray<intptr_t> loops(flow_graph_->preorder().length());
   for (intptr_t i = 0; i < flow_graph_->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()) {
@@ skipping 44 matching lines @@
       }
 
       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())) {
           worklist.Add(input);
-        } else if (input->IsPhi() && input->Type()->ToCid() == kSmiCid) {
+        } 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_trace_smi_widening) {
             OS::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
@@ skipping 46 matching lines @@
           gain--;
           if (FLAG_trace_smi_widening) {
             OS::Print("v [%" Pd "] (u) %s\n",
                       gain,
                       use->instruction()->ToCString());
           }
         }
       }
     }
 
-    processed->AddAll(worklist.contains());
+    processed->AddAll(worklist.contains_vector());
 
     if (FLAG_trace_smi_widening) {
       OS::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];
@@ skipping 5101 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart