libv8 4.5.95.5-amd64-freebsd-10 → 5.0.71.48.1beta2-amd64-freebsd-10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c31f48ab20e5d70a85c455e309aca1d296d0c62
-  data.tar.gz: 26dfac57635a22c1a03ad18e6c481c8bbb93d600
+  metadata.gz: d29345eeebbadc0956a0d6992c33573bbb1fe610
+  data.tar.gz: 49d6bb27768fbd824590ae589d4624842d5483a9
 SHA512:
-  metadata.gz: 58c7df53644e702bd4f6e257deaba44b421b5f1ae62e89d8a5566141e193748d33c4f3fc46ec26ec64eb563131bd820b728aa993d11b68b2069e84fbd4e5a31c
-  data.tar.gz: 931950748fdf1aab9e36c271bcaef8b8b69fba7bcb1d34a00640217130b6ee892cd92e3d4950d685437bbbddce2f9901756f509e4374569afdb015475a35de53
+  metadata.gz: 159e9c3259460ede9b5a6a72b35005c600716422762883de25a78296610fa40bae1bb62a719bd92107973172c646f5d39ee2a2c4b51267758823f4094166f135
+  data.tar.gz: 41acf675ea7153fe7f57c053086da7d57687f76a5db09d7a6f899f156f9589779af6ac92f3efb9b907754ec27d91095e88ab2cb2e104263c4c816a80160924e2

data/ext/libv8/arch.rb

@@ -10,6 +10,7 @@ module Libv8
       when /^a(rm|arch)64$/   then 'arm64'
       when /^x86$/            then 'ia32'
       when /^(x86_64|amd64)$/ then 'x64'
+      when /^universal$/      then 'x64' # OS X
       else
         warn "Unsupported target: #{Gem::Platform.local.cpu}"
         Gem::Platform.local.cpu

data/ext/libv8/location.rb

@@ -59,16 +59,15 @@ module Libv8
       class NotFoundError < StandardError
         def initialize(*args)
           super(<<-EOS)
-You have chosen to use the version of V8 found on your system
-and *not* the one that is bundle with the libv8 rubygem. However,
-it could not be located. please make sure you have a version of
-v8 that is compatible with #{Libv8::VERSION} installed. You may
-need to special --with-v8-dir options if it is in a non-standard
-location
+By using --with-system-v8, you have chosen to use the version 
+of V8 found on your system and *not* the one that is bundled with 
+the libv8 rubygem. 
 
-thanks,
-The Mgmt
+However, your system version of v8 could not be located. 
 
+Please make sure your system version of v8 that is compatible 
+with #{Libv8::VERSION} installed. You may need to use the 
+--with-v8-dir option if it is installed in a non-standard location
 EOS
         end
       end

data/lib/libv8/version.rb

@@ -1,3 +1,3 @@
 module Libv8
-  VERSION = "4.5.95.5"
+  VERSION = "5.0.71.48.1beta2"
 end

data/vendor/v8/include/v8-debug.h

@@ -5,7 +5,7 @@
 #ifndef V8_V8_DEBUG_H_
 #define V8_V8_DEBUG_H_
 
-#include "v8.h"
+#include "v8.h"  // NOLINT(build/include)
 
 /**
  * Debugger support for the V8 JavaScript engine.
@@ -60,20 +60,20 @@ class V8_EXPORT Debug {
      * callbacks as their content becomes invalid. These objects are from the
      * debugger event that started the debug message loop.
      */
-    virtual Handle<Object> GetExecutionState() const = 0;
-    virtual Handle<Object> GetEventData() const = 0;
+    virtual Local<Object> GetExecutionState() const = 0;
+    virtual Local<Object> GetEventData() const = 0;
 
     /**
      * Get the debugger protocol JSON.
      */
-    virtual Handle<String> GetJSON() const = 0;
+    virtual Local<String> GetJSON() const = 0;
 
     /**
      * Get the context active when the debug event happened. Note this is not
      * the current active context as the JavaScript part of the debugger is
      * running in its own context which is entered at this point.
      */
