Fix CompilerStats info

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 664 matching lines @@
     const intptr_t prev_deopt_id = isolate()->deopt_id();
     isolate()->set_deopt_id(0);
     // Install bailout jump.
     LongJumpScope jump;
     if (setjmp(*jump.Set()) == 0) {
       // Parse the callee function.
       bool in_cache;
       ParsedFunction* parsed_function;
       {
         TimerScope timer(FLAG_compiler_stats,
-                         &CompilerStats::graphinliner_parse_timer,
+                         &CSTAT_TIMER(graphinliner_parse_timer),
                          isolate());
         const Error& error = Error::Handle(Z,
             Compiler::EnsureUnoptimizedCode(Thread::Current(), function));
         if (!error.IsNull()) {
           Exceptions::PropagateError(error);
         }
         parsed_function = GetParsedFunction(function, &in_cache);
       }
 
       // Load IC data for the callee.
       ZoneGrowableArray<const ICData*>* ic_data_array =
             new(Z) ZoneGrowableArray<const ICData*>();
       function.RestoreICDataMap(ic_data_array);
 
       // Build the callee graph.
       InlineExitCollector* exit_collector =
           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,
+                         &CSTAT_TIMER(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(Z) ZoneGrowableArray<Definition*>(
@@ skipping 35 matching lines @@
           BlockEntryInstr* block = it.Current();
           block->set_try_index(try_index);
         }
       }
 
       BlockScheduler block_scheduler(callee_graph);
       block_scheduler.AssignEdgeWeights();
 
       {
         TimerScope timer(FLAG_compiler_stats,
-                         &CompilerStats::graphinliner_ssa_timer,
+                         &CSTAT_TIMER(graphinliner_ssa_timer),
                          isolate());
         // Compute SSA on the callee graph, catching bailouts.
         callee_graph->ComputeSSA(caller_graph_->max_virtual_register_number(),
                                  param_stubs);
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
       }
 
       {
         TimerScope timer(FLAG_compiler_stats,
-                         &CompilerStats::graphinliner_opt_timer,
+                         &CSTAT_TIMER(graphinliner_opt_timer),
                          isolate());
         // TODO(zerny): Do more optimization passes on the callee graph.
         FlowGraphOptimizer optimizer(callee_graph);
         optimizer.ApplyICData();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge instructions. Must occur before
         // 'SelectRepresentations' which inserts conversion nodes.
         optimizer.TryOptimizePatterns();
         DEBUG_ASSERT(callee_graph->VerifyUseLists());
@@ skipping 159 matching lines @@
             info.call_instr->GetDeoptId(),
             info.inlined->ToQualifiedCString(),
             info.bailout_reason);
         call_instructions_printed.Add(info.call_instr->GetDeoptId());
       }
     }
   }
 
   void InlineCall(InlinedCallData* call_data) {
     TimerScope timer(FLAG_compiler_stats,
-                     &CompilerStats::graphinliner_subst_timer,
+                     &CSTAT_TIMER(graphinliner_subst_timer),
                      Isolate::Current());
     FlowGraph* callee_graph = call_data->callee_graph;
     TargetEntryInstr* callee_entry =
         callee_graph->graph_entry()->normal_entry();
     // Plug result in the caller graph.
     InlineExitCollector* exit_collector = call_data->exit_collector;
     exit_collector->PrepareGraphs(callee_graph);
     exit_collector->ReplaceCall(callee_entry);
 
     // Replace each stub with the actual argument or the caller's constant.
@@ skipping 912 matching lines @@
 intptr_t FlowGraphInliner::NextInlineId(const Function& function,
                                         intptr_t parent_id) {
   const intptr_t id = inline_id_to_function_->length();
   inline_id_to_function_->Add(&function);
   caller_inline_id_->Add(parent_id);
   return id;
 }
 
 
 }  // namespace dart