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

runtime/vm/intermediate_language_x64.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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/compiler.h"
@@ skipping 1708 matching lines @@
 
 
 class BoxAllocationSlowPath : public SlowPathCode {
  public:
   BoxAllocationSlowPath(Instruction* instruction,
                         const Class& cls,
                         Register result)
       : instruction_(instruction), cls_(cls), result_(result) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+    compiler->SpecialStatsBegin(
+        CombinedCodeStatistics::kTagBoxAllocationSlowPath);
     if (Assembler::EmittingComments()) {
       __ Comment("%s slow path allocation of %s", instruction_->DebugName(),
                  String::Handle(cls_.ScrubbedName()).ToCString());
     }
     __ Bind(entry_label());
     const Code& stub = Code::ZoneHandle(
         compiler->zone(), StubCode::GetAllocationStubForClass(cls_));
     const StubEntry stub_entry(stub);
 
     LocationSummary* locs = instruction_->locs();
 
     locs->live_registers()->Remove(Location::RegisterLocation(result_));
 
     compiler->SaveLiveRegisters(locs);
     compiler->GenerateCall(TokenPosition::kNoSource,  // No token position.
                            stub_entry, RawPcDescriptors::kOther, locs);
     compiler->AddStubCallTarget(stub);
     __ MoveRegister(result_, RAX);
     compiler->RestoreLiveRegisters(locs);
     __ jmp(exit_label());
+    compiler->SpecialStatsEnd(
+        CombinedCodeStatistics::kTagBoxAllocationSlowPath);
   }
 
   static void Allocate(FlowGraphCompiler* compiler,
                        Instruction* instruction,
                        const Class& cls,
                        Register result,
                        Register temp) {
     if (compiler->intrinsic_mode()) {
       __ TryAllocate(cls, compiler->intrinsic_slow_path_label(),
                      Assembler::kFarJump, result, temp);
@@ skipping 638 matching lines @@
 }
 
 
 class AllocateContextSlowPath : public SlowPathCode {
  public:
   explicit AllocateContextSlowPath(
       AllocateUninitializedContextInstr* instruction)
       : instruction_(instruction) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+    compiler->SpecialStatsBegin(
+        CombinedCodeStatistics::kTagAllocateContextSlowPath);
     __ Comment("AllocateContextSlowPath");
     __ Bind(entry_label());
 
     LocationSummary* locs = instruction_->locs();
     locs->live_registers()->Remove(locs->out(0));
 
     compiler->SaveLiveRegisters(locs);
 
     __ LoadImmediate(R10, Immediate(instruction_->num_context_variables()));
     const Code& stub = Code::ZoneHandle(
         compiler->zone(), StubCode::AllocateContext_entry()->code());
     compiler->AddStubCallTarget(stub);
     compiler->GenerateCall(instruction_->token_pos(),
                            *StubCode::AllocateContext_entry(),
                            RawPcDescriptors::kOther, locs);
     ASSERT(instruction_->locs()->out(0).reg() == RAX);
     compiler->RestoreLiveRegisters(instruction_->locs());
     __ jmp(exit_label());
+    compiler->SpecialStatsEnd(
+        CombinedCodeStatistics::kTagAllocateContextSlowPath);
   }
 
  private:
   AllocateUninitializedContextInstr* instruction_;
 };
 
 
 void AllocateUninitializedContextInstr::EmitNativeCode(
     FlowGraphCompiler* compiler) {
   ASSERT(compiler->is_optimizing());
@@ skipping 189 matching lines @@
   return summary;
 }
 
 
 class CheckStackOverflowSlowPath : public SlowPathCode {
  public:
   explicit CheckStackOverflowSlowPath(CheckStackOverflowInstr* instruction)
       : instruction_(instruction) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+    compiler->SpecialStatsBegin(
+        CombinedCodeStatistics::kTagCheckStackOverflowSlowPath);
     if (FLAG_use_osr && osr_entry_label()->IsLinked()) {
       __ Comment("CheckStackOverflowSlowPathOsr");
       __ Bind(osr_entry_label());
       __ movq(Address(THR, Thread::stack_overflow_flags_offset()),
               Immediate(Thread::kOsrRequest));
     }
     __ Comment("CheckStackOverflowSlowPath");
     __ Bind(entry_label());
     compiler->SaveLiveRegisters(instruction_->locs());
     // pending_deoptimization_env_ is needed to generate a runtime call that
     // may throw an exception.
     ASSERT(compiler->pending_deoptimization_env_ == NULL);
     Environment* env = compiler->SlowPathEnvironmentFor(instruction_);
     compiler->pending_deoptimization_env_ = env;
     compiler->GenerateRuntimeCall(
         instruction_->token_pos(), instruction_->deopt_id(),
         kStackOverflowRuntimeEntry, 0, instruction_->locs());
 
     if (FLAG_use_osr && !compiler->is_optimizing() && instruction_->in_loop()) {
       // In unoptimized code, record loop stack checks as possible OSR entries.
       compiler->AddCurrentDescriptor(RawPcDescriptors::kOsrEntry,
                                      instruction_->deopt_id(),
                                      TokenPosition::kNoSource);
     }
     compiler->pending_deoptimization_env_ = NULL;
     compiler->RestoreLiveRegisters(instruction_->locs());
     __ jmp(exit_label());
+    compiler->SpecialStatsEnd(
+        CombinedCodeStatistics::kTagCheckStackOverflowSlowPath);
   }
 
 
   Label* osr_entry_label() {
     ASSERT(FLAG_use_osr);
     return &osr_entry_label_;
   }
 
  private:
   CheckStackOverflowInstr* instruction_;