-    virtual Handle<Context> GetEventContext() const = 0;
+    virtual Local<Context> GetEventContext() const = 0;
 
     /**
      * Client data passed with the corresponding request if any. This is the
@@ -104,21 +104,21 @@ class V8_EXPORT Debug {
      * Access to execution state and event data of the debug event. Don't store
      * these cross callbacks as their content becomes invalid.
      */
-    virtual Handle<Object> GetExecutionState() const = 0;
-    virtual Handle<Object> GetEventData() const = 0;
+    virtual Local<Object> GetExecutionState() const = 0;
+    virtual Local<Object> GetEventData() const = 0;
 
     /**
      * Get the context active when the debug event happened. Note this is not
      * the current active context as the JavaScript part of the debugger is
      * running in its own context which is entered at this point.
      */
-    virtual Handle<Context> GetEventContext() const = 0;
+    virtual Local<Context> GetEventContext() const = 0;
 
     /**
      * Client data passed with the corresponding callback when it was
      * registered.
      */
-    virtual Handle<Value> GetCallbackData() const = 0;
+    virtual Local<Value> GetCallbackData() const = 0;
 
     /**
      * Client data passed to DebugBreakForCommand function. The
@@ -155,8 +155,11 @@ class V8_EXPORT Debug {
    */
   typedef void (*DebugMessageDispatchHandler)();
 
-  static bool SetDebugEventListener(EventCallback that,
-                                    Handle<Value> data = Handle<Value>());
+  static bool SetDebugEventListener(Isolate* isolate, EventCallback that,
+                                    Local<Value> data = Local<Value>());
+  V8_DEPRECATED("Use version with an Isolate",
+                static bool SetDebugEventListener(
+                    EventCallback that, Local<Value> data = Local<Value>()));
 
   // Schedule a debugger break to happen when JavaScript code is run
   // in the given isolate.
@@ -170,7 +173,9 @@ class V8_EXPORT Debug {
   static bool CheckDebugBreak(Isolate* isolate);
 
   // Message based interface. The message protocol is JSON.
-  static void SetMessageHandler(MessageHandler handler);
+  static void SetMessageHandler(Isolate* isolate, MessageHandler handler);
+  V8_DEPRECATED("Use version with an Isolate",
+                static void SetMessageHandler(MessageHandler handler));
 
   static void SendCommand(Isolate* isolate,
                           const uint16_t* command, int length,
@@ -194,22 +199,21 @@ class V8_EXPORT Debug {
   *   }
   * \endcode
   */
-  static V8_DEPRECATE_SOON(
-      "Use maybe version",
-      Local<Value> Call(v8::Handle<v8::Function> fun,
-                        Handle<Value> data = Handle<Value>()));
+  static V8_DEPRECATED("Use maybe version",
+                       Local<Value> Call(v8::Local<v8::Function> fun,
+                                         Local<Value> data = Local<Value>()));
   // TODO(dcarney): data arg should be a MaybeLocal
   static MaybeLocal<Value> Call(Local<Context> context,
-                                v8::Handle<v8::Function> fun,
-                                Handle<Value> data = Handle<Value>());
+                                v8::Local<v8::Function> fun,
+                                Local<Value> data = Local<Value>());
 
   /**
    * Returns a mirror object for the given object.
    */
-  static V8_DEPRECATE_SOON("Use maybe version",
-                           Local<Value> GetMirror(v8::Handle<v8::Value> obj));
+  static V8_DEPRECATED("Use maybe version",
+                       Local<Value> GetMirror(v8::Local<v8::Value> obj));
   static MaybeLocal<Value> GetMirror(Local<Context> context,
-                                     v8::Handle<v8::Value> obj);
+                                     v8::Local<v8::Value> obj);
 
   /**
    * Makes V8 process all pending debug messages.
@@ -242,7 +246,9 @@ class V8_EXPORT Debug {
    * "Evaluate" debug command behavior currently is not specified in scope
    * of this method.
    */
