Add Zone-based handle allocation interface and reduce use of Isolate-based interfaces.

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 46 matching lines @@
 DEFINE_FLAG(bool, enable_inlining_annotations, false,
             "Enable inlining annotations");
 
 DECLARE_FLAG(bool, compiler_stats);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 DECLARE_FLAG(bool, print_flow_graph);
 DECLARE_FLAG(bool, print_flow_graph_optimized);
 DECLARE_FLAG(bool, verify_compiler);
 
+// Quick access to the current zone.
+#define Z (zone())
+
 #define TRACE_INLINING(statement)                                              \
   do {                                                                         \
     if (FLAG_trace_inlining) statement;                                        \
   } while (false)
 
 #define PRINT_INLINING_TREE(comment, caller, target, instance_call)            \
   do {                                                                         \
     if (FLAG_print_inlining_tree) {                                            \
       inlined_info_.Add(InlinedInfo(                                           \
           caller, target, inlining_depth_, instance_call, comment));           \
@@ skipping 354 matching lines @@
  private:
   bool CheckInlinedDuplicate(const Function& target);
   bool CheckNonInlinedDuplicate(const Function& target);
 
   bool TryInliningPoly(intptr_t receiver_cid, const Function& target);
   bool TryInlineRecognizedMethod(intptr_t receiver_cid, const Function& target);
 
   TargetEntryInstr* BuildDecisionGraph();
 
   Isolate* isolate() const;
+  Zone* zone() const;
 
   CallSiteInliner* const owner_;
   PolymorphicInstanceCallInstr* const call_;
   const intptr_t num_variants_;
   GrowableArray<CidTarget> variants_;
 
   GrowableArray<CidTarget> inlined_variants_;
   GrowableArray<CidTarget> non_inlined_variants_;
   GrowableArray<BlockEntryInstr*> inlined_entries_;
   InlineExitCollector* exit_collector_;
@@ skipping 32 matching lines @@
         inlined_recursive_call_(false),
         inlining_depth_(1),
         inlining_recursion_depth_(0),
         collected_call_sites_(NULL),
         inlining_call_sites_(NULL),
         function_cache_(),
         inlined_info_() { }
 
   FlowGraph* caller_graph() const { return caller_graph_; }
 
+  Thread* thread() const { return caller_graph_->thread(); }
   Isolate* isolate() const { return caller_graph_->isolate(); }
+  Zone* zone() const { return caller_graph_->zone(); }
 
   // Inlining heuristics based on Cooper et al. 2008.
   bool ShouldWeInline(const Function& callee,
                       intptr_t instr_count,
                       intptr_t call_site_count,
                       intptr_t const_arg_count) {
     if (FlowGraphInliner::AlwaysInline(callee)) {
       return true;
     }
     if (inlined_size_ > FLAG_inlining_caller_size_threshold) {
@@ skipping 74 matching lines @@
     return static_cast<double>(inlined_size_) /
         static_cast<double>(initial_size_);
   }
 
   // Helper to create a parameter stub from an actual argument.
   Definition* CreateParameterStub(intptr_t i,
                                   Value* argument,
                                   FlowGraph* graph) {
     ConstantInstr* constant = argument->definition()->AsConstant();
     if (constant != NULL) {
-      return new(isolate()) ConstantInstr(constant->value());
+      return new(Z) ConstantInstr(constant->value());
     } else {
-      return new(isolate()) ParameterInstr(i, graph->graph_entry());
+      return new(Z) ParameterInstr(i, graph->graph_entry());
     }
   }
 
   bool TryInlining(const Function& function,
                    const Array& argument_names,
                    InlinedCallData* call_data) {
     TRACE_INLINING(OS::Print("  => %s (deopt count %d)\n",
                              function.ToCString(),
                              function.deoptimization_counter()));
 
@@ skipping 66 matching lines @@
       ParsedFunction* parsed_function;
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_parse_timer,
                          isolate());
         parsed_function = GetParsedFunction(function, &in_cache);
       }
 
       // Load IC data for the callee.
       ZoneGrowableArray<const ICData*>* ic_data_array =
-            new(isolate()) ZoneGrowableArray<const ICData*>();
+            new(Z) ZoneGrowableArray<const ICData*>();
       function.RestoreICDataMap(ic_data_array);
 
       // Build the callee graph.
       InlineExitCollector* exit_collector =
-          new(isolate()) InlineExitCollector(caller_graph_, call);
+          new(Z) InlineExitCollector(caller_graph_, call);
       FlowGraphBuilder builder(parsed_function,
                                *ic_data_array,
                                exit_collector,
                                Isolate::kNoDeoptId);
       builder.SetInitialBlockId(caller_graph_->max_block_id());
       FlowGraph* callee_graph;
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphinliner_build_timer,
                          isolate());
         callee_graph = builder.BuildGraph();
       }
 
       // The parameter stubs are a copy of the actual arguments providing
       // concrete information about the values, for example constant values,
       // without linking between the caller and callee graphs.
       // TODO(zerny): Put more information in the stubs, eg, type information.
       ZoneGrowableArray<Definition*>* param_stubs =
