Minor cleanups, hopefully fixing an issue with VC's /Ze option on the way.

src/hydrogen-bch.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 84 matching lines @@
    private:
     HBasicBlock* block_;
     bool is_start_;
     bool is_proper_exit_;
     bool is_in_loop_;
     bool has_check_;
     InductionVariableLimitUpdate additional_limit_;
     int current_dominated_block_;
   };
 
-  HGraph* graph() { return graph_; }
-  HBasicBlock* loop_header() { return loop_header_; }
-  Element* at(int index) { return &(elements_.at(index)); }
-  Element* at(HBasicBlock* block) { return at(block->block_id()); }
+  HGraph* graph() const { return graph_; }
+  Counters* counters() const { return graph()->isolate()->counters(); }
+  HBasicBlock* loop_header() const { return loop_header_; }
+  Element* at(int index) const { return &(elements_.at(index)); }
+  Element* at(HBasicBlock* block) const { return at(block->block_id()); }
 
   void AddCheckAt(HBasicBlock* block) {
     at(block->block_id())->set_has_check();
   }
 
   /*
    * Initializes the table for a given loop (identified by its induction
    * variable).
    */
   void InitializeLoop(InductionVariableData* data) {
@@ skipping 132 matching lines @@
     if (hoistability == NOT_HOISTABLE ||
         (hoistability == OPTIMISTICALLY_HOISTABLE &&
          !graph()->use_optimistic_licm())) {
       return;
     }
 
     // We will do the hoisting, but we must see if the limit is "limit" or if
     // all checks are done on constants: if all check are done against the same
     // constant limit we will use that instead of the induction limit.
     bool has_upper_constant_limit = true;
-    InductionVariableData::InductionVariableCheck* current_check = check;
     int32_t upper_constant_limit =
-        current_check != NULL && current_check->HasUpperLimit() ?
-        current_check->upper_limit() : 0;
-    while (current_check != NULL) {
-      if (check->HasUpperLimit()) {
-        if (check->upper_limit() != upper_constant_limit) {
-          has_upper_constant_limit = false;
-        }
-      } else {
-        has_upper_constant_limit = false;
-      }
-
-      current_check->check()->block()->graph()->isolate()->counters()->
-          bounds_checks_eliminated()->Increment();
+        check != NULL && check->HasUpperLimit() ? check->upper_limit() : 0;
+    for (InductionVariableData::InductionVariableCheck* current_check = check;
+         current_check != NULL;
+         current_check = current_check->next()) {
+      has_upper_constant_limit =
+          has_upper_constant_limit &&
+          check->HasUpperLimit() &&
+          check->upper_limit() == upper_constant_limit;
+      counters()->bounds_checks_eliminated()->Increment();
       current_check->check()->set_skip_check();
-      current_check = current_check->next();
     }
 
     // Choose the appropriate limit.
     Zone* zone = graph()->zone();
     HValue* context = graph()->GetInvalidContext();
     HValue* limit = data->limit();
     if (has_upper_constant_limit) {
       HConstant* new_limit = HConstant::New(zone, context,
                                             upper_constant_limit);
       new_limit->InsertBefore(pre_header->end());
       limit = new_limit;
     }
 
     // If necessary, redefine the limit in the preheader.
     if (limit->IsInteger32Constant() &&
         limit->block() != pre_header &&
         !limit->block()->Dominates(pre_header)) {
       HConstant* new_limit = HConstant::New(zone, context,
                                             limit->GetInteger32Constant());
       new_limit->InsertBefore(pre_header->end());
       limit = new_limit;
     }
 
     // Do the hoisting.
     HBoundsCheck* hoisted_check = HBoundsCheck::New(
         zone, context, limit, check->check()->length());
     hoisted_check->InsertBefore(pre_header->end());
     hoisted_check->set_allow_equality(true);
-    hoisted_check->block()->graph()->isolate()->counters()->
-        bounds_checks_hoisted()->Increment();
+    counters()->bounds_checks_hoisted()->Increment();
   }
 
   void CollectInductionVariableData(HBasicBlock* bb) {
     bool additional_limit = false;
 
     for (int i = 0; i < bb->phis()->length(); i++) {
       HPhi* phi = bb->phis()->at(i);
       phi->DetectInductionVariable();
     }
 
@@ skipping 16 matching lines @@
       if (!phi->IsInductionVariable()) continue;
       InductionVariableData* data = phi->induction_variable_data();
 
       // For now ignore loops decrementing the index.
       if (data->increment() <= 0) continue;
       if (!data->LowerLimitIsNonNegativeConstant()) continue;
 
       // TODO(mmassi): skip OSR values for check->length().
       if (check->length() == data->limit() ||
           check->length() == data->additional_upper_limit()) {
-        check->block()->graph()->isolate()->counters()->
-            bounds_checks_eliminated()->Increment();
+        counters()->bounds_checks_eliminated()->Increment();
         check->set_skip_check();
         continue;
       }
 
       if (!phi->IsLimitedInductionVariable()) continue;
 
       int32_t limit = data->ComputeUpperLimit(decomposition.and_mask,
                                               decomposition.or_mask);
       phi->induction_variable_data()->AddCheck(check, limit);
     }
@@ skipping 44 matching lines @@
 
 void HBoundsCheckHoistingPhase::HoistRedundantBoundsChecks() {
   InductionVariableBlocksTable table(graph());
   table.CollectInductionVariableData(graph()->entry_block());
   for (int i = 0; i < graph()->blocks()->length(); i++) {
     table.EliminateRedundantBoundsChecks(graph()->blocks()->at(i));
   }
 }
 
 } }  // namespace v8::internal
-