Implemented GetSample.

include/v8.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.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 37 matching lines @@
 #  define V8_EXPORT __attribute__ ((visibility("default")))
 # else
 #  define V8_EXPORT
 # endif
 #else
 # define V8_EXPORT
 #endif
 
 #endif  // V8_OS_WIN
 
+#if V8_OS_POSIX && !V8_OS_CYGWIN
+#include <ucontext.h>
+typedef ucontext_t context_t;
+#elif V8_OS_WIN || V8_OS_CYGWIN
+#include "src/base/win32-headers.h"
+/* #include <windows.h> */
+/* #if !defined(__MINGW32__) || defined(__MINGW64_VERSION_MAJOR) */

[yurys, 2014/09/19 08:08:11]

We shouldn't expose all this platform-specific stuff in v8.h. All of the can be
handled on the embedder side. Look at  src/sampler.h - it doesn't include any of
this
(https://code.google.com/p/chromium/codesearch#chromium/src/v8/src/sampler.h&q...).

+/* #include <dbghelp.h>  // For SymLoadModule64 and al. */
+/* #endif  // !defined(__MINGW32__) || defined(__MINGW64_VERSION_MAJOR) */
+/* #include <ws2tcpip.h> */
+/* #undef CONST */
+/* #undef STRICT */
+typedef CONTEXT context_t;
+#endif
+
 /**
  * The v8 JavaScript engine.
  */
 namespace v8 {
 
 class AccessorSignature;
 class Array;
 class Boolean;
 class BooleanObject;
 class Context;
@@ skipping 1340 matching lines @@
   bool IsEval() const;
 
   /**
    * Returns whether or not the associated function is called as a
    * constructor via "new".
    */
   bool IsConstructor() const;
 };
 
 
+struct RegisterState {
+  RegisterState() : pc(NULL), sp(NULL), fp(NULL) {}
+  explicit RegisterState(const context_t& context);

[yurys, 2014/09/19 08:08:11]

This is a platform-specific constructor, please don't expose it in the API (see
above).

+  void* pc;  // Instruction pointer.
+  void* sp;  // Stack pointer.
+  void* fp;  // Frame pointer.
+};
+
+
+/**
+ * Isolate::GetSample collects the current JS execution state as a sample.
+ * A collected sample contains program counter values.
+ */
+class V8_EXPORT Sample {
+ public:
+  enum { kMaxSize = 255u };
+
+  Sample() : size_(0) {}
+  template <class InputIterator>
+  Sample(InputIterator first, InputIterator last)
+      : size_(0) {
+    for (; first != last && size_ < kMaxSize; ++first) data_[size_++] = *first;
+  }
+
+  typedef const void* const* const_iterator;
+  const_iterator begin() const { return &data_[0]; }
+  const_iterator end() const { return &data_[size_]; }
+  size_t size() const { return size_; }
+
+ private:
+  const void* data_[kMaxSize];
+  size_t size_;
+};
+
+
 /**
  * A JSON Parser.
  */
 class V8_EXPORT JSON {
  public:
   /**
    * Tries to parse the string |json_string| and returns it as value if
    * successful.
    *
    * \param json_string The string to parse.
@@ skipping 3114 matching lines @@
    * are in the range of 0 - GetNumberOfDataSlots() - 1.
    */
   V8_INLINE static uint32_t GetNumberOfDataSlots();
 
   /**
    * Get statistics about the heap memory usage.
    */
   void GetHeapStatistics(HeapStatistics* heap_statistics);
 
   /**
+   * Get a sample from the isolate.
+   * \param sp Stack pointer.

[yurys, 2014/09/19 08:08:11]

There are not such params, they are passed as |state|

+   * \param fp Frame pointer.
+   * \param sample Pointer to (a pre-allocated) sample which will be filled.
+   * \note GetSample should only be called when the JS thread is paused or
+   *       interrupted. If that is not the case,
+   *       GetSample behaviour is undefined.
+   */
+  void GetSample(const RegisterState& state, Sample* sample);
+
+  /**
    * Adjusts the amount of registered external memory. Used to give V8 an
    * indication of the amount of externally allocated memory that is kept alive
    * by JavaScript objects. V8 uses this to decide when to perform global
    * garbage collections. Registering externally allocated memory will trigger
    * global garbage collections more often than it would otherwise in an attempt
    * to garbage collect the JavaScript objects that keep the externally
    * allocated memory alive.
    *
    * \param change_in_bytes the change in externally allocated memory that is
    *   kept alive by JavaScript objects.
@@ skipping 2433 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_