Thread/Isolate refactoring: new(Isolate) -> new(Zone)

runtime/vm/flow_graph_range_analysis.cc

 // Copyright (c) 2014, 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_range_analysis.h"
 
 #include "vm/bit_vector.h"
 #include "vm/il_printer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, array_bounds_check_elimination, true,
     "Eliminate redundant bounds checks.");
 DEFINE_FLAG(bool, trace_range_analysis, false, "Trace range analysis progress");
 DEFINE_FLAG(bool, trace_integer_ir_selection, false,
     "Print integer IR selection optimization pass.");
 DECLARE_FLAG(bool, trace_constant_propagation);
 
-// Quick access to the locally defined isolate() method.
+// Quick access to the locally defined isolate() and zone() methods.
 #define I (isolate())
+#define Z (zone())
 
 void RangeAnalysis::Analyze() {
   CollectValues();
   InsertConstraints();
   DiscoverSimpleInductionVariables();
   InferRanges();
   EliminateRedundantBoundsChecks();
   MarkUnreachableBlocks();
 
   NarrowMintToInt32();
@@ skipping 306 matching lines @@
 
 
 // Given a boundary (right operand) and a comparison operation return
 // a symbolic range constraint for the left operand of the comparison assuming
 // that it evaluated to true.
 // For example for the comparison a < b symbol a is constrained with range
 // [Smi::kMinValue, b - 1].
 Range* RangeAnalysis::ConstraintSmiRange(Token::Kind op, Definition* boundary) {
   switch (op) {
     case Token::kEQ:
-      return new(I) Range(RangeBoundary::FromDefinition(boundary),
+      return new(Z) Range(RangeBoundary::FromDefinition(boundary),
                           RangeBoundary::FromDefinition(boundary));
     case Token::kNE:
-      return new(I) Range(Range::Full(RangeBoundary::kRangeBoundarySmi));
+      return new(Z) Range(Range::Full(RangeBoundary::kRangeBoundarySmi));
     case Token::kLT:
-      return new(I) Range(RangeBoundary::MinSmi(),
+      return new(Z) Range(RangeBoundary::MinSmi(),
                           RangeBoundary::FromDefinition(boundary, -1));
     case Token::kGT:
-      return new(I) Range(RangeBoundary::FromDefinition(boundary, 1),
+      return new(Z) Range(RangeBoundary::FromDefinition(boundary, 1),
                           RangeBoundary::MaxSmi());
     case Token::kLTE:
-      return new(I) Range(RangeBoundary::MinSmi(),
+      return new(Z) Range(RangeBoundary::MinSmi(),
                           RangeBoundary::FromDefinition(boundary));
     case Token::kGTE:
-      return new(I) Range(RangeBoundary::FromDefinition(boundary),
+      return new(Z) Range(RangeBoundary::FromDefinition(boundary),
                           RangeBoundary::MaxSmi());
     default:
       UNREACHABLE();
       return NULL;
   }
 }
 
 
 ConstraintInstr* RangeAnalysis::InsertConstraintFor(Value* use,
                                                     Definition* defn,
                                                     Range* constraint_range,
                                                     Instruction* after) {
   // No need to constrain constants.
   if (defn->IsConstant()) return NULL;
 
   // Check if the value is already constrained to avoid inserting duplicated
   // constraints.
   ConstraintInstr* constraint = after->next()->AsConstraint();
   while (constraint != NULL) {
     if ((constraint->value()->definition() == defn) &&
         constraint->constraint()->Equals(constraint_range)) {
       return NULL;
     }
     constraint = constraint->next()->AsConstraint();
   }
 
-  constraint = new(I) ConstraintInstr(
+  constraint = new(Z) ConstraintInstr(
       use->CopyWithType(), constraint_range);
 
   flow_graph_->InsertAfter(after, constraint, NULL, FlowGraph::kValue);
   RenameDominatedUses(defn, constraint, constraint);
   constraints_.Add(constraint);
   return constraint;
 }
 
 
 bool RangeAnalysis::ConstrainValueAfterBranch(Value* use, Definition* defn) {
@@ skipping 63 matching lines @@
 
 void RangeAnalysis::ConstrainValueAfterCheckArrayBound(
     Value* use,
     Definition* defn) {
   CheckArrayBoundInstr* check = use->instruction()->AsCheckArrayBound();
   intptr_t use_index = use->use_index();
 
   Range* constraint_range = NULL;
   if (use_index == CheckArrayBoundInstr::kIndexPos) {
     Definition* length = check->length()->definition();
-    constraint_range = new(I) Range(
+    constraint_range = new(Z) Range(
         RangeBoundary::FromConstant(0),
         RangeBoundary::FromDefinition(length, -1));
   } else {
     ASSERT(use_index == CheckArrayBoundInstr::kLengthPos);
     Definition* index = check->index()->definition();
-    constraint_range = new(I) Range(
+    constraint_range = new(Z) Range(
         RangeBoundary::FromDefinition(index, 1),
         RangeBoundary::MaxSmi());
   }
   InsertConstraintFor(use, defn, constraint_range, check);
 }
 
 
 void RangeAnalysis::InsertConstraints() {
   for (intptr_t i = 0; i < values_.length(); i++) {
     InsertConstraintsFor(values_[i]);
@@ skipping 1157 matching lines @@
     NarrowBinaryMintOp(binary_mint_ops_[i]);
   }
 
   for (intptr_t i = 0; i < shift_mint_ops_.length(); i++) {
     NarrowShiftMintOp(shift_mint_ops_[i]);
   }
 }
 
 
 IntegerInstructionSelector::IntegerInstructionSelector(FlowGraph* flow_graph)
-    : flow_graph_(flow_graph),
-      isolate_(NULL) {
+    : flow_graph_(flow_graph) {
   ASSERT(flow_graph_ != NULL);
-  isolate_ = flow_graph_->isolate();
-  ASSERT(isolate_ != NULL);
-  Zone* zone = flow_graph_->zone();
+  zone_ = flow_graph_->zone();
   selected_uint32_defs_ =
-      new(zone) BitVector(zone, flow_graph_->current_ssa_temp_index());
+      new(zone_) BitVector(zone_, flow_graph_->current_ssa_temp_index());
 }
 
 
 void IntegerInstructionSelector::Select() {
   if (FLAG_trace_integer_ir_selection) {
     ISL_Print("---- starting integer ir selection -------\n");
   }
   FindPotentialUint32Definitions();
   FindUint32NarrowingDefinitions();
   Propagate();
@@ skipping 172 matching lines @@
   // Should only see mint definitions.
   ASSERT(IsPotentialUint32Definition(def));
   // Should not see constant instructions.
   ASSERT(!def->IsConstant());
   if (def->IsBinaryMintOp()) {
     BinaryMintOpInstr* op = def->AsBinaryMintOp();
     Token::Kind op_kind = op->op_kind();
     Value* left = op->left()->CopyWithType();
     Value* right = op->right()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
-    return new(I) BinaryUint32OpInstr(op_kind, left, right, deopt_id);
+    return new(Z) BinaryUint32OpInstr(op_kind, left, right, deopt_id);
   } else if (def->IsBoxInt64()) {
     Value* value = def->AsBoxInt64()->value()->CopyWithType();
-    return new(I) BoxUint32Instr(value);
+    return new(Z) BoxUint32Instr(value);
   } else if (def->IsUnboxInt64()) {
     UnboxInstr* unbox = def->AsUnboxInt64();
     Value* value = unbox->value()->CopyWithType();
     intptr_t deopt_id = unbox->DeoptimizationTarget();
-    return new(I) UnboxUint32Instr(value, deopt_id);
+    return new(Z) UnboxUint32Instr(value, deopt_id);
   } else if (def->IsUnaryMintOp()) {
     UnaryMintOpInstr* op = def->AsUnaryMintOp();
     Token::Kind op_kind = op->op_kind();
     Value* value = op->value()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
-    return new(I) UnaryUint32OpInstr(op_kind, value, deopt_id);
+    return new(Z) UnaryUint32OpInstr(op_kind, value, deopt_id);
   } else if (def->IsShiftMintOp()) {
     ShiftMintOpInstr* op = def->AsShiftMintOp();
     Token::Kind op_kind = op->op_kind();
     Value* left = op->left()->CopyWithType();
     Value* right = op->right()->CopyWithType();
     intptr_t deopt_id = op->DeoptimizationTarget();
-    return new(I) ShiftUint32OpInstr(op_kind, left, right, deopt_id);
+    return new(Z) ShiftUint32OpInstr(op_kind, left, right, deopt_id);
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 void IntegerInstructionSelector::ReplaceInstructions() {
   if (FLAG_trace_integer_ir_selection) {
     ISL_Print("++++ Replacing instructions:\n");
   }
@@ skipping 1276 matching lines @@
     }
   } while (CanonicalizeMaxBoundary(&max) ||
            CanonicalizeMinBoundary(&canonical_length));
 
   // Failed to prove that maximum is bounded with array length.
   return false;
 }
 
 
 }  // namespace dart