PATCH (not to be comitted): Support for printing instruction statistics

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"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/locations.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/timeline.h"
+#include "vm/code_statistics.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool,
             enable_simd_inline,
             true,
             "Enable inlining of SIMD related method calls.");
 DEFINE_FLAG(
     bool,
     inline_smi_string_hashcode,
@@ skipping 160 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<TokenPosition>& inline_id_to_token_pos,
-    const GrowableArray<intptr_t>& caller_inline_id)
+    const GrowableArray<intptr_t>& caller_inline_id,
+    CodeStatistics* stats)
     : thread_(Thread::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),
@@ skipping 16 matching lines @@
           Class::ZoneHandle(isolate()->object_store()->int32x4_class())),
       list_class_(Class::ZoneHandle(Library::Handle(Library::CoreLibrary())
                                         .LookupClass(Symbols::List()))),
       parallel_move_resolver_(this),
       pending_deoptimization_env_(NULL),
       deopt_id_to_ic_data_(NULL),
       edge_counters_array_(Array::ZoneHandle()),
       inlined_code_intervals_(Array::ZoneHandle(Object::empty_array().raw())),
       inline_id_to_function_(inline_id_to_function),
       inline_id_to_token_pos_(inline_id_to_token_pos),
-      caller_inline_id_(caller_inline_id) {
+      caller_inline_id_(caller_inline_id),
+      stats_(stats) {
   ASSERT(flow_graph->parsed_function().function().raw() ==
          parsed_function.function().raw());
   if (!is_optimizing) {
     const intptr_t len = thread()->deopt_id();
     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;
     }
     // TODO(fschneider): Abstract iteration into ICDataArrayIterator.
@@ skipping 183 matching lines @@
       // Instructions that can be deoptimization targets need to record kDeopt
       // PcDescriptor corresponding to their deopt id. GotoInstr records its
       // own so that it can control the placement.
       AddCurrentDescriptor(RawPcDescriptors::kDeopt, instr->deopt_id(),
                            instr->token_pos());
     }
     AllocateRegistersLocally(instr);
   } else if (instr->MayThrow() &&
              (CurrentTryIndex() != CatchClauseNode::kInvalidTryIndex)) {
     // Optimized try-block: Sync locals to fixed stack locations.
+    SpecialStatsBegin(CombinedCodeStatistics::kTagTrySyncSpilling);
     EmitTrySync(instr, CurrentTryIndex());
+    SpecialStatsEnd(CombinedCodeStatistics::kTagTrySyncSpilling);
   }
 }
 
 
 void FlowGraphCompiler::EmitSourceLine(Instruction* instr) {
   if (!instr->token_pos().IsReal() || (instr->env() == NULL)) {
     return;
   }
   const Script& script =
       Script::Handle(zone(), instr->env()->function().script());
@@ skipping 70 matching lines @@
       FrameStateClear();
     }
 #endif
 
     LoopInfoComment(assembler(), *entry, *loop_headers);
 
     entry->set_offset(assembler()->CodeSize());
     BeginCodeSourceRange();
     ASSERT(pending_deoptimization_env_ == NULL);
     pending_deoptimization_env_ = entry->env();
+    StatsBegin(entry);
     entry->EmitNativeCode(this);
+    StatsEnd(entry);
     pending_deoptimization_env_ = NULL;
     EndCodeSourceRange(entry->token_pos());
     // Compile all successors until an exit, branch, or a block entry.
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       Instruction* instr = it.Current();
+
+      StatsBegin(instr);
+
       // Compose intervals.
       if (instr->has_inlining_id() && is_optimizing()) {
         if (prev_inlining_id != instr->inlining_id()) {
           intervals.Add(
               IntervalStruct(prev_offset, prev_inlining_pos, prev_inlining_id));
           prev_offset = assembler()->CodeSize();
           prev_inlining_id = instr->inlining_id();
           if (prev_inlining_id < inline_id_to_token_pos_.length()) {
             prev_inlining_pos = inline_id_to_token_pos_[prev_inlining_id];
           } else {
@@ skipping 24 matching lines @@
         pending_deoptimization_env_ = NULL;
         EmitInstructionEpilogue(instr);
         EndCodeSourceRange(instr->token_pos());
       }
 
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
       if (!is_optimizing()) {
         FrameStateUpdateWith(instr);
       }
 #endif
+      StatsEnd(instr);
     }
 
 #if defined(DEBUG) && !defined(TARGET_ARCH_DBC)
     ASSERT(is_optimizing() || FrameStateIsSafeToCall());
 #endif
   }
 
   if (is_optimizing()) {
     LogBlock lb;
     intervals.Add(
@@ skipping 543 matching lines @@
     if (parsed_function().function().kind() == RawFunction::kImplicitGetter) {
       // TODO(27590) Store Field object inside RawFunction::data_ if possible.
       name = Field::NameFromGetter(name);
       const Field& field = Field::Handle(owner.LookupFieldAllowPrivate(name));
       ASSERT(!field.IsNull());
 
       // Only intrinsify getter if the field cannot contain a mutable double.
       // Reading from a mutable double box requires allocating a fresh double.
       if (field.is_instance() &&
           (FLAG_precompiled_mode || !IsPotentialUnboxedField(field))) {
+        SpecialStatsBegin(CombinedCodeStatistics::kTagIntrinsics);
         GenerateInlinedGetter(field.Offset());
+        SpecialStatsEnd(CombinedCodeStatistics::kTagIntrinsics);
         return !FLAG_use_field_guards;
       }
       return false;
     }
     if (parsed_function().function().kind() == RawFunction::kImplicitSetter) {
       // TODO(27590) Store Field object inside RawFunction::data_ if possible.
       name = Field::NameFromSetter(name);
       const Field& field = Field::Handle(owner.LookupFieldAllowPrivate(name));
       ASSERT(!field.IsNull());
 
       if (field.is_instance() &&
           (FLAG_precompiled_mode || field.guarded_cid() == kDynamicCid)) {
+        SpecialStatsBegin(CombinedCodeStatistics::kTagIntrinsics);
         GenerateInlinedSetter(field.Offset());
+        SpecialStatsEnd(CombinedCodeStatistics::kTagIntrinsics);
         return !FLAG_use_field_guards;
       }
       return false;
     }
   }
 
   EnterIntrinsicMode();
 
+  SpecialStatsBegin(CombinedCodeStatistics::kTagIntrinsics);
   bool complete = Intrinsifier::Intrinsify(parsed_function(), this);
+  SpecialStatsEnd(CombinedCodeStatistics::kTagIntrinsics);
 
   ExitIntrinsicMode();
 
   // "Deoptimization" from intrinsic continues here. All deoptimization
   // branches from intrinsic code redirect to here where the slow-path
   // (normal function body) starts.
   // This means that there must not be any side-effects in intrinsic code
   // before any deoptimization point.
   ASSERT(!intrinsic_slow_path_label_.IsBound());
   assembler()->Bind(&intrinsic_slow_path_label_);
@@ skipping 793 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif  // defined(DEBUG) && !defined(TARGET_ARCH_DBC)
 
 
 }  // namespace dart