Cleanups: parsed_function()->function() => function()

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 179 matching lines @@
         instance_calls_() { }
 
   struct InstanceCallInfo {
     PolymorphicInstanceCallInstr* call;
     double ratio;
     const Function* caller;
     InstanceCallInfo(PolymorphicInstanceCallInstr* call_arg,
                      FlowGraph* flow_graph)
         : call(call_arg),
           ratio(0.0),
-          caller(&flow_graph->parsed_function()->function()) {}
+          caller(&flow_graph->function()) {}
   };
 
   struct StaticCallInfo {
     StaticCallInstr* call;
     double ratio;
     const Function* caller;
     StaticCallInfo(StaticCallInstr* value, FlowGraph* flow_graph)
         : call(value),
           ratio(0.0),
-          caller(&flow_graph->parsed_function()->function()) {}
+          caller(&flow_graph->function()) {}
   };
 
   struct ClosureCallInfo {
     ClosureCallInstr* call;
     const Function* caller;
     ClosureCallInfo(ClosureCallInstr* value, FlowGraph* flow_graph)
         : call(value),
-          caller(&flow_graph->parsed_function()->function()) {}
+          caller(&flow_graph->function()) {}
   };
 
   const GrowableArray<InstanceCallInfo>& instance_calls() const {
     return instance_calls_;
   }
 
   const GrowableArray<StaticCallInfo>& static_calls() const {
     return static_calls_;
   }
 