-  static void ProcessDebugMessages();
+  static void ProcessDebugMessages(Isolate* isolate);
+  V8_DEPRECATED("Use version with an Isolate",
+                static void ProcessDebugMessages());
 
   /**
    * Debugger is running in its own context which is entered while debugger
@@ -251,7 +257,9 @@ class V8_EXPORT Debug {
    * to change. The Context exists only when the debugger is active, i.e. at
    * least one DebugEventListener or MessageHandler is set.
    */
-  static Local<Context> GetDebugContext();
+  static Local<Context> GetDebugContext(Isolate* isolate);
+  V8_DEPRECATED("Use version with an Isolate",
+                static Local<Context> GetDebugContext());
 
 
   /**

data/vendor/v8/include/v8-experimental.h

@@ -0,0 +1,54 @@
+// Copyright 2015 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.
+
+/**
+ * This header contains a set of experimental V8 APIs. We hope these will
+ * become a part of standard V8, but they may also be removed if we deem the
+ * experiment to not be successul.
+ */
+#ifndef V8_INCLUDE_V8_EXPERIMENTAL_H_
+#define V8_INCLUDE_V8_EXPERIMENTAL_H_
+
+#include "include/v8.h"
+
+namespace v8 {
+namespace experimental {
+
+// Allow the embedder to construct accessors that V8 can compile and use
+// directly, without jumping into the runtime.
+class V8_EXPORT FastAccessorBuilder {
+ public:
+  struct ValueId {
+    size_t value_id;
+  };
+  struct LabelId {
+    size_t label_id;
+  };
+
+  static FastAccessorBuilder* New(Isolate* isolate);
+
+  ValueId IntegerConstant(int int_constant);
+  ValueId GetReceiver();
+  ValueId LoadInternalField(ValueId value_id, int field_no);
+  ValueId LoadValue(ValueId value_id, int offset);
+  ValueId LoadObject(ValueId value_id, int offset);
+  void ReturnValue(ValueId value_id);
+  void CheckFlagSetOrReturnNull(ValueId value_id, int mask);
+  void CheckNotZeroOrReturnNull(ValueId value_id);
+  LabelId MakeLabel();
+  void SetLabel(LabelId label_id);
+  void CheckNotZeroOrJump(ValueId value_id, LabelId label_id);
+  ValueId Call(v8::FunctionCallback callback, ValueId value_id);
+
+ private:
+  FastAccessorBuilder() = delete;
+  FastAccessorBuilder(const FastAccessorBuilder&) = delete;
+  ~FastAccessorBuilder() = delete;
+  void operator=(const FastAccessorBuilder&) = delete;
+};
+
+}  // namespace experimental
+}  // namespace v8
+
+#endif  // V8_INCLUDE_V8_EXPERIMENTAL_H_

data/vendor/v8/include/v8-platform.h

@@ -5,6 +5,9 @@
 #ifndef V8_V8_PLATFORM_H_
 #define V8_V8_PLATFORM_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 namespace v8 {
 
 class Isolate;
@@ -19,6 +22,20 @@ class Task {
   virtual void Run() = 0;
 };
 
