[turbofan] basic block profiler

src/isolate.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ISOLATE_H_
 #define V8_ISOLATE_H_
 
 #include "include/v8-debug.h"
 #include "src/allocation.h"
 #include "src/assert-scope.h"
@@ skipping 70 matching lines @@
 class PromiseOnStack;
 
 #if !defined(__arm__) && V8_TARGET_ARCH_ARM || \
     !defined(__aarch64__) && V8_TARGET_ARCH_ARM64 || \
     !defined(__mips__) && V8_TARGET_ARCH_MIPS || \
     !defined(__mips__) && V8_TARGET_ARCH_MIPS64
 class Redirection;
 class Simulator;
 #endif
 
+namespace compiler {

[titzer, 2014/09/23 14:14:09]

The more I think about it, this thing can't (entirely) live in the compiler
directory, i.e. V8 cannot depend on TurboFan internals. So you will have to
split the BasicBlockProfiler part that does the instrumentation to live in
TurboFan, and the other part live in V8.

+class BasicBlockProfiler;
+}
 
 // Static indirection table for handles to constants.  If a frame
 // element represents a constant, the data contains an index into
 // this table of handles to the actual constants.
 // Static indirection table for handles to constants.  If a Result
 // represents a constant, the data contains an index into this table
 // of handles to the actual constants.
 typedef ZoneList<Handle<Object> > ZoneObjectList;
 
 #define RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate)    \
@@ skipping 999 matching lines @@
   void AddCallCompletedCallback(CallCompletedCallback callback);
   void RemoveCallCompletedCallback(CallCompletedCallback callback);
   void FireCallCompletedCallback();
 
   void EnqueueMicrotask(Handle<Object> microtask);
   void RunMicrotasks();
 
   void SetUseCounterCallback(v8::Isolate::UseCounterCallback callback);
   void CountUsage(v8::Isolate::UseCounterFeature feature);
 
+  compiler::BasicBlockProfiler* GetBasicBlockProfiler();
+
   static Isolate* NewForTesting() { return new Isolate(); }
 
  private:
   Isolate();
 
   friend struct GlobalState;
   friend struct InitializeGlobalState;
 
   enum State {
     UNINITIALIZED,    // Some components may not have been allocated.
@@ skipping 200 matching lines @@
 
   // Counts deopt points if deopt_every_n_times is enabled.
   unsigned int stress_deopt_count_;
 
   int next_optimization_id_;
 
   // List of callbacks when a Call completes.
   List<CallCompletedCallback> call_completed_callbacks_;
 
   v8::Isolate::UseCounterCallback use_counter_callback_;
+  compiler::BasicBlockProfiler* basic_block_profiler_;
 
   friend class ExecutionAccess;
   friend class HandleScopeImplementer;
   friend class IsolateInitializer;
   friend class OptimizingCompilerThread;
   friend class SweeperThread;
   friend class ThreadManager;
   friend class Simulator;
   friend class StackGuard;
   friend class ThreadId;
@@ skipping 209 matching lines @@
   }
 
   EmbeddedVector<char, 128> filename_;
   FILE* file_;
   int scope_depth_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ISOLATE_H_