Move SimulatorHelper into V8 out of profiler clients.

include/v8-profiler.h

 // Copyright 2010 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_V8_PROFILER_H_
 #define V8_V8_PROFILER_H_
 
 #include <vector>
 #include "v8.h"  // NOLINT(build/include)
 
@@ skipping 42 matching lines @@
   // samples don't care.
   enum RecordCEntryFrame { kIncludeCEntryFrame, kSkipCEntryFrame };
 
   TickSample()
       : state(OTHER),
         pc(nullptr),
         external_callback_entry(nullptr),
         frames_count(0),
         has_external_callback(false),
         update_stats(true) {}
+
+  /**
+   * Initialize a tick sample from the isolate.
+   * \param isolate The currect isolate.

[alph, 2016/08/08 21:36:57]

typo. Perhaps just "The isolate" would be fine.

[lpy, 2016/08/09 18:31:43]

Done.

+   * \param state Execution state.
+   * \param record_c_entry_frame Include or skip the runtime function.
+   * \param update_stats Whether update the sample to the aggregated stats.
+   * \param update_state If set to true, V8 will update the register state
+                         when running on simulator. Default value is true,
+                         unless the register state is absolutely correct,
+                         otherwise don't use it.
+   */
   void Init(Isolate* isolate, const v8::RegisterState& state,
-            RecordCEntryFrame record_c_entry_frame, bool update_stats);
-  static bool GetStackSample(Isolate* isolate, const v8::RegisterState& state,
+            RecordCEntryFrame record_c_entry_frame, bool update_stats,
+            bool update_state = true);

[alph, 2016/08/08 21:36:57]

How does it update the state if it's declared const?
Perhaps the name is misleading. How about use_simulator_state?

[lpy, 2016/08/09 18:31:43]

My question is where we want to propagate the updated register state from
simulator? Here I assume the caller of TickSample::Init doesn't need to know. In
the current CL only the caller of TickSample::GetStackSample get the updated
register state.
Is it OK to expose the fact that we are running on simulator? What about
`allow_updated_state`?

+  /**
+   * Get a call stack sample from the isolate.
+   * \param isolate The currect isolate.
+   * \param state Register state.
+   * \param record_c_entry_frame Include or skip the runtime function.
+   * \param frames Caller allocated buffer to store stack frames.
+   * \param frames_limit Maximum number of frames to capture. The buffer must
+   *                     be large enough to hold the number of frames.
+   * \param sample_info The sample info is filled up by the function
+   *                    provides number of actual captured stack frames and
+   *                    the current VM state.
+   * \param update_state If set to true, V8 will update the given register state
+                         when running on simulator. Default value is true,
+                         unless the register state is absolutely correct,
+                         otherwise don't use it.
+   * \note GetStackSample should only be called when the JS thread is paused or
+   *       interrupted. Otherwise the behavior is undefined.

[alph, 2016/08/08 21:36:57]

Could you please also note that the function is thread and signal safe.

[lpy, 2016/08/09 18:31:43]

Done.

+   */
+  static bool GetStackSample(Isolate* isolate, v8::RegisterState& state,

[alph, 2016/08/08 21:36:57]

if state is an in-out parameter now, it should be passed by pointer.

[lpy, 2016/08/09 18:31:43]

Done.

                              RecordCEntryFrame record_c_entry_frame,
                              void** frames, size_t frames_limit,
-                             v8::SampleInfo* sample_info);
+                             v8::SampleInfo* sample_info,
+                             bool update_state = true);
   StateTag state;  // The state of the VM.
   void* pc;        // Instruction pointer.
   union {
     void* tos;  // Top stack value (*sp).
     void* external_callback_entry;
   };
   static const unsigned kMaxFramesCountLog2 = 8;
   static const unsigned kMaxFramesCount = (1 << kMaxFramesCountLog2) - 1;
   void* stack[kMaxFramesCount];                 // Call stack.
   unsigned frames_count : kMaxFramesCountLog2;  // Number of captured frames.
@@ skipping 746 matching lines @@
   uint32_t index;  // Index of the time interval that was changed.
   uint32_t count;  // New value of count field for the interval with this index.
   uint32_t size;  // New value of size field for the interval with this index.
 };
 
 
 }  // namespace v8
 
 
 #endif  // V8_V8_PROFILER_H_