-          new(isolate()) ZoneGrowableArray<Definition*>(
+          new(Z) ZoneGrowableArray<Definition*>(
               function.NumParameters());
 
       // Create a parameter stub for each fixed positional parameter.
       for (intptr_t i = 0; i < function.num_fixed_parameters(); ++i) {
         param_stubs->Add(CreateParameterStub(i, (*arguments)[i], callee_graph));
       }
 
       // If the callee has optional parameters, rebuild the argument and stub
       // arrays so that actual arguments are in one-to-one with the formal
       // parameters.
@@ skipping 254 matching lines @@
         callee_graph->graph_entry()->initial_definitions();
     for (intptr_t i = 0; i < defns->length(); ++i) {
       ConstantInstr* constant = (*defns)[i]->AsConstant();
       if ((constant != NULL) && constant->HasUses()) {
         constant->ReplaceUsesWith(
             caller_graph_->GetConstant(constant->value()));
       }
       CurrentContextInstr* context = (*defns)[i]->AsCurrentContext();
       if ((context != NULL) && context->HasUses()) {
         ASSERT(call->IsClosureCall());
-        LoadFieldInstr* context_load = new(isolate()) LoadFieldInstr(
+        LoadFieldInstr* context_load = new(Z) LoadFieldInstr(
             new Value((*arguments)[0]->definition()),
             Closure::context_offset(),
             AbstractType::ZoneHandle(isolate(), AbstractType::null()),
             call_data->call->token_pos());
         context_load->set_is_immutable(true);
         context_load->set_ssa_temp_index(
             caller_graph_->alloc_ssa_temp_index());
         context_load->InsertBefore(callee_entry->next());
         context->ReplaceUsesWith(context_load);
       }
@@ skipping 16 matching lines @@
     // TODO(zerny): Use a hash map for the cache.
     for (intptr_t i = 0; i < function_cache_.length(); ++i) {
       ParsedFunction* parsed_function = function_cache_[i];
       if (parsed_function->function().raw() == function.raw()) {
         *in_cache = true;
         return parsed_function;
       }
     }
     *in_cache = false;
     ParsedFunction* parsed_function =
-        new(isolate()) ParsedFunction(isolate(), function);
+        new(Z) ParsedFunction(thread(), function);
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
     return parsed_function;
   }
 
   // Include special handling for List. factory: inlining it is not helpful
   // if the incoming argument is a non-constant value.
   // TODO(srdjan): Fix inlining of List. factory.
   void InlineStaticCalls() {
     const GrowableArray<CallSites::StaticCallInfo>& call_info =
@@ skipping 141 matching lines @@
       }
       ASSERT(function.NumOptionalPositionalParameters() ==
              (param_count - fixed_param_count));
       // For each optional positional parameter without an actual, add its
       // default value.
       for (intptr_t i = arg_count; i < param_count; ++i) {
         const Object& object =
             Object::ZoneHandle(
                 parsed_function.default_parameter_values().At(
                     i - fixed_param_count));
-        ConstantInstr* constant = new(isolate()) ConstantInstr(object);
+        ConstantInstr* constant = new(Z) ConstantInstr(object);
         arguments->Add(NULL);
         param_stubs->Add(constant);
       }
       return true;
     }
 
     ASSERT(function.HasOptionalNamedParameters());
 
     // Passed arguments must match fixed parameters plus named arguments.
     intptr_t argument_names_count =
@@ skipping 67 matching lines @@
 PolymorphicInliner::PolymorphicInliner(CallSiteInliner* owner,
                                        PolymorphicInstanceCallInstr* call,
                                        const Function& caller_function)
     : owner_(owner),
       call_(call),
       num_variants_(call->ic_data().NumberOfChecks()),
       variants_(num_variants_),
       inlined_variants_(num_variants_),
       non_inlined_variants_(num_variants_),
       inlined_entries_(num_variants_),
-      exit_collector_(new(isolate())
+      exit_collector_(new(Z)
           InlineExitCollector(owner->caller_graph(), call)),
       caller_function_(caller_function) {
 }
 
 
 Isolate* PolymorphicInliner::isolate() const {
   return owner_->caller_graph()->isolate();
 }
 
 
+Zone* PolymorphicInliner::zone() const {
+  return owner_->caller_graph()->zone();
+}
+
+
 // Inlined bodies are shared if two different class ids have the same
 // inlined target.  This sharing is represented by using three different
 // types of entries in the inlined_entries_ array:
 //
 //   * GraphEntry: the inlined body is not shared.
 //
 //   * TargetEntry: the inlined body is shared and this is the first variant.
 //
 //   * JoinEntry: the inlined body is shared and this is a subsequent variant.
 bool PolymorphicInliner::CheckInlinedDuplicate(const Function& target) {
@@ skipping 19 matching lines @@
         old_target->ReplaceAsPredecessorWith(new_join);
         for (intptr_t j = 0; j < old_target->dominated_blocks().length(); ++j) {
           BlockEntryInstr* block = old_target->dominated_blocks()[j];
           new_join->AddDominatedBlock(block);
         }
         // Create a new target with the join as unconditional successor.
         TargetEntryInstr* new_target =
             new TargetEntryInstr(owner_->caller_graph()->allocate_block_id(),
                                  old_target->try_index());
         new_target->InheritDeoptTarget(isolate(), new_join);
-        GotoInstr* new_goto = new(isolate()) GotoInstr(new_join);
+        GotoInstr* new_goto = new(Z) GotoInstr(new_join);
         new_goto->InheritDeoptTarget(isolate(), new_join);
         new_target->LinkTo(new_goto);
         new_target->set_last_instruction(new_goto);
         new_join->predecessors_.Add(new_target);
 
         // Record the new target for the first variant.
         inlined_entries_[i] = new_target;
       }
       ASSERT(inlined_entries_[i]->IsTargetEntry());
       // Record the shared join for this variant.
@@ skipping 41 matching lines @@
   FlowGraph* callee_graph = call_data.callee_graph;
   call_data.exit_collector->PrepareGraphs(callee_graph);
   inlined_entries_.Add(callee_graph->graph_entry());
   exit_collector_->Union(call_data.exit_collector);
 
   // Replace parameter stubs and constants.  Replace the receiver argument
   // with a redefinition to prevent code from the inlined body from being
   // hoisted above the inlined entry.
   ASSERT(arguments.length() > 0);
   Value* actual = arguments[0];
-  RedefinitionInstr* redefinition = new(isolate())
+  RedefinitionInstr* redefinition = new(Z)
       RedefinitionInstr(actual->Copy(isolate()));
   redefinition->set_ssa_temp_index(
       owner_->caller_graph()->alloc_ssa_temp_index());
   redefinition->UpdateType(CompileType::FromCid(receiver_cid));
   redefinition->InsertAfter(callee_graph->graph_entry()->normal_entry());
   Definition* stub = (*call_data.parameter_stubs)[0];
   stub->ReplaceUsesWith(redefinition);
 
   for (intptr_t i = 1; i < arguments.length(); ++i) {
     actual = arguments[i];
     if (actual != NULL) {
       stub = (*call_data.parameter_stubs)[i];
       stub->ReplaceUsesWith(actual->definition());
     }
   }
   GrowableArray<Definition*>* defns =
       callee_graph->graph_entry()->initial_definitions();
   for (intptr_t i = 0; i < defns->length(); ++i) {
     ConstantInstr* constant = (*defns)[i]->AsConstant();
     if ((constant != NULL) && constant->HasUses()) {
       constant->ReplaceUsesWith(
           owner_->caller_graph()->GetConstant(constant->value()));
     }
     CurrentContextInstr* context = (*defns)[i]->AsCurrentContext();
     if ((context != NULL) && context->HasUses()) {
       ASSERT(call_data.call->IsClosureCall());
-      LoadFieldInstr* context_load = new(isolate()) LoadFieldInstr(
+      LoadFieldInstr* context_load = new(Z) LoadFieldInstr(
           new Value(redefinition),
           Closure::context_offset(),
           AbstractType::ZoneHandle(isolate(), AbstractType::null()),
           call_data.call->token_pos());
       context_load->set_is_immutable(true);
       context_load->set_ssa_temp_index(
           owner_->caller_graph()->alloc_ssa_temp_index());
       context_load->InsertAfter(redefinition);
       context->ReplaceUsesWith(context_load);
     }
@@ skipping 16 matching lines @@
 bool PolymorphicInliner::TryInlineRecognizedMethod(intptr_t receiver_cid,
                                                    const Function& target) {
   FlowGraphOptimizer optimizer(owner_->caller_graph());
   TargetEntryInstr* entry;
   Definition* last;
   // Replace the receiver argument with a redefinition to prevent code from
   // the inlined body from being hoisted above the inlined entry.
   GrowableArray<Definition*> arguments(call_->ArgumentCount());
   Definition* receiver = call_->ArgumentAt(0);
     RedefinitionInstr* redefinition =
-        new(isolate()) RedefinitionInstr(new(isolate()) Value(receiver));
+        new(Z) RedefinitionInstr(new(Z) Value(receiver));
     redefinition->set_ssa_temp_index(
         owner_->caller_graph()->alloc_ssa_temp_index());
   if (optimizer.TryInlineRecognizedMethod(receiver_cid,
                                           target,
                                           call_,
                                           redefinition,
                                           call_->instance_call()->token_pos(),
                                           *call_->instance_call()->ic_data(),
                                           &entry, &last)) {
     // Create a graph fragment.
     redefinition->InsertAfter(entry);
     InlineExitCollector* exit_collector =
-        new(isolate()) InlineExitCollector(owner_->caller_graph(), call_);
+        new(Z) InlineExitCollector(owner_->caller_graph(), call_);
 
     ReturnInstr* result =
-        new(isolate()) ReturnInstr(call_->instance_call()->token_pos(),
-            new(isolate()) Value(last));
+        new(Z) ReturnInstr(call_->instance_call()->token_pos(),
+            new(Z) Value(last));
     owner_->caller_graph()->AppendTo(
         last,
         result,
         call_->env(),  // Return can become deoptimization target.
         FlowGraph::kEffect);
     entry->set_last_instruction(result);
     exit_collector->AddExit(result);
     GraphEntryInstr* graph_entry =
-        new(isolate()) GraphEntryInstr(NULL,  // No parsed function.
+        new(Z) GraphEntryInstr(NULL,  // No parsed function.
                                        entry,
                                        Isolate::kNoDeoptId);  // No OSR id.
     // Update polymorphic inliner state.
     inlined_entries_.Add(graph_entry);
     exit_collector_->Union(exit_collector);
     return true;
   }
   return false;
 }
 
 
 // Build a DAG to dispatch to the inlined function bodies.  Load the class
 // id of the receiver and make explicit comparisons for each inlined body,
 // in frequency order.  If all variants are inlined, the entry to the last
 // inlined body is guarded by a CheckClassId instruction which can deopt.
 // If not all variants are inlined, we add a PolymorphicInstanceCall
 // instruction to handle the non-inlined variants.
 TargetEntryInstr* PolymorphicInliner::BuildDecisionGraph() {
   // Start with a fresh target entry.
   TargetEntryInstr* entry =
-      new(isolate()) TargetEntryInstr(
+      new(Z) TargetEntryInstr(
           owner_->caller_graph()->allocate_block_id(),
           call_->GetBlock()->try_index());
   entry->InheritDeoptTarget(isolate(), call_);
 
   // This function uses a cursor (a pointer to the 'current' instruction) to
   // build the graph.  The next instruction will be inserted after the
   // cursor.
   TargetEntryInstr* current_block = entry;
   Instruction* cursor = entry;
 
   Definition* receiver = call_->ArgumentAt(0);
   // There are at least two variants including non-inlined ones, so we have
   // at least one branch on the class id.
   LoadClassIdInstr* load_cid =
-      new(isolate()) LoadClassIdInstr(new(isolate()) Value(receiver));
+      new(Z) LoadClassIdInstr(new(Z) Value(receiver));
   load_cid->set_ssa_temp_index(owner_->caller_graph()->alloc_ssa_temp_index());
   cursor = AppendInstruction(cursor, load_cid);
   for (intptr_t i = 0; i < inlined_variants_.length(); ++i) {
     // 1. Guard the body with a class id check.
     if ((i == (inlined_variants_.length() - 1)) &&
         non_inlined_variants_.is_empty()) {
       // If it is the last variant use a check class id instruction which can
       // deoptimize, followed unconditionally by the body.
       RedefinitionInstr* cid_redefinition =
-          new RedefinitionInstr(new(isolate()) Value(load_cid));
+          new RedefinitionInstr(new(Z) Value(load_cid));
       cid_redefinition->set_ssa_temp_index(
           owner_->caller_graph()->alloc_ssa_temp_index());
       cursor = AppendInstruction(cursor, cid_redefinition);
-      CheckClassIdInstr* check_class_id = new(isolate()) CheckClassIdInstr(
-          new(isolate()) Value(cid_redefinition),
+      CheckClassIdInstr* check_class_id = new(Z) CheckClassIdInstr(
+          new(Z) Value(cid_redefinition),
           inlined_variants_[i].cid,
           call_->deopt_id());
       check_class_id->InheritDeoptTarget(isolate(), call_);
       cursor = AppendInstruction(cursor, check_class_id);
 
       // The next instruction is the first instruction of the inlined body.
       // Handle the two possible cases (unshared and shared subsequent
       // predecessors) separately.
       BlockEntryInstr* callee_entry = inlined_entries_[i];
       if (callee_entry->IsGraphEntry()) {
@@ skipping 288 matching lines @@
 
 
 intptr_t FlowGraphInliner::NextInlineId(const Function& function) {
   const intptr_t id = inline_id_to_function_->length();
   inline_id_to_function_->Add(&function);
   return id;
 }
 
 
 }  // namespace dart