+
+/**
+* An IdleTask represents a unit of work to be performed in idle time.
+* The Run method is invoked with an argument that specifies the deadline in
+* seconds returned by MonotonicallyIncreasingTime().
+* The idle task is expected to complete by this deadline.
+*/
+class IdleTask {
+ public:
+  virtual ~IdleTask() {}
+  virtual void Run(double deadline_in_seconds) = 0;
+};
+
+
 /**
  * V8 Platform abstraction layer.
  *
@@ -39,6 +56,15 @@ class Platform {
 
   virtual ~Platform() {}
 
+  /**
+   * Gets the number of threads that are used to execute background tasks. Is
+   * used to estimate the number of tasks a work package should be split into.
+   * A return value of 0 means that there are no background threads available.
+   * Note that a value of 0 won't prohibit V8 from posting tasks using
+   * |CallOnBackgroundThread|.
+   */
+  virtual size_t NumberOfAvailableBackgroundThreads() { return 0; }
+
   /**
    * Schedules a task to be invoked on a background thread. |expected_runtime|
    * indicates that the task will run a long time. The Platform implementation
@@ -63,8 +89,26 @@ class Platform {
    * scheduling. The definition of "foreground" is opaque to V8.
    */
   virtual void CallDelayedOnForegroundThread(Isolate* isolate, Task* task,
-                                             double delay_in_seconds) {
+                                             double delay_in_seconds) = 0;
+
+  /**
+   * Schedules a task to be invoked on a foreground thread wrt a specific
+   * |isolate| when the embedder is idle.
+   * Requires that SupportsIdleTasks(isolate) is true.
+   * Idle tasks may be reordered relative to other task types and may be
+   * starved for an arbitrarily long time if no idle time is available.
+   * The definition of "foreground" is opaque to V8.
+   */
+  virtual void CallIdleOnForegroundThread(Isolate* isolate, IdleTask* task) {
+    // TODO(ulan): Make this function abstract after V8 roll in Chromium.
+  }
+
+  /**
+   * Returns true if idle tasks are enabled for the given |isolate|.
+   */
+  virtual bool IdleTasksEnabled(Isolate* isolate) {
     // TODO(ulan): Make this function abstract after V8 roll in Chromium.
+    return false;
   }
 
   /**
@@ -75,6 +119,51 @@ class Platform {
    * the epoch.
    **/
   virtual double MonotonicallyIncreasingTime() = 0;
+
+  /**
+   * Called by TRACE_EVENT* macros, don't call this directly.
+   * The name parameter is a category group for example:
+   * TRACE_EVENT0("v8,parse", "V8.Parse")
+   * The pointer returned points to a value with zero or more of the bits
+   * defined in CategoryGroupEnabledFlags.
+   **/
+  virtual const uint8_t* GetCategoryGroupEnabled(const char* name) {
+    static uint8_t no = 0;
+    return &no;
+  }
+
+  /**
+   * Gets the category group name of the given category_enabled_flag pointer.
+   * Usually used while serliazing TRACE_EVENTs.
+   **/
+  virtual const char* GetCategoryGroupName(
+      const uint8_t* category_enabled_flag) {
+    static const char dummy[] = "dummy";
+    return dummy;
+  }
+
+  /**
+   * Adds a trace event to the platform tracing system. This function call is
+   * usually the result of a TRACE_* macro from trace_event_common.h when
+   * tracing and the category of the particular trace are enabled. It is not
+   * advisable to call this function on its own; it is really only meant to be
+   * used by the trace macros. The returned handle can be used by
+   * UpdateTraceEventDuration to update the duration of COMPLETE events.
+   */
+  virtual uint64_t AddTraceEvent(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      uint64_t id, uint64_t bind_id, int32_t num_args, const char** arg_names,
+      const uint8_t* arg_types, const uint64_t* arg_values,
+      unsigned int flags) {
+    return 0;
+  }
+
+  /**
+   * Sets the duration field of a COMPLETE trace event. It must be called with
+   * the handle returned from AddTraceEvent().
+   **/
+  virtual void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
+                                        const char* name, uint64_t handle) {}
 };
 
 }  // namespace v8

data/vendor/v8/include/v8-profiler.h

@@ -6,7 +6,7 @@
 #define V8_V8_PROFILER_H_
 
 #include <vector>
-#include "v8.h"
+#include "v8.h"  // NOLINT(build/include)
 
 /**
  * Profiler support for the V8 JavaScript engine.
@@ -60,13 +60,13 @@ class V8_EXPORT CpuProfileNode {
   };
 
   /** Returns function name (empty string for anonymous functions.) */
-  Handle<String> GetFunctionName() const;
+  Local<String> GetFunctionName() const;
 
   /** Returns id of the script where function is located. */
   int GetScriptId() const;
 
   /** Returns resource name for script from where the function originates. */
-  Handle<String> GetScriptResourceName() const;
+  Local<String> GetScriptResourceName() const;
 
   /**
    * Returns the number, 1-based, of the line where the function originates.
@@ -129,7 +129,7 @@ class V8_EXPORT CpuProfileNode {
 class V8_EXPORT CpuProfile {
  public:
   /** Returns CPU profile title. */
