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

runtime/vm/flow_graph_compiler.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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
@@ skipping 37 matching lines @@
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(int, regexp_optimization_counter_threshold);
 DECLARE_FLAG(int, reoptimization_counter_threshold);
 DECLARE_FLAG(int, stacktrace_every);
 DECLARE_FLAG(charp, stacktrace_filter);
 DECLARE_FLAG(bool, use_cha);
 DECLARE_FLAG(bool, use_osr);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
 
-// Quick access to the locally defined isolate() method.
-#define I (isolate())
-
 // Assign locations to incoming arguments, i.e., values pushed above spill slots
 // with PushArgument.  Recursively allocates from outermost to innermost
 // environment.
 void CompilerDeoptInfo::AllocateIncomingParametersRecursive(
     Environment* env,
     intptr_t* stack_height) {
   if (env == NULL) return;
   AllocateIncomingParametersRecursive(env->outer(), stack_height);
   for (Environment::ShallowIterator it(env); !it.Done(); it.Advance()) {
     if (it.CurrentLocation().IsInvalid() &&
@@ skipping 18 matching lines @@
 
 
 FlowGraphCompiler::FlowGraphCompiler(
     Assembler* assembler,
     FlowGraph* flow_graph,
     const ParsedFunction& parsed_function,
     bool is_optimizing,
     const GrowableArray<const Function*>& inline_id_to_function,
     const GrowableArray<intptr_t>& caller_inline_id)
       : isolate_(Isolate::Current()),
+        zone_(Thread::Current()->zone()),
         assembler_(assembler),
         parsed_function_(parsed_function),
         flow_graph_(*flow_graph),
         block_order_(*flow_graph->CodegenBlockOrder(is_optimizing)),
         current_block_(NULL),
         exception_handlers_list_(NULL),
         pc_descriptors_list_(NULL),
         stackmap_table_builder_(NULL),
         block_info_(block_order_.length()),
         deopt_infos_(),
@@ skipping 21 matching lines @@
         patch_code_pc_offset_(Code::kInvalidPc),
         lazy_deopt_pc_offset_(Code::kInvalidPc),
         deopt_id_to_ic_data_(NULL),
         inlined_code_intervals_(NULL),
         inline_id_to_function_(inline_id_to_function),
         caller_inline_id_(caller_inline_id) {
   ASSERT(flow_graph->parsed_function().function().raw() ==
          parsed_function.function().raw());
   if (!is_optimizing) {
     const intptr_t len = isolate()->deopt_id();
-    deopt_id_to_ic_data_ = new(isolate()) ZoneGrowableArray<const ICData*>(len);
+    deopt_id_to_ic_data_ = new(zone()) ZoneGrowableArray<const ICData*>(len);
     deopt_id_to_ic_data_->SetLength(len);
     for (intptr_t i = 0; i < len; i++) {
       (*deopt_id_to_ic_data_)[i] = NULL;
     }
-    const Array& old_saved_icdata = Array::Handle(isolate(),
+    const Array& old_saved_icdata = Array::Handle(zone(),
         flow_graph->function().ic_data_array());
     const intptr_t saved_len =
         old_saved_icdata.IsNull() ? 0 : old_saved_icdata.Length();
     for (intptr_t i = 0; i < saved_len; i++) {
-      ICData& icd = ICData::ZoneHandle(isolate());
+      ICData& icd = ICData::ZoneHandle(zone());
       icd ^= old_saved_icdata.At(i);
       (*deopt_id_to_ic_data_)[icd.deopt_id()] = &icd;
     }
   }
   ASSERT(assembler != NULL);
   ASSERT(!list_class_.IsNull());
 }
 
 
 void FlowGraphCompiler::InitCompiler() {
@@ skipping 598 matching lines @@
 //     FlowGraphCompiler::SaveLiveRegisters
 //     MaterializeObjectInstr::RemapRegisters
 //
 Environment* FlowGraphCompiler::SlowPathEnvironmentFor(
     Instruction* instruction) {
   if (instruction->env() == NULL) {
     ASSERT(!is_optimizing());
     return NULL;
   }
 
-  Environment* env = instruction->env()->DeepCopy(isolate());
+  Environment* env = instruction->env()->DeepCopy(zone());
   // 1. Iterate the registers in the order they will be spilled to compute
   //    the slots they will be spilled to.
   intptr_t next_slot = StackSize() + env->CountArgsPushed();
   RegisterSet* regs = instruction->locs()->live_registers();
   intptr_t fpu_reg_slots[kNumberOfFpuRegisters];
   intptr_t cpu_reg_slots[kNumberOfCpuRegisters];
   const intptr_t kFpuRegisterSpillFactor = kFpuRegisterSize / kWordSize;
   // FPU registers are spilled first from highest to lowest register number.
   for (intptr_t i = kNumberOfFpuRegisters - 1; i >= 0; --i) {
     FpuRegister reg = static_cast<FpuRegister>(i);
@@ skipping 67 matching lines @@
   code.set_lazy_deopt_pc_offset(lazy_deopt_pc_offset_);
 }
 
 
 void FlowGraphCompiler::FinalizeDeoptInfo(const Code& code) {
   // For functions with optional arguments, all incoming arguments are copied
   // to spill slots. The deoptimization environment does not track them.
   const Function& function = parsed_function().function();
   const intptr_t incoming_arg_count =
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
-  DeoptInfoBuilder builder(isolate(), incoming_arg_count);
+  DeoptInfoBuilder builder(zone(), incoming_arg_count);
 
   intptr_t deopt_info_table_size = DeoptTable::SizeFor(deopt_infos_.length());
   if (deopt_info_table_size == 0) {
     code.set_deopt_info_array(Object::empty_array());
     code.set_object_table(Object::empty_array());
   } else {
     const Array& array =
         Array::Handle(Array::New(deopt_info_table_size, Heap::kOld));
     Smi& offset = Smi::Handle();
     DeoptInfo& info = DeoptInfo::Handle();
@@ skipping 53 matching lines @@
   code.set_static_calls_target_table(
       Array::Handle(Array::MakeArray(static_calls_target_table_)));
 }
 
 
 // Returns 'true' if code generation for this function is complete, i.e.,
 // no fall-through to regular code is needed.
 void FlowGraphCompiler::TryIntrinsify() {
   // Intrinsification skips arguments checks, therefore disable if in checked
   // mode.
-  if (FLAG_intrinsify && !I->TypeChecksEnabled()) {
+  if (FLAG_intrinsify && !isolate()->TypeChecksEnabled()) {
     if (parsed_function().function().kind() == RawFunction::kImplicitGetter) {
       // An implicit getter must have a specific AST structure.
       const SequenceNode& sequence_node = *parsed_function().node_sequence();
       ASSERT(sequence_node.length() == 1);
       ASSERT(sequence_node.NodeAt(0)->IsReturnNode());
       const ReturnNode& return_node = *sequence_node.NodeAt(0)->AsReturnNode();
       ASSERT(return_node.value()->IsLoadInstanceFieldNode());
       const LoadInstanceFieldNode& load_node =
           *return_node.value()->AsLoadInstanceFieldNode();
       // Only intrinsify getter if the field cannot contain a mutable double.
@@ skipping 206 matching lines @@
     }
   }
   UNREACHABLE();
   return kNoRegister;
 }
 
 
 void FlowGraphCompiler::AllocateRegistersLocally(Instruction* instr) {
   ASSERT(!is_optimizing());
 
-  instr->InitializeLocationSummary(I->current_zone(),
+  instr->InitializeLocationSummary(zone(),
                                    false);  // Not optimizing.
   LocationSummary* locs = instr->locs();
 
   bool blocked_registers[kNumberOfCpuRegisters];
 
   // Mark all available registers free.
   for (intptr_t i = 0; i < kNumberOfCpuRegisters; i++) {
     blocked_registers[i] = false;
   }
 
@@ skipping 360 matching lines @@
     const Array& arguments_descriptor,
     intptr_t num_args_tested) {
   if ((deopt_id_to_ic_data_ != NULL) &&
       ((*deopt_id_to_ic_data_)[deopt_id] != NULL)) {
     const ICData* res = (*deopt_id_to_ic_data_)[deopt_id];
     ASSERT(res->deopt_id() == deopt_id);
     ASSERT(res->target_name() == target_name.raw());
     ASSERT(res->NumArgsTested() == num_args_tested);
     return res;
   }
-  const ICData& ic_data = ICData::ZoneHandle(isolate(), ICData::New(
+  const ICData& ic_data = ICData::ZoneHandle(zone(), ICData::New(
       parsed_function().function(), target_name,
       arguments_descriptor, deopt_id, num_args_tested));
   (*deopt_id_to_ic_data_)[deopt_id] = &ic_data;
   return &ic_data;
 }
 
 
 const ICData* FlowGraphCompiler::GetOrAddStaticCallICData(
     intptr_t deopt_id,
     const Function& target,
     const Array& arguments_descriptor,
     intptr_t num_args_tested) {
   if ((deopt_id_to_ic_data_ != NULL) &&
       ((*deopt_id_to_ic_data_)[deopt_id] != NULL)) {
     const ICData* res = (*deopt_id_to_ic_data_)[deopt_id];
     ASSERT(res->deopt_id() == deopt_id);
     ASSERT(res->target_name() == target.name());
     ASSERT(res->NumArgsTested() == num_args_tested);
     return res;
   }
-  const ICData& ic_data = ICData::ZoneHandle(isolate(), ICData::New(
-      parsed_function().function(), String::Handle(isolate(), target.name()),
+  const ICData& ic_data = ICData::ZoneHandle(zone(), ICData::New(
+      parsed_function().function(), String::Handle(zone(), target.name()),
       arguments_descriptor, deopt_id, num_args_tested));
   ic_data.AddTarget(target);
   (*deopt_id_to_ic_data_)[deopt_id] = &ic_data;
   return &ic_data;
 }
 
 
 intptr_t FlowGraphCompiler::GetOptimizationThreshold() const {
   intptr_t threshold;
   if (is_optimizing()) {
@@ skipping 110 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif
 
 
 }  // namespace dart