Use isolate when allocation Zone objects and handles: focus on FlowGraphOptimizer, next inliner.

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 140 matching lines @@
     }
   }
 
   for (intptr_t i = 0; i < class_ids.length(); i++) {
     if (class_ids[i] == kDynamicCid) {
       // Not all cid-s known.
       return false;
     }
   }
 
-  const Array& args_desc_array = Array::Handle(
+  const Array& args_desc_array = Array::Handle(isolate(),
       ArgumentsDescriptor::New(call->ArgumentCount(), call->argument_names()));
   ArgumentsDescriptor args_desc(args_desc_array);
-  const Class& receiver_class = Class::Handle(
-      Isolate::Current()->class_table()->At(class_ids[0]));
-  const Function& function = Function::Handle(
+  const Class& receiver_class = Class::Handle(isolate(),
+      isolate()->class_table()->At(class_ids[0]));
+  const Function& function = Function::Handle(isolate(),
       Resolver::ResolveDynamicForReceiverClass(
           receiver_class,
           call->function_name(),
           args_desc));
   if (function.IsNull()) {
     return false;
   }
   // Create new ICData, do not modify the one attached to the instruction
   // since it is attached to the assembly instruction itself.
   // TODO(srdjan): Prevent modification of ICData object that is
   // referenced in assembly code.
-  ICData& ic_data = ICData::ZoneHandle(ICData::New(
+  ICData& ic_data = ICData::ZoneHandle(isolate(), ICData::New(
       flow_graph_->parsed_function().function(),
       call->function_name(),
       args_desc_array,
       call->deopt_id(),
       class_ids.length()));
   if (class_ids.length() > 1) {
     ic_data.AddCheck(class_ids, function);
   } else {
     ASSERT(class_ids.length() == 1);
     ic_data.AddReceiverCheck(class_ids[0], function);
   }
   call->set_ic_data(&ic_data);
   return true;
 }
 
 
-static const ICData& TrySpecializeICData(const ICData& ic_data, intptr_t cid) {
+const ICData& FlowGraphOptimizer::TrySpecializeICData(const ICData& ic_data,
+                                                      intptr_t cid) {
   ASSERT(ic_data.NumArgsTested() == 1);
 
   if ((ic_data.NumberOfChecks() == 1) &&
       (ic_data.GetReceiverClassIdAt(0) == cid)) {
     return ic_data;  // Nothing to do
   }
 
   const Function& function =
-      Function::Handle(ic_data.GetTargetForReceiverClassId(cid));
+      Function::Handle(isolate(), ic_data.GetTargetForReceiverClassId(cid));
   // TODO(fschneider): Try looking up the function on the class if it is
   // not found in the ICData.
   if (!function.IsNull()) {
-    const ICData& new_ic_data = ICData::ZoneHandle(ICData::New(
-        Function::Handle(ic_data.owner()),
-        String::Handle(ic_data.target_name()),
+    const ICData& new_ic_data = ICData::ZoneHandle(isolate(), ICData::New(
+        Function::Handle(isolate(), ic_data.owner()),
+        String::Handle(isolate(), ic_data.target_name()),
         Object::empty_array(),  // Dummy argument descriptor.
         ic_data.deopt_id(),
         ic_data.NumArgsTested()));
     new_ic_data.SetDeoptReasons(ic_data.DeoptReasons());
     new_ic_data.AddReceiverCheck(cid, function);
     return new_ic_data;
   }
 
   return ic_data;
 }
@@ skipping 12 matching lines @@
   }
 
   const ICData& ic_data = TrySpecializeICData(call->ic_data(), receiver_cid);
   if (ic_data.raw() == call->ic_data().raw()) {
     // No specialization.
     return;
   }
 
   const bool with_checks = false;
   PolymorphicInstanceCallInstr* specialized =
-      new PolymorphicInstanceCallInstr(call->instance_call(),
-                                       ic_data,
-                                       with_checks);
+      new(isolate()) PolymorphicInstanceCallInstr(call->instance_call(),
+                                                  ic_data,
+                                                  with_checks);
   call->ReplaceWith(specialized, current_iterator());
 }
 
 
 static BinarySmiOpInstr* AsSmiShiftLeftInstruction(Definition* d) {
   BinarySmiOpInstr* instr = d->AsBinarySmiOp();
   if ((instr != NULL) && (instr->op_kind() == Token::kSHL)) {
     return instr;
   }
   return NULL;
@@ skipping 30 matching lines @@
   if ((smi_shift_left == NULL) && (bit_and_instr->InputAt(1)->IsSingleUse())) {
     smi_shift_left = AsSmiShiftLeftInstruction(right_instr);
   }
   if (smi_shift_left == NULL) return;
 
   // Pattern recognized.
   smi_shift_left->set_is_truncating(true);
   ASSERT(bit_and_instr->IsBinarySmiOp() || bit_and_instr->IsBinaryMintOp());
   if (bit_and_instr->IsBinaryMintOp()) {
     // Replace Mint op with Smi op.
-    BinarySmiOpInstr* smi_op = new BinarySmiOpInstr(
+    BinarySmiOpInstr* smi_op = new(isolate()) BinarySmiOpInstr(
         Token::kBIT_AND,
-        new Value(left_instr),
-        new Value(right_instr),
+        new(isolate()) Value(left_instr),
+        new(isolate()) Value(right_instr),
         Isolate::kNoDeoptId,  // BIT_AND cannot deoptimize.
         Scanner::kNoSourcePos);
     bit_and_instr->ReplaceWith(smi_op, current_iterator());
   }
 }
 
 
 
 // Used by TryMergeDivMod.
 // Inserts a load-indexed instruction between a TRUNCDIV or MOD instruction,
 // and the using instruction. This is an intermediate step before merging.
 void FlowGraphOptimizer::AppendLoadIndexedForMerged(Definition* instr,
                                                     intptr_t ix,
                                                     intptr_t cid) {
   const intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(cid);
   ConstantInstr* index_instr =
-      flow_graph()->GetConstant(Smi::Handle(Smi::New(ix)));
-  LoadIndexedInstr* load = new LoadIndexedInstr(new Value(instr),
-                                                new Value(index_instr),
-                                                index_scale,
-                                                cid,
-                                                Isolate::kNoDeoptId,
-                                                instr->token_pos());
+      flow_graph()->GetConstant(Smi::Handle(isolate(), Smi::New(ix)));
+  LoadIndexedInstr* load =
+      new(isolate()) LoadIndexedInstr(new(isolate()) Value(instr),
+                                      new(isolate()) Value(index_instr),
+                                      index_scale,
+                                      cid,
+                                      Isolate::kNoDeoptId,
+                                      instr->token_pos());
   instr->ReplaceUsesWith(load);
   flow_graph()->InsertAfter(instr, load, NULL, FlowGraph::kValue);
 }
 
 
 void FlowGraphOptimizer::AppendExtractNthOutputForMerged(Definition* instr,
                                                          intptr_t index,
                                                          Representation rep,
                                                          intptr_t cid) {
-  ExtractNthOutputInstr* extract = new ExtractNthOutputInstr(new Value(instr),
-                                                             index,
-                                                             rep,
-                                                             cid);
+  ExtractNthOutputInstr* extract =
+      new(isolate()) ExtractNthOutputInstr(new(isolate()) Value(instr),
+                                           index,
+                                           rep,
+                                           cid);
   instr->ReplaceUsesWith(extract);
   flow_graph()->InsertAfter(instr, extract, NULL, FlowGraph::kValue);
 }
 
 
 // Dart:
 //  var x = d % 10;
 //  var y = d ~/ 10;
 //  var z = x + y;
 //
@@ skipping 40 matching lines @@
         AppendExtractNthOutputForMerged(
             curr_instr,
             MergedMathInstr::OutputIndexOf(curr_instr->op_kind()),
             kTagged, kSmiCid);
         ASSERT(other_binop->HasUses());
         AppendExtractNthOutputForMerged(
             other_binop,
             MergedMathInstr::OutputIndexOf(other_binop->op_kind()),
             kTagged, kSmiCid);
 
-        ZoneGrowableArray<Value*>* args = new ZoneGrowableArray<Value*>(2);
-        args->Add(new Value(curr_instr->left()->definition()));
-        args->Add(new Value(curr_instr->right()->definition()));
+        ZoneGrowableArray<Value*>* args =
+            new(isolate()) ZoneGrowableArray<Value*>(2);
+        args->Add(new(isolate()) Value(curr_instr->left()->definition()));
+        args->Add(new(isolate()) Value(curr_instr->right()->definition()));
 
         // Replace with TruncDivMod.
-        MergedMathInstr* div_mod = new MergedMathInstr(
+        MergedMathInstr* div_mod = new(isolate()) MergedMathInstr(
             args,
             curr_instr->deopt_id(),
             MergedMathInstr::kTruncDivMod);
         curr_instr->ReplaceWith(div_mod, current_iterator());
         other_binop->ReplaceUsesWith(div_mod);
         other_binop->RemoveFromGraph();
         // Only one merge possible. Because canonicalization happens later,
         // more candidates are possible.
         // TODO(srdjan): Allow merging of trunc-div/mod into truncDivMod.
         break;
@@ skipping 34 matching lines @@
         (*merge_candidates)[k] = NULL;  // Clear it.
         ASSERT(curr_instr->HasUses());
         AppendExtractNthOutputForMerged(curr_instr,
                                         MergedMathInstr::OutputIndexOf(kind),
                                         kUnboxedDouble, kDoubleCid);
         ASSERT(other_op->HasUses());
         AppendExtractNthOutputForMerged(
             other_op,
             MergedMathInstr::OutputIndexOf(other_kind),
             kUnboxedDouble, kDoubleCid);
-        ZoneGrowableArray<Value*>* args = new ZoneGrowableArray<Value*>(1);
-        args->Add(new Value(curr_instr->value()->definition()));
+        ZoneGrowableArray<Value*>* args =
+            new(isolate()) ZoneGrowableArray<Value*>(1);
+        args->Add(new(isolate()) Value(curr_instr->value()->definition()));
         // Replace with SinCos.
         MergedMathInstr* sin_cos =
-            new MergedMathInstr(args, curr_instr->DeoptimizationTarget(),
-                                MergedMathInstr::kSinCos);
+            new(isolate()) MergedMathInstr(args,
+                                           curr_instr->DeoptimizationTarget(),
+                                           MergedMathInstr::kSinCos);
         curr_instr->ReplaceWith(sin_cos, current_iterator());
         other_op->ReplaceUsesWith(sin_cos);
         other_op->RemoveFromGraph();
         // Only one merge possible. Because canonicalization happens later,
         // more candidates are possible.
         // TODO(srdjan): Allow merging of sin/cos into sincos.
         break;
       }
     }
   }
@@ skipping 126 matching lines @@
   } else {
     deopt_target = insert_before = use->instruction();
   }
 
   Definition* converted = NULL;
   if ((from == kTagged) && (to == kUnboxedMint)) {
     ASSERT((deopt_target != NULL) ||
            (use->Type()->ToCid() == kUnboxedMint));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new UnboxIntegerInstr(use->CopyWithType(), deopt_id);
+    converted = new(isolate()) UnboxIntegerInstr(use->CopyWithType(), deopt_id);
 
   } else if ((from == kUnboxedMint) && (to == kTagged)) {
-    converted = new BoxIntegerInstr(use->CopyWithType());
+    converted = new(isolate()) BoxIntegerInstr(use->CopyWithType());
 
   } else if (from == kUnboxedMint && to == kUnboxedDouble) {
     ASSERT(CanUnboxDouble());
     // Convert by boxing/unboxing.
     // TODO(fschneider): Implement direct unboxed mint-to-double conversion.
-    BoxIntegerInstr* boxed = new BoxIntegerInstr(use->CopyWithType());
+    BoxIntegerInstr* boxed =
+        new(isolate()) BoxIntegerInstr(use->CopyWithType());
     use->BindTo(boxed);
     InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
 
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new UnboxDoubleInstr(new Value(boxed), deopt_id);
+    converted = new(isolate()) UnboxDoubleInstr(
+        new(isolate()) Value(boxed), deopt_id);
 
   } else if ((from == kUnboxedDouble) && (to == kTagged)) {
     ASSERT(CanUnboxDouble());
-    converted = new BoxDoubleInstr(use->CopyWithType());
+    converted = new(isolate()) BoxDoubleInstr(use->CopyWithType());
 
   } else if ((from == kTagged) && (to == kUnboxedDouble)) {
     ASSERT(CanUnboxDouble());
     ASSERT((deopt_target != NULL) ||
            (use->Type()->ToCid() == kDoubleCid));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     ConstantInstr* constant = use->definition()->AsConstant();
     if ((constant != NULL) && constant->value().IsSmi()) {
       const double dbl_val = Smi::Cast(constant->value()).AsDoubleValue();
       const Double& dbl_obj =
-          Double::ZoneHandle(Double::New(dbl_val, Heap::kOld));
+          Double::ZoneHandle(isolate(), Double::New(dbl_val, Heap::kOld));
       ConstantInstr* double_const = flow_graph()->GetConstant(dbl_obj);
-      converted = new UnboxDoubleInstr(new Value(double_const), deopt_id);
+      converted = new(isolate()) UnboxDoubleInstr(
+          new(isolate()) Value(double_const), deopt_id);
     } else {
-      converted = new UnboxDoubleInstr(use->CopyWithType(), deopt_id);
+      converted = new(isolate()) UnboxDoubleInstr(
+          use->CopyWithType(), deopt_id);
     }
   } else if ((from == kTagged) && (to == kUnboxedFloat32x4)) {
     ASSERT((deopt_target != NULL) ||
            (use->Type()->ToCid() == kFloat32x4Cid));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new UnboxFloat32x4Instr(use->CopyWithType(), deopt_id);
+    converted = new(isolate()) UnboxFloat32x4Instr(
+        use->CopyWithType(), deopt_id);
   } else if ((from == kUnboxedFloat32x4) && (to == kTagged)) {
-    converted = new BoxFloat32x4Instr(use->CopyWithType());
+    converted = new(isolate()) BoxFloat32x4Instr(use->CopyWithType());
   } else if ((from == kTagged) && (to == kUnboxedInt32x4)) {
     ASSERT((deopt_target != NULL) || (use->Type()->ToCid() == kInt32x4Cid));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new UnboxInt32x4Instr(use->CopyWithType(), deopt_id);
+    converted = new(isolate()) UnboxInt32x4Instr(use->CopyWithType(), deopt_id);
   } else if ((from == kUnboxedInt32x4) && (to == kTagged)) {
-    converted = new BoxInt32x4Instr(use->CopyWithType());
+    converted = new(isolate()) BoxInt32x4Instr(use->CopyWithType());
   } else if ((from == kTagged) && (to == kUnboxedFloat64x2)) {
     ASSERT((deopt_target != NULL) || (use->Type()->ToCid() == kFloat64x2Cid));
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
-    converted = new UnboxFloat64x2Instr(use->CopyWithType(), deopt_id);
+    converted = new(isolate()) UnboxFloat64x2Instr(
+        use->CopyWithType(), deopt_id);
   } else if ((from == kUnboxedFloat64x2) && (to == kTagged)) {
-    converted = new BoxFloat64x2Instr(use->CopyWithType());
+    converted = new(isolate()) BoxFloat64x2Instr(use->CopyWithType());
   } else {
     // We have failed to find a suitable conversion instruction.
     // Insert two "dummy" conversion instructions with the correct
     // "from" and "to" representation. The inserted instructions will
     // trigger a deoptimization if executed. See #12417 for a discussion.
     const intptr_t deopt_id = (deopt_target != NULL) ?
         deopt_target->DeoptimizationTarget() : Isolate::kNoDeoptId;
     ASSERT(from != kTagged);
     ASSERT(to != kTagged);
     Definition* boxed = NULL;
     if (from == kUnboxedDouble) {
-      boxed = new BoxDoubleInstr(use->CopyWithType());
+      boxed = new(isolate()) BoxDoubleInstr(use->CopyWithType());
     } else if (from == kUnboxedInt32x4) {
-      boxed = new BoxInt32x4Instr(use->CopyWithType());
+      boxed = new(isolate()) BoxInt32x4Instr(use->CopyWithType());
     } else if (from == kUnboxedFloat32x4) {
-      boxed = new BoxFloat32x4Instr(use->CopyWithType());
+      boxed = new(isolate()) BoxFloat32x4Instr(use->CopyWithType());
     } else if (from == kUnboxedMint) {
-      boxed = new BoxIntegerInstr(use->CopyWithType());
+      boxed = new(isolate()) BoxIntegerInstr(use->CopyWithType());
     } else if (from == kUnboxedFloat64x2) {
-      boxed = new BoxFloat64x2Instr(use->CopyWithType());
+      boxed = new(isolate()) BoxFloat64x2Instr(use->CopyWithType());
     } else {
       UNIMPLEMENTED();
     }
     use->BindTo(boxed);
     InsertBefore(insert_before, boxed, NULL, FlowGraph::kValue);
-    Value* to_value = new Value(boxed);
+    Value* to_value = new(isolate()) Value(boxed);
     if (to == kUnboxedDouble) {
-      converted = new UnboxDoubleInstr(to_value, deopt_id);
+      converted = new(isolate()) UnboxDoubleInstr(to_value, deopt_id);
     } else if (to == kUnboxedInt32x4) {
-      converted = new UnboxInt32x4Instr(to_value, deopt_id);
+      converted = new(isolate()) UnboxInt32x4Instr(to_value, deopt_id);
     } else if (to == kUnboxedFloat32x4) {
-      converted = new UnboxFloat32x4Instr(to_value, deopt_id);
+      converted = new(isolate()) UnboxFloat32x4Instr(to_value, deopt_id);
     } else if (to == kUnboxedMint) {
-      converted = new UnboxIntegerInstr(to_value, deopt_id);
+      converted = new(isolate()) UnboxIntegerInstr(to_value, deopt_id);
     } else if (to == kUnboxedFloat64x2) {
-      converted = new UnboxFloat64x2Instr(to_value, deopt_id);
+      converted = new(isolate()) UnboxFloat64x2Instr(to_value, deopt_id);
     } else {
       UNIMPLEMENTED();
     }
   }
   ASSERT(converted != NULL);
   InsertBefore(insert_before, converted, use->instruction()->env(),
                FlowGraph::kValue);
   if (is_environment_use) {
     use->BindToEnvironment(converted);
   } else {
@@ skipping 260 matching lines @@
   call->ReplaceWith(replacement, current_iterator());
 }
 
 
 void FlowGraphOptimizer::AddCheckSmi(Definition* to_check,
                                      intptr_t deopt_id,
                                      Environment* deopt_environment,
                                      Instruction* insert_before) {
   if (to_check->Type()->ToCid() != kSmiCid) {
     InsertBefore(insert_before,
-                 new CheckSmiInstr(new Value(to_check),
-                                   deopt_id,
-                                   insert_before->token_pos()),
+                 new(isolate()) CheckSmiInstr(new(isolate()) Value(to_check),
+                                              deopt_id,
+                                              insert_before->token_pos()),
                  deopt_environment,
                  FlowGraph::kEffect);
   }
 }
 
 
 Instruction* FlowGraphOptimizer::GetCheckClass(Definition* to_check,
                                                const ICData& unary_checks,
                                                intptr_t deopt_id,
                                                intptr_t token_pos) {
   if ((unary_checks.NumberOfChecks() == 1) &&
       (unary_checks.GetReceiverClassIdAt(0) == kSmiCid)) {
-    return new CheckSmiInstr(new Value(to_check),
-                             deopt_id,
-                             token_pos);
+    return new(isolate()) CheckSmiInstr(new(isolate()) Value(to_check),
+                                        deopt_id,
+                                        token_pos);
   }
-  return new CheckClassInstr(
-      new Value(to_check), deopt_id, unary_checks, token_pos);
+  return new(isolate()) CheckClassInstr(
+      new(isolate()) Value(to_check), deopt_id, unary_checks, token_pos);
 }
 
 
 void FlowGraphOptimizer::AddCheckClass(Definition* to_check,
                                        const ICData& unary_checks,
                                        intptr_t deopt_id,
                                        Environment* deopt_environment,
                                        Instruction* insert_before) {
   // Type propagation has not run yet, we cannot eliminate the check.
   Instruction* check = GetCheckClass(
       to_check, unary_checks, deopt_id, insert_before->token_pos());
   InsertBefore(insert_before, check, deopt_environment, FlowGraph::kEffect);
 }
 
 
 void FlowGraphOptimizer::AddReceiverCheck(InstanceCallInstr* call) {
   AddCheckClass(call->ArgumentAt(0),
-                ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks()),
+                ICData::ZoneHandle(isolate(),
+                                   call->ic_data()->AsUnaryClassChecks()),
                 call->deopt_id(),
                 call->env(),
                 call);
 }
 
 
 static bool ArgIsAlways(intptr_t cid,
                         const ICData& ic_data,
                         intptr_t arg_number) {
   ASSERT(ic_data.NumArgsTested() > arg_number);
@@ skipping 85 matching lines @@
     default:
       break;
   }
   return kIllegalCid;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithStoreIndexed(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
-  const ICData& ic_data = ICData::Handle(call->ic_data()->AsUnaryClassChecks());
+  const ICData& ic_data = ICData::Handle(isolate(),
+                                         call->ic_data()->AsUnaryClassChecks());
   if (ic_data.NumberOfChecks() != 1) return false;
   ASSERT(ic_data.HasOneTarget());
 
-  const Function& target = Function::Handle(ic_data.GetTargetAt(0));
+  const Function& target = Function::Handle(isolate(), ic_data.GetTargetAt(0));
   TargetEntryInstr* entry;
   Definition* last;
   if (!TryInlineRecognizedMethod(ic_data.GetReceiverClassIdAt(0),
                                  target,
                                  call,
                                  call->ArgumentAt(0),
                                  call->token_pos(),
                                  *call->ic_data(),
                                  &entry, &last)) {
     return false;
@@ skipping 32 matching lines @@
     const ICData& value_check,
     TargetEntryInstr** entry,
     Definition** last) {
   intptr_t array_cid = MethodKindToCid(kind);
   ASSERT(array_cid != kIllegalCid);
 
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
   Definition* stored_value = call->ArgumentAt(2);
 
-  *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
-                                call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(call);
+  *entry = new(isolate()) TargetEntryInstr(flow_graph()->allocate_block_id(),
+                                           call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(isolate(), call);
   Instruction* cursor = *entry;
   if (FLAG_enable_type_checks) {
     // Only type check for the value. A type check for the index is not
     // needed here because we insert a deoptimizing smi-check for the case
     // the index is not a smi.
     const AbstractType& value_type =
-        AbstractType::ZoneHandle(target.ParameterTypeAt(2));
+        AbstractType::ZoneHandle(isolate(), target.ParameterTypeAt(2));
     Definition* instantiator = NULL;
     Definition* type_args = NULL;
     switch (array_cid) {
       case kArrayCid:
       case kGrowableObjectArrayCid: {
-        const Class& instantiator_class = Class::Handle(target.Owner());
+        const Class& instantiator_class =
+            Class::Handle(isolate(), target.Owner());
         intptr_t type_arguments_field_offset =
             instantiator_class.type_arguments_field_offset();
         LoadFieldInstr* load_type_args =
-            new LoadFieldInstr(new Value(array),
-                               type_arguments_field_offset,
-                               Type::ZoneHandle(),  // No type.
-                               call->token_pos());
+            new(isolate()) LoadFieldInstr(
+                new(isolate()) Value(array),
+                type_arguments_field_offset,
+                Type::ZoneHandle(isolate(), Type::null()),  // No type.
+                call->token_pos());
         cursor = flow_graph()->AppendTo(cursor,
                                         load_type_args,
                                         NULL,
                                         FlowGraph::kValue);
 
         instantiator = array;
         type_args = load_type_args;
         break;
       }
       case kTypedDataInt8ArrayCid:
@@ skipping 28 matching lines @@
         ASSERT((array_cid != kTypedDataFloat64x2ArrayCid) ||
                value_type.IsFloat64x2Type());
         ASSERT(value_type.IsInstantiated());
         break;
       }
       default:
         // TODO(fschneider): Add support for other array types.
         UNREACHABLE();
     }
     AssertAssignableInstr* assert_value =
-        new AssertAssignableInstr(token_pos,
-                                  new Value(stored_value),
-                                  new Value(instantiator),
-                                  new Value(type_args),
-                                  value_type,
-                                  Symbols::Value());
+        new(isolate()) AssertAssignableInstr(token_pos,
+                                             new(isolate()) Value(stored_value),
+                                             new(isolate()) Value(instantiator),
+                                             new(isolate()) Value(type_args),
+                                             value_type,
+                                             Symbols::Value());
     // Newly inserted instructions that can deoptimize or throw an exception
     // must have a deoptimization id that is valid for lookup in the unoptimized
     // code.
     assert_value->deopt_id_ = call->deopt_id();
     cursor = flow_graph()->AppendTo(cursor,
                                     assert_value,
                                     call->env(),
                                     FlowGraph::kValue);
   }
 
@@ skipping 16 matching lines @@
     Instruction* check = GetCheckClass(
         stored_value, value_check, call->deopt_id(), call->token_pos());
     cursor = flow_graph()->AppendTo(cursor,
                                     check,
                                     call->env(),
                                     FlowGraph::kEffect);
   }
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
     stored_value =
-        new DoubleToFloatInstr(new Value(stored_value), call->deopt_id());
+        new(isolate()) DoubleToFloatInstr(
+            new(isolate()) Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
                                     FlowGraph::kValue);
   }
 
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
-  *last = new StoreIndexedInstr(new Value(array),
-                                new Value(index),
-                                new Value(stored_value),
-                                needs_store_barrier,
-                                index_scale,
-                                array_cid,
-                                call->deopt_id(),
-                                call->token_pos());
+  *last = new(isolate()) StoreIndexedInstr(new(isolate()) Value(array),
+                                           new(isolate()) Value(index),
+                                           new(isolate()) Value(stored_value),
+                                           needs_store_barrier,
+                                           index_scale,
+                                           array_cid,
+                                           call->deopt_id(),
+                                           call->token_pos());
   flow_graph()->AppendTo(cursor,
                          *last,
                          call->env(),
                          FlowGraph::kEffect);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target,
                                                    Instruction* call,
                                                    Definition* receiver,
                                                    intptr_t token_pos,
                                                    const ICData& ic_data,
                                                    TargetEntryInstr** entry,
                                                    Definition** last) {
-  ICData& value_check = ICData::ZoneHandle();
+  ICData& value_check = ICData::ZoneHandle(isolate(), ICData::null());
   MethodRecognizer::Kind kind = MethodRecognizer::RecognizeKind(target);
   switch (kind) {
     // Recognized [] operators.
     case MethodRecognizer::kImmutableArrayGetIndexed:
     case MethodRecognizer::kObjectArrayGetIndexed:
     case MethodRecognizer::kGrowableArrayGetIndexed:
     case MethodRecognizer::kInt8ArrayGetIndexed:
     case MethodRecognizer::kUint8ArrayGetIndexed:
     case MethodRecognizer::kUint8ClampedArrayGetIndexed:
     case MethodRecognizer::kExternalUint8ArrayGetIndexed:
@@ skipping 215 matching lines @@
   }
 }
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineIndexedOp(Instruction* call,
                                                     intptr_t array_cid,
                                                     Definition** array,
                                                     Definition* index,
                                                     Instruction** cursor) {
   // Insert index smi check.
-  *cursor = flow_graph()->AppendTo(*cursor,
-                                   new CheckSmiInstr(new Value(index),
-                                                     call->deopt_id(),
-                                                     call->token_pos()),
-                                   call->env(),
-                                   FlowGraph::kEffect);
+  *cursor = flow_graph()->AppendTo(
+      *cursor,
+      new(isolate()) CheckSmiInstr(new(isolate()) Value(index),
+                                   call->deopt_id(),
+                                   call->token_pos()),
+      call->env(),
+      FlowGraph::kEffect);
 
   // Insert array length load and bounds check.
   LoadFieldInstr* length =
-      new LoadFieldInstr(new Value(*array),
-                         CheckArrayBoundInstr::LengthOffsetFor(array_cid),
-                         Type::ZoneHandle(Type::SmiType()),
-                         call->token_pos());
+      new(isolate()) LoadFieldInstr(
+          new(isolate()) Value(*array),
+          CheckArrayBoundInstr::LengthOffsetFor(array_cid),
+          Type::ZoneHandle(isolate(), Type::SmiType()),
+          call->token_pos());
   length->set_is_immutable(
       CheckArrayBoundInstr::IsFixedLengthArrayType(array_cid));
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(array_cid));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    length,
                                    NULL,
                                    FlowGraph::kValue);
 
   *cursor = flow_graph()->AppendTo(*cursor,
-                                   new CheckArrayBoundInstr(
-                                       new Value(length),
-                                       new Value(index),
+                                   new(isolate()) CheckArrayBoundInstr(
+                                       new(isolate()) Value(length),
+                                       new(isolate()) Value(index),
                                        call->deopt_id()),
                                    call->env(),
                                    FlowGraph::kEffect);
 
   if (array_cid == kGrowableObjectArrayCid) {
     // Insert data elements load.
     LoadFieldInstr* elements =
-        new LoadFieldInstr(new Value(*array),
-                           GrowableObjectArray::data_offset(),
-                           Type::ZoneHandle(Type::DynamicType()),
-                           call->token_pos());
+        new(isolate()) LoadFieldInstr(
+            new(isolate()) Value(*array),
+            GrowableObjectArray::data_offset(),
+            Type::ZoneHandle(isolate(), Type::DynamicType()),
+            call->token_pos());
     elements->set_result_cid(kArrayCid);
     *cursor = flow_graph()->AppendTo(*cursor,
                                      elements,
                                      NULL,
                                      FlowGraph::kValue);
     // Load from the data from backing store which is a fixed-length array.
     *array = elements;
     array_cid = kArrayCid;
   } else if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements =
-        new LoadUntaggedInstr(new Value(*array),
-                              ExternalTypedData::data_offset());
+        new(isolate()) LoadUntaggedInstr(new(isolate()) Value(*array),
+                                         ExternalTypedData::data_offset());
     *cursor = flow_graph()->AppendTo(*cursor,
                                      elements,
                                      NULL,
                                      FlowGraph::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
 bool FlowGraphOptimizer::InlineGetIndexed(MethodRecognizer::Kind kind,
                                           Instruction* call,
                                           Definition* receiver,
                                           const ICData& ic_data,
                                           TargetEntryInstr** entry,
                                           Definition** last) {
   intptr_t array_cid = MethodKindToCid(kind);
   ASSERT(array_cid != kIllegalCid);
 
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
-  *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
-                                call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(call);
+  *entry = new(isolate()) TargetEntryInstr(flow_graph()->allocate_block_id(),
+                                           call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(isolate(), call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineIndexedOp(call,
                                      array_cid,
                                      &array,
                                      index,
                                      &cursor);
 
   intptr_t deopt_id = Isolate::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
       (array_cid == kTypedDataUint32ArrayCid)) {
     // Set deopt_id if we can optimistically assume that the result is Smi.
     // Assume mixed Mint/Smi if this instruction caused deoptimization once.
     deopt_id = ic_data.HasDeoptReasons() ?
         Isolate::kNoDeoptId : call->deopt_id();
   }
 
   // Array load and return.
   intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(array_cid);
-  *last = new LoadIndexedInstr(new Value(array),
-                               new Value(index),
-                               index_scale,
-                               array_cid,
-                               deopt_id,
-                               call->token_pos());
+  *last = new(isolate()) LoadIndexedInstr(new(isolate()) Value(array),
+                                          new(isolate()) Value(index),
+                                          index_scale,
+                                          array_cid,
+                                          deopt_id,
+                                          call->token_pos());
   cursor = flow_graph()->AppendTo(
       cursor,
       *last,
       deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
 
   if (array_cid == kTypedDataFloat32ArrayCid) {
-    *last = new FloatToDoubleInstr(new Value(*last), deopt_id);
+    *last = new(isolate()) FloatToDoubleInstr(
+        new(isolate()) Value(*last), deopt_id);
     flow_graph()->AppendTo(cursor,
                            *last,
                            deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
                            FlowGraph::kValue);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithLoadIndexed(InstanceCallInstr* call) {
   // Check for monomorphic IC data.
   if (!call->HasICData()) return false;
-  const ICData& ic_data = ICData::Handle(call->ic_data()->AsUnaryClassChecks());
+  const ICData& ic_data =
+      ICData::Handle(isolate(), call->ic_data()->AsUnaryClassChecks());
   if (ic_data.NumberOfChecks() != 1) return false;
   ASSERT(ic_data.HasOneTarget());
 
-  const Function& target = Function::Handle(ic_data.GetTargetAt(0));
+  const Function& target = Function::Handle(isolate(), ic_data.GetTargetAt(0));
   TargetEntryInstr* entry;
   Definition* last;
   if (!TryInlineRecognizedMethod(ic_data.GetReceiverClassIdAt(0),
                                  target,
                                  call,
                                  call->ArgumentAt(0),
                                  call->token_pos(),
                                  *call->ic_data(),
                                  &entry, &last)) {
     return false;
@@ skipping 58 matching lines @@
     left = right;
     right = temp;
   }
   if (IsLengthOneString(left)) {
     // Optimize if left is a string with length one (either constant or
     // result of string-from-char-code.
     if (left->IsConstant()) {
       ConstantInstr* left_const = left->AsConstant();
       const String& str = String::Cast(left_const->value());
       ASSERT(str.Length() == 1);
-      ConstantInstr* char_code_left =
-          flow_graph()->GetConstant(Smi::ZoneHandle(Smi::New(str.CharAt(0))));
-      left_val = new Value(char_code_left);
+      ConstantInstr* char_code_left = flow_graph()->GetConstant(
+          Smi::ZoneHandle(isolate(), Smi::New(str.CharAt(0))));
+      left_val = new(isolate()) Value(char_code_left);
     } else if (left->IsStringFromCharCode()) {
       // Use input of string-from-charcode as left value.
       StringFromCharCodeInstr* instr = left->AsStringFromCharCode();
-      left_val = new Value(instr->char_code()->definition());
+      left_val = new(isolate()) Value(instr->char_code()->definition());
       to_remove_left = instr;
     } else {
       // IsLengthOneString(left) should have been false.
       UNREACHABLE();
     }
 
     Definition* to_remove_right = NULL;
     Value* right_val = NULL;
     if (right->IsStringFromCharCode()) {
       // Skip string-from-char-code, and use its input as right value.
       StringFromCharCodeInstr* right_instr = right->AsStringFromCharCode();
-      right_val = new Value(right_instr->char_code()->definition());
+      right_val = new(isolate()) Value(right_instr->char_code()->definition());
       to_remove_right = right_instr;
     } else {
       const ICData& unary_checks_1 =
-          ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecksForArgNr(1));
+          ICData::ZoneHandle(isolate(),
+                             call->ic_data()->AsUnaryClassChecksForArgNr(1));
       AddCheckClass(right,
                     unary_checks_1,
                     call->deopt_id(),
                     call->env(),
                     call);
       // String-to-char-code instructions returns -1 (illegal charcode) if
       // string is not of length one.
       StringToCharCodeInstr* char_code_right =
-          new StringToCharCodeInstr(new Value(right), kOneByteStringCid);
+          new(isolate()) StringToCharCodeInstr(
+              new(isolate()) Value(right), kOneByteStringCid);
       InsertBefore(call, char_code_right, call->env(), FlowGraph::kValue);
-      right_val = new Value(char_code_right);
+      right_val = new(isolate()) Value(char_code_right);
     }
 
     // Comparing char-codes instead of strings.
     EqualityCompareInstr* comp =
-        new EqualityCompareInstr(call->token_pos(),
-                                 op_kind,
-                                 left_val,
-                                 right_val,
-                                 kSmiCid,
-                                 call->deopt_id());
+        new(isolate()) EqualityCompareInstr(call->token_pos(),
+                                            op_kind,
+                                            left_val,
+                                            right_val,
+                                            kSmiCid,
+                                            call->deopt_id());
     ReplaceCall(call, comp);
 
     // Remove dead instructions.
     if ((to_remove_left != NULL) &&
         (to_remove_left->input_use_list() == NULL)) {
       to_remove_left->ReplaceUsesWith(flow_graph()->constant_null());
       to_remove_left->RemoveFromGraph();
     }
     if ((to_remove_right != NULL) &&
         (to_remove_right->input_use_list() == NULL)) {
@@ skipping 19 matching lines @@
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kOneByteStringCid)) {
     if (TryStringLengthOneEquality(call, op_kind)) {
       return true;
     } else {
       return false;
     }
   } else if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(left),
-                                   call->deopt_id(),
-                                   call->token_pos()),
+                 new(isolate()) CheckSmiInstr(new(isolate()) Value(left),
+                                              call->deopt_id(),
+                                              call->token_pos()),
                  call->env(),
                  FlowGraph::kEffect);
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(right),
-                                   call->deopt_id(),
-                                   call->token_pos()),
+                 new(isolate()) CheckSmiInstr(new(isolate()) Value(right),
+                                              call->deopt_id(),
+                                              call->token_pos()),
                  call->env(),
                  FlowGraph::kEffect);
     cid = kSmiCid;
   } else if (HasTwoMintOrSmi(ic_data) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     cid = kMintCid;
   } else if (HasTwoDoubleOrSmi(ic_data) && CanUnboxDouble()) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
     } else {
       if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
         // We cannot use double comparison on two smis. Need polymorphic
         // call.
         return false;
       } else {
         InsertBefore(call,
-                     new CheckEitherNonSmiInstr(new Value(left),
-                                                new Value(right),
-                                                call->deopt_id()),
+                     new(isolate()) CheckEitherNonSmiInstr(
+                         new(isolate()) Value(left),
+                         new(isolate()) Value(right),
+                         call->deopt_id()),
                      call->env(),
                      FlowGraph::kEffect);
         cid = kDoubleCid;
       }
     }
   } else {
     // Check if ICDData contains checks with Smi/Null combinations. In that case
     // we can still emit the optimized Smi equality operation but need to add
     // checks for null or Smi.
     GrowableArray<intptr_t> smi_or_null(2);
     smi_or_null.Add(kSmiCid);
     smi_or_null.Add(kNullCid);
     if (ICDataHasOnlyReceiverArgumentClassIds(ic_data,
                                               smi_or_null,
                                               smi_or_null)) {
       const ICData& unary_checks_0 =
-          ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks());
+          ICData::ZoneHandle(isolate(),
+                             call->ic_data()->AsUnaryClassChecks());
       AddCheckClass(left,
                     unary_checks_0,
                     call->deopt_id(),
                     call->env(),
                     call);
 
       const ICData& unary_checks_1 =
-          ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecksForArgNr(1));
+          ICData::ZoneHandle(isolate(),
+                             call->ic_data()->AsUnaryClassChecksForArgNr(1));
       AddCheckClass(right,
                     unary_checks_1,
                     call->deopt_id(),
                     call->env(),
                     call);
       cid = kSmiCid;
     } else {
       // Shortcut for equality with null.
       ConstantInstr* right_const = right->AsConstant();
       ConstantInstr* left_const = left->AsConstant();
       if ((right_const != NULL && right_const->value().IsNull()) ||
           (left_const != NULL && left_const->value().IsNull())) {
         StrictCompareInstr* comp =
-            new StrictCompareInstr(call->token_pos(),
-                                   Token::kEQ_STRICT,
-                                   new Value(left),
-                                   new Value(right),
-                                   false);  // No number check.
+            new(isolate()) StrictCompareInstr(call->token_pos(),
+                                              Token::kEQ_STRICT,
+                                              new(isolate()) Value(left),
+                                              new(isolate()) Value(right),
+                                              false);  // No number check.
         ReplaceCall(call, comp);
         return true;
       }
       return false;
     }
   }
   ASSERT(cid != kIllegalCid);