-  Handle<String> GetTitle() const;
+  Local<String> GetTitle() const;
 
   /** Returns the root node of the top down call tree. */
   const CpuProfileNode* GetTopDownRoot() const;
@@ -198,13 +198,20 @@ class V8_EXPORT CpuProfiler {
    * |record_samples| parameter controls whether individual samples should
    * be recorded in addition to the aggregated tree.
    */
-  void StartProfiling(Handle<String> title, bool record_samples = false);
+  void StartProfiling(Local<String> title, bool record_samples = false);
 
   /**
    * Stops collecting CPU profile with a given title and returns it.
    * If the title given is empty, finishes the last profile started.
    */
-  CpuProfile* StopProfiling(Handle<String> title);
+  CpuProfile* StopProfiling(Local<String> title);
+
+  /**
+   * Force collection of a sample. Must be called on the VM thread.
+   * Recording the forced sample does not contribute to the aggregated
+   * profile statistics.
+   */
+  void CollectSample();
 
   /**
    * Tells the profiler whether the embedder is idle.
@@ -246,7 +253,7 @@ class V8_EXPORT HeapGraphEdge {
    * Returns edge name. This can be a variable name, an element index, or
    * a property name.
    */
-  Handle<Value> GetName() const;
+  Local<Value> GetName() const;
 
   /** Returns origin node. */
   const HeapGraphNode* GetFromNode() const;
@@ -287,7 +294,7 @@ class V8_EXPORT HeapGraphNode {
    * of the constructor (for objects), the name of the function (for
    * closures), string value, or an empty string (for compiled code).
    */
-  Handle<String> GetName() const;
+  Local<String> GetName() const;
 
   /**
    * Returns node id. For the same heap object, the id remains the same
@@ -418,6 +425,90 @@ class V8_EXPORT ActivityControl {  // NOLINT
 };
 
 
+/**
+ * AllocationProfile is a sampled profile of allocations done by the program.
+ * This is structured as a call-graph.
+ */
+class V8_EXPORT AllocationProfile {
+ public:
+  struct Allocation {
+    /**
+     * Size of the sampled allocation object.
+     */
+    size_t size;
+
+    /**
+     * The number of objects of such size that were sampled.
+     */
+    unsigned int count;
+  };
+
+  /**
+   * Represents a node in the call-graph.
+   */
+  struct Node {
+    /**
+     * Name of the function. May be empty for anonymous functions or if the
+     * script corresponding to this function has been unloaded.
+     */
+    Local<String> name;
+
+    /**
+     * Name of the script containing the function. May be empty if the script
+     * name is not available, or if the script has been unloaded.
+     */
+    Local<String> script_name;
+
+    /**
+     * id of the script where the function is located. May be equal to
+     * v8::UnboundScript::kNoScriptId in cases where the script doesn't exist.
+     */
+    int script_id;
+
+    /**
+     * Start position of the function in the script.
+     */
+    int start_position;
+
+    /**
+     * 1-indexed line number where the function starts. May be
+     * kNoLineNumberInfo if no line number information is available.
+     */
+    int line_number;
+
+    /**
+     * 1-indexed column number where the function starts. May be
+     * kNoColumnNumberInfo if no line number information is available.
+     */
+    int column_number;
+
+    /**
+     * List of callees called from this node for which we have sampled
+     * allocations. The lifetime of the children is scoped to the containing
+     * AllocationProfile.
+     */
+    std::vector<Node*> children;
+
+    /**
+     * List of self allocations done by this node in the call-graph.
+     */
+    std::vector<Allocation> allocations;
+  };
+
+  /**
+   * Returns the root node of the call-graph. The root node corresponds to an
+   * empty JS call-stack. The lifetime of the returned Node* is scoped to the
+   * containing AllocationProfile.
+   */
+  virtual Node* GetRootNode() = 0;
+
+  virtual ~AllocationProfile() {}
+
+  static const int kNoLineNumberInfo = Message::kNoLineNumberInfo;
+  static const int kNoColumnNumberInfo = Message::kNoColumnInfo;
+};
+
+
 /**
  * Interface for controlling heap profiling. Instance of the
  * profiler can be retrieved using v8::Isolate::GetHeapProfiler.
@@ -430,8 +521,8 @@ class V8_EXPORT HeapProfiler {
    * while the callback is running: only getters on the handle and
    * GetPointerFromInternalField on the objects are allowed.
    */
-  typedef RetainedObjectInfo* (*WrapperInfoCallback)
-      (uint16_t class_id, Handle<Value> wrapper);
+  typedef RetainedObjectInfo* (*WrapperInfoCallback)(uint16_t class_id,
+                                                     Local<Value> wrapper);
 
   /** Returns the number of snapshots taken. */
   int GetSnapshotCount();
@@ -443,13 +534,13 @@ class V8_EXPORT HeapProfiler {
    * Returns SnapshotObjectId for a heap object referenced by |value| if
    * it has been seen by the heap profiler, kUnknownObjectId otherwise.
    */
-  SnapshotObjectId GetObjectId(Handle<Value> value);
+  SnapshotObjectId GetObjectId(Local<Value> value);
 
   /**
    * Returns heap object with given SnapshotObjectId if the object is alive,
    * otherwise empty handle is returned.
    */
-  Handle<Value> FindObjectById(SnapshotObjectId id);
+  Local<Value> FindObjectById(SnapshotObjectId id);
 
   /**
    * Clears internal map from SnapshotObjectId to heap object. The new objects
@@ -474,7 +565,8 @@ class V8_EXPORT HeapProfiler {
      * Returns name to be used in the heap snapshot for given node. Returned
      * string must stay alive until snapshot collection is completed.
      */
-    virtual const char* GetName(Handle<Object> object) = 0;
+    virtual const char* GetName(Local<Object> object) = 0;
+
    protected:
     virtual ~ObjectNameResolver() {}
   };
@@ -520,6 +612,49 @@ class V8_EXPORT HeapProfiler {
    */
   void StopTrackingHeapObjects();
 
+  /**
+   * Starts gathering a sampling heap profile. A sampling heap profile is
+   * similar to tcmalloc's heap profiler and Go's mprof. It samples object
+   * allocations and builds an online 'sampling' heap profile. At any point in
+   * time, this profile is expected to be a representative sample of objects
+   * currently live in the system. Each sampled allocation includes the stack
+   * trace at the time of allocation, which makes this really useful for memory
+   * leak detection.
+   *
+   * This mechanism is intended to be cheap enough that it can be used in
+   * production with minimal performance overhead.
+   *
+   * Allocations are sampled using a randomized Poisson process. On average, one
+   * allocation will be sampled every |sample_interval| bytes allocated. The
+   * |stack_depth| parameter controls the maximum number of stack frames to be
+   * captured on each allocation.
+   *
+   * NOTE: This is a proof-of-concept at this point. Right now we only sample
+   * newspace allocations. Support for paged space allocation (e.g. pre-tenured
+   * objects, large objects, code objects, etc.) and native allocations
+   * doesn't exist yet, but is anticipated in the future.
+   *
+   * Objects allocated before the sampling is started will not be included in
+   * the profile.
+   *
+   * Returns false if a sampling heap profiler is already running.
+   */
+  bool StartSamplingHeapProfiler(uint64_t sample_interval = 512 * 1024,
+                                 int stack_depth = 16);
+
+  /**
+   * Stops the sampling heap profile and discards the current profile.
+   */
+  void StopSamplingHeapProfiler();
+
+  /**
+   * Returns the sampled profile of allocations allocated (and still live) since
+   * StartSamplingHeapProfiler was called. The ownership of the pointer is
+   * transfered to the caller. Returns nullptr if sampling heap profiler is not
+   * active.
+   */
+  AllocationProfile* GetAllocationProfile();
+
   /**
    * Deletes all snapshots taken. All previously returned pointers to
    * snapshots and their contents become invalid after this call.