@@ skipping 55 matching lines @@
       const double ratio = (max_count == 0) ?
           0.0 : static_cast<double>(static_call_counts[i]) / max_count;
       static_calls_[i + static_call_start_ix].ratio = ratio;
     }
   }
 
   static void RecordAllNotInlinedFunction(
       FlowGraph* graph,
       intptr_t depth,
       GrowableArray<InlinedInfo>* inlined_info) {
-    const Function* caller = &graph->parsed_function()->function();
+    const Function* caller = &graph->function();
     Function& target  = Function::ZoneHandle();
     for (BlockIterator block_it = graph->postorder_iterator();
          !block_it.Done();
          block_it.Advance()) {
       for (ForwardInstructionIterator it(block_it.Current());
            !it.Done();
            it.Advance()) {
         Instruction* current = it.Current();
         Definition* call = NULL;
         if (current->IsPolymorphicInstanceCall()) {
@@ skipping 46 matching lines @@
           PolymorphicInstanceCallInstr* instance_call =
               current->AsPolymorphicInstanceCall();
           if (!inline_only_recognized_methods ||
               instance_call->HasSingleRecognizedTarget() ||
               instance_call->HasOnlyDispatcherTargets()) {
             instance_calls_.Add(InstanceCallInfo(instance_call, graph));
           } else {
             // Method not inlined because inlining too deep and method
             // not recognized.
             if (FLAG_print_inlining_tree) {
-              const Function* caller = &graph->parsed_function()->function();
+              const Function* caller = &graph->function();
               const Function* target =
                   &Function::ZoneHandle(
                       instance_call->ic_data().GetTargetAt(0));
               inlined_info->Add(InlinedInfo(
                   caller, target, depth + 1, instance_call, "Too deep"));
             }
           }
         } else if (current->IsStaticCall()) {
           StaticCallInstr* static_call = current->AsStaticCall();
           if (!inline_only_recognized_methods ||
               static_call->function().IsRecognized()) {
             static_calls_.Add(StaticCallInfo(static_call, graph));
           } else {
             // Method not inlined because inlining too deep and method
             // not recognized.
             if (FLAG_print_inlining_tree) {
-              const Function* caller = &graph->parsed_function()->function();
+              const Function* caller = &graph->function();
               const Function* target = &static_call->function();
               inlined_info->Add(InlinedInfo(
                   caller, target, depth + 1, static_call, "Too deep"));
             }
           }
         } else if (current->IsClosureCall()) {
           if (!inline_only_recognized_methods) {
             ClosureCallInstr* closure_call = current->AsClosureCall();
             closure_calls_.Add(ClosureCallInfo(closure_call, graph));
           }
@@ skipping 138 matching lines @@
     if ((const_arg_count >= FLAG_inlining_constant_arguments_count) &&
         (instr_count <= FLAG_inlining_constant_arguments_min_size_threshold)) {
       return true;
     }
     return false;
   }
 
   void InlineCalls() {
     // If inlining depth is less then one abort.
     if (FLAG_inlining_depth_threshold < 1) return;
-    if (caller_graph_->parsed_function()->function().deoptimization_counter() >=
+    if (caller_graph_->function().deoptimization_counter() >=
         FLAG_deoptimization_counter_inlining_threshold) {
       return;
     }
     // Create two call site collections to swap between.
     CallSites sites1(caller_graph_);
     CallSites sites2(caller_graph_);
     CallSites* call_sites_temp = NULL;
     collected_call_sites_ = &sites1;
     inlining_call_sites_ = &sites2;
     // Collect initial call sites.
@@ skipping 296 matching lines @@
       // list of guarded fields.
       for (intptr_t i = 0; i < callee_graph->guarded_fields()->length(); ++i) {
         FlowGraph::AddToGuardedFields(caller_graph_->guarded_fields(),
                                       (*callee_graph->guarded_fields())[i]);
       }
       // When inlined, we add the deferred prefixes of the callee to the
       // caller's list of deferred prefixes.
       caller_graph()->AddToDeferredPrefixes(callee_graph->deferred_prefixes());
 
       FlowGraphInliner::SetInliningId(*callee_graph,
-          inliner_->NextInlineId(callee_graph->parsed_function()->function()));
+          inliner_->NextInlineId(callee_graph->function()));
       // We allocate a ZoneHandle for the unoptimized code so that it cannot be
       // disconnected from its function during the rest of compilation.
       Code::ZoneHandle(unoptimized_code.raw());
       TRACE_INLINING(OS::Print("     Success\n"));
       PRINT_INLINING_TREE(NULL,
           &call_data->caller, &function, call);
       return true;
     } else {
       Error& error = Error::Handle();
       error = isolate()->object_store()->sticky_error();
@@ skipping 861 matching lines @@
   exit_collector_->ReplaceCall(entry);
 }
 
 
 static uint16_t ClampUint16(intptr_t v) {
   return (v > 0xFFFF) ? 0xFFFF : static_cast<uint16_t>(v);
 }
 
 
 void FlowGraphInliner::CollectGraphInfo(FlowGraph* flow_graph, bool force) {
-  const Function& function = flow_graph->parsed_function()->function();
+  const Function& function = flow_graph->function();
   if (force || (function.optimized_instruction_count() == 0)) {
     GraphInfoCollector info;
     info.Collect(*flow_graph);
 
     function.set_optimized_instruction_count(
         ClampUint16(info.instruction_count()));
     function.set_optimized_call_site_count(ClampUint16(info.call_site_count()));
   }
 }
 
@@ skipping 34 matching lines @@
   }
   return MethodRecognizer::AlwaysInline(function);
 }
 
 
 void FlowGraphInliner::Inline() {
   // Collect graph info and store it on the function.
   // We might later use it for an early bailout from the inlining.
   CollectGraphInfo(flow_graph_);
 
-  const Function& top = flow_graph_->parsed_function()->function();
+  const Function& top = flow_graph_->function();
   if ((FLAG_inlining_filter != NULL) &&
       (strstr(top.ToFullyQualifiedCString(), FLAG_inlining_filter) == NULL)) {
     return;
   }
 
   TRACE_INLINING(OS::Print("Inlining calls in %s\n", top.ToCString()));
 
   if (FLAG_trace_inlining &&
       (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized)) {
     OS::Print("Before Inlining of %s\n", flow_graph_->
-              parsed_function()->function().ToFullyQualifiedCString());
+              function().ToFullyQualifiedCString());
     FlowGraphPrinter printer(*flow_graph_);
     printer.PrintBlocks();
   }
 
   CallSiteInliner inliner(this);
   inliner.InlineCalls();
   if (FLAG_print_inlining_tree) {
     inliner.PrintInlinedInfo(top);
   }
 
   if (inliner.inlined()) {
     flow_graph_->DiscoverBlocks();
     if (FLAG_trace_inlining) {
       OS::Print("Inlining growth factor: %f\n", inliner.GrowthFactor());
       if (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized) {
         OS::Print("After Inlining of %s\n", flow_graph_->
-                  parsed_function()->function().ToFullyQualifiedCString());
+                  function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 
 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