-  EqualityCompareInstr* comp = new EqualityCompareInstr(call->token_pos(),
-                                                        op_kind,
-                                                        new Value(left),
-                                                        new Value(right),
-                                                        cid,
-                                                        call->deopt_id());
+  EqualityCompareInstr* comp = new(isolate()) EqualityCompareInstr(
+      call->token_pos(),
+      op_kind,
+      new(isolate()) Value(left),
+      new(isolate()) Value(right),
+      cid,
+      call->deopt_id());
   ReplaceCall(call, comp);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithRelationalOp(InstanceCallInstr* call,
                                                     Token::Kind op_kind) {
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.NumArgsTested() == 2);
 
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
 
   intptr_t cid = kIllegalCid;
   if (HasOnlyTwoOf(ic_data, kSmiCid)) {
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(left),
-                                   call->deopt_id(),
-                                   call->token_pos()),
+                 new(isolate()) CheckSmiInstr(new(isolate()) Value(left),
+                                              call->deopt_id(),
+                                              call->token_pos()),
                  call->env(),
                  FlowGraph::kEffect);
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(right),
-                                   call->deopt_id(),
-                                   call->token_pos()),
+                 new(isolate()) CheckSmiInstr(new(isolate()) Value(right),
+                                              call->deopt_id(),
+                                              call->token_pos()),
                  call->env(),
                  FlowGraph::kEffect);
     cid = kSmiCid;
   } else if (HasTwoMintOrSmi(ic_data) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
     cid = kMintCid;
   } else if (HasTwoDoubleOrSmi(ic_data) && CanUnboxDouble()) {
     // Use double comparison.
     if (SmiFitsInDouble()) {
       cid = kDoubleCid;
     } else {
       if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
         // We cannot use double comparison on two smis. Need polymorphic
         // call.
         return false;
       } else {
         InsertBefore(call,
-                     new CheckEitherNonSmiInstr(new Value(left),
-                                                new Value(right),
-                                                call->deopt_id()),
+                     new(isolate()) CheckEitherNonSmiInstr(
+                         new(isolate()) Value(left),
+                         new(isolate()) Value(right),
+                         call->deopt_id()),
                      call->env(),
                      FlowGraph::kEffect);
         cid = kDoubleCid;
       }
     }
   } else {
     return false;
   }
   ASSERT(cid != kIllegalCid);
