Remove isolate argument from handle allocation: Part I

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 413 matching lines @@
 void ConstantPropagator::VisitIfThenElse(IfThenElseInstr* instr) {
   instr->comparison()->Accept(this);
   const Object& value = instr->comparison()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     ASSERT(!value.IsNull());
     ASSERT(value.IsBool());
     bool result = Bool::Cast(value).value();
     SetValue(instr,
-             Smi::Handle(I, Smi::New(
+             Smi::Handle(Z, Smi::New(
                  result ? instr->if_true() : instr->if_false())));
   }
 }
 
 
 void ConstantPropagator::VisitStrictCompare(StrictCompareInstr* instr) {
   Definition* left_defn = instr->left()->definition();
   Definition* right_defn = instr->right()->definition();
 
   Definition* unwrapped_left_defn = UnwrapPhi(left_defn);
@@ skipping 69 matching lines @@
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     // BitOp does not work on Bigints.
     if (left.IsInteger() && right.IsInteger() &&
         !left.IsBigint() && !right.IsBigint()) {
       const bool result = CompareIntegers(
           instr->kind(),
-          Integer::Handle(I, Integer::Cast(left).BitOp(Token::kBIT_AND,
+          Integer::Handle(Z, Integer::Cast(left).BitOp(Token::kBIT_AND,
                                                        Integer::Cast(right))),
-          Smi::Handle(I, Smi::New(0)));
+          Smi::Handle(Z, Smi::New(0)));
       SetValue(instr, result ? Bool::True() : Bool::False());
     } else {
       SetValue(instr, non_constant_);
     }
   }
 }
 
 
 void ConstantPropagator::VisitTestCids(TestCidsInstr* instr) {
   SetValue(instr, non_constant_);
@@ skipping 118 matching lines @@
     if (!index_obj.IsSmi()) {
       // Should not occur.
       SetValue(instr, non_constant_);
       return;
     }
     const intptr_t index = Smi::Cast(index_obj).Value();
     if (index >= 0) {
       if (array_obj.IsString()) {
         const String& str = String::Cast(array_obj);
         if (str.Length() > index) {
-          SetValue(instr, Smi::Handle(I,
+          SetValue(instr, Smi::Handle(Z,
               Smi::New(static_cast<intptr_t>(str.CharAt(index)))));
           return;
         }
       } else if (array_obj.IsArray()) {
         const Array& a = Array::Cast(array_obj);
         if ((a.Length() > index) && a.IsImmutable()) {
-          Instance& result = Instance::Handle(I);
+          Instance& result = Instance::Handle(Z);
           result ^= a.At(index);
           SetValue(instr, result);
           return;
         }
       }
     }
     SetValue(instr, non_constant_);
   }
 }
 
@@ skipping 16 matching lines @@
 
 
 void ConstantPropagator::VisitInitStaticField(InitStaticFieldInstr* instr) {
   // Nothing to do.
 }
 
 
 void ConstantPropagator::VisitLoadStaticField(LoadStaticFieldInstr* instr) {
   const Field& field = instr->StaticField();
   ASSERT(field.is_static());
-  Instance& obj = Instance::Handle(I, field.StaticValue());
+  Instance& obj = Instance::Handle(Z, field.StaticValue());
   if (field.is_final() && (obj.raw() != Object::sentinel().raw()) &&
       (obj.raw() != Object::transition_sentinel().raw())) {
     if (obj.IsSmi() || obj.IsOld()) {
       SetValue(instr, obj);
       return;
     }
   }
   SetValue(instr, non_constant_);
 }
 
@@ skipping 197 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));
+          Integer::Handle(Z, binary_op->Evaluate(left_int, right_int));
       if (!result.IsNull()) {
         SetValue(binary_op, Integer::ZoneHandle(Z, result.raw()));
         return;
       }
     }
   }
 
   SetValue(binary_op, non_constant_);
 }
 
@@ skipping 38 matching lines @@
   // TODO(kmillikin): Handle unbox operation.
   SetValue(instr, non_constant_);
 }
 
 
 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));
+        Integer::Handle(Z, unary_op->Evaluate(value_int));
     if (!result.IsNull()) {
       SetValue(unary_op, Integer::ZoneHandle(Z, result.raw()));
       return;
     }
   }
 
   SetValue(unary_op, non_constant_);
 }
 
 
@@ skipping 14 matching lines @@
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle unary operations.
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitSmiToDouble(SmiToDoubleInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
-    SetValue(instr, Double::Handle(I,
+    SetValue(instr, Double::Handle(Z,
         Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
   } else if (!IsUnknown(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitMintToDouble(MintToDoubleInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
-    SetValue(instr, Double::Handle(I,
+    SetValue(instr, Double::Handle(Z,
         Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
   } else if (!IsUnknown(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitInt32ToDouble(Int32ToDoubleInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsConstant(value) && value.IsInteger()) {
-    SetValue(instr, Double::Handle(I,
+    SetValue(instr, Double::Handle(Z,
         Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
   } else if (!IsUnknown(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitDoubleToInteger(DoubleToIntegerInstr* instr) {
   // TODO(kmillikin): Handle conversion.
   SetValue(instr, non_constant_);
@@ skipping 625 matching lines @@
   graph_->MergeBlocks();
   GrowableArray<BitVector*> dominance_frontier;
   graph_->ComputeDominators(&dominance_frontier);
 
   if (FLAG_trace_constant_propagation) {
     FlowGraphPrinter::PrintGraph("After CP", graph_);
   }
 }
 
 }  // namespace dart