@@ skipping 140 matching lines @@
   }
 }
 
 
 class CheckedSmiSlowPath : public SlowPathCode {
  public:
   CheckedSmiSlowPath(CheckedSmiOpInstr* instruction, intptr_t try_index)
       : instruction_(instruction), try_index_(try_index) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+    compiler->SpecialStatsBegin(CombinedCodeStatistics::kTagCheckedSmiSlowPath);
     if (Assembler::EmittingComments()) {
       __ Comment("slow path smi operation");
     }
     __ Bind(entry_label());
     LocationSummary* locs = instruction_->locs();
     Register result = locs->out(0).reg();
     locs->live_registers()->Remove(Location::RegisterLocation(result));
 
     compiler->SaveLiveRegisters(locs);
     __ pushq(locs->in(0).reg());
     __ pushq(locs->in(1).reg());
     compiler->EmitMegamorphicInstanceCall(
         *instruction_->call()->ic_data(), instruction_->call()->ArgumentCount(),
         instruction_->call()->deopt_id(), instruction_->call()->token_pos(),
         locs, try_index_,
         /* slow_path_argument_count = */ 2);
     __ MoveRegister(result, RAX);
     compiler->RestoreLiveRegisters(locs);
     __ jmp(exit_label());
+    compiler->SpecialStatsEnd(CombinedCodeStatistics::kTagCheckedSmiSlowPath);
   }
 
  private:
   CheckedSmiOpInstr* instruction_;
   intptr_t try_index_;
 };
 
 
 LocationSummary* CheckedSmiOpInstr::MakeLocationSummary(Zone* zone,
                                                         bool opt) const {
@@ skipping 121 matching lines @@
   CheckedSmiComparisonSlowPath(CheckedSmiComparisonInstr* instruction,
                                intptr_t try_index,
                                BranchLabels labels,
                                bool merged = false)
       : instruction_(instruction),
         try_index_(try_index),
         labels_(labels),
         merged_(merged) {}
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler) {
+    compiler->SpecialStatsBegin(CombinedCodeStatistics::kTagCheckedSmiCmpSlowPath);
     if (Assembler::EmittingComments()) {
       __ Comment("slow path smi comparison");
     }
     __ Bind(entry_label());
     LocationSummary* locs = instruction_->locs();
     Register result = merged_ ? locs->temp(0).reg() : locs->out(0).reg();
     locs->live_registers()->Remove(Location::RegisterLocation(result));
 
     compiler->SaveLiveRegisters(locs);
     __ pushq(locs->in(0).reg());
     __ pushq(locs->in(1).reg());
     compiler->EmitMegamorphicInstanceCall(
         *instruction_->call()->ic_data(), instruction_->call()->ArgumentCount(),
         instruction_->call()->deopt_id(), instruction_->call()->token_pos(),
         locs, try_index_,
         /* slow_path_argument_count = */ 2);
     __ MoveRegister(result, RAX);
     compiler->RestoreLiveRegisters(locs);
     if (merged_) {
       __ CompareObject(result, Bool::True());
       __ j(EQUAL, instruction_->is_negated() ? labels_.false_label
                                              : labels_.true_label);
       __ jmp(instruction_->is_negated() ? labels_.true_label
                                         : labels_.false_label);
     } else {
       __ jmp(exit_label());
     }
+    compiler->SpecialStatsEnd(CombinedCodeStatistics::kTagCheckedSmiCmpSlowPath);
   }
 
  private:
   CheckedSmiComparisonInstr* instruction_;
   intptr_t try_index_;
   BranchLabels labels_;
   bool merged_;
 };
 
 
@@ skipping 3790 matching lines @@
   __ Drop(1);
   __ popq(result);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64