-  RelationalOpInstr* comp = new RelationalOpInstr(call->token_pos(),
-                                                  op_kind,
-                                                  new Value(left),
-                                                  new Value(right),
-                                                  cid,
-                                                  call->deopt_id());
+  RelationalOpInstr* comp = new(isolate()) RelationalOpInstr(
+      call->token_pos(),
+      op_kind,
+      new(isolate()) Value(left),
+      new(isolate()) Value(right),
+      cid,
+      call->deopt_id());
   ReplaceCall(call, comp);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithBinaryOp(InstanceCallInstr* call,
                                                 Token::Kind op_kind) {
   intptr_t operands_type = kIllegalCid;
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
@@ skipping 72 matching lines @@
         // Left shift may overflow from smi into mint or big ints.
         // Don't generate smi code if the IC data is marked because
         // of an overflow.
         if (ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
           return false;
         }
         operands_type = ic_data.HasDeoptReason(ICData::kDeoptBinarySmiOp)
             ? kMintCid
             : kSmiCid;
       } else if (HasTwoMintOrSmi(ic_data) &&
-                 HasOnlyOneSmi(ICData::Handle(
+                 HasOnlyOneSmi(ICData::Handle(isolate(),
                      ic_data.AsUnaryClassChecksForArgNr(1)))) {
         // Don't generate mint code if the IC data is marked because of an
         // overflow.
         if (ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
           return false;
         }
         // Check for smi/mint << smi or smi/mint >> smi.
         operands_type = kMintCid;
       } else {
         return false;
@@ skipping 19 matching lines @@
   Definition* right = call->ArgumentAt(1);
   if (operands_type == kDoubleCid) {
     if (!CanUnboxDouble()) {
       return false;
     }
     // Check that either left or right are not a smi.  Result of a
     // binary operation with two smis is a smi not a double, except '/' which
     // returns a double for two smis.
     if (op_kind != Token::kDIV) {
       InsertBefore(call,
-                   new CheckEitherNonSmiInstr(new Value(left),
-                                              new Value(right),
-                                              call->deopt_id()),
+                   new(isolate()) CheckEitherNonSmiInstr(
+                       new(isolate()) Value(left),
+                       new(isolate()) Value(right),
+                       call->deopt_id()),
                    call->env(),
                    FlowGraph::kEffect);
     }
 
     BinaryDoubleOpInstr* double_bin_op =
-        new BinaryDoubleOpInstr(op_kind, new Value(left), new Value(right),
-                                call->deopt_id(), call->token_pos());
+        new(isolate()) BinaryDoubleOpInstr(op_kind,
+                                           new(isolate()) Value(left),
+                                           new(isolate()) Value(right),
+                                           call->deopt_id(), call->token_pos());
     ReplaceCall(call, double_bin_op);
   } else if (operands_type == kMintCid) {
     if (!FlowGraphCompiler::SupportsUnboxedMints()) return false;
     if ((op_kind == Token::kSHR) || (op_kind == Token::kSHL)) {
       ShiftMintOpInstr* shift_op =
-          new ShiftMintOpInstr(op_kind, new Value(left), new Value(right),
-                               call->deopt_id());
+          new(isolate()) ShiftMintOpInstr(
+              op_kind, new(isolate()) Value(left), new(isolate()) Value(right),
+              call->deopt_id());
       ReplaceCall(call, shift_op);
     } else {
       BinaryMintOpInstr* bin_op =
-          new BinaryMintOpInstr(op_kind, new Value(left), new Value(right),
-                                call->deopt_id());
+          new(isolate()) BinaryMintOpInstr(
+              op_kind, new(isolate()) Value(left), new(isolate()) Value(right),
+              call->deopt_id());
       ReplaceCall(call, bin_op);
     }
   } else if (operands_type == kFloat32x4Cid) {
     return InlineFloat32x4BinaryOp(call, op_kind);
   } else if (operands_type == kInt32x4Cid) {
     return InlineInt32x4BinaryOp(call, op_kind);
   } else if (operands_type == kFloat64x2Cid) {
     return InlineFloat64x2BinaryOp(call, op_kind);
   } else if (op_kind == Token::kMOD) {
     ASSERT(operands_type == kSmiCid);
     if (right->IsConstant()) {
       const Object& obj = right->AsConstant()->value();
       if (obj.IsSmi() && Utils::IsPowerOfTwo(Smi::Cast(obj).Value())) {
         // Insert smi check and attach a copy of the original environment
         // because the smi operation can still deoptimize.
         InsertBefore(call,
-                     new CheckSmiInstr(new Value(left),
-                                       call->deopt_id(),
-                                       call->token_pos()),
+                     new(isolate()) CheckSmiInstr(new(isolate()) Value(left),
+                                                  call->deopt_id(),
+                                                  call->token_pos()),
                      call->env(),
                      FlowGraph::kEffect);
         ConstantInstr* constant =
-            flow_graph()->GetConstant(Smi::Handle(
+            flow_graph()->GetConstant(Smi::Handle(isolate(),
                 Smi::New(Smi::Cast(obj).Value() - 1)));
         BinarySmiOpInstr* bin_op =
-            new BinarySmiOpInstr(Token::kBIT_AND,
-                                 new Value(left),
-                                 new Value(constant),
+            new(isolate()) BinarySmiOpInstr(Token::kBIT_AND,
+                                 new(isolate()) Value(left),
+                                 new(isolate()) Value(constant),
                                  call->deopt_id(),
                                  call->token_pos());
         ReplaceCall(call, bin_op);
         return true;
       }
     }
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     AddCheckSmi(left, call->deopt_id(), call->env(), call);
     AddCheckSmi(right, call->deopt_id(), call->env(), call);
     BinarySmiOpInstr* bin_op =
-        new BinarySmiOpInstr(op_kind, new Value(left), new Value(right),
-                             call->deopt_id(), call->token_pos());
+        new(isolate()) BinarySmiOpInstr(op_kind,
+                                        new(isolate()) Value(left),
+                                        new(isolate()) Value(right),
+                                        call->deopt_id(), call->token_pos());
     ReplaceCall(call, bin_op);
   } else {
     ASSERT(operands_type == kSmiCid);
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     AddCheckSmi(left, call->deopt_id(), call->env(), call);
     AddCheckSmi(right, call->deopt_id(), call->env(), call);
     if (left->IsConstant() &&
         ((op_kind == Token::kADD) || (op_kind == Token::kMUL))) {
       // Constant should be on the right side.
       Definition* temp = left;
       left = right;
       right = temp;
     }
     BinarySmiOpInstr* bin_op =
-        new BinarySmiOpInstr(op_kind, new Value(left), new Value(right),
-                             call->deopt_id(), call->token_pos());
+        new(isolate()) BinarySmiOpInstr(
+            op_kind, new(isolate()) Value(left), new(isolate()) Value(right),
+            call->deopt_id(), call->token_pos());
     ReplaceCall(call, bin_op);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(InstanceCallInstr* call,
                                                Token::Kind op_kind) {
   ASSERT(call->ArgumentCount() == 1);
   Definition* input = call->ArgumentAt(0);
   Definition* unary_op = NULL;
   if (HasOnlyOneSmi(*call->ic_data())) {
     InsertBefore(call,
-                 new CheckSmiInstr(new Value(input),
-                                   call->deopt_id(),
-                                   call->token_pos()),
+                 new(isolate()) CheckSmiInstr(new(isolate()) Value(input),
+                                              call->deopt_id(),
+                                              call->token_pos()),
                  call->env(),
                  FlowGraph::kEffect);
-    unary_op = new UnarySmiOpInstr(op_kind, new Value(input), call->deopt_id());
+    unary_op = new(isolate()) UnarySmiOpInstr(
+        op_kind, new(isolate()) Value(input), call->deopt_id());
   } else if ((op_kind == Token::kBIT_NOT) &&
              HasOnlySmiOrMint(*call->ic_data()) &&
              FlowGraphCompiler::SupportsUnboxedMints()) {
-    unary_op = new UnaryMintOpInstr(
-        op_kind, new Value(input), call->deopt_id());
+    unary_op = new(isolate()) UnaryMintOpInstr(
+        op_kind, new(isolate()) Value(input), call->deopt_id());
   } else if (HasOnlyOneDouble(*call->ic_data()) &&
              (op_kind == Token::kNEGATE) &&
              CanUnboxDouble()) {
     AddReceiverCheck(call);
-    unary_op = new UnaryDoubleOpInstr(
-        Token::kNEGATE, new Value(input), call->deopt_id());
+    unary_op = new(isolate()) UnaryDoubleOpInstr(
+        Token::kNEGATE, new(isolate()) Value(input), call->deopt_id());
   } else {
     return false;
   }
   ASSERT(unary_op != NULL);
   ReplaceCall(call, unary_op);
   return true;
 }
 
 
 // Using field class
@@ skipping 16 matching lines @@
 // callee functions, then no class check is needed.
 bool FlowGraphOptimizer::InstanceCallNeedsClassCheck(
     InstanceCallInstr* call) const {
   if (!FLAG_use_cha) return true;
   Definition* callee_receiver = call->ArgumentAt(0);
   ASSERT(callee_receiver != NULL);
   const Function& function = flow_graph_->parsed_function().function();
   if (function.IsDynamicFunction() &&
       callee_receiver->IsParameter() &&
       (callee_receiver->AsParameter()->index() == 0)) {
-    return CHA::HasOverride(Class::Handle(function.Owner()),
+    return CHA::HasOverride(Class::Handle(isolate(), function.Owner()),
                             call->function_name());
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::MethodExtractorNeedsClassCheck(
     InstanceCallInstr* call) const {
   if (!FLAG_use_cha) return true;
   Definition* callee_receiver = call->ArgumentAt(0);
   ASSERT(callee_receiver != NULL);
   const Function& function = flow_graph_->parsed_function().function();
   if (function.IsDynamicFunction() &&
       callee_receiver->IsParameter() &&
       (callee_receiver->AsParameter()->index() == 0)) {
     const String& field_name =
-      String::Handle(Field::NameFromGetter(call->function_name()));
-    return CHA::HasOverride(Class::Handle(function.Owner()), field_name);
+      String::Handle(isolate(), Field::NameFromGetter(call->function_name()));
+    return CHA::HasOverride(Class::Handle(isolate(), function.Owner()),
+                            field_name);
   }
   return true;
 }
 
 
 void FlowGraphOptimizer::InlineImplicitInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   ASSERT(ic_data.HasOneTarget());
-  Function& target = Function::Handle();
+  Function& target = Function::Handle(isolate(), Function::null());
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   ASSERT(class_ids.length() == 1);
   // Inline implicit instance getter.
   const String& field_name =
-      String::Handle(Field::NameFromGetter(call->function_name()));
-  const Field& field = Field::ZoneHandle(GetField(class_ids[0], field_name));
+      String::Handle(isolate(), Field::NameFromGetter(call->function_name()));
+  const Field& field =
+      Field::ZoneHandle(isolate(), GetField(class_ids[0], field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(call)) {
     AddReceiverCheck(call);
   }
-  LoadFieldInstr* load = new LoadFieldInstr(
-      new Value(call->ArgumentAt(0)),
+  LoadFieldInstr* load = new(isolate()) LoadFieldInstr(
+      new(isolate()) Value(call->ArgumentAt(0)),
       &field,
-      AbstractType::ZoneHandle(field.type()),
+      AbstractType::ZoneHandle(isolate(), field.type()),
       call->token_pos());
   load->set_is_immutable(field.is_final());
   if (field.guarded_cid() != kIllegalCid) {
     if (!field.is_nullable() || (field.guarded_cid() == kNullCid)) {
       load->set_result_cid(field.guarded_cid());
     }
     FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
   }
 
   // Discard the environment from the original instruction because the load
   // can't deoptimize.
   call->RemoveEnvironment();
   ReplaceCall(call, load);
 
   if (load->result_cid() != kDynamicCid) {
     // Reset value types if guarded_cid was used.
     for (Value::Iterator it(load->input_use_list());
          !it.Done();
          it.Advance()) {
       it.Current()->SetReachingType(NULL);
     }
   }
 }
 
 
-static LoadFieldInstr* BuildLoadStringLength(Definition* str) {
+LoadFieldInstr* FlowGraphOptimizer::BuildLoadStringLength(Definition* str) {
   // Treat length loads as mutable (i.e. affected by side effects) to avoid
   // hoisting them since we can't hoist the preceding class-check. This
   // is because of externalization of strings that affects their class-id.
-  LoadFieldInstr* load = new LoadFieldInstr(
-      new Value(str),
+  LoadFieldInstr* load = new(isolate()) LoadFieldInstr(
+      new(isolate()) Value(str),
       String::length_offset(),
-      Type::ZoneHandle(Type::SmiType()),
+      Type::ZoneHandle(isolate(), Type::SmiType()),
       str->token_pos());
   load->set_result_cid(kSmiCid);
   load->set_recognized_kind(MethodRecognizer::kStringBaseLength);
   return load;
 }
 
 
 bool FlowGraphOptimizer::InlineFloat32x4Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
-                    call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                    isolate(), call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   intptr_t mask = 0;
   if ((getter == MethodRecognizer::kFloat32x4Shuffle) ||
       (getter == MethodRecognizer::kFloat32x4ShuffleMix)) {
     // Extract shuffle mask.
     Definition* mask_definition = NULL;
     if (getter == MethodRecognizer::kFloat32x4Shuffle) {
       ASSERT(call->ArgumentCount() == 2);
@@ skipping 13 matching lines @@
       return false;
     }
     ASSERT(constant_mask.IsSmi());
     mask = Smi::Cast(constant_mask).Value();
     if ((mask < 0) || (mask > 255)) {
       // Not a valid mask.
       return false;
     }
   }
   if (getter == MethodRecognizer::kFloat32x4GetSignMask) {
-    Simd32x4GetSignMaskInstr* instr = new Simd32x4GetSignMaskInstr(
+    Simd32x4GetSignMaskInstr* instr = new(isolate()) Simd32x4GetSignMaskInstr(
         getter,
-        new Value(call->ArgumentAt(0)),
+        new(isolate()) Value(call->ArgumentAt(0)),
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   } else if (getter == MethodRecognizer::kFloat32x4ShuffleMix) {
-    Simd32x4ShuffleMixInstr* instr = new Simd32x4ShuffleMixInstr(
+    Simd32x4ShuffleMixInstr* instr = new(isolate()) Simd32x4ShuffleMixInstr(
         getter,
-        new Value(call->ArgumentAt(0)),
-        new Value(call->ArgumentAt(1)),
+        new(isolate()) Value(call->ArgumentAt(0)),
+        new(isolate()) Value(call->ArgumentAt(1)),
         mask,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   } else {
     ASSERT((getter == MethodRecognizer::kFloat32x4Shuffle)  ||
            (getter == MethodRecognizer::kFloat32x4ShuffleX) ||
            (getter == MethodRecognizer::kFloat32x4ShuffleY) ||
            (getter == MethodRecognizer::kFloat32x4ShuffleZ) ||
            (getter == MethodRecognizer::kFloat32x4ShuffleW));
-    Simd32x4ShuffleInstr* instr = new Simd32x4ShuffleInstr(
+    Simd32x4ShuffleInstr* instr = new(isolate()) Simd32x4ShuffleInstr(
         getter,
-        new Value(call->ArgumentAt(0)),
+        new(isolate()) Value(call->ArgumentAt(0)),
         mask,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
   UNREACHABLE();
   return false;
 }
 
 
 bool FlowGraphOptimizer::InlineFloat64x2Getter(InstanceCallInstr* call,
                                                MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
-                    call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                    isolate(), call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   if ((getter == MethodRecognizer::kFloat64x2GetX) ||
       (getter == MethodRecognizer::kFloat64x2GetY)) {
-    Simd64x2ShuffleInstr* instr = new Simd64x2ShuffleInstr(
+    Simd64x2ShuffleInstr* instr = new(isolate()) Simd64x2ShuffleInstr(
         getter,
-        new Value(call->ArgumentAt(0)),
+        new(isolate()) Value(call->ArgumentAt(0)),
         0,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
   UNREACHABLE();
   return false;
 }
 
 
 bool FlowGraphOptimizer::InlineInt32x4Getter(InstanceCallInstr* call,
                                               MethodRecognizer::Kind getter) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   AddCheckClass(call->ArgumentAt(0),
                 ICData::ZoneHandle(
-                    call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                    isolate(), call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   intptr_t mask = 0;
   if ((getter == MethodRecognizer::kInt32x4Shuffle) ||
       (getter == MethodRecognizer::kInt32x4ShuffleMix)) {
     // Extract shuffle mask.
     Definition* mask_definition = NULL;
     if (getter == MethodRecognizer::kInt32x4Shuffle) {
       ASSERT(call->ArgumentCount() == 2);
@@ skipping 13 matching lines @@
       return false;
     }
     ASSERT(constant_mask.IsSmi());
     mask = Smi::Cast(constant_mask).Value();
     if ((mask < 0) || (mask > 255)) {
       // Not a valid mask.
       return false;
     }
   }
   if (getter == MethodRecognizer::kInt32x4GetSignMask) {
-    Simd32x4GetSignMaskInstr* instr = new Simd32x4GetSignMaskInstr(
+    Simd32x4GetSignMaskInstr* instr = new(isolate()) Simd32x4GetSignMaskInstr(
         getter,
-        new Value(call->ArgumentAt(0)),
+        new(isolate()) Value(call->ArgumentAt(0)),
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   } else if (getter == MethodRecognizer::kInt32x4ShuffleMix) {
-    Simd32x4ShuffleMixInstr* instr = new Simd32x4ShuffleMixInstr(
+    Simd32x4ShuffleMixInstr* instr = new(isolate()) Simd32x4ShuffleMixInstr(
         getter,
-        new Value(call->ArgumentAt(0)),
-        new Value(call->ArgumentAt(1)),
+        new(isolate()) Value(call->ArgumentAt(0)),
+        new(isolate()) Value(call->ArgumentAt(1)),
         mask,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   } else if (getter == MethodRecognizer::kInt32x4Shuffle) {
-    Simd32x4ShuffleInstr* instr = new Simd32x4ShuffleInstr(
+    Simd32x4ShuffleInstr* instr = new(isolate()) Simd32x4ShuffleInstr(
         getter,
-        new Value(call->ArgumentAt(0)),
+        new(isolate()) Value(call->ArgumentAt(0)),
         mask,
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   } else {
-    Int32x4GetFlagInstr* instr = new Int32x4GetFlagInstr(
+    Int32x4GetFlagInstr* instr = new(isolate()) Int32x4GetFlagInstr(
         getter,
-        new Value(call->ArgumentAt(0)),
+        new(isolate()) Value(call->ArgumentAt(0)),
         call->deopt_id());
     ReplaceCall(call, instr);
     return true;
   }
 }
 
 
 bool FlowGraphOptimizer::InlineFloat32x4BinaryOp(InstanceCallInstr* call,
                                                  Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left.
   AddCheckClass(left,
                 ICData::ZoneHandle(
-                    call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                    isolate(), call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   // Type check right.
   AddCheckClass(right,
                 ICData::ZoneHandle(
-                    call->ic_data()->AsUnaryClassChecksForArgNr(1)),
+                    isolate(), call->ic_data()->AsUnaryClassChecksForArgNr(1)),
                 call->deopt_id(),
                 call->env(),
                 call);
   // Replace call.
   BinaryFloat32x4OpInstr* float32x4_bin_op =
-      new BinaryFloat32x4OpInstr(op_kind, new Value(left), new Value(right),
-                                 call->deopt_id());
+      new(isolate()) BinaryFloat32x4OpInstr(
+          op_kind, new(isolate()) Value(left), new(isolate()) Value(right),
+          call->deopt_id());
   ReplaceCall(call, float32x4_bin_op);
 
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineInt32x4BinaryOp(InstanceCallInstr* call,
                                                 Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left.
   AddCheckClass(left,
                 ICData::ZoneHandle(
-                    call->ic_data()->AsUnaryClassChecksForArgNr(0)),
+                    isolate(), call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   // Type check right.
   AddCheckClass(right,
-                ICData::ZoneHandle(
+                ICData::ZoneHandle(isolate(),
                     call->ic_data()->AsUnaryClassChecksForArgNr(1)),
                 call->deopt_id(),
                 call->env(),
                 call);
   // Replace call.
   BinaryInt32x4OpInstr* int32x4_bin_op =
-      new BinaryInt32x4OpInstr(op_kind, new Value(left), new Value(right),
-                                call->deopt_id());
+      new(isolate()) BinaryInt32x4OpInstr(
+          op_kind, new(isolate()) Value(left), new(isolate()) Value(right),
+          call->deopt_id());
   ReplaceCall(call, int32x4_bin_op);
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineFloat64x2BinaryOp(InstanceCallInstr* call,
                                                  Token::Kind op_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   ASSERT(call->ArgumentCount() == 2);
   Definition* left = call->ArgumentAt(0);
   Definition* right = call->ArgumentAt(1);
   // Type check left.
   AddCheckClass(left,
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                 call->deopt_id(),
                 call->env(),
                 call);
   // Type check right.
   AddCheckClass(right,
                 ICData::ZoneHandle(
                     call->ic_data()->AsUnaryClassChecksForArgNr(1)),
                 call->deopt_id(),
                 call->env(),
                 call);
   // Replace call.
   BinaryFloat64x2OpInstr* float64x2_bin_op =
-      new BinaryFloat64x2OpInstr(op_kind, new Value(left), new Value(right),
-                                 call->deopt_id());
+      new(isolate()) BinaryFloat64x2OpInstr(
+          op_kind, new(isolate()) Value(left), new(isolate()) Value(right),
+          call->deopt_id());
   ReplaceCall(call, float64x2_bin_op);
   return true;
 }
 
 
 // Only unique implicit instance getters can be currently handled.
 bool FlowGraphOptimizer::TryInlineInstanceGetter(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if (ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
 
   if (!ic_data.HasOneTarget()) {
     // Polymorphic sites are inlined like normal methods by conventional
     // inlining in FlowGraphInliner.
     return false;
   }
 
-  const Function& target = Function::Handle(ic_data.GetTargetAt(0));
+  const Function& target = Function::Handle(isolate(), ic_data.GetTargetAt(0));
   if (target.kind() != RawFunction::kImplicitGetter) {
     // Non-implicit getters are inlined like normal methods by conventional
     // inlining in FlowGraphInliner.
     return false;
   }
   InlineImplicitInstanceGetter(call);
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceInstanceCallWithInline(
     InstanceCallInstr* call) {
   ASSERT(call->HasICData());
-  Function& target = Function::Handle();
+  Function& target = Function::Handle(isolate(), Function::null());
   GrowableArray<intptr_t> class_ids;
   call->ic_data()->GetCheckAt(0, &class_ids, &target);
   const intptr_t receiver_cid = class_ids[0];
 
   TargetEntryInstr* entry;
   Definition* last;
   if (!TryInlineRecognizedMethod(receiver_cid,
                                  target,
                                  call,
                                  call->ArgumentAt(0),
@@ skipping 29 matching lines @@
 
 // Returns the LoadIndexedInstr.
 Definition* FlowGraphOptimizer::PrepareInlineStringIndexOp(
     Instruction* call,
     intptr_t cid,
     Definition* str,
     Definition* index,
     Instruction* cursor) {
 
   cursor = flow_graph()->AppendTo(cursor,
-                                  new CheckSmiInstr(new Value(index),
-                                                    call->deopt_id(),
-                                                    call->token_pos()),
+                                  new(isolate()) CheckSmiInstr(
+                                      new(isolate()) Value(index),
+                                      call->deopt_id(),
+                                      call->token_pos()),
                                   call->env(),
                                   FlowGraph::kEffect);
 
   // Load the length of the string.
   LoadFieldInstr* length = BuildLoadStringLength(str);
   cursor = flow_graph()->AppendTo(cursor, length, NULL, FlowGraph::kValue);
   // Bounds check.
   cursor = flow_graph()->AppendTo(cursor,
-                                   new CheckArrayBoundInstr(new Value(length),
-                                                            new Value(index),
-                                                            call->deopt_id()),
+                                   new(isolate()) CheckArrayBoundInstr(
+                                       new(isolate()) Value(length),
+                                       new(isolate()) Value(index),
+                                       call->deopt_id()),
                                    call->env(),
                                    FlowGraph::kEffect);
 
-  LoadIndexedInstr* load_indexed = new LoadIndexedInstr(
-      new Value(str),
-      new Value(index),
+  LoadIndexedInstr* load_indexed = new(isolate()) LoadIndexedInstr(
+      new(isolate()) Value(str),
+      new(isolate()) Value(index),
       FlowGraphCompiler::ElementSizeFor(cid),
       cid,
       Isolate::kNoDeoptId,
       call->token_pos());
 
   cursor = flow_graph()->AppendTo(cursor,
                                   load_indexed,
                                   NULL,
                                   FlowGraph::kValue);
   ASSERT(cursor == load_indexed);
   return load_indexed;
 }
 
 
 bool FlowGraphOptimizer::InlineStringCodeUnitAt(
     Instruction* call,
     intptr_t cid,
     TargetEntryInstr** entry,
     Definition** last) {
   // TODO(johnmccutchan): Handle external strings in PrepareInlineStringIndexOp.
   if (RawObject::IsExternalStringClassId(cid)) {
     return false;
   }
 
   Definition* str = call->ArgumentAt(0);
   Definition* index = call->ArgumentAt(1);
 
-  *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
-                                call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(call);
+  *entry = new(isolate()) TargetEntryInstr(flow_graph()->allocate_block_id(),
+                                           call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(isolate(), call);
 
   *last = PrepareInlineStringIndexOp(call, cid, str, index, *entry);
 
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineStringBaseCharAt(
     Instruction* call,
     intptr_t cid,
     TargetEntryInstr** entry,
     Definition** last) {
   // TODO(johnmccutchan): Handle external strings in PrepareInlineStringIndexOp.
   if (RawObject::IsExternalStringClassId(cid) || cid != kOneByteStringCid) {
     return false;
   }
   Definition* str = call->ArgumentAt(0);
   Definition* index = call->ArgumentAt(1);
 
-  *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
-                                call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(call);
+  *entry = new(isolate()) TargetEntryInstr(flow_graph()->allocate_block_id(),
+                                           call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(isolate(), call);
 
   *last = PrepareInlineStringIndexOp(call, cid, str, index, *entry);
 
-  StringFromCharCodeInstr* char_at =
-          new StringFromCharCodeInstr(new Value(*last), cid);
+  StringFromCharCodeInstr* char_at = new(isolate()) StringFromCharCodeInstr(
+      new(isolate()) Value(*last), cid);
 
   flow_graph()->AppendTo(*last, char_at, NULL, FlowGraph::kValue);
   *last = char_at;
 
   return true;
 }
 
 
 void FlowGraphOptimizer::ReplaceWithMathCFunction(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   AddReceiverCheck(call);
   ZoneGrowableArray<Value*>* args =
-      new ZoneGrowableArray<Value*>(call->ArgumentCount());
+      new(isolate()) ZoneGrowableArray<Value*>(call->ArgumentCount());
   for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
-    args->Add(new Value(call->ArgumentAt(i)));
+    args->Add(new(isolate()) Value(call->ArgumentAt(i)));
   }
   InvokeMathCFunctionInstr* invoke =
-      new InvokeMathCFunctionInstr(args,
-                                   call->deopt_id(),
-                                   recognized_kind,
-                                   call->token_pos());
+      new(isolate()) InvokeMathCFunctionInstr(args,
+                                              call->deopt_id(),
+                                              recognized_kind,
+                                              call->token_pos());
   ReplaceCall(call, invoke);
 }
 
 
 static bool IsSupportedByteArrayViewCid(intptr_t cid) {
   switch (cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
@@ skipping 15 matching lines @@
 
 // Inline only simple, frequently called core library methods.
 bool FlowGraphOptimizer::TryInlineInstanceMethod(InstanceCallInstr* call) {
   ASSERT(call->HasICData());
   const ICData& ic_data = *call->ic_data();
   if ((ic_data.NumberOfChecks() == 0) || !ic_data.HasOneTarget()) {
     // No type feedback collected or multiple targets found.
     return false;
   }
 
-  Function& target = Function::Handle();
+  Function& target = Function::Handle(isolate(), Function::null());
   GrowableArray<intptr_t> class_ids;
   ic_data.GetCheckAt(0, &class_ids, &target);
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(target);
 
   if ((recognized_kind == MethodRecognizer::kGrowableArraySetData) &&
       (ic_data.NumberOfChecks() == 1) &&
       (class_ids[0] == kGrowableObjectArrayCid)) {
     // This is an internal method, no need to check argument types.
     Definition* array = call->ArgumentAt(0);
     Definition* value = call->ArgumentAt(1);
-    StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
+    StoreInstanceFieldInstr* store = new(isolate()) StoreInstanceFieldInstr(
         GrowableObjectArray::data_offset(),
-        new Value(array),
-        new Value(value),
+        new(isolate()) Value(array),
+        new(isolate()) Value(value),
         kEmitStoreBarrier,
         call->token_pos());
     ReplaceCall(call, store);
     return true;
   }
 
   if ((recognized_kind == MethodRecognizer::kGrowableArraySetLength) &&
       (ic_data.NumberOfChecks() == 1) &&
       (class_ids[0] == kGrowableObjectArrayCid)) {
     // This is an internal method, no need to check argument types nor
     // range.
     Definition* array = call->ArgumentAt(0);
     Definition* value = call->ArgumentAt(1);
-    StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
+    StoreInstanceFieldInstr* store = new(isolate()) StoreInstanceFieldInstr(
         GrowableObjectArray::length_offset(),
-        new Value(array),
-        new Value(value),
+        new(isolate()) Value(array),
+        new(isolate()) Value(value),
         kEmitStoreBarrier,
         call->token_pos());
     ReplaceCall(call, store);
     return true;
   }
 
   if (((recognized_kind == MethodRecognizer::kStringBaseCodeUnitAt) ||
        (recognized_kind == MethodRecognizer::kStringBaseCharAt)) &&
       (ic_data.NumberOfChecks() == 1) &&
       ((class_ids[0] == kOneByteStringCid) ||
        (class_ids[0] == kTwoByteStringCid))) {
     return TryReplaceInstanceCallWithInline(call);
   }
 
   if ((class_ids[0] == kOneByteStringCid) && (ic_data.NumberOfChecks() == 1)) {
     if (recognized_kind == MethodRecognizer::kOneByteStringSetAt) {
       // This is an internal method, no need to check argument types nor
       // range.
       Definition* str = call->ArgumentAt(0);
       Definition* index = call->ArgumentAt(1);
       Definition* value = call->ArgumentAt(2);
-      StoreIndexedInstr* store_op = new StoreIndexedInstr(
-          new Value(str),
-          new Value(index),
-          new Value(value),
+      StoreIndexedInstr* store_op = new(isolate()) StoreIndexedInstr(
+          new(isolate()) Value(str),
+          new(isolate()) Value(index),
+          new(isolate()) Value(value),
           kNoStoreBarrier,
           1,  // Index scale
           kOneByteStringCid,
           call->deopt_id(),
           call->token_pos());
       ReplaceCall(call, store_op);
       return true;
     }
     return false;
   }
 
   if (CanUnboxDouble() &&
       (recognized_kind == MethodRecognizer::kIntegerToDouble) &&
       (ic_data.NumberOfChecks() == 1) &&
       (class_ids[0] == kSmiCid)) {
     AddReceiverCheck(call);
     ReplaceCall(call,
-                new SmiToDoubleInstr(new Value(call->ArgumentAt(0)),
-                                     call->token_pos()));
+                new(isolate()) SmiToDoubleInstr(
+                    new(isolate()) Value(call->ArgumentAt(0)),
+                    call->token_pos()));
     return true;
   }
 
   if (class_ids[0] == kDoubleCid) {
     if (!CanUnboxDouble()) {
       return false;
     }
     switch (recognized_kind) {
       case MethodRecognizer::kDoubleToInteger: {
         AddReceiverCheck(call);
         ASSERT(call->HasICData());
         const ICData& ic_data = *call->ic_data();
         Definition* input = call->ArgumentAt(0);
         Definition* d2i_instr = NULL;
         if (ic_data.HasDeoptReason(ICData::kDeoptDoubleToSmi)) {
           // Do not repeatedly deoptimize because result didn't fit into Smi.
-          d2i_instr = new DoubleToIntegerInstr(new Value(input), call);
+          d2i_instr =  new(isolate()) DoubleToIntegerInstr(
+              new(isolate()) Value(input), call);
         } else {
           // Optimistically assume result fits into Smi.
-          d2i_instr = new DoubleToSmiInstr(new Value(input), call->deopt_id());
+          d2i_instr = new(isolate()) DoubleToSmiInstr(
+              new(isolate()) Value(input), call->deopt_id());
         }
         ReplaceCall(call, d2i_instr);
         return true;
       }
       case MethodRecognizer::kDoubleMod:
       case MethodRecognizer::kDoubleRound:
         ReplaceWithMathCFunction(call, recognized_kind);
         return true;
       case MethodRecognizer::kDoubleTruncate:
       case MethodRecognizer::kDoubleFloor:
       case MethodRecognizer::kDoubleCeil:
         if (!TargetCPUFeatures::double_truncate_round_supported()) {
           ReplaceWithMathCFunction(call, recognized_kind);
         } else {
           AddReceiverCheck(call);
           DoubleToDoubleInstr* d2d_instr =
-              new DoubleToDoubleInstr(new Value(call->ArgumentAt(0)),
-                                      recognized_kind, call->deopt_id());
+              new(isolate()) DoubleToDoubleInstr(
+                  new(isolate()) Value(call->ArgumentAt(0)),
+                  recognized_kind, call->deopt_id());
           ReplaceCall(call, d2d_instr);
         }
         return true;
       default:
         // Unsupported method.
         return false;
     }
   }
 
   if (IsSupportedByteArrayViewCid(class_ids[0]) &&
@@ skipping 96 matching lines @@
       ASSERT(int32_mask->IsConstant());
       const Integer& mask_literal = Integer::Cast(
           int32_mask->AsConstant()->value());
       const int64_t mask_value = mask_literal.AsInt64Value();
       ASSERT(mask_value >= 0);
       if (mask_value > Smi::kMaxValue) {
         // The result will not be Smi.
         return false;
       }
       BinarySmiOpInstr* left_shift =
-          new BinarySmiOpInstr(Token::kSHL,
-                               new Value(value), new Value(count),
-                               call->deopt_id(), call->token_pos());
+          new(isolate()) BinarySmiOpInstr(Token::kSHL,
+                                          new(isolate()) Value(value),
+                                          new(isolate()) Value(count),
+                                          call->deopt_id(), call->token_pos());
       left_shift->set_is_truncating(true);
       if ((kBitsPerWord == 32) && (mask_value == 0xffffffffLL)) {
         // No BIT_AND operation needed.
         ReplaceCall(call, left_shift);
       } else {
         InsertBefore(call, left_shift, call->env(), FlowGraph::kValue);
         BinarySmiOpInstr* bit_and =
-            new BinarySmiOpInstr(Token::kBIT_AND,
-                                 new Value(left_shift), new Value(int32_mask),
-                                 call->deopt_id(), call->token_pos());
+            new(isolate()) BinarySmiOpInstr(Token::kBIT_AND,
+                                            new(isolate()) Value(left_shift),
+                                            new(isolate()) Value(int32_mask),
+                                            call->deopt_id(),
+                                            call->token_pos());
         ReplaceCall(call, bit_and);
       }
       return true;
     }
 
     if (HasTwoMintOrSmi(ic_data) &&
-        HasOnlyOneSmi(ICData::Handle(ic_data.AsUnaryClassChecksForArgNr(1)))) {
+        HasOnlyOneSmi(ICData::Handle(isolate(),
+                                     ic_data.AsUnaryClassChecksForArgNr(1)))) {
       if (!FlowGraphCompiler::SupportsUnboxedMints() ||
           ic_data.HasDeoptReason(ICData::kDeoptShiftMintOp)) {
         return false;
       }
       ShiftMintOpInstr* left_shift =
-          new ShiftMintOpInstr(Token::kSHL,
-                               new Value(value), new Value(count),
-                               call->deopt_id());
+          new(isolate()) ShiftMintOpInstr(Token::kSHL,
+                                          new(isolate()) Value(value),
+                                          new(isolate()) Value(count),
+                                          call->deopt_id());
       InsertBefore(call, left_shift, call->env(), FlowGraph::kValue);
       BinaryMintOpInstr* bit_and =
-          new BinaryMintOpInstr(Token::kBIT_AND,
-                                new Value(left_shift), new Value(int32_mask),
-                                call->deopt_id());
+          new(isolate()) BinaryMintOpInstr(Token::kBIT_AND,
+                                           new(isolate()) Value(left_shift),
+                                           new(isolate()) Value(int32_mask),
+                                           call->deopt_id());
       ReplaceCall(call, bit_and);
       return true;
     }
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   if (recognized_kind == MethodRecognizer::kFloat32x4Zero) {
-    Float32x4ZeroInstr* zero = new Float32x4ZeroInstr(call->deopt_id());
+    Float32x4ZeroInstr* zero =
+        new(isolate()) Float32x4ZeroInstr(call->deopt_id());
     ReplaceCall(call, zero);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat32x4Splat) {
     Float32x4SplatInstr* splat =
-        new Float32x4SplatInstr(new Value(call->ArgumentAt(1)),
-                                call->deopt_id());
+        new(isolate()) Float32x4SplatInstr(
+            new(isolate()) Value(call->ArgumentAt(1)), call->deopt_id());
     ReplaceCall(call, splat);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat32x4Constructor) {
     Float32x4ConstructorInstr* con =
-        new Float32x4ConstructorInstr(new Value(call->ArgumentAt(1)),
-                                      new Value(call->ArgumentAt(2)),
-                                      new Value(call->ArgumentAt(3)),
-                                      new Value(call->ArgumentAt(4)),
-                                      call->deopt_id());
+        new(isolate()) Float32x4ConstructorInstr(
+            new(isolate()) Value(call->ArgumentAt(1)),
+            new(isolate()) Value(call->ArgumentAt(2)),
+            new(isolate()) Value(call->ArgumentAt(3)),
+            new(isolate()) Value(call->ArgumentAt(4)),
+            call->deopt_id());
     ReplaceCall(call, con);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat32x4FromInt32x4Bits) {
     Int32x4ToFloat32x4Instr* cast =
-        new Int32x4ToFloat32x4Instr(new Value(call->ArgumentAt(1)),
-                                    call->deopt_id());
+        new(isolate()) Int32x4ToFloat32x4Instr(
+            new(isolate()) Value(call->ArgumentAt(1)), call->deopt_id());
     ReplaceCall(call, cast);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat32x4FromFloat64x2) {
     Float64x2ToFloat32x4Instr* cast =
-        new Float64x2ToFloat32x4Instr(new Value(call->ArgumentAt(1)),
-                                      call->deopt_id());
+        new(isolate()) Float64x2ToFloat32x4Instr(
+            new(isolate()) Value(call->ArgumentAt(1)), call->deopt_id());
     ReplaceCall(call, cast);
     return true;
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat64x2Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   if (recognized_kind == MethodRecognizer::kFloat64x2Zero) {
-    Float64x2ZeroInstr* zero = new Float64x2ZeroInstr(call->deopt_id());
+    Float64x2ZeroInstr* zero =
+        new(isolate()) Float64x2ZeroInstr(call->deopt_id());
     ReplaceCall(call, zero);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat64x2Splat) {
     Float64x2SplatInstr* splat =
-        new Float64x2SplatInstr(new Value(call->ArgumentAt(1)),
-                                call->deopt_id());
+        new(isolate()) Float64x2SplatInstr(
+            new(isolate()) Value(call->ArgumentAt(1)), call->deopt_id());
     ReplaceCall(call, splat);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat64x2Constructor) {
     Float64x2ConstructorInstr* con =
-        new Float64x2ConstructorInstr(new Value(call->ArgumentAt(1)),
-                                      new Value(call->ArgumentAt(2)),
-                                      call->deopt_id());
+        new(isolate()) Float64x2ConstructorInstr(
+            new(isolate()) Value(call->ArgumentAt(1)),
+            new(isolate()) Value(call->ArgumentAt(2)),
+            call->deopt_id());
     ReplaceCall(call, con);
     return true;
   } else if (recognized_kind == MethodRecognizer::kFloat64x2FromFloat32x4) {
     Float32x4ToFloat64x2Instr* cast =
-        new Float32x4ToFloat64x2Instr(new Value(call->ArgumentAt(1)),
-                                    call->deopt_id());
+        new(isolate()) Float32x4ToFloat64x2Instr(
+            new(isolate()) Value(call->ArgumentAt(1)), call->deopt_id());
     ReplaceCall(call, cast);
     return true;
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineInt32x4Constructor(
     StaticCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
   if (!ShouldInlineSimd()) {
     return false;
   }
   if (recognized_kind == MethodRecognizer::kInt32x4BoolConstructor) {
-    Int32x4BoolConstructorInstr* con = new Int32x4BoolConstructorInstr(
-        new Value(call->ArgumentAt(1)),
-        new Value(call->ArgumentAt(2)),
-        new Value(call->ArgumentAt(3)),
-        new Value(call->ArgumentAt(4)),
-        call->deopt_id());
+    Int32x4BoolConstructorInstr* con =
+        new(isolate()) Int32x4BoolConstructorInstr(
+            new(isolate()) Value(call->ArgumentAt(1)),
+            new(isolate()) Value(call->ArgumentAt(2)),
+            new(isolate()) Value(call->ArgumentAt(3)),
+            new(isolate()) Value(call->ArgumentAt(4)),
+            call->deopt_id());
     ReplaceCall(call, con);
     return true;
   } else if (recognized_kind == MethodRecognizer::kInt32x4FromFloat32x4Bits) {
     Float32x4ToInt32x4Instr* cast =
-        new Float32x4ToInt32x4Instr(new Value(call->ArgumentAt(1)),
-                                     call->deopt_id());
+        new(isolate()) Float32x4ToInt32x4Instr(
+            new(isolate()) Value(call->ArgumentAt(1)), call->deopt_id());
     ReplaceCall(call, cast);
     return true;
   }
   return false;
 }
 
 
 bool FlowGraphOptimizer::TryInlineFloat32x4Method(
     InstanceCallInstr* call,
     MethodRecognizer::Kind recognized_kind) {
@@ skipping 15 matching lines @@
     case MethodRecognizer::kFloat32x4GreaterThan:
     case MethodRecognizer::kFloat32x4GreaterThanOrEqual:
     case MethodRecognizer::kFloat32x4LessThan:
     case MethodRecognizer::kFloat32x4LessThanOrEqual:
     case MethodRecognizer::kFloat32x4NotEqual: {
       Definition* left = call->ArgumentAt(0);
       Definition* right = call->ArgumentAt(1);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       // Replace call.
       Float32x4ComparisonInstr* cmp =
-          new Float32x4ComparisonInstr(recognized_kind, new Value(left),
-                                       new Value(right), call->deopt_id());
+          new(isolate()) Float32x4ComparisonInstr(
+              recognized_kind,
+              new(isolate()) Value(left),
+              new(isolate()) Value(right),
+              call->deopt_id());
       ReplaceCall(call, cmp);
       return true;
     }
     case MethodRecognizer::kFloat32x4Min:
     case MethodRecognizer::kFloat32x4Max: {
       Definition* left = call->ArgumentAt(0);
       Definition* right = call->ArgumentAt(1);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4MinMaxInstr* minmax =
-          new Float32x4MinMaxInstr(recognized_kind, new Value(left),
-                                   new Value(right), call->deopt_id());
+          new(isolate()) Float32x4MinMaxInstr(
+              recognized_kind,
+              new(isolate()) Value(left),
+              new(isolate()) Value(right),
+              call->deopt_id());
       ReplaceCall(call, minmax);
       return true;
     }
     case MethodRecognizer::kFloat32x4Scale: {
       Definition* left = call->ArgumentAt(0);
       Definition* right = call->ArgumentAt(1);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       // Left and right values are swapped when handed to the instruction,
       // this is done so that the double value is loaded into the output
       // register and can be destroyed.
       Float32x4ScaleInstr* scale =
-          new Float32x4ScaleInstr(recognized_kind, new Value(right),
-                                  new Value(left), call->deopt_id());
+          new(isolate()) Float32x4ScaleInstr(
+              recognized_kind,
+              new(isolate()) Value(right),
+              new(isolate()) Value(left),
+              call->deopt_id());
       ReplaceCall(call, scale);
       return true;
     }
     case MethodRecognizer::kFloat32x4Sqrt:
     case MethodRecognizer::kFloat32x4ReciprocalSqrt:
     case MethodRecognizer::kFloat32x4Reciprocal: {
       Definition* left = call->ArgumentAt(0);
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4SqrtInstr* sqrt =
-          new Float32x4SqrtInstr(recognized_kind, new Value(left),
-                                 call->deopt_id());
+          new(isolate()) Float32x4SqrtInstr(
+              recognized_kind,
+              new(isolate()) Value(left),
+              call->deopt_id());
       ReplaceCall(call, sqrt);
       return true;
     }
     case MethodRecognizer::kFloat32x4WithX:
     case MethodRecognizer::kFloat32x4WithY:
     case MethodRecognizer::kFloat32x4WithZ:
     case MethodRecognizer::kFloat32x4WithW: {
       Definition* left = call->ArgumentAt(0);
       Definition* right = call->ArgumentAt(1);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
-      Float32x4WithInstr* with = new Float32x4WithInstr(recognized_kind,
-                                                        new Value(left),
-                                                        new Value(right),
-                                                        call->deopt_id());
+      Float32x4WithInstr* with = new(isolate()) Float32x4WithInstr(
+          recognized_kind,
+          new(isolate()) Value(left),
+          new(isolate()) Value(right),
+          call->deopt_id());
       ReplaceCall(call, with);
       return true;
     }
     case MethodRecognizer::kFloat32x4Absolute:
     case MethodRecognizer::kFloat32x4Negate: {
       Definition* left = call->ArgumentAt(0);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float32x4ZeroArgInstr* zeroArg =
-          new Float32x4ZeroArgInstr(recognized_kind, new Value(left),
-                                    call->deopt_id());
+          new(isolate()) Float32x4ZeroArgInstr(
+              recognized_kind, new(isolate()) Value(left), call->deopt_id());
       ReplaceCall(call, zeroArg);
       return true;
     }
     case MethodRecognizer::kFloat32x4Clamp: {
       Definition* left = call->ArgumentAt(0);
       Definition* lower = call->ArgumentAt(1);
       Definition* upper = call->ArgumentAt(2);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
-      Float32x4ClampInstr* clamp = new Float32x4ClampInstr(new Value(left),
-                                                           new Value(lower),
-                                                           new Value(upper),
-                                                           call->deopt_id());
+      Float32x4ClampInstr* clamp = new(isolate()) Float32x4ClampInstr(
+          new(isolate()) Value(left),
+          new(isolate()) Value(lower),
+          new(isolate()) Value(upper),
+          call->deopt_id());
       ReplaceCall(call, clamp);
       return true;
     }
     case MethodRecognizer::kFloat32x4ShuffleMix:
     case MethodRecognizer::kFloat32x4Shuffle: {
       return InlineFloat32x4Getter(call, recognized_kind);
     }
     default:
       return false;
   }
@@ skipping 14 matching lines @@
       ASSERT(call->ic_data()->HasOneTarget());
       return InlineFloat64x2Getter(call, recognized_kind);
     case MethodRecognizer::kFloat64x2Negate:
     case MethodRecognizer::kFloat64x2Abs:
     case MethodRecognizer::kFloat64x2Sqrt:
     case MethodRecognizer::kFloat64x2GetSignMask: {
       Definition* left = call->ArgumentAt(0);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float64x2ZeroArgInstr* zeroArg =
-          new Float64x2ZeroArgInstr(recognized_kind, new Value(left),
-                                    call->deopt_id());
+          new(isolate()) Float64x2ZeroArgInstr(
+              recognized_kind, new(isolate()) Value(left), call->deopt_id());
       ReplaceCall(call, zeroArg);
       return true;
     }
     case MethodRecognizer::kFloat64x2Scale:
     case MethodRecognizer::kFloat64x2WithX:
     case MethodRecognizer::kFloat64x2WithY:
     case MethodRecognizer::kFloat64x2Min:
     case MethodRecognizer::kFloat64x2Max: {
       Definition* left = call->ArgumentAt(0);
       Definition* right = call->ArgumentAt(1);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
       Float64x2OneArgInstr* zeroArg =
-          new Float64x2OneArgInstr(recognized_kind, new Value(left),
-                                   new Value(right), call->deopt_id());
+          new(isolate()) Float64x2OneArgInstr(
+              recognized_kind,
+              new(isolate()) Value(left),
+              new(isolate()) Value(right),
+              call->deopt_id());
       ReplaceCall(call, zeroArg);
       return true;
     }
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::TryInlineInt32x4Method(
@@ skipping 15 matching lines @@
       ASSERT(call->ic_data()->HasOneTarget());
       return InlineInt32x4Getter(call, recognized_kind);
 
     case MethodRecognizer::kInt32x4Select: {
       Definition* mask = call->ArgumentAt(0);
       Definition* trueValue = call->ArgumentAt(1);
       Definition* falseValue = call->ArgumentAt(2);
       // Type check left.
       AddCheckClass(mask,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
-      Int32x4SelectInstr* select = new Int32x4SelectInstr(
-          new Value(mask),
-          new Value(trueValue),
-          new Value(falseValue),
+      Int32x4SelectInstr* select = new(isolate()) Int32x4SelectInstr(
+          new(isolate()) Value(mask),
+          new(isolate()) Value(trueValue),
+          new(isolate()) Value(falseValue),
           call->deopt_id());
       ReplaceCall(call, select);
       return true;
     }
     case MethodRecognizer::kInt32x4WithFlagX:
     case MethodRecognizer::kInt32x4WithFlagY:
     case MethodRecognizer::kInt32x4WithFlagZ:
     case MethodRecognizer::kInt32x4WithFlagW: {
       Definition* left = call->ArgumentAt(0);
       Definition* flag = call->ArgumentAt(1);
       // Type check left.
       AddCheckClass(left,
                     ICData::ZoneHandle(
+                        isolate(),
                         call->ic_data()->AsUnaryClassChecksForArgNr(0)),
                     call->deopt_id(),
                     call->env(),
                     call);
-      Int32x4SetFlagInstr* setFlag = new Int32x4SetFlagInstr(
+      Int32x4SetFlagInstr* setFlag = new(isolate()) Int32x4SetFlagInstr(
           recognized_kind,
-          new Value(left),
-          new Value(flag),
+          new(isolate()) Value(left),
+          new(isolate()) Value(flag),
           call->deopt_id());
       ReplaceCall(call, setFlag);
       return true;
     }
     default:
       return false;
   }
 }
 
 
 bool FlowGraphOptimizer::InlineByteArrayViewLoad(Instruction* call,
                                                  Definition* receiver,
                                                  intptr_t array_cid,
                                                  intptr_t view_cid,
                                                  const ICData& ic_data,
                                                  TargetEntryInstr** entry,
                                                  Definition** last) {
   ASSERT(array_cid != kIllegalCid);
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
-  *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
-                                call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(call);
+  *entry = new(isolate()) TargetEntryInstr(flow_graph()->allocate_block_id(),
+                                           call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(isolate(), call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineByteArrayViewOp(call,
                                            array_cid,
                                            view_cid,
                                            &array,
                                            index,
                                            &cursor);
 
   intptr_t deopt_id = Isolate::kNoDeoptId;
   if ((array_cid == kTypedDataInt32ArrayCid) ||
       (array_cid == kTypedDataUint32ArrayCid)) {
     // Set deopt_id if we can optimistically assume that the result is Smi.
     // Assume mixed Mint/Smi if this instruction caused deoptimization once.
     deopt_id = ic_data.HasDeoptReasons() ?
         Isolate::kNoDeoptId : call->deopt_id();
   }
 
-  *last = new LoadIndexedInstr(new Value(array),
-                               new Value(index),
-                               1,
-                               view_cid,
-                               deopt_id,
-                               call->token_pos());
+  *last = new(isolate()) LoadIndexedInstr(new(isolate()) Value(array),
+                                          new(isolate()) Value(index),
+                                          1,
+                                          view_cid,
+                                          deopt_id,
+                                          call->token_pos());
   cursor = flow_graph()->AppendTo(
       cursor,
       *last,
       deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
       FlowGraph::kValue);
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
-    *last = new FloatToDoubleInstr(new Value(*last), deopt_id);
+    *last = new(isolate()) FloatToDoubleInstr(
+        new(isolate()) Value(*last), deopt_id);
     flow_graph()->AppendTo(cursor,
                            *last,
                            deopt_id != Isolate::kNoDeoptId ? call->env() : NULL,
                            FlowGraph::kValue);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::InlineByteArrayViewStore(const Function& target,
                                                   Instruction* call,
                                                   Definition* receiver,
                                                   intptr_t array_cid,
                                                   intptr_t view_cid,
                                                   const ICData& ic_data,
                                                   TargetEntryInstr** entry,
                                                   Definition** last) {
   ASSERT(array_cid != kIllegalCid);
   Definition* array = receiver;
   Definition* index = call->ArgumentAt(1);
-  *entry = new TargetEntryInstr(flow_graph()->allocate_block_id(),
-                                call->GetBlock()->try_index());
-  (*entry)->InheritDeoptTarget(call);
+  *entry = new(isolate()) TargetEntryInstr(flow_graph()->allocate_block_id(),
+                                           call->GetBlock()->try_index());
+  (*entry)->InheritDeoptTarget(isolate(), call);
   Instruction* cursor = *entry;
 
   array_cid = PrepareInlineByteArrayViewOp(call,
                                            array_cid,
                                            view_cid,
                                            &array,
                                            index,
                                            &cursor);
 
   // Extract the instance call so we can use the function_name in the stored
   // value check ICData.
   InstanceCallInstr* i_call = NULL;
   if (call->IsPolymorphicInstanceCall()) {
     i_call = call->AsPolymorphicInstanceCall()->instance_call();
   } else {
     ASSERT(call->IsInstanceCall());
     i_call = call->AsInstanceCall();
   }
   ASSERT(i_call != NULL);
-  ICData& value_check = ICData::ZoneHandle();
+  ICData& value_check = ICData::ZoneHandle(isolate(), ICData::null());
   switch (view_cid) {
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid:
     case kExternalTypedDataUint8ArrayCid:
     case kExternalTypedDataUint8ClampedArrayCid:
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       // Check that value is always smi.
       value_check = ICData::New(flow_graph_->parsed_function().function(),
@@ skipping 54 matching lines @@
       UNREACHABLE();
   }
 
   Definition* stored_value = call->ArgumentAt(2);
   if (!value_check.IsNull()) {
     AddCheckClass(stored_value, value_check, call->deopt_id(), call->env(),
                   call);
   }
 
   if (view_cid == kTypedDataFloat32ArrayCid) {
-    stored_value =
-        new DoubleToFloatInstr(new Value(stored_value), call->deopt_id());
+    stored_value = new(isolate()) DoubleToFloatInstr(
+        new(isolate()) Value(stored_value), call->deopt_id());
     cursor = flow_graph()->AppendTo(cursor,
                                     stored_value,
                                     NULL,
                                     FlowGraph::kValue);
   }
 
   StoreBarrierType needs_store_barrier = kNoStoreBarrier;
-  *last = new StoreIndexedInstr(new Value(array),
-                                new Value(index),
-                                new Value(stored_value),
-                                needs_store_barrier,
-                                1,  // Index scale
-                                view_cid,
-                                call->deopt_id(),
-                                call->token_pos());
+  *last = new(isolate()) StoreIndexedInstr(new(isolate()) Value(array),
+                                           new(isolate()) Value(index),
+                                           new(isolate()) Value(stored_value),
+                                           needs_store_barrier,
+                                           1,  // Index scale
+                                           view_cid,
+                                           call->deopt_id(),
+                                           call->token_pos());
 
   flow_graph()->AppendTo(cursor,
                          *last,
                          call->deopt_id() != Isolate::kNoDeoptId ?
                             call->env() : NULL,
                          FlowGraph::kEffect);
   return true;
 }
 
 
 
 intptr_t FlowGraphOptimizer::PrepareInlineByteArrayViewOp(
     Instruction* call,
     intptr_t array_cid,
     intptr_t view_cid,
     Definition** array,
     Definition* byte_index,
     Instruction** cursor) {
   // Insert byte_index smi check.
   *cursor = flow_graph()->AppendTo(*cursor,
-                                   new CheckSmiInstr(new Value(byte_index),
-                                                     call->deopt_id(),
-                                                     call->token_pos()),
+                                   new(isolate()) CheckSmiInstr(
+                                       new(isolate()) Value(byte_index),
+                                       call->deopt_id(),
+                                       call->token_pos()),
                                    call->env(),
                                    FlowGraph::kEffect);
 
   LoadFieldInstr* length =
-      new LoadFieldInstr(new Value(*array),
-                         CheckArrayBoundInstr::LengthOffsetFor(array_cid),
-                         Type::ZoneHandle(Type::SmiType()),
-                         call->token_pos());
+      new(isolate()) LoadFieldInstr(
+          new(isolate()) Value(*array),
+          CheckArrayBoundInstr::LengthOffsetFor(array_cid),
+          Type::ZoneHandle(isolate(), Type::SmiType()),
+          call->token_pos());
   length->set_is_immutable(true);
   length->set_result_cid(kSmiCid);
   length->set_recognized_kind(
       LoadFieldInstr::RecognizedKindFromArrayCid(array_cid));
   *cursor = flow_graph()->AppendTo(*cursor,
                                    length,
                                    NULL,
                                    FlowGraph::kValue);
 
   intptr_t element_size = FlowGraphCompiler::ElementSizeFor(array_cid);
   ConstantInstr* bytes_per_element =
-      flow_graph()->GetConstant(Smi::Handle(Smi::New(element_size)));
+      flow_graph()->GetConstant(Smi::Handle(isolate(), Smi::New(element_size)));
   BinarySmiOpInstr* len_in_bytes =
-      new BinarySmiOpInstr(Token::kMUL,
-                           new Value(length),
-                           new Value(bytes_per_element),
-                           call->deopt_id(), call->token_pos());
+      new(isolate()) BinarySmiOpInstr(Token::kMUL,
+                                      new(isolate()) Value(length),
+                                      new(isolate()) Value(bytes_per_element),
+                                      call->deopt_id(), call->token_pos());
   *cursor = flow_graph()->AppendTo(*cursor, len_in_bytes, call->env(),
                                    FlowGraph::kValue);
 
   ConstantInstr* length_adjustment =
-      flow_graph()->GetConstant(Smi::Handle(Smi::New(
+      flow_graph()->GetConstant(Smi::Handle(isolate(), Smi::New(
           FlowGraphCompiler::ElementSizeFor(view_cid) - 1)));
   // adjusted_length = len_in_bytes - (element_size - 1).
   BinarySmiOpInstr* adjusted_length =
-      new BinarySmiOpInstr(Token::kSUB,
-                           new Value(len_in_bytes),
-                           new Value(length_adjustment),
-                           call->deopt_id(), call->token_pos());
+      new(isolate()) BinarySmiOpInstr(Token::kSUB,
+                                      new(isolate()) Value(len_in_bytes),
+                                      new(isolate()) Value(length_adjustment),
+                                      call->deopt_id(), call->token_pos());
   *cursor = flow_graph()->AppendTo(*cursor, adjusted_length, call->env(),
                                    FlowGraph::kValue);
 
   // Check adjusted_length > 0.
-  ConstantInstr* zero = flow_graph()->GetConstant(Smi::Handle(Smi::New(0)));
+  ConstantInstr* zero =
+      flow_graph()->GetConstant(Smi::Handle(isolate(), Smi::New(0)));
   *cursor = flow_graph()->AppendTo(*cursor,
-                                   new CheckArrayBoundInstr(
-                                       new Value(adjusted_length),
-                                       new Value(zero),
+                                   new(isolate()) CheckArrayBoundInstr(
+                                       new(isolate()) Value(adjusted_length),
+                                       new(isolate()) Value(zero),
                                        call->deopt_id()),
                                    call->env(),
                                    FlowGraph::kEffect);
   // Check 0 <= byte_index < adjusted_length.
   *cursor = flow_graph()->AppendTo(*cursor,
-                                   new CheckArrayBoundInstr(
-                                       new Value(adjusted_length),
-                                       new Value(byte_index),
+                                   new(isolate()) CheckArrayBoundInstr(
+                                       new(isolate()) Value(adjusted_length),
+                                       new(isolate()) Value(byte_index),
                                        call->deopt_id()),
                                    call->env(),
                                    FlowGraph::kEffect);
 
   if (RawObject::IsExternalTypedDataClassId(array_cid)) {
     LoadUntaggedInstr* elements =
-        new LoadUntaggedInstr(new Value(*array),
-                              ExternalTypedData::data_offset());
+        new(isolate()) LoadUntaggedInstr(new(isolate()) Value(*array),
+                                         ExternalTypedData::data_offset());
     *cursor = flow_graph()->AppendTo(*cursor,
                                      elements,
                                      NULL,
                                      FlowGraph::kValue);
     *array = elements;
   }
   return array_cid;
 }
 
 
@@ skipping 37 matching lines @@
 // check.
 RawBool* FlowGraphOptimizer::InstanceOfAsBool(
     const ICData& ic_data,
     const AbstractType& type,
     ZoneGrowableArray<intptr_t>* results) const {
   ASSERT(results->is_empty());
   ASSERT(ic_data.NumArgsTested() == 1);  // Unary checks only.
   if (!type.IsInstantiated() || type.IsMalformedOrMalbounded()) {
     return Bool::null();
   }
-  const Class& type_class = Class::Handle(type.type_class());
+  const Class& type_class = Class::Handle(isolate(), type.type_class());
   const intptr_t num_type_args = type_class.NumTypeArguments();
   if (num_type_args > 0) {
     // Only raw types can be directly compared, thus disregarding type
     // arguments.
     const intptr_t num_type_params = type_class.NumTypeParameters();
     const intptr_t from_index = num_type_args - num_type_params;
     const TypeArguments& type_arguments =
-        TypeArguments::Handle(type.arguments());
+        TypeArguments::Handle(isolate(), type.arguments());
     const bool is_raw_type = type_arguments.IsNull() ||
         type_arguments.IsRaw(from_index, num_type_params);
     if (!is_raw_type) {
       // Unknown result.
       return Bool::null();
     }
   }
 
-  const ClassTable& class_table = *Isolate::Current()->class_table();
-  Bool& prev = Bool::Handle();
-  Class& cls = Class::Handle();
+  const ClassTable& class_table = *isolate()->class_table();
+  Bool& prev = Bool::Handle(isolate(), Bool::null());
+  Class& cls = Class::Handle(isolate(), Class::null());
 
   bool results_differ = false;
   for (int i = 0; i < ic_data.NumberOfChecks(); i++) {
     cls = class_table.At(ic_data.GetReceiverClassIdAt(i));
     if (cls.NumTypeArguments() > 0) {
       return Bool::null();
     }
-    const bool is_subtype = cls.IsSubtypeOf(TypeArguments::Handle(),
-                                            type_class,
-                                            TypeArguments::Handle(),
-                                            NULL);
+    const bool is_subtype = cls.IsSubtypeOf(
+        TypeArguments::Handle(isolate(), TypeArguments::null()),
+        type_class,
+        TypeArguments::Handle(isolate(), TypeArguments::null()),
+        NULL);
     results->Add(cls.id());
     results->Add(is_subtype);
     if (prev.IsNull()) {
       prev = Bool::Get(is_subtype).raw();
     } else {
       if (is_subtype != prev.value()) {
         results_differ = true;
       }
     }
   }
@@ skipping 90 matching lines @@
 void FlowGraphOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeTestOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* instantiator = call->ArgumentAt(1);
   Definition* type_args = call->ArgumentAt(2);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value());
   const bool negate = Bool::Cast(
       call->ArgumentAt(4)->OriginalDefinition()->AsConstant()->value()).value();
   const ICData& unary_checks =
-      ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks());
+      ICData::ZoneHandle(isolate(), call->ic_data()->AsUnaryClassChecks());
   if (FLAG_warn_on_javascript_compatibility &&
       !unary_checks.IssuedJSWarning() &&
       (type.IsIntType() || type.IsDoubleType() || !type.IsInstantiated())) {
     // No warning was reported yet for this type check, either because it has
     // not been executed yet, or because no problematic combinations of instance
     // type and test type have been encountered so far. A warning may still be
     // reported, so do not replace the instance call.
     return;
   }
   if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
     ZoneGrowableArray<intptr_t>* results =
-        new ZoneGrowableArray<intptr_t>(unary_checks.NumberOfChecks() * 2);
+        new(isolate()) ZoneGrowableArray<intptr_t>(
+            unary_checks.NumberOfChecks() * 2);
     Bool& as_bool =
-        Bool::ZoneHandle(InstanceOfAsBool(unary_checks, type, results));
+        Bool::ZoneHandle(isolate(),
+                         InstanceOfAsBool(unary_checks, type, results));
     if (as_bool.IsNull()) {
       if (results->length() == unary_checks.NumberOfChecks() * 2) {
         const bool can_deopt = TryExpandTestCidsResult(results, type);
-        TestCidsInstr* test_cids = new TestCidsInstr(
+        TestCidsInstr* test_cids = new(isolate()) TestCidsInstr(
             call->token_pos(),
             negate ? Token::kISNOT : Token::kIS,
-            new Value(left),
+            new(isolate()) Value(left),
             *results,
             can_deopt ? call->deopt_id() : Isolate::kNoDeoptId);
         // Remove type.
         ReplaceCall(call, test_cids);
         return;
       }
     } else {
       // TODO(srdjan): Use TestCidsInstr also for this case.
       // One result only.
       AddReceiverCheck(call);
       if (negate) {
         as_bool = Bool::Get(!as_bool.value()).raw();
       }
       ConstantInstr* bool_const = flow_graph()->GetConstant(as_bool);
       for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
         PushArgumentInstr* push = call->PushArgumentAt(i);
         push->ReplaceUsesWith(push->value()->definition());
         push->RemoveFromGraph();
       }
       call->ReplaceUsesWith(bool_const);
       ASSERT(current_iterator()->Current() == call);
       current_iterator()->RemoveCurrentFromGraph();
       return;
     }
   }
 
   if (TypeCheckAsClassEquality(type)) {
-    LoadClassIdInstr* left_cid = new LoadClassIdInstr(new Value(left));
+    LoadClassIdInstr* left_cid =
+        new(isolate()) LoadClassIdInstr(new(isolate()) Value(left));
     InsertBefore(call,
                  left_cid,
                  NULL,
                  FlowGraph::kValue);
-    const intptr_t type_cid = Class::Handle(type.type_class()).id();
+    const intptr_t type_cid = Class::Handle(isolate(), type.type_class()).id();
     ConstantInstr* cid =
-        flow_graph()->GetConstant(Smi::Handle(Smi::New(type_cid)));
+        flow_graph()->GetConstant(Smi::Handle(isolate(), Smi::New(type_cid)));
 
     StrictCompareInstr* check_cid =
-        new StrictCompareInstr(call->token_pos(),
-                               negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
-                               new Value(left_cid),
-                               new Value(cid),
-                               false);  // No number check.
+        new(isolate()) StrictCompareInstr(
+            call->token_pos(),
+            negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
+            new(isolate()) Value(left_cid),
+            new(isolate()) Value(cid),
+            false);  // No number check.
     ReplaceCall(call, check_cid);
     return;
   }
 
   InstanceOfInstr* instance_of =
-      new InstanceOfInstr(call->token_pos(),
-                          new Value(left),
-                          new Value(instantiator),
-                          new Value(type_args),
-                          type,
-                          negate,
-                          call->deopt_id());
+      new(isolate()) InstanceOfInstr(call->token_pos(),
+                                     new(isolate()) Value(left),
+                                     new(isolate()) Value(instantiator),
+                                     new(isolate()) Value(type_args),
+                                     type,
+                                     negate,
+                                     call->deopt_id());
   ReplaceCall(call, instance_of);
 }
 
 
 // TODO(srdjan): Apply optimizations as in ReplaceWithInstanceOf (TestCids).
 void FlowGraphOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeCastOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* instantiator = call->ArgumentAt(1);
   Definition* type_args = call->ArgumentAt(2);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value());
   ASSERT(!type.IsMalformedOrMalbounded());
   const ICData& unary_checks =
-      ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks());
+      ICData::ZoneHandle(isolate(), call->ic_data()->AsUnaryClassChecks());
   if (FLAG_warn_on_javascript_compatibility &&
       !unary_checks.IssuedJSWarning() &&
       (type.IsIntType() || type.IsDoubleType() || !type.IsInstantiated())) {
     // No warning was reported yet for this type check, either because it has
     // not been executed yet, or because no problematic combinations of instance
     // type and test type have been encountered so far. A warning may still be
     // reported, so do not replace the instance call.
     return;
   }
   if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
     ZoneGrowableArray<intptr_t>* results =
-        new ZoneGrowableArray<intptr_t>(unary_checks.NumberOfChecks() * 2);
-    const Bool& as_bool =
-        Bool::ZoneHandle(InstanceOfAsBool(unary_checks, type, results));
+        new(isolate()) ZoneGrowableArray<intptr_t>(
+            unary_checks.NumberOfChecks() * 2);
+    const Bool& as_bool = Bool::ZoneHandle(isolate(),
+        InstanceOfAsBool(unary_checks, type, results));
     if (as_bool.raw() == Bool::True().raw()) {
       AddReceiverCheck(call);
       // Remove the original push arguments.
       for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
         PushArgumentInstr* push = call->PushArgumentAt(i);
         push->ReplaceUsesWith(push->value()->definition());
         push->RemoveFromGraph();
       }
       // Remove call, replace it with 'left'.
       call->ReplaceUsesWith(left);
       ASSERT(current_iterator()->Current() == call);
       current_iterator()->RemoveCurrentFromGraph();
       return;
     }
   }
-  const String& dst_name = String::ZoneHandle(
+  const String& dst_name = String::ZoneHandle(isolate(),
       Symbols::New(Exceptions::kCastErrorDstName));
   AssertAssignableInstr* assert_as =
-      new AssertAssignableInstr(call->token_pos(),
-                                new Value(left),
-                                new Value(instantiator),
-                                new Value(type_args),
-                                type,
-                                dst_name);
+      new(isolate()) AssertAssignableInstr(call->token_pos(),
+                                           new(isolate()) Value(left),
+                                           new(isolate()) Value(instantiator),
+                                           new(isolate()) Value(type_args),
+                                           type,
+                                           dst_name);
   // Newly inserted instructions that can deoptimize or throw an exception
   // must have a deoptimization id that is valid for lookup in the unoptimized
   // code.
   assert_as->deopt_id_ = call->deopt_id();
   ReplaceCall(call, assert_as);
 }
 
 
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   if (!instr->HasICData() || (instr->ic_data()->NumberOfChecks() == 0)) {
     return;
   }
 
   const Token::Kind op_kind = instr->token_kind();
   // Type test is special as it always gets converted into inlined code.
   if (Token::IsTypeTestOperator(op_kind)) {
     ReplaceWithInstanceOf(instr);
     return;
   }
 
   if (Token::IsTypeCastOperator(op_kind)) {
     ReplaceWithTypeCast(instr);
     return;
   }
 
   const ICData& unary_checks =
-      ICData::ZoneHandle(instr->ic_data()->AsUnaryClassChecks());
+      ICData::ZoneHandle(isolate(), instr->ic_data()->AsUnaryClassChecks());
 
   intptr_t max_checks = (op_kind == Token::kEQ)
       ? FLAG_max_equality_polymorphic_checks
       : FLAG_max_polymorphic_checks;
   if ((unary_checks.NumberOfChecks() > max_checks) &&
       InstanceCallNeedsClassCheck(instr)) {
     // Too many checks, it will be megamorphic which needs unary checks.
     instr->set_ic_data(&unary_checks);
     return;
   }
@@ skipping 31 matching lines @@
   }
   if (TryInlineInstanceMethod(instr)) {
     return;
   }
 
   bool has_one_target = unary_checks.HasOneTarget();
 
   if (has_one_target) {
     // Check if the single target is a polymorphic target, if it is,
     // we don't have one target.
-    const Function& target = Function::Handle(unary_checks.GetTargetAt(0));
+    const Function& target =
+        Function::Handle(isolate(), unary_checks.GetTargetAt(0));
     const bool polymorphic_target = MethodRecognizer::PolymorphicTarget(target);
     has_one_target = !polymorphic_target;
   }
 
   if (has_one_target) {
     const bool is_method_extraction =
-        Function::Handle(unary_checks.GetTargetAt(0)).IsMethodExtractor();
+        Function::Handle(isolate(),
+                         unary_checks.GetTargetAt(0)).IsMethodExtractor();
 
     if ((is_method_extraction && !MethodExtractorNeedsClassCheck(instr)) ||
         (!is_method_extraction && !InstanceCallNeedsClassCheck(instr))) {
       const bool call_with_checks = false;
       PolymorphicInstanceCallInstr* call =
-          new PolymorphicInstanceCallInstr(instr, unary_checks,
-                                           call_with_checks);
+          new(isolate()) PolymorphicInstanceCallInstr(instr, unary_checks,
+                                                      call_with_checks);
       instr->ReplaceWith(call, current_iterator());
       return;
     }
   }
 
   if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
     bool call_with_checks;
     if (has_one_target) {
       // Type propagation has not run yet, we cannot eliminate the check.
       AddReceiverCheck(instr);
       // Call can still deoptimize, do not detach environment from instr.
       call_with_checks = false;
     } else {
       call_with_checks = true;
     }
     PolymorphicInstanceCallInstr* call =
-        new PolymorphicInstanceCallInstr(instr, unary_checks,
-                                         call_with_checks);
+        new(isolate()) PolymorphicInstanceCallInstr(instr, unary_checks,
+                                                    call_with_checks);
     instr->ReplaceWith(call, current_iterator());
   }
 }
 
 
 void FlowGraphOptimizer::VisitStaticCall(StaticCallInstr* call) {
   if (!CanUnboxDouble()) {
     return;
   }
   MethodRecognizer::Kind recognized_kind =
       MethodRecognizer::RecognizeKind(call->function());
   MathUnaryInstr::MathUnaryKind unary_kind;
   switch (recognized_kind) {
     case MethodRecognizer::kMathSqrt:
       unary_kind = MathUnaryInstr::kSqrt;
       break;
     case MethodRecognizer::kMathSin:
       unary_kind = MathUnaryInstr::kSin;
       break;
     case MethodRecognizer::kMathCos:
       unary_kind = MathUnaryInstr::kCos;
       break;
     default:
       unary_kind = MathUnaryInstr::kIllegal;
       break;
   }
   if (unary_kind != MathUnaryInstr::kIllegal) {
     MathUnaryInstr* math_unary =
-        new MathUnaryInstr(unary_kind,
-                           new Value(call->ArgumentAt(0)),
-                           call->deopt_id());
+        new(isolate()) MathUnaryInstr(unary_kind,
+                                      new(isolate()) Value(call->ArgumentAt(0)),
+                                      call->deopt_id());
     ReplaceCall(call, math_unary);
   } else if ((recognized_kind == MethodRecognizer::kFloat32x4Zero) ||
              (recognized_kind == MethodRecognizer::kFloat32x4Splat) ||
              (recognized_kind == MethodRecognizer::kFloat32x4Constructor) ||
              (recognized_kind == MethodRecognizer::kFloat32x4FromFloat64x2)) {
     TryInlineFloat32x4Constructor(call, recognized_kind);
   } else if ((recognized_kind == MethodRecognizer::kFloat64x2Constructor) ||
              (recognized_kind == MethodRecognizer::kFloat64x2Zero) ||
              (recognized_kind == MethodRecognizer::kFloat64x2Splat) ||
              (recognized_kind == MethodRecognizer::kFloat64x2FromFloat32x4)) {
@@ skipping 18 matching lines @@
     // being either doubles or smis.
     if (call->HasICData() && (call->ic_data()->NumberOfChecks() == 1)) {
       const ICData& ic_data = *call->ic_data();
       intptr_t result_cid = kIllegalCid;
       if (ICDataHasReceiverArgumentClassIds(ic_data, kDoubleCid, kDoubleCid)) {
         result_cid = kDoubleCid;
       } else if (ICDataHasReceiverArgumentClassIds(ic_data, kSmiCid, kSmiCid)) {
         result_cid = kSmiCid;
       }
       if (result_cid != kIllegalCid) {
-        MathMinMaxInstr* min_max = new MathMinMaxInstr(
+        MathMinMaxInstr* min_max = new(isolate()) MathMinMaxInstr(
             recognized_kind,
-            new Value(call->ArgumentAt(0)),
-            new Value(call->ArgumentAt(1)),
+            new(isolate()) Value(call->ArgumentAt(0)),
+            new(isolate()) Value(call->ArgumentAt(1)),
             call->deopt_id(),
             result_cid);
         const ICData& unary_checks =
-            ICData::ZoneHandle(ic_data.AsUnaryClassChecks());
+            ICData::ZoneHandle(isolate(), ic_data.AsUnaryClassChecks());
         AddCheckClass(min_max->left()->definition(),
                       unary_checks,
                       call->deopt_id(),
                       call->env(),
                       call);
         AddCheckClass(min_max->right()->definition(),
                       unary_checks,
                       call->deopt_id(),
                       call->env(),
                       call);
         ReplaceCall(call, min_max);
       }
     }
   } else if (recognized_kind == MethodRecognizer::kMathDoublePow) {
     // We know that first argument is double, the second is num.
     // InvokeMathCFunctionInstr requires unboxed doubles. UnboxDouble
     // instructions contain type checks and conversions to double.
     ZoneGrowableArray<Value*>* args =
-        new ZoneGrowableArray<Value*>(call->ArgumentCount());
+        new(isolate()) ZoneGrowableArray<Value*>(call->ArgumentCount());
     for (intptr_t i = 0; i < call->ArgumentCount(); i++) {
-      args->Add(new Value(call->ArgumentAt(i)));
+      args->Add(new(isolate()) Value(call->ArgumentAt(i)));
     }
     InvokeMathCFunctionInstr* invoke =
-        new InvokeMathCFunctionInstr(args,
-                                     call->deopt_id(),
-                                     recognized_kind,
-                                     call->token_pos());
+        new(isolate()) InvokeMathCFunctionInstr(args,
+                                                call->deopt_id(),
+                                                recognized_kind,
+                                                call->token_pos());
     ReplaceCall(call, invoke);
   } else if (recognized_kind == MethodRecognizer::kObjectArrayConstructor) {
-    Value* type = new Value(call->ArgumentAt(0));
-    Value* num_elements = new Value(call->ArgumentAt(1));
+    Value* type = new(isolate()) Value(call->ArgumentAt(0));
+    Value* num_elements = new(isolate()) Value(call->ArgumentAt(1));
     CreateArrayInstr* create_array =
-        new CreateArrayInstr(call->token_pos(), type, num_elements);
+        new(isolate()) CreateArrayInstr(call->token_pos(), type, num_elements);
     ReplaceCall(call, create_array);
   } else if (Library::PrivateCoreLibName(Symbols::ClassId()).Equals(
-      String::Handle(call->function().name()))) {
+      String::Handle(isolate(), call->function().name()))) {
     // Check for core library get:_classId.
-    intptr_t cid = Class::Handle(call->function().Owner()).id();
+    intptr_t cid = Class::Handle(isolate(), call->function().Owner()).id();
     // Currently only implemented for a subset of classes.
     ASSERT((cid == kOneByteStringCid) || (cid == kTwoByteStringCid) ||
            (cid == kExternalOneByteStringCid) ||
            (cid == kGrowableObjectArrayCid) ||
            (cid == kImmutableArrayCid) || (cid == kArrayCid));
-    ConstantInstr* cid_instr = new ConstantInstr(Smi::Handle(Smi::New(cid)));
+    ConstantInstr* cid_instr =
+        new(isolate()) ConstantInstr(Smi::Handle(isolate(), Smi::New(cid)));
     ReplaceCall(call, cid_instr);
   } else if (call->function().IsFactory()) {
-    const Class& function_class = Class::Handle(call->function().Owner());
+    const Class& function_class =
+        Class::Handle(isolate(), call->function().Owner());
     if ((function_class.library() == Library::CoreLibrary()) ||
         (function_class.library() == Library::TypedDataLibrary())) {
       intptr_t cid = FactoryRecognizer::ResultCid(call->function());
       switch (cid) {
         case kArrayCid: {
-          Value* type = new Value(call->ArgumentAt(0));
-          Value* num_elements = new Value(call->ArgumentAt(1));
+          Value* type = new(isolate()) Value(call->ArgumentAt(0));
+          Value* num_elements = new(isolate()) Value(call->ArgumentAt(1));
           if (num_elements->BindsToConstant() &&
               num_elements->BoundConstant().IsSmi()) {
             intptr_t length = Smi::Cast(num_elements->BoundConstant()).Value();
             if (length >= 0 && length <= Array::kMaxElements) {
               CreateArrayInstr* create_array =
-                  new CreateArrayInstr(call->token_pos(), type, num_elements);
+                  new(isolate()) CreateArrayInstr(
+                      call->token_pos(), type, num_elements);
               ReplaceCall(call, create_array);
             }
           }
         }
         default:
           break;
       }
     }
   }
 }
 
 
 void FlowGraphOptimizer::VisitStoreInstanceField(
     StoreInstanceFieldInstr* instr) {
   if (instr->IsUnboxedStore()) {
     ASSERT(instr->is_initialization_);
     // Determine if this field should be unboxed based on the usage of getter
     // and setter functions: The heuristic requires that the setter has a
     // usage count of at least 1/kGetterSetterRatio of the getter usage count.
     // This is to avoid unboxing fields where the setter is never or rarely
     // executed.
-    const Field& field = Field::ZoneHandle(instr->field().raw());
-    const String& field_name = String::Handle(field.name());
-    class Class& owner = Class::Handle(field.owner());
+    const Field& field = Field::ZoneHandle(isolate(), instr->field().raw());
+    const String& field_name = String::Handle(isolate(), field.name());
+    class Class& owner = Class::Handle(isolate(), field.owner());
     const Function& getter =
-        Function::Handle(owner.LookupGetterFunction(field_name));
+        Function::Handle(isolate(), owner.LookupGetterFunction(field_name));
     const Function& setter =
-        Function::Handle(owner.LookupSetterFunction(field_name));
+        Function::Handle(isolate(), owner.LookupSetterFunction(field_name));
     bool result = !getter.IsNull()
                && !setter.IsNull()
                && (setter.usage_counter() > 0)
                && (FLAG_getter_setter_ratio * setter.usage_counter() >
                    getter.usage_counter());
     if (!result) {
       if (FLAG_trace_optimization) {
         OS::Print("Disabling unboxing of %s\n", field.ToCString());
       }
       field.set_is_unboxing_candidate(false);
@@ skipping 18 matching lines @@
   ASSERT(instr->HasICData());
   if (unary_ic_data.NumberOfChecks() == 0) {
     // No type feedback collected.
     return false;
   }
   if (!unary_ic_data.HasOneTarget()) {
     // Polymorphic sites are inlined like normal method calls by conventional
     // inlining.
     return false;
   }
-  Function& target = Function::Handle();
+  Function& target = Function::Handle(isolate(), Function::null());
   intptr_t class_id;
   unary_ic_data.GetOneClassCheckAt(0, &class_id, &target);
   if (target.kind() != RawFunction::kImplicitSetter) {
     // Non-implicit setter are inlined like normal method calls.
     return false;
   }
   // Inline implicit instance setter.
   const String& field_name =
-      String::Handle(Field::NameFromSetter(instr->function_name()));
-  const Field& field = Field::ZoneHandle(GetField(class_id, field_name));
+      String::Handle(isolate(), Field::NameFromSetter(instr->function_name()));
+  const Field& field =
+      Field::ZoneHandle(isolate(), GetField(class_id, field_name));
   ASSERT(!field.IsNull());
 
   if (InstanceCallNeedsClassCheck(instr)) {
     AddReceiverCheck(instr);
   }
   StoreBarrierType needs_store_barrier = kEmitStoreBarrier;
   if (ArgIsAlways(kSmiCid, *instr->ic_data(), 1)) {
     InsertBefore(instr,
-                 new CheckSmiInstr(new Value(instr->ArgumentAt(1)),
-                                   instr->deopt_id(),
-                                   instr->token_pos()),
+                 new(isolate()) CheckSmiInstr(
+                     new(isolate()) Value(instr->ArgumentAt(1)),
+                     instr->deopt_id(),
+                     instr->token_pos()),
                  instr->env(),
                  FlowGraph::kEffect);
     needs_store_barrier = kNoStoreBarrier;
   }
 
   if (field.guarded_cid() != kDynamicCid) {
     InsertBefore(instr,
-                 new GuardFieldInstr(new Value(instr->ArgumentAt(1)),
-                                     field,
-                                     instr->deopt_id()),
+                 new(isolate()) GuardFieldInstr(
+                     new(isolate()) Value(instr->ArgumentAt(1)),
+                      field,
+                      instr->deopt_id()),
                  instr->env(),
                  FlowGraph::kEffect);
   }
 
   // Field guard was detached.
-  StoreInstanceFieldInstr* store = new StoreInstanceFieldInstr(
+  StoreInstanceFieldInstr* store = new(isolate()) StoreInstanceFieldInstr(
       field,
-      new Value(instr->ArgumentAt(0)),
-      new Value(instr->ArgumentAt(1)),
+      new(isolate()) Value(instr->ArgumentAt(0)),
+      new(isolate()) Value(instr->ArgumentAt(1)),
       needs_store_barrier,
       instr->token_pos());
 
   if (store->IsUnboxedStore()) {
     FlowGraph::AddToGuardedFields(flow_graph_->guarded_fields(), &field);
   }
 
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
@@ skipping 74 matching lines @@
     if (*direction != new_direction) {
       if (*direction != kUnknown) new_direction = kBoth;
       *direction = new_direction;
     }
   }
 
   // Remove artificial Constraint instructions and replace them with actual
   // unconstrained definitions.
   void RemoveConstraints();
 
+  Range* ConstraintRange(Token::Kind op, Definition* boundary);
+
+  Isolate* isolate() const { return flow_graph_->isolate(); }
+
   FlowGraph* flow_graph_;
 
   GrowableArray<Definition*> smi_values_;  // Value that are known to be smi.
   GrowableArray<CheckSmiInstr*> smi_checks_;  // All CheckSmi instructions.
 
   // All Constraints inserted during InsertConstraints phase. They are treated
   // as smi values.
   GrowableArray<ConstraintInstr*> constraints_;
 
   // Bitvector for a quick filtering of known smi values.
@@ skipping 132 matching lines @@
       return Token::kILLEGAL;
   }
 }
 
 
 // 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].
-static Range* ConstraintRange(Token::Kind op, Definition* boundary) {
+Range* RangeAnalysis::ConstraintRange(Token::Kind op, Definition* boundary) {
   switch (op) {
     case Token::kEQ:
-      return new Range(RangeBoundary::FromDefinition(boundary),
-                       RangeBoundary::FromDefinition(boundary));
+      return new(isolate()) Range(RangeBoundary::FromDefinition(boundary),
+                                  RangeBoundary::FromDefinition(boundary));
     case Token::kNE:
       return Range::Unknown();
     case Token::kLT:
-      return new Range(RangeBoundary::MinSmi(),
-                       RangeBoundary::FromDefinition(boundary, -1));
+      return new(isolate()) Range(RangeBoundary::MinSmi(),
+                                  RangeBoundary::FromDefinition(boundary, -1));
     case Token::kGT:
-      return new Range(RangeBoundary::FromDefinition(boundary, 1),
-                       RangeBoundary::MaxSmi());
+      return new(isolate()) Range(RangeBoundary::FromDefinition(boundary, 1),
+                                  RangeBoundary::MaxSmi());
     case Token::kLTE:
-      return new Range(RangeBoundary::MinSmi(),
-                       RangeBoundary::FromDefinition(boundary));
+      return new(isolate()) Range(RangeBoundary::MinSmi(),
+                                  RangeBoundary::FromDefinition(boundary));
     case Token::kGTE:
-      return new Range(RangeBoundary::FromDefinition(boundary),
-                       RangeBoundary::MaxSmi());
+      return new(isolate()) Range(RangeBoundary::FromDefinition(boundary),
+                                  RangeBoundary::MaxSmi());
     default:
       UNREACHABLE();
       return Range::Unknown();
   }
 }
 
 
 ConstraintInstr* RangeAnalysis::InsertConstraintFor(Definition* defn,
                                                     Range* constraint_range,
                                                     Instruction* after) {
   // No need to constrain constants.
   if (defn->IsConstant()) return NULL;
 
-  ConstraintInstr* constraint =
-      new ConstraintInstr(new Value(defn), constraint_range);
+  ConstraintInstr* constraint = new(isolate()) ConstraintInstr(
+      new(isolate()) Value(defn), constraint_range);
   flow_graph_->InsertAfter(after, constraint, NULL, FlowGraph::kValue);
   RenameDominatedUses(defn, constraint, constraint);
   constraints_.Add(constraint);
   return constraint;
 }
 
 
 void RangeAnalysis::ConstrainValueAfterBranch(Definition* defn, Value* use) {
   BranchInstr* branch = use->instruction()->AsBranch();
   RelationalOpInstr* rel_op = branch->comparison()->AsRelationalOp();
@@ skipping 54 matching lines @@
     }
   }
 }
 
 
 void RangeAnalysis::ConstrainValueAfterCheckArrayBound(
     Definition* defn, CheckArrayBoundInstr* check, intptr_t use_index) {
   Range* constraint_range = NULL;
   if (use_index == CheckArrayBoundInstr::kIndexPos) {
     Definition* length = check->length()->definition();
-    constraint_range = new Range(
+    constraint_range = new(isolate()) Range(
         RangeBoundary::FromConstant(0),
         RangeBoundary::FromDefinition(length, -1));
   } else {
     ASSERT(use_index == CheckArrayBoundInstr::kLengthPos);
     Definition* index = check->index()->definition();
-    constraint_range = new Range(
+    constraint_range = new(isolate()) Range(
         RangeBoundary::FromDefinition(index, 1),
         RangeBoundary::MaxSmi());
   }
   InsertConstraintFor(defn, constraint_range, check);
 }
 
 
 void RangeAnalysis::InsertConstraints() {
   for (intptr_t i = 0; i < smi_checks_.length(); i++) {
     CheckSmiInstr* check = smi_checks_[i];
     InsertConstraintFor(check->value()->definition(), Range::Unknown(), check);
   }
 
   for (intptr_t i = 0; i < smi_values_.length(); i++) {
     InsertConstraintsFor(smi_values_[i]);
   }
 
   for (intptr_t i = 0; i < constraints_.length(); i++) {
     InsertConstraintsFor(constraints_[i]);
   }
 }
 
 
 void RangeAnalysis::ResetWorklist() {
   if (marked_defns_ == NULL) {
-    marked_defns_ = new BitVector(flow_graph_->current_ssa_temp_index());
+    marked_defns_ = new(isolate()) BitVector(
+        flow_graph_->current_ssa_temp_index());
   } else {
     marked_defns_->Clear();
   }
   worklist_.Clear();
 }
 
 
 void RangeAnalysis::MarkDefinition(Definition* defn) {
   // Unwrap constrained value.
   while (defn->IsConstraint()) {
@@ skipping 97 matching lines @@
     }
   }
 
 
   // We transitively discovered all dependencies of the given phi
   // and confirmed that it depends on a single value coming from outside of
   // the loop and some linear combinations of itself.
   // Compute the range based on initial value and the direction of the growth.
   switch (direction) {
     case kPositive:
-      return new Range(RangeBoundary::FromDefinition(initial_value),
-                       RangeBoundary::MaxSmi());
+      return new(isolate()) Range(RangeBoundary::FromDefinition(initial_value),
+                                  RangeBoundary::MaxSmi());
 
     case kNegative:
-      return new Range(RangeBoundary::MinSmi(),
-                       RangeBoundary::FromDefinition(initial_value));
+      return new(isolate()) Range(RangeBoundary::MinSmi(),
+                                  RangeBoundary::FromDefinition(initial_value));
 
     case kUnknown:
     case kBoth:
       return Range::Unknown();
   }
 
   UNREACHABLE();
   return NULL;
 }
 
@@ skipping 39 matching lines @@
   }
 
   for (intptr_t i = 0; i < block->dominated_blocks().length(); ++i) {
     InferRangesRecursive(block->dominated_blocks()[i]);
   }
 }
 
 
 void RangeAnalysis::InferRanges() {
   // Initialize bitvector for quick filtering of smi values.
-  smi_definitions_ = new BitVector(flow_graph_->current_ssa_temp_index());
+  smi_definitions_ =
+      new(isolate()) BitVector(flow_graph_->current_ssa_temp_index());
   for (intptr_t i = 0; i < smi_values_.length(); i++) {
     smi_definitions_->Add(smi_values_[i]->ssa_temp_index());
   }
   for (intptr_t i = 0; i < constraints_.length(); i++) {
     smi_definitions_->Add(constraints_[i]->ssa_temp_index());
   }
 
   // Infer initial values of ranges.
   const GrowableArray<Definition*>& initial =
       *flow_graph_->graph_entry()->initial_definitions();
@@ skipping 83 matching lines @@
             }
           }
         }
       }
     }
     for (intptr_t j = 0; j < idefs->length(); ++j) {
       if (cdefs[j] != NULL && cdefs[j]->IsConstant()) {
         // TODO(fschneider): Use constants from the constant pool.
         Definition* old = (*idefs)[j];
         ConstantInstr* orig = cdefs[j]->AsConstant();
-        ConstantInstr* copy = new ConstantInstr(orig->value());
+        ConstantInstr* copy =
+            new(flow_graph->isolate()) ConstantInstr(orig->value());
         copy->set_ssa_temp_index(flow_graph->alloc_ssa_temp_index());
         old->ReplaceUsesWith(copy);
         (*idefs)[j] = copy;
       }
     }
   }
 }
 
 
 static BlockEntryInstr* FindPreHeader(BlockEntryInstr* header) {
@@ skipping 462 matching lines @@
   }
 
   bool Equals(Place* other) const {
     return (kind_ == other->kind_) &&
         (representation_ == other->representation_) &&
         (instance_ == other->instance_) &&
         SameField(other);
   }
 
   // Create a zone allocated copy of this place.
-  static Place* Wrap(const Place& place);
+  static Place* Wrap(Isolate* isolate, const Place& place);
 
  private:
   bool SameField(Place* other) const {
     return (kind_ == kField) ? (field().raw() == other->field().raw())
                              : (offset_in_bytes_ == other->offset_in_bytes_);
   }
 
   intptr_t FieldHashcode() const {
     return (kind_ == kField) ? reinterpret_cast<intptr_t>(field().raw())
                              : offset_in_bytes_;
@@ skipping 17 matching lines @@
  public:
   explicit ZonePlace(const Place& place) : place_(place) { }
 
   Place* place() { return &place_; }
 
  private:
   Place place_;
 };
 
 
-Place* Place::Wrap(const Place& place) {
-  return (new ZonePlace(place))->place();
+Place* Place::Wrap(Isolate* isolate, const Place& place) {
+  return (new(isolate) ZonePlace(place))->place();
 }
 
 
 // Correspondence between places connected through outgoing phi moves on the
 // edge that targets join.
 class PhiPlaceMoves : public ZoneAllocated {
  public:
   // Record a move from the place with id |from| to the place with id |to| at
   // the given block.
-  void CreateOutgoingMove(BlockEntryInstr* block, intptr_t from, intptr_t to) {
+  void CreateOutgoingMove(Isolate* isolate,
+                          BlockEntryInstr* block, intptr_t from, intptr_t to) {
     const intptr_t block_num = block->preorder_number();
     while (moves_.length() <= block_num) {
       moves_.Add(NULL);
     }
 
     if (moves_[block_num] == NULL) {
-      moves_[block_num] = new ZoneGrowableArray<Move>(5);
+      moves_[block_num] = new(isolate) ZoneGrowableArray<Move>(5);
     }
 
     moves_[block_num]->Add(Move(from, to));
   }
 
   class Move {
    public:
     Move(intptr_t from, intptr_t to) : from_(from), to_(to) { }
 
     intptr_t from() const { return from_; }
@@ skipping 15 matching lines @@
  private:
   GrowableArray<ZoneGrowableArray<Move>* > moves_;
 };
 
 
 // A map from aliases to a set of places sharing the alias. Additionally
 // carries a set of places that can be aliased by side-effects, essentially
 // those that are affected by calls.
 class AliasedSet : public ZoneAllocated {
  public:
-  explicit AliasedSet(ZoneGrowableArray<Place*>* places,
-                      PhiPlaceMoves* phi_moves)
-      : places_(*places),
+  AliasedSet(Isolate* isolate,
+             ZoneGrowableArray<Place*>* places,
+             PhiPlaceMoves* phi_moves)
+      : isolate_(isolate),
+        places_(*places),
         phi_moves_(phi_moves),
         sets_(),
-        aliased_by_effects_(new BitVector(places->length())),
+        aliased_by_effects_(new(isolate) BitVector(places->length())),
         max_field_id_(0),
         field_ids_(),
         max_index_id_(0),
         index_ids_(),
         max_unknown_index_id_(0),
         unknown_index_ids_(),
         max_vm_field_id_(0),
         vm_field_ids_() { }
 
   Alias ComputeAlias(Place* place) {
@@ skipping 109 matching lines @@
     }
   }
 
   void AddIdForAlias(const Alias alias, intptr_t place_id) {
     const intptr_t idx = alias.ToIndex();
     while (sets_.length() <= idx) {
       sets_.Add(NULL);
     }
 
     if (sets_[idx] == NULL) {
-      sets_[idx] = new BitVector(max_place_id());
+      sets_[idx] = new(isolate_) BitVector(max_place_id());
     }
 
     sets_[idx]->Add(place_id);
   }
 
   intptr_t max_place_id() const { return places().length(); }
   bool IsEmpty() const { return max_place_id() == 0; }
 
   BitVector* aliased_by_effects() const { return aliased_by_effects_; }
 
@@ skipping 332 matching lines @@
     static inline bool IsKeyEqual(Pair kv, Key key) {
       return (KeyOf(kv).offset_ == key.offset_) &&
           (KeyOf(kv).instance_id_ == key.instance_id_);
     }
 
    private:
     Key key_;
     Value value_;
   };
 
+  Isolate* isolate_;
+
   const ZoneGrowableArray<Place*>& places_;
 
   const PhiPlaceMoves* phi_moves_;
 
   // Maps alias index to a set of ssa indexes corresponding to loads with the
   // given alias.
   GrowableArray<BitVector*> sets_;
 
   BitVector* aliased_by_effects_;
 
@@ skipping 44 matching lines @@
 }
 
 
 // For each place that depends on a phi ensure that equivalent places
 // corresponding to phi input are numbered and record outgoing phi moves
 // for each block which establish correspondence between phi dependent place
 // and phi input's place that is flowing in.
 static PhiPlaceMoves* ComputePhiMoves(
     DirectChainedHashMap<PointerKeyValueTrait<Place> >* map,
     ZoneGrowableArray<Place*>* places) {
-  PhiPlaceMoves* phi_moves = new PhiPlaceMoves();
+  Isolate* isolate = Isolate::Current();
+  PhiPlaceMoves* phi_moves = new(isolate) PhiPlaceMoves();
 
   for (intptr_t i = 0; i < places->length(); i++) {
     Place* place = (*places)[i];
 
     if (IsPhiDependentPlace(place)) {
       PhiInstr* phi = place->instance()->AsPhi();
       BlockEntryInstr* block = phi->GetBlock();
 
       if (FLAG_trace_optimization) {
         OS::Print("phi dependent place %s\n", place->ToCString());
       }
 
       Place input_place(*place);
       for (intptr_t j = 0; j < phi->InputCount(); j++) {
         input_place.set_instance(phi->InputAt(j)->definition());
 
         Place* result = map->Lookup(&input_place);
         if (result == NULL) {
           input_place.set_id(places->length());
-          result = Place::Wrap(input_place);
+          result = Place::Wrap(isolate, input_place);
           map->Insert(result);
           places->Add(result);
           if (FLAG_trace_optimization) {
             OS::Print("  adding place %s as %" Pd "\n",
                       result->ToCString(),
                       result->id());
           }
         }
-        phi_moves->CreateOutgoingMove(block->PredecessorAt(j),
+        phi_moves->CreateOutgoingMove(isolate,
+                                      block->PredecessorAt(j),
                                       result->id(),
                                       place->id());
       }
     }
   }
 
   return phi_moves;
 }
 
 
 enum CSEMode {
   kOptimizeLoads,
   kOptimizeStores
 };
 
 
 static AliasedSet* NumberPlaces(
     FlowGraph* graph,
     DirectChainedHashMap<PointerKeyValueTrait<Place> >* map,
     CSEMode mode) {
   // Loads representing different expression ids will be collected and
   // used to build per offset kill sets.
-  ZoneGrowableArray<Place*>* places = new ZoneGrowableArray<Place*>(10);
+  Isolate* isolate = graph->isolate();
+  ZoneGrowableArray<Place*>* places =
+      new(isolate) ZoneGrowableArray<Place*>(10);
 
   bool has_loads = false;
   bool has_stores = false;
   for (BlockIterator it = graph->reverse_postorder_iterator();
        !it.Done();
        it.Advance()) {
     BlockEntryInstr* block = it.Current();
     for (ForwardInstructionIterator instr_it(block);
          !instr_it.Done();
          instr_it.Advance()) {
       Instruction* instr = instr_it.Current();
       Place place(instr, &has_loads, &has_stores);
       if (place.kind() == Place::kNone) {
         continue;
       }
 
       Place* result = map->Lookup(&place);
       if (result == NULL) {
         place.set_id(places->length());
-        result = Place::Wrap(place);
+        result = Place::Wrap(isolate, place);
         map->Insert(result);
         places->Add(result);
 
         if (FLAG_trace_optimization) {
           OS::Print("numbering %s as %" Pd "\n",
                     result->ToCString(),
                     result->id());
         }
       }
 
       instr->set_place_id(result->id());
     }
   }
 
   if ((mode == kOptimizeLoads) && !has_loads) {
     return NULL;
   }
   if ((mode == kOptimizeStores) && !has_stores) {
     return NULL;
   }
 
   PhiPlaceMoves* phi_moves = ComputePhiMoves(map, places);
 
   // Build aliasing sets mapping aliases to loads.
-  AliasedSet* aliased_set = new AliasedSet(places, phi_moves);
+  AliasedSet* aliased_set = new(isolate) AliasedSet(isolate, places, phi_moves);
   for (intptr_t i = 0; i < places->length(); i++) {
     Place* place = (*places)[i];
     aliased_set->AddRepresentative(place);
   }
 
   aliased_set->EnsureAliasingForUnknownIndices();
 
   return aliased_set;
 }
 
@@ skipping 12 matching lines @@
         kill_(graph_->preorder().length()),
         exposed_values_(graph_->preorder().length()),
         out_values_(graph_->preorder().length()),
         phis_(5),
         worklist_(5),
         in_worklist_(NULL),
         forwarded_(false) {
     const intptr_t num_blocks = graph_->preorder().length();
     for (intptr_t i = 0; i < num_blocks; i++) {
       out_.Add(NULL);
-      gen_.Add(new BitVector(aliased_set_->max_place_id()));
-      kill_.Add(new BitVector(aliased_set_->max_place_id()));
-      in_.Add(new BitVector(aliased_set_->max_place_id()));
+      gen_.Add(new(isolate()) BitVector(aliased_set_->max_place_id()));
+      kill_.Add(new(isolate()) BitVector(aliased_set_->max_place_id()));
+      in_.Add(new(isolate()) BitVector(aliased_set_->max_place_id()));
 
       exposed_values_.Add(NULL);
       out_values_.Add(NULL);
     }
   }
 
+  Isolate* isolate() const { return graph_->isolate(); }
+
   static bool OptimizeGraph(FlowGraph* graph) {
     ASSERT(FLAG_load_cse);
     if (FLAG_trace_load_optimization) {
       FlowGraphPrinter::PrintGraph("Before LoadOptimizer", graph);
     }
 
     DirectChainedHashMap<PointerKeyValueTrait<Place> > map;
     AliasedSet* aliased_set = NumberPlaces(graph, &map, kOptimizeLoads);
     if ((aliased_set != NULL) && !aliased_set->IsEmpty()) {
       // If any loads were forwarded return true from Optimize to run load
@@ skipping 170 matching lines @@
           defn->ReplaceUsesWith(replacement);
           instr_it.RemoveCurrentFromGraph();
           forwarded_ = true;
           continue;
         } else if (!kill->Contains(place_id)) {
           // This is an exposed load: it is the first representative of a
           // given expression id and it is not killed on the path from
           // the block entry.
           if (exposed_values == NULL) {
             static const intptr_t kMaxExposedValuesInitialSize = 5;
-            exposed_values = new ZoneGrowableArray<Definition*>(
+            exposed_values = new(isolate()) ZoneGrowableArray<Definition*>(
                 Utils::Minimum(kMaxExposedValuesInitialSize,
                                aliased_set_->max_place_id()));
           }
 
           exposed_values->Add(defn);
         }
 
         gen->Add(place_id);
 
         if (out_values == NULL) out_values = CreateBlockOutValues();
@@ skipping 27 matching lines @@
 
       out->Remove(to);
     }
 
     out->AddAll(forwarded_loads);
   }
 
   // Compute OUT sets by propagating them iteratively until fix point
   // is reached.
   void ComputeOutSets() {
-    BitVector* temp = new BitVector(aliased_set_->max_place_id());
-    BitVector* forwarded_loads = new BitVector(aliased_set_->max_place_id());
-    BitVector* temp_out = new BitVector(aliased_set_->max_place_id());
+    BitVector* temp = new(isolate()) BitVector(aliased_set_->max_place_id());
+    BitVector* forwarded_loads =
+        new(isolate()) BitVector(aliased_set_->max_place_id());
+    BitVector* temp_out =
+        new(isolate()) BitVector(aliased_set_->max_place_id());
 
     bool changed = true;
     while (changed) {
       changed = false;
 
       for (BlockIterator block_it = graph_->reverse_postorder_iterator();
            !block_it.Done();
            block_it.Advance()) {
         BlockEntryInstr* block = block_it.Current();
 
@@ skipping 31 matching lines @@
         if (!temp->Equals(*block_in) || (block_out == NULL)) {
           // If IN set has changed propagate the change to OUT set.
           block_in->CopyFrom(temp);
 
           temp->RemoveAll(block_kill);
           temp->AddAll(block_gen);
 
           if ((block_out == NULL) || !block_out->Equals(*temp)) {
             if (block_out == NULL) {
               block_out = out_[preorder_number] =
-                  new BitVector(aliased_set_->max_place_id());
+                  new(isolate()) BitVector(aliased_set_->max_place_id());
             }
             block_out->CopyFrom(temp);
             changed = true;
           }
         }
       }
     }
   }
 
   // Compute out_values mappings by propagating them in reverse postorder once
@@ skipping 32 matching lines @@
           out_values_[preorder_number] = block_out_values =
               CreateBlockOutValues();
         }
 
         if ((*block_out_values)[place_id] == NULL) {
           ASSERT(block->PredecessorCount() > 0);
           Definition* in_value = can_merge_eagerly ?
               MergeIncomingValues(block, place_id) : NULL;
           if ((in_value == NULL) &&
               (in_[preorder_number]->Contains(place_id))) {
-            PhiInstr* phi = new PhiInstr(block->AsJoinEntry(),
-                                         block->PredecessorCount());
+            PhiInstr* phi = new(isolate()) PhiInstr(block->AsJoinEntry(),
+                                                    block->PredecessorCount());
             phi->set_place_id(place_id);
             pending_phis.Add(phi);
             in_value = phi;
           }
           (*block_out_values)[place_id] = in_value;
         }
       }
 
       // If the block has outgoing phi moves perform them. Use temporary list
       // of values to ensure that cyclic moves are performed correctly.
@@ skipping 52 matching lines @@
       }
     }
     return true;
   }
 
   void MarkLoopInvariantLoads() {
     const ZoneGrowableArray<BlockEntryInstr*>& loop_headers =
         graph_->loop_headers();
 
     ZoneGrowableArray<BitVector*>* invariant_loads =
-        new ZoneGrowableArray<BitVector*>(loop_headers.length());
+        new(isolate()) ZoneGrowableArray<BitVector*>(loop_headers.length());
 
     for (intptr_t i = 0; i < loop_headers.length(); i++) {
       BlockEntryInstr* header = loop_headers[i];
       BlockEntryInstr* pre_header = FindPreHeader(header);
       if (pre_header == NULL) {
         invariant_loads->Add(NULL);
         continue;
       }
 
-      BitVector* loop_gen = new BitVector(aliased_set_->max_place_id());
+      BitVector* loop_gen =
+          new(isolate()) BitVector(aliased_set_->max_place_id());
       for (BitVector::Iterator loop_it(header->loop_info());
            !loop_it.Done();
            loop_it.Advance()) {
         const intptr_t preorder_number = loop_it.Current();
         loop_gen->AddAll(gen_[preorder_number]);
       }
 
       for (BitVector::Iterator loop_it(header->loop_info());
            !loop_it.Done();
            loop_it.Advance()) {
@@ skipping 35 matching lines @@
         incoming = kDifferentValuesMarker;
       }
     }
 
     if (incoming != kDifferentValuesMarker) {
       ASSERT(incoming != NULL);
       return incoming;
     }
 
     // Incoming values are different. Phi is required to merge.
-    PhiInstr* phi = new PhiInstr(
+    PhiInstr* phi = new(isolate()) PhiInstr(
         block->AsJoinEntry(), block->PredecessorCount());
     phi->set_place_id(place_id);
     FillPhiInputs(phi);
     return phi;
   }
 
   void FillPhiInputs(PhiInstr* phi) {
     BlockEntryInstr* block = phi->GetBlock();
     const intptr_t place_id = phi->place_id();
 
     for (intptr_t i = 0; i < block->PredecessorCount(); i++) {
       BlockEntryInstr* pred = block->PredecessorAt(i);
       ZoneGrowableArray<Definition*>* pred_out_values =
           out_values_[pred->preorder_number()];
       ASSERT((*pred_out_values)[place_id] != NULL);
 
       // Sets of outgoing values are not linked into use lists so
       // they might contain values that were replaced and removed
       // from the graph by this iteration.
       // To prevent using them we additionally mark definitions themselves
       // as replaced and store a pointer to the replacement.
       Definition* replacement = (*pred_out_values)[place_id]->Replacement();
-      Value* input = new Value(replacement);
+      Value* input = new(isolate()) Value(replacement);
       phi->SetInputAt(i, input);
       replacement->AddInputUse(input);
     }
 
     phi->set_ssa_temp_index(graph_->alloc_ssa_temp_index());
     phis_.Add(phi);  // Postpone phi insertion until after load forwarding.
 
     if (FLAG_trace_load_optimization) {
       OS::Print("created pending phi %s for %s at B%" Pd "\n",
                 phi->ToCString(),
@@ skipping 52 matching lines @@
   // Eliminate it as redundant if this is the case.
   // When analyzing phi operands assumes that only generated during
   // this load phase can be redundant. They can be distinguished because
   // they are not marked alive.
   // TODO(vegorov): move this into a separate phase over all phis.
   bool EliminateRedundantPhi(PhiInstr* phi) {
     Definition* value = NULL;  // Possible value of this phi.
 
     worklist_.Clear();
     if (in_worklist_ == NULL) {
-      in_worklist_ = new BitVector(graph_->current_ssa_temp_index());
+      in_worklist_ = new(isolate()) BitVector(graph_->current_ssa_temp_index());
     } else {
       in_worklist_->Clear();
     }
 
     worklist_.Add(phi);
     in_worklist_->Add(phi->ssa_temp_index());
 
     for (intptr_t i = 0; i < worklist_.length(); i++) {
       PhiInstr* phi = worklist_[i];
 
@@ skipping 52 matching lines @@
   }
 
   // Replace the given phi with another if they are equal.
   // Returns true if succeeds.
   bool ReplacePhiWith(PhiInstr* phi, PhiInstr* replacement) {
     ASSERT(phi->InputCount() == replacement->InputCount());
     ASSERT(phi->block() == replacement->block());
 
     worklist_.Clear();
     if (in_worklist_ == NULL) {
-      in_worklist_ = new BitVector(graph_->current_ssa_temp_index());
+      in_worklist_ = new(isolate()) BitVector(graph_->current_ssa_temp_index());
     } else {
       in_worklist_->Clear();
     }
 
     // During the comparison worklist contains pairs of phis to be compared.
     AddPhiPairToWorklist(phi, replacement);
 
     // Process the worklist. It might grow during each comparison step.
     for (intptr_t i = 0; i < worklist_.length(); i += 2) {
       PhiInstr* a = worklist_[i];
@@ skipping 68 matching lines @@
       if ((phi != NULL) && (!phi->HasUses() || !EmitPhi(phi))) {
         for (intptr_t j = phi->InputCount() - 1; j >= 0; --j) {
           phi->InputAt(j)->RemoveFromUseList();
         }
       }
     }
   }
 
   ZoneGrowableArray<Definition*>* CreateBlockOutValues() {
     ZoneGrowableArray<Definition*>* out =
-        new ZoneGrowableArray<Definition*>(aliased_set_->max_place_id());
+        new(isolate()) ZoneGrowableArray<Definition*>(
+            aliased_set_->max_place_id());
     for (intptr_t i = 0; i < aliased_set_->max_place_id(); i++) {
       out->Add(NULL);
     }
     return out;
   }
 
   FlowGraph* graph_;
   DirectChainedHashMap<PointerKeyValueTrait<Place> >* map_;
 
   // Mapping between field offsets in words and expression ids of loads from
@@ skipping 83 matching lines @@
       case Instruction::kStoreIndexed:
       case Instruction::kStoreStaticField:
         return true;
       default:
         UNREACHABLE();
         return false;
     }
   }
 
   virtual void ComputeInitialSets() {
-    BitVector* all_places = new BitVector(aliased_set_->max_place_id());
+    Isolate* isolate = graph_->isolate();
+    BitVector* all_places = new(isolate) BitVector(
+        aliased_set_->max_place_id());
     all_places->SetAll();
     for (BlockIterator block_it = graph_->postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       BlockEntryInstr* block = block_it.Current();
       const intptr_t postorder_number = block->postorder_number();
 
       BitVector* kill = kill_[postorder_number];
       BitVector* live_in = live_in_[postorder_number];
       BitVector* live_out = live_out_[postorder_number];
@@ skipping 24 matching lines @@
                     "Removing dead store to place %" Pd " in block B%" Pd "\n",
                     instr->place_id(), block->block_id());
               }
               instr_it.RemoveCurrentFromGraph();
             }
           } else if (!live_in->Contains(instr->place_id())) {
             // Mark this store as down-ward exposed: They are the only
             // candidates for the global store elimination.
             if (exposed_stores == NULL) {
               const intptr_t kMaxExposedStoresInitialSize = 5;
-              exposed_stores = new ZoneGrowableArray<Instruction*>(
+              exposed_stores = new(isolate) ZoneGrowableArray<Instruction*>(
                   Utils::Minimum(kMaxExposedStoresInitialSize,
                                  aliased_set_->max_place_id()));
             }
             exposed_stores->Add(instr);
           }
           // Interfering stores kill only loads from the same place.
           kill->Add(instr->place_id());
           live_in->Remove(instr->place_id());
           continue;
         }
@@ skipping 275 matching lines @@
 }
 
 
 ConstantPropagator::ConstantPropagator(
     FlowGraph* graph,
     const GrowableArray<BlockEntryInstr*>& ignored)
     : FlowGraphVisitor(ignored),
       graph_(graph),
       unknown_(Object::unknown_constant()),
       non_constant_(Object::non_constant()),
-      reachable_(new BitVector(graph->preorder().length())),
-      definition_marks_(new BitVector(graph->max_virtual_register_number())),
+      reachable_(new(graph->isolate()) BitVector(graph->preorder().length())),
+      definition_marks_(new(graph->isolate()) BitVector(
+          graph->max_virtual_register_number())),
       block_worklist_(),
       definition_worklist_() {}
 
 
 void ConstantPropagator::Optimize(FlowGraph* graph) {
   GrowableArray<BlockEntryInstr*> ignored;
   ConstantPropagator cp(graph, ignored);
   cp.Analyze();
   cp.Transform();
 }
@@ skipping 185 matching lines @@
 void ConstantPropagator::VisitCheckArrayBound(CheckArrayBoundInstr* instr) { }
 
 
 // --------------------------------------------------------------------------
 // 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(Unknown());
+  Object& value = Object::ZoneHandle(isolate(), 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());
     }
   }
   SetValue(instr, value);
 }
 
@@ skipping 96 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(Smi::New(
+             Smi::Handle(isolate(), Smi::New(
                  result ? instr->if_true() : instr->if_false())));
   }
 }
 
 
 void ConstantPropagator::VisitStrictCompare(StrictCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
 
   if (instr->left()->definition() == instr->right()->definition()) {
@@ skipping 55 matching lines @@
 
 void ConstantPropagator::VisitTestSmi(TestSmiInstr* instr) {
   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)) {
     if (left.IsInteger() && right.IsInteger()) {
       const bool result = CompareIntegers(
           instr->kind(),
-          Integer::Handle(Integer::Cast(left).BitOp(Token::kBIT_AND,
+          Integer::Handle(isolate(),
+                          Integer::Cast(left).BitOp(Token::kBIT_AND,
                                                     Integer::Cast(right))),
-          Smi::Handle(Smi::New(0)));
+          Smi::Handle(isolate(), 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 63 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(table[ch_code]));
+      SetValue(instr, String::ZoneHandle(isolate(), 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) ? str.CharAt(0) : -1;
-    SetValue(instr, Smi::ZoneHandle(Smi::New(result)));
+    SetValue(instr, Smi::ZoneHandle(isolate(), Smi::New(result)));
   }
 }
 
 
 
 
 void ConstantPropagator::VisitStringInterpolate(StringInterpolateInstr* instr) {
   SetValue(instr, non_constant_);
   return;
 }
 
 
 void ConstantPropagator::VisitLoadIndexed(LoadIndexedInstr* instr) {
   const Object& array_obj = instr->array()->definition()->constant_value();
   const Object& index_obj = instr->index()->definition()->constant_value();
   if (IsNonConstant(array_obj) || IsNonConstant(index_obj)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(array_obj) && IsConstant(index_obj)) {
     // Need index to be Smi and array to be either String or an immutable array.
     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(Smi::New(str.CharAt(index))));
+          SetValue(instr, Smi::Handle(isolate(), Smi::New(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();
+          Instance& result = Instance::Handle(isolate(), Instance::null());
           result ^= a.At(index);
           SetValue(instr, result);
           return;
         }
       }
     }
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitStoreIndexed(StoreIndexedInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
 void ConstantPropagator::VisitStoreInstanceField(
     StoreInstanceFieldInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
 void ConstantPropagator::VisitLoadStaticField(LoadStaticFieldInstr* instr) {
   const Field& field = instr->StaticField();
   ASSERT(field.is_static());
   if (field.is_final()) {
-    Instance& obj = Instance::Handle(field.value());
+    Instance& obj = Instance::Handle(isolate(), field.value());
     ASSERT(obj.raw() != Object::sentinel().raw());
     ASSERT(obj.raw() != Object::transition_sentinel().raw());
     if (obj.IsSmi() || obj.IsOld()) {
       SetValue(instr, obj);
       return;
     }
   }
   SetValue(instr, non_constant_);
 }
 
@@ skipping 54 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(Smi::New(cid)));
+    SetValue(instr, Smi::ZoneHandle(isolate(), Smi::New(cid)));
     return;
   }
   const Object& object = instr->object()->definition()->constant_value();
   if (IsConstant(object)) {
-    SetValue(instr, Smi::ZoneHandle(Smi::New(object.GetClassId())));
+    SetValue(instr, Smi::ZoneHandle(isolate(), Smi::New(object.GetClassId())));
     return;
   }
   SetValue(instr, non_constant_);
 }
 
 
 void ConstantPropagator::VisitLoadField(LoadFieldInstr* instr) {
   if ((instr->recognized_kind() == MethodRecognizer::kObjectArrayLength) &&
       (instr->instance()->definition()->IsCreateArray())) {
     Value* num_elements =
         instr->instance()->definition()->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(Smi::New(length));
+      const Object& result = Smi::ZoneHandle(isolate(), Smi::New(length));
       SetValue(instr, result);
       return;
     }
   }
 
   if (instr->IsImmutableLengthLoad()) {
     ConstantInstr* constant = instr->instance()->definition()->AsConstant();
     if (constant != NULL) {
       if (constant->value().IsString()) {
-        SetValue(instr, Smi::ZoneHandle(
+        SetValue(instr, Smi::ZoneHandle(isolate(),
             Smi::New(String::Cast(constant->value()).Length())));
         return;
       }
       if (constant->value().IsArray()) {
-        SetValue(instr, Smi::ZoneHandle(
+        SetValue(instr, Smi::ZoneHandle(isolate(),
             Smi::New(Array::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(Type::DynamicType()));
+        SetValue(instr, Type::ZoneHandle(isolate(), 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 51 matching lines @@
         case Token::kMOD:
           // Check right value for zero.
           if (right_int.AsInt64Value() == 0) {
             SetValue(instr, non_constant_);
             break;
           }
           // Fall through.
         case Token::kADD:
         case Token::kSUB:
         case Token::kMUL: {
-          Instance& result = Integer::ZoneHandle(
+          Instance& result = Integer::ZoneHandle(isolate(),
               left_int.ArithmeticOp(op_kind, right_int));
           result = result.CheckAndCanonicalize(NULL);
           ASSERT(!result.IsNull());
           SetValue(instr, result);
           break;
         }
         case Token::kSHL:
         case Token::kSHR:
           if (left.IsSmi() && right.IsSmi()) {
-            Instance& result = Integer::ZoneHandle(
+            Instance& result = Integer::ZoneHandle(isolate(),
                 Smi::Cast(left_int).ShiftOp(op_kind, Smi::Cast(right_int)));
             result = result.CheckAndCanonicalize(NULL);
             ASSERT(!result.IsNull());
             SetValue(instr, result);
           } else {
             SetValue(instr, non_constant_);
           }
           break;
         case Token::kBIT_AND:
         case Token::kBIT_OR:
         case Token::kBIT_XOR: {
-          Instance& result = Integer::ZoneHandle(
+          Instance& result = Integer::ZoneHandle(isolate(),
               left_int.BitOp(op_kind, right_int));
           result = result.CheckAndCanonicalize(NULL);
           ASSERT(!result.IsNull());
           SetValue(instr, result);
           break;
         }
         case Token::kDIV:
           SetValue(instr, non_constant_);
           break;
         default:
@@ skipping 58 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(
+    SetValue(instr, Double::Handle(isolate(),
         Double::New(Integer::Cast(value).AsDoubleValue(), Heap::kOld)));
   } else if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   }
 }
 
 
 void ConstantPropagator::VisitDoubleToInteger(DoubleToIntegerInstr* instr) {
   // TODO(kmillikin): Handle conversion.
   SetValue(instr, non_constant_);
@@ skipping 442 matching lines @@
     current = current->next()->AsGoto()->successor();
   }
   return current;
 }
 
 
 void ConstantPropagator::EliminateRedundantBranches() {
   // Canonicalize branches that have no side-effects and where true- and
   // false-targets are the same.
   bool changed = false;
-  BitVector* empty_blocks = new BitVector(graph_->preorder().length());
+  BitVector* empty_blocks =
+      new(graph_->isolate()) BitVector(graph_->preorder().length());
   for (BlockIterator b = graph_->postorder_iterator();
        !b.Done();
        b.Advance()) {
     BlockEntryInstr* block = b.Current();
     BranchInstr* branch = block->last_instruction()->AsBranch();
     empty_blocks->Clear();
     if ((branch != NULL) && branch->Effects().IsNone()) {
       ASSERT(branch->previous() != NULL);  // Not already eliminated.
       BlockEntryInstr* if_true =
           FindFirstNonEmptySuccessor(branch->true_successor(), empty_blocks);
       BlockEntryInstr* if_false =
           FindFirstNonEmptySuccessor(branch->false_successor(), empty_blocks);
       if (if_true == if_false) {
         // Replace the branch with a jump to the common successor.
         // Drop the comparison, which does not have side effects
         JoinEntryInstr* join = if_true->AsJoinEntry();
         if (join->phis() == NULL) {
-          GotoInstr* jump = new GotoInstr(if_true->AsJoinEntry());
-          jump->InheritDeoptTarget(branch);
+          GotoInstr* jump =
+              new(graph_->isolate()) GotoInstr(if_true->AsJoinEntry());
+          jump->InheritDeoptTarget(isolate(), branch);
 
           Instruction* previous = branch->previous();
           branch->set_previous(NULL);
           previous->LinkTo(jump);
 
           // Remove uses from branch and all the empty blocks that
           // are now unreachable.
           branch->UnuseAllInputs();
           for (BitVector::Iterator it(empty_blocks); !it.Done(); it.Advance()) {
             BlockEntryInstr* empty_block = graph_->preorder()[it.Current()];
@@ skipping 124 matching lines @@
     if (branch != NULL) {
       TargetEntryInstr* if_true = branch->true_successor();
       TargetEntryInstr* if_false = branch->false_successor();
       JoinEntryInstr* join = NULL;
       Instruction* next = NULL;
 
       if (!reachable_->Contains(if_true->preorder_number())) {
         ASSERT(reachable_->Contains(if_false->preorder_number()));
         ASSERT(if_false->parallel_move() == NULL);
         ASSERT(if_false->loop_info() == NULL);
-        join = new JoinEntryInstr(if_false->block_id(), if_false->try_index());
-        join->InheritDeoptTarget(if_false);
+        join = new(isolate()) JoinEntryInstr(if_false->block_id(),
+                                             if_false->try_index());
+        join->InheritDeoptTarget(isolate(), if_false);
         if_false->UnuseAllInputs();
         next = if_false->next();
       } else if (!reachable_->Contains(if_false->preorder_number())) {
         ASSERT(if_true->parallel_move() == NULL);
         ASSERT(if_true->loop_info() == NULL);
-        join = new JoinEntryInstr(if_true->block_id(), if_true->try_index());
-        join->InheritDeoptTarget(if_true);
+        join = new(isolate()) JoinEntryInstr(if_true->block_id(),
+                                             if_true->try_index());
+        join->InheritDeoptTarget(isolate(), if_true);
         if_true->UnuseAllInputs();
         next = if_true->next();
       }
 
       if (join != NULL) {
         // Replace the branch with a jump to the reachable successor.
         // Drop the comparison, which does not have side effects as long
         // as it is a strict compare (the only one we can determine is
         // constant with the current analysis).
-        GotoInstr* jump = new GotoInstr(join);
-        jump->InheritDeoptTarget(branch);
+        GotoInstr* jump = new(isolate()) GotoInstr(join);
+        jump->InheritDeoptTarget(isolate(), branch);
 
         Instruction* previous = branch->previous();
         branch->set_previous(NULL);
         previous->LinkTo(jump);
 
         // Replace the false target entry with the new join entry. We will
         // recompute the dominators after this pass.
         join->LinkTo(next);
         branch->UnuseAllInputs();
       }
@@ skipping 54 matching lines @@
       (right == NULL) ? NULL : right->definition()->AsConstant();
   return (phi != NULL) &&
       (constant != NULL) &&
       (phi->GetBlock() == block) &&
       PhiHasSingleUse(phi, left) &&
       (block->next() == branch) &&
       (block->phis()->length() == 1);
 }
 
 
-JoinEntryInstr* BranchSimplifier::ToJoinEntry(TargetEntryInstr* target) {
+JoinEntryInstr* BranchSimplifier::ToJoinEntry(Isolate* isolate,
+                                              TargetEntryInstr* target) {
   // Convert a target block into a join block.  Branches will be duplicated
   // so the former true and false targets become joins of the control flows
   // from all the duplicated branches.
   JoinEntryInstr* join =
-      new JoinEntryInstr(target->block_id(), target->try_index());
-  join->InheritDeoptTarget(target);
+      new(isolate) JoinEntryInstr(target->block_id(), target->try_index());
+  join->InheritDeoptTarget(isolate, target);
   join->LinkTo(target->next());
   join->set_last_instruction(target->last_instruction());
   target->UnuseAllInputs();
   return join;
 }
 
 
-BranchInstr* BranchSimplifier::CloneBranch(BranchInstr* branch,
+BranchInstr* BranchSimplifier::CloneBranch(Isolate* isolate,
+                                           BranchInstr* branch,
                                            Value* new_left,
                                            Value* new_right) {
   ComparisonInstr* comparison = branch->comparison();
   ComparisonInstr* new_comparison =
       comparison->CopyWithNewOperands(new_left, new_right);
-  BranchInstr* new_branch = new BranchInstr(new_comparison);
+  BranchInstr* new_branch = new(isolate) BranchInstr(new_comparison);
   new_branch->set_is_checked(branch->is_checked());
   return new_branch;
 }
 
 
 void BranchSimplifier::Simplify(FlowGraph* flow_graph) {
   // Optimize some branches that test the value of a phi.  When it is safe
   // to do so, push the branch to each of the predecessor blocks.  This is
   // an optimization when (a) it can avoid materializing a boolean object at
   // the phi only to test its value, and (b) it can expose opportunities for
   // constant propagation and unreachable code elimination.  This
   // optimization is intended to run after inlining which creates
   // opportunities for optimization (a) and before constant folding which
   // can perform optimization (b).
 
   // Begin with a worklist of join blocks ending in branches.  They are
   // candidates for the pattern below.
+  Isolate* isolate = flow_graph->isolate();
   const GrowableArray<BlockEntryInstr*>& postorder = flow_graph->postorder();
   GrowableArray<BlockEntryInstr*> worklist(postorder.length());
   for (BlockIterator it(postorder); !it.Done(); it.Advance()) {
     BlockEntryInstr* block = it.Current();
     if (block->IsJoinEntry() && block->last_instruction()->IsBranch()) {
       worklist.Add(block);
     }
   }
 
   // Rewrite until no more instance of the pattern exists.
   bool changed = false;
   while (!worklist.is_empty()) {
     // All blocks in the worklist are join blocks (ending with a branch).
     JoinEntryInstr* block = worklist.RemoveLast()->AsJoinEntry();
     ASSERT(block != NULL);
 
     if (Match(block)) {
       changed = true;
 
       // The branch will be copied and pushed to all the join's
       // predecessors.  Convert the true and false target blocks into join
       // blocks to join the control flows from all of the true
       // (respectively, false) targets of the copied branches.
       //
       // The converted join block will have no phis, so it cannot be another
       // instance of the pattern.  There is thus no need to add it to the
       // worklist.
       BranchInstr* branch = block->last_instruction()->AsBranch();
       ASSERT(branch != NULL);
-      JoinEntryInstr* join_true = ToJoinEntry(branch->true_successor());
-      JoinEntryInstr* join_false = ToJoinEntry(branch->false_successor());
+      JoinEntryInstr* join_true =
+          ToJoinEntry(isolate, branch->true_successor());
+      JoinEntryInstr* join_false =
+          ToJoinEntry(isolate, branch->false_successor());
 
       ComparisonInstr* comparison = branch->comparison();
       PhiInstr* phi = comparison->left()->definition()->AsPhi();
       ConstantInstr* constant = comparison->right()->definition()->AsConstant();
       ASSERT(constant != NULL);
       // Copy the constant and branch and push it to all the predecessors.
       for (intptr_t i = 0, count = block->PredecessorCount(); i < count; ++i) {
         GotoInstr* old_goto =
             block->PredecessorAt(i)->last_instruction()->AsGoto();
         ASSERT(old_goto != NULL);
 
         // Replace the goto in each predecessor with a rewritten branch,
         // rewritten to use the corresponding phi input instead of the phi.
-        Value* new_left = phi->InputAt(i)->Copy();
-        Value* new_right = new Value(constant);
-        BranchInstr* new_branch = CloneBranch(branch, new_left, new_right);
+        Value* new_left = phi->InputAt(i)->Copy(isolate);
+        Value* new_right = new(isolate) Value(constant);
+        BranchInstr* new_branch =
+            CloneBranch(isolate, branch, new_left, new_right);
         if (branch->env() == NULL) {
-          new_branch->InheritDeoptTarget(old_goto);
+          new_branch->InheritDeoptTarget(isolate, old_goto);
         } else {
           // Take the environment from the branch if it has one.
-          new_branch->InheritDeoptTarget(branch);
+          new_branch->InheritDeoptTarget(isolate, branch);
           // InheritDeoptTarget gave the new branch's comparison the same
           // deopt id that it gave the new branch.  The id should be the
           // deopt id of the original comparison.
           new_branch->comparison()->SetDeoptId(comparison->GetDeoptId());
           // The phi can be used in the branch's environment.  Rename such
           // uses.
           for (Environment::DeepIterator it(new_branch->env());
                !it.Done();
                it.Advance()) {
             Value* use = it.CurrentValue();
@@ skipping 12 matching lines @@
 
         // Update the predecessor block.  We may have created another
         // instance of the pattern so add it to the worklist if necessary.
         BlockEntryInstr* branch_block = new_branch->GetBlock();
         branch_block->set_last_instruction(new_branch);
         if (branch_block->IsJoinEntry()) worklist.Add(branch_block);
 
         // Connect the branch to the true and false joins, via empty target
         // blocks.
         TargetEntryInstr* true_target =
-            new TargetEntryInstr(flow_graph->max_block_id() + 1,
-                                 block->try_index());
-        true_target->InheritDeoptTarget(join_true);
+            new(isolate) TargetEntryInstr(flow_graph->max_block_id() + 1,
+                                          block->try_index());
+        true_target->InheritDeoptTarget(isolate, join_true);
         TargetEntryInstr* false_target =
-            new TargetEntryInstr(flow_graph->max_block_id() + 2,
-                                 block->try_index());
-        false_target->InheritDeoptTarget(join_false);
+            new(isolate) TargetEntryInstr(flow_graph->max_block_id() + 2,
+                                          block->try_index());
+        false_target->InheritDeoptTarget(isolate, join_false);
         flow_graph->set_max_block_id(flow_graph->max_block_id() + 2);
         *new_branch->true_successor_address() = true_target;
         *new_branch->false_successor_address() = false_target;
-        GotoInstr* goto_true = new GotoInstr(join_true);
-        goto_true->InheritDeoptTarget(join_true);
+        GotoInstr* goto_true = new(isolate) GotoInstr(join_true);
+        goto_true->InheritDeoptTarget(isolate, join_true);
         true_target->LinkTo(goto_true);
         true_target->set_last_instruction(goto_true);
-        GotoInstr* goto_false = new GotoInstr(join_false);
-        goto_false->InheritDeoptTarget(join_false);
+        GotoInstr* goto_false = new(isolate) GotoInstr(join_false);
+        goto_false->InheritDeoptTarget(isolate, join_false);
         false_target->LinkTo(goto_false);
         false_target->set_last_instruction(goto_false);
       }
       // When all predecessors have been rewritten, the original block is
       // unreachable from the graph.
       phi->UnuseAllInputs();
       branch->UnuseAllInputs();
       block->UnuseAllInputs();
       ASSERT(!phi->HasUses());
     }
@@ skipping 23 matching lines @@
 
   if ((block->next() == instr) &&
       (instr->next() == block->last_instruction())) {
     before->previous()->LinkTo(instr);
     instr->LinkTo(before);
   }
 }
 
 
 void IfConverter::Simplify(FlowGraph* flow_graph) {
+  Isolate* isolate = flow_graph->isolate();
   bool changed = false;
 
   const GrowableArray<BlockEntryInstr*>& postorder = flow_graph->postorder();
   for (BlockIterator it(postorder); !it.Done(); it.Advance()) {
     BlockEntryInstr* block = it.Current();
     JoinEntryInstr* join = block->AsJoinEntry();
 
     // Detect diamond control flow pattern which materializes a value depending
     // on the result of the comparison:
     //
@@ skipping 33 matching lines @@
         ComparisonInstr* comparison = branch->comparison();
 
         // Check if the platform supports efficient branchless IfThenElseInstr
         // for the given combination of comparison and values flowing from
         // false and true paths.
         if (IfThenElseInstr::Supports(comparison, v1, v2)) {
           Value* if_true = (pred1 == branch->true_successor()) ? v1 : v2;
           Value* if_false = (pred2 == branch->true_successor()) ? v1 : v2;
 
           ComparisonInstr* new_comparison =
-              comparison->CopyWithNewOperands(comparison->left()->Copy(),
-                                              comparison->right()->Copy());
-          IfThenElseInstr* if_then_else = new IfThenElseInstr(
+              comparison->CopyWithNewOperands(
+                  comparison->left()->Copy(isolate),
+                  comparison->right()->Copy(isolate));
+          IfThenElseInstr* if_then_else = new(isolate) IfThenElseInstr(
               new_comparison,
-              if_true->Copy(),
-              if_false->Copy());
+              if_true->Copy(isolate),
+              if_false->Copy(isolate));
           flow_graph->InsertBefore(branch,
                                    if_then_else,
                                    NULL,
                                    FlowGraph::kValue);
 
           phi->ReplaceUsesWith(if_then_else);
 
           // Connect IfThenElseInstr to the first instruction in the merge block
           // effectively eliminating diamond control flow.
           // Current block as well as pred1 and pred2 blocks are no longer in
@@ skipping 214 matching lines @@
 
 
 // Insert MaterializeObject instruction for the given allocation before
 // the given instruction that can deoptimize.
 void AllocationSinking::CreateMaterializationAt(
     Instruction* exit,
     AllocateObjectInstr* alloc,
     const Class& cls,
     const ZoneGrowableArray<const Object*>& slots) {
   ZoneGrowableArray<Value*>* values =
-      new ZoneGrowableArray<Value*>(slots.length());
+      new(isolate()) ZoneGrowableArray<Value*>(slots.length());
 
   // Insert load instruction for every field.
   for (intptr_t i = 0; i < slots.length(); i++) {
     LoadFieldInstr* load = slots[i]->IsField()
-        ? new LoadFieldInstr(new Value(alloc),
-                             &Field::Cast(*slots[i]),
-                             AbstractType::ZoneHandle(),
-                             alloc->token_pos())
-        : new LoadFieldInstr(new Value(alloc),
-                             Smi::Cast(*slots[i]).Value(),
-                             AbstractType::ZoneHandle(),
-                             alloc->token_pos());
+        ? new(isolate()) LoadFieldInstr(
+            new(isolate()) Value(alloc),
+            &Field::Cast(*slots[i]),
+            AbstractType::ZoneHandle(isolate(), AbstractType::null()),
+            alloc->token_pos())
+        : new(isolate()) LoadFieldInstr(
+            new(isolate()) Value(alloc),
+            Smi::Cast(*slots[i]).Value(),
+            AbstractType::ZoneHandle(isolate(), AbstractType::null()),
+            alloc->token_pos());
     flow_graph_->InsertBefore(
         exit, load, NULL, FlowGraph::kValue);
-    values->Add(new Value(load));
+    values->Add(new(isolate()) Value(load));
   }
 
-  MaterializeObjectInstr* mat = new MaterializeObjectInstr(cls, slots, values);
+  MaterializeObjectInstr* mat =
+      new(isolate()) MaterializeObjectInstr(cls, slots, values);
   flow_graph_->InsertBefore(exit, mat, NULL, FlowGraph::kValue);
 
   // Replace all mentions of this allocation with a newly inserted
   // MaterializeObject instruction.
   // We must preserve the identity: all mentions are replaced by the same
   // materialization.
   for (Environment::DeepIterator env_it(exit->env());
        !env_it.Done();
        env_it.Advance()) {
     Value* use = env_it.CurrentValue();
     if (use->definition() == alloc) {
       use->RemoveFromUseList();
       use->set_definition(mat);
       mat->AddEnvUse(use);
     }
   }
 
   // Record inserted materialization.
   materializations_.Add(mat);
 }
 
 
 void AllocationSinking::InsertMaterializations(AllocateObjectInstr* alloc) {
   // Collect all fields that are written for this instance.
   ZoneGrowableArray<const Object*>* slots =
-      new ZoneGrowableArray<const Object*>(5);
+      new(isolate()) ZoneGrowableArray<const Object*>(5);
 
   for (Value* use = alloc->input_use_list();
        use != NULL;
        use = use->next_use()) {
     StoreInstanceFieldInstr* store = use->instruction()->AsStoreInstanceField();
     if (!store->field().IsNull()) {
       AddSlot(slots, store->field());
     } else {
-      AddSlot(slots, Smi::ZoneHandle(Smi::New(store->offset_in_bytes())));
+      AddSlot(slots, Smi::ZoneHandle(isolate(),
+                                     Smi::New(store->offset_in_bytes())));
     }
   }
 
   if (alloc->ArgumentCount() > 0) {
     ASSERT(alloc->ArgumentCount() == 1);
     intptr_t type_args_offset = alloc->cls().type_arguments_field_offset();
-    AddSlot(slots, Smi::ZoneHandle(Smi::New(type_args_offset)));
+    AddSlot(slots, Smi::ZoneHandle(isolate(), Smi::New(type_args_offset)));
   }
 
   // Collect all instructions that mention this object in the environment.
   GrowableArray<Instruction*> exits(10);
   for (Value* use = alloc->env_use_list();
        use != NULL;
        use = use->next_use()) {
     AddInstruction(&exits, use->instruction());
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart