Keep zone cached in SnapshotReader to allow removing ZoneHandle(Isolate*) interface.

runtime/vm/constant_propagator.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/constant_propagator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_range_analysis.h"
@@ skipping 278 matching lines @@
 }
 
 
 // --------------------------------------------------------------------------
 // Analysis of definitions.  Compute the constant value.  If it has changed
 // and the definition has input uses, add the definition to the definition
 // worklist so that the used can be processed.
 void ConstantPropagator::VisitPhi(PhiInstr* instr) {
   // Compute the join over all the reachable predecessor values.
   JoinEntryInstr* block = instr->block();
-  Object& value = Object::ZoneHandle(I, Unknown());
+  Object& value = Object::ZoneHandle(Z, Unknown());
   for (intptr_t pred_idx = 0; pred_idx < instr->InputCount(); ++pred_idx) {
     if (reachable_->Contains(
             block->PredecessorAt(pred_idx)->preorder_number())) {
       Join(&value,
            instr->InputAt(pred_idx)->definition()->constant_value());
     }
   }
   if (!SetValue(instr, value) &&
       marked_phis_->Contains(instr->ssa_temp_index())) {
     marked_phis_->Remove(instr->ssa_temp_index());
@@ skipping 284 matching lines @@
 void ConstantPropagator::VisitStringFromCharCode(
     StringFromCharCodeInstr* instr) {
   const Object& o = instr->char_code()->definition()->constant_value();
   if (o.IsNull() || IsNonConstant(o)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(o)) {
     const intptr_t ch_code = Smi::Cast(o).Value();
     ASSERT(ch_code >= 0);
     if (ch_code < Symbols::kMaxOneCharCodeSymbol) {
       RawString** table = Symbols::PredefinedAddress();
-      SetValue(instr, String::ZoneHandle(I, table[ch_code]));
+      SetValue(instr, String::ZoneHandle(Z, table[ch_code]));
     } else {
       SetValue(instr, non_constant_);
     }
   }
 }
 
 
 void ConstantPropagator::VisitStringToCharCode(StringToCharCodeInstr* instr) {
   const Object& o = instr->str()->definition()->constant_value();
   if (o.IsNull() || IsNonConstant(o)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(o)) {
     const String& str = String::Cast(o);
     const intptr_t result =
         (str.Length() == 1) ? static_cast<intptr_t>(str.CharAt(0)) : -1;
-    SetValue(instr, Smi::ZoneHandle(I, Smi::New(result)));
+    SetValue(instr, Smi::ZoneHandle(Z, Smi::New(result)));
   }
 }
 
 
 void ConstantPropagator::VisitStringInterpolate(StringInterpolateInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitLoadIndexed(LoadIndexedInstr* instr) {
@@ skipping 142 matching lines @@
 
 
 void ConstantPropagator::VisitLoadUntagged(LoadUntaggedInstr* instr) {
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitLoadClassId(LoadClassIdInstr* instr) {
   intptr_t cid = instr->object()->Type()->ToCid();
   if (cid != kDynamicCid) {
-    SetValue(instr, Smi::ZoneHandle(I, Smi::New(cid)));
+    SetValue(instr, Smi::ZoneHandle(Z, Smi::New(cid)));
     return;
   }
   const Object& object = instr->object()->definition()->constant_value();
   if (IsConstant(object)) {
-    SetValue(instr, Smi::ZoneHandle(I, Smi::New(object.GetClassId())));
+    SetValue(instr, Smi::ZoneHandle(Z, Smi::New(object.GetClassId())));
     return;
   }
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitLoadField(LoadFieldInstr* instr) {
   Value* instance = instr->instance();
   if ((instr->recognized_kind() == MethodRecognizer::kObjectArrayLength) &&
       instance->definition()->OriginalDefinition()->IsCreateArray()) {
     Value* num_elements = instance->definition()->OriginalDefinition()
         ->AsCreateArray()->num_elements();
     if (num_elements->BindsToConstant() &&
         num_elements->BoundConstant().IsSmi()) {
       intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
-      const Object& result = Smi::ZoneHandle(I, Smi::New(length));
+      const Object& result = Smi::ZoneHandle(Z, Smi::New(length));
       SetValue(instr, result);
       return;
     }
   }
 
   if (instr->IsImmutableLengthLoad()) {
     ConstantInstr* constant =
         instance->definition()->OriginalDefinition()->AsConstant();
     if (constant != NULL) {
       if (constant->value().IsString()) {
-        SetValue(instr, Smi::ZoneHandle(I,
+        SetValue(instr, Smi::ZoneHandle(Z,
             Smi::New(String::Cast(constant->value()).Length())));
         return;
       }
       if (constant->value().IsArray()) {
-        SetValue(instr, Smi::ZoneHandle(I,
+        SetValue(instr, Smi::ZoneHandle(Z,
             Smi::New(Array::Cast(constant->value()).Length())));
         return;
       }
       if (constant->value().IsTypedData()) {
-        SetValue(instr, Smi::ZoneHandle(I,
+        SetValue(instr, Smi::ZoneHandle(Z,
             Smi::New(TypedData::Cast(constant->value()).Length())));
         return;
       }
     }
   }
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitInstantiateType(InstantiateTypeInstr* instr) {
   const Object& object =
       instr->instantiator()->definition()->constant_value();
   if (IsNonConstant(object)) {
     SetValue(instr, non_constant_);
     return;
   }
   if (IsConstant(object)) {
     if (instr->type().IsTypeParameter()) {
       if (object.IsNull()) {
-        SetValue(instr, Type::ZoneHandle(I, Type::DynamicType()));
+        SetValue(instr, Type::ZoneHandle(Z, Type::DynamicType()));
         return;
       }
       // We could try to instantiate the type parameter and return it if no
       // malformed error is reported.
     }
     SetValue(instr, non_constant_);
   }
 }
 
 
@@ skipping 42 matching lines @@
 void ConstantPropagator::VisitBinaryIntegerOp(BinaryIntegerOpInstr* binary_op) {
   const Object& left = binary_op->left()->definition()->constant_value();
   const Object& right = binary_op->right()->definition()->constant_value();
   if (IsConstant(left) && IsConstant(right)) {
     if (left.IsInteger() && right.IsInteger()) {
       const Integer& left_int = Integer::Cast(left);
       const Integer& right_int = Integer::Cast(right);
       const Integer& result =
           Integer::Handle(I, binary_op->Evaluate(left_int, right_int));
       if (!result.IsNull()) {
-        SetValue(binary_op, Integer::ZoneHandle(I, result.raw()));
+        SetValue(binary_op, Integer::ZoneHandle(Z, result.raw()));
         return;
       }
     }
   }
 
   SetValue(binary_op, non_constant_);
 }
 
 
 void ConstantPropagator::VisitBinarySmiOp(BinarySmiOpInstr* instr) {
@@ skipping 38 matching lines @@
 }
 
 
 void ConstantPropagator::VisitUnaryIntegerOp(UnaryIntegerOpInstr* unary_op) {
   const Object& value = unary_op->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
     const Integer& value_int = Integer::Cast(value);
     const Integer& result =
         Integer::Handle(I, unary_op->Evaluate(value_int));
     if (!result.IsNull()) {
-      SetValue(unary_op, Integer::ZoneHandle(I, result.raw()));
+      SetValue(unary_op, Integer::ZoneHandle(Z, result.raw()));
       return;
     }
   }
 
   SetValue(unary_op, non_constant_);
 }
 
 
 void ConstantPropagator::VisitUnaryMintOp(UnaryMintOpInstr* instr) {
   VisitUnaryIntegerOp(instr);
@@ skipping 680 matching lines @@
   graph_->MergeBlocks();
   GrowableArray<BitVector*> dominance_frontier;
   graph_->ComputeDominators(&dominance_frontier);
 
   if (FLAG_trace_constant_propagation) {
     FlowGraphPrinter::PrintGraph("After CP", graph_);
   }
 }
 
 }  // namespace dart