Upgrade V8 to 5.1.281.57 DO NOT MERGE
FPIIM-449
Change-Id: Id981b686b4d587ac31697662eb98bb34be42ad90
(cherry picked from commit 3b9bc31999c9787eb726ecdbfd5796bfdec32a18)
diff --git a/include/v8.h b/include/v8.h
index 9ccbc6e..703a4f4 100644
--- a/include/v8.h
+++ b/include/v8.h
@@ -18,6 +18,8 @@
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
+#include <utility>
+#include <vector>
#include "v8-version.h" // NOLINT(build/include)
#include "v8config.h" // NOLINT(build/include)
@@ -328,6 +330,8 @@
template <class F1, class F2, class F3>
friend class PersistentValueMapBase;
template<class F1, class F2> friend class PersistentValueVector;
+ template <class F>
+ friend class ReturnValue;
explicit V8_INLINE Local(T* that) : val_(that) {}
V8_INLINE static Local<T> New(Isolate* isolate, T* that);
@@ -594,6 +598,13 @@
V8_INLINE void ClearWeak() { ClearWeak<void>(); }
/**
+ * Allows the embedder to tell the v8 garbage collector that a certain object
+ * is alive. Only allowed when the embedder is asked to trace its heap by
+ * EmbedderHeapTracer.
+ */
+ V8_INLINE void RegisterExternalReference(Isolate* isolate);
+
+ /**
* Marks the reference to this object independent. Garbage collector is free
* to ignore any object groups containing this object. Weak callback for an
* independent handle should not assume that it will be preceded by a global
@@ -2628,6 +2639,10 @@
PROHIBITS_OVERWRITING = 1 << 2
};
+/**
+ * Integrity level for objects.
+ */
+enum class IntegrityLevel { kFrozen, kSealed };
/**
* A JavaScript object (ECMA-262, 4.3.3)
@@ -2819,6 +2834,11 @@
*/
Local<String> GetConstructorName();
+ /**
+ * Sets the integrity level of the object.
+ */
+ Maybe<bool> SetIntegrityLevel(Local<Context> context, IntegrityLevel level);
+
/** Gets the number of internal fields for this Object. */
int InternalFieldCount();
@@ -3118,12 +3138,17 @@
V8_INLINE void SetUndefined();
V8_INLINE void SetEmptyString();
// Convenience getter for Isolate
- V8_INLINE Isolate* GetIsolate();
+ V8_INLINE Isolate* GetIsolate() const;
// Pointer setter: Uncompilable to prevent inadvertent misuse.
template <typename S>
V8_INLINE void Set(S* whatever);
+ // Getter. Creates a new Local<> so it comes with a certain performance
+ // hit. If the ReturnValue was not yet set, this will return the undefined
+ // value.
+ V8_INLINE Local<Value> Get() const;
+
private:
template<class F> friend class ReturnValue;
template<class F> friend class FunctionCallbackInfo;
@@ -4886,7 +4911,6 @@
V8_INLINE Local<Boolean> True(Isolate* isolate);
V8_INLINE Local<Boolean> False(Isolate* isolate);
-
/**
* A set of constraints that specifies the limits of the runtime's memory use.
* You must set the heap size before initializing the VM - the size cannot be
@@ -4895,6 +4919,9 @@
* If you are using threads then you should hold the V8::Locker lock while
* setting the stack limit and you must set a non-default stack limit separately
* for each thread.
+ *
+ * The arguments for set_max_semi_space_size, set_max_old_space_size,
+ * set_max_executable_size, set_code_range_size specify limits in MB.
*/
class V8_EXPORT ResourceConstraints {
public:
@@ -4913,17 +4940,23 @@
uint64_t virtual_memory_limit);
int max_semi_space_size() const { return max_semi_space_size_; }
- void set_max_semi_space_size(int value) { max_semi_space_size_ = value; }
+ void set_max_semi_space_size(int limit_in_mb) {
+ max_semi_space_size_ = limit_in_mb;
+ }
int max_old_space_size() const { return max_old_space_size_; }
- void set_max_old_space_size(int value) { max_old_space_size_ = value; }
+ void set_max_old_space_size(int limit_in_mb) {
+ max_old_space_size_ = limit_in_mb;
+ }
int max_executable_size() const { return max_executable_size_; }
- void set_max_executable_size(int value) { max_executable_size_ = value; }
+ void set_max_executable_size(int limit_in_mb) {
+ max_executable_size_ = limit_in_mb;
+ }
uint32_t* stack_limit() const { return stack_limit_; }
// Sets an address beyond which the VM's stack may not grow.
void set_stack_limit(uint32_t* value) { stack_limit_ = value; }
size_t code_range_size() const { return code_range_size_; }
- void set_code_range_size(size_t value) {
- code_range_size_ = value;
+ void set_code_range_size(size_t limit_in_mb) {
+ code_range_size_ = limit_in_mb;
}
private:
@@ -5047,9 +5080,57 @@
typedef void (*PromiseRejectCallback)(PromiseRejectMessage message);
-// --- Microtask Callback ---
+// --- Microtasks Callbacks ---
+typedef void (*MicrotasksCompletedCallback)(Isolate*);
typedef void (*MicrotaskCallback)(void* data);
+
+/**
+ * Policy for running microtasks:
+ * - explicit: microtasks are invoked with Isolate::RunMicrotasks() method;
+ * - scoped: microtasks invocation is controlled by MicrotasksScope objects;
+ * - auto: microtasks are invoked when the script call depth decrements
+ * to zero.
+ */
+enum class MicrotasksPolicy { kExplicit, kScoped, kAuto };
+
+
+/**
+ * This scope is used to control microtasks when kScopeMicrotasksInvocation
+ * is used on Isolate. In this mode every non-primitive call to V8 should be
+ * done inside some MicrotasksScope.
+ * Microtasks are executed when topmost MicrotasksScope marked as kRunMicrotasks
+ * exits.
+ * kDoNotRunMicrotasks should be used to annotate calls not intended to trigger
+ * microtasks.
+ */
+class V8_EXPORT MicrotasksScope {
+ public:
+ enum Type { kRunMicrotasks, kDoNotRunMicrotasks };
+
+ MicrotasksScope(Isolate* isolate, Type type);
+ ~MicrotasksScope();
+
+ /**
+ * Runs microtasks if no kRunMicrotasks scope is currently active.
+ */
+ static void PerformCheckpoint(Isolate* isolate);
+
+ /**
+ * Returns current depth of nested kRunMicrotasks scopes.
+ */
+ static int GetCurrentDepth(Isolate* isolate);
+
+ private:
+ internal::Isolate* const isolate_;
+ bool run_;
+
+ // Prevent copying.
+ MicrotasksScope(const MicrotasksScope&);
+ MicrotasksScope& operator=(const MicrotasksScope&);
+};
+
+
// --- Failed Access Check Callback ---
typedef void (*FailedAccessCheckCallback)(Local<Object> target,
AccessType type,
@@ -5121,6 +5202,7 @@
size_t total_available_size() { return total_available_size_; }
size_t used_heap_size() { return used_heap_size_; }
size_t heap_size_limit() { return heap_size_limit_; }
+ size_t malloced_memory() { return malloced_memory_; }
size_t does_zap_garbage() { return does_zap_garbage_; }
private:
@@ -5130,6 +5212,7 @@
size_t total_available_size_;
size_t used_heap_size_;
size_t heap_size_limit_;
+ size_t malloced_memory_;
bool does_zap_garbage_;
friend class V8;
@@ -5294,6 +5377,52 @@
uint16_t class_id) {}
};
+/**
+ * Memory pressure level for the MemoryPressureNotification.
+ * kNone hints V8 that there is no memory pressure.
+ * kModerate hints V8 to speed up incremental garbage collection at the cost of
+ * of higher latency due to garbage collection pauses.
+ * kCritical hints V8 to free memory as soon as possible. Garbage collection
+ * pauses at this level will be large.
+ */
+enum class MemoryPressureLevel { kNone, kModerate, kCritical };
+
+/**
+ * Interface for tracing through the embedder heap. During the v8 garbage
+ * collection, v8 collects hidden fields of all potential wrappers, and at the
+ * end of its marking phase iterates the collection and asks the embedder to
+ * trace through its heap and call PersistentBase::RegisterExternalReference on
+ * each js object reachable from any of the given wrappers.
+ *
+ * Before the first call to the TraceWrappableFrom function v8 will call
+ * TraceRoots. When the v8 garbage collection is finished, v8 will call
+ * ClearTracingMarks.
+ */
+class EmbedderHeapTracer {
+ public:
+ /**
+ * V8 will call this method at the beginning of the gc cycle.
+ */
+ virtual void TraceRoots(Isolate* isolate) = 0;
+
+ /**
+ * V8 will call this method with internal fields of a potential wrappers.
+ * Embedder is expected to trace its heap (synchronously) and call
+ * PersistentBase::RegisterExternalReference() on all wrappers reachable from
+ * any of the given wrappers.
+ */
+ virtual void TraceWrappableFrom(
+ Isolate* isolate,
+ const std::vector<std::pair<void*, void*> >& internal_fields) = 0;
+ /**
+ * V8 will call this method at the end of the gc cycle. Allocation is *not*
+ * allowed in the ClearTracingMarks.
+ */
+ virtual void ClearTracingMarks(Isolate* isolate) = 0;
+
+ protected:
+ virtual ~EmbedderHeapTracer() = default;
+};
/**
* Isolate represents an isolated instance of the V8 engine. V8 isolates have
@@ -5489,6 +5618,9 @@
kArrayPrototypeConstructorModified = 26,
kArrayInstanceProtoModified = 27,
kArrayInstanceConstructorModified = 28,
+ kLegacyFunctionDeclaration = 29,
+ kRegExpPrototypeSourceGetter = 30,
+ kRegExpPrototypeOldFlagGetter = 31,
// If you add new values here, you'll also need to update V8Initializer.cpp
// in Chromium.
@@ -5532,6 +5664,14 @@
AbortOnUncaughtExceptionCallback callback);
/**
+ * Optional notification that the system is running low on memory.
+ * V8 uses these notifications to guide heuristics.
+ * It is allowed to call this function from another thread while
+ * the isolate is executing long running JavaScript code.
+ */
+ void MemoryPressureNotification(MemoryPressureLevel level);
+
+ /**
* Methods below this point require holding a lock (using Locker) in
* a multi-threaded environment.
*/
@@ -5753,6 +5893,11 @@
void RemoveGCPrologueCallback(GCCallback callback);
/**
+ * Sets the embedder heap tracer for the isolate.
+ */
+ void SetEmbedderHeapTracer(EmbedderHeapTracer* tracer);
+
+ /**
* Enables the host application to receive a notification after a
* garbage collection. Allocations are allowed in the callback function,
* but the callback is not re-entrant: if the allocation inside it will
@@ -5888,17 +6033,39 @@
*/
void EnqueueMicrotask(MicrotaskCallback microtask, void* data = NULL);
- /**
- * Experimental: Controls whether the Microtask Work Queue is automatically
- * run when the script call depth decrements to zero.
+ /**
+ * Experimental: Controls how Microtasks are invoked. See MicrotasksPolicy
+ * for details.
*/
- void SetAutorunMicrotasks(bool autorun);
+ void SetMicrotasksPolicy(MicrotasksPolicy policy);
+ V8_DEPRECATE_SOON("Use SetMicrotasksPolicy",
+ void SetAutorunMicrotasks(bool autorun));
/**
- * Experimental: Returns whether the Microtask Work Queue is automatically
- * run when the script call depth decrements to zero.
+ * Experimental: Returns the policy controlling how Microtasks are invoked.
*/
- bool WillAutorunMicrotasks() const;
+ MicrotasksPolicy GetMicrotasksPolicy() const;
+ V8_DEPRECATE_SOON("Use GetMicrotasksPolicy",
+ bool WillAutorunMicrotasks() const);
+
+ /**
+ * Experimental: adds a callback to notify the host application after
+ * microtasks were run. The callback is triggered by explicit RunMicrotasks
+ * call or automatic microtasks execution (see SetAutorunMicrotasks).
+ *
+ * Callback will trigger even if microtasks were attempted to run,
+ * but the microtasks queue was empty and no single microtask was actually
+ * executed.
+ *
+ * Executing scriptsinside the callback will not re-trigger microtasks and
+ * the callback.
+ */
+ void AddMicrotasksCompletedCallback(MicrotasksCompletedCallback callback);
+
+ /**
+ * Removes callback that was installed by AddMicrotasksCompletedCallback.
+ */
+ void RemoveMicrotasksCompletedCallback(MicrotasksCompletedCallback callback);
/**
* Sets a callback for counting the number of times a feature of V8 is used.
@@ -6195,11 +6362,23 @@
static void SetSnapshotDataBlob(StartupData* startup_blob);
/**
- * Create a new isolate and context for the purpose of capturing a snapshot
+ * Bootstrap an isolate and a context from scratch to create a startup
+ * snapshot. Include the side-effects of running the optional script.
* Returns { NULL, 0 } on failure.
- * The caller owns the data array in the return value.
+ * The caller acquires ownership of the data array in the return value.
*/
- static StartupData CreateSnapshotDataBlob(const char* custom_source = NULL);
+ static StartupData CreateSnapshotDataBlob(const char* embedded_source = NULL);
+
+ /**
+ * Bootstrap an isolate and a context from the cold startup blob, run the
+ * warm-up script to trigger code compilation. The side effects are then
+ * discarded. The resulting startup snapshot will include compiled code.
+ * Returns { NULL, 0 } on failure.
+ * The caller acquires ownership of the data array in the return value.
+ * The argument startup blob is untouched.
+ */
+ static StartupData WarmUpSnapshotDataBlob(StartupData cold_startup_blob,
+ const char* warmup_source);
/**
* Adds a message listener.
@@ -6475,6 +6654,8 @@
static internal::Object** CopyPersistent(internal::Object** handle);
static void DisposeGlobal(internal::Object** global_handle);
typedef WeakCallbackData<Value, void>::Callback WeakCallback;
+ static void RegisterExternallyReferencedObject(internal::Object** object,
+ internal::Isolate* isolate);
static void MakeWeak(internal::Object** global_handle, void* data,
WeakCallback weak_callback);
static void MakeWeak(internal::Object** global_handle, void* data,
@@ -7149,7 +7330,7 @@
1 * kApiPointerSize + kApiIntSize;
static const int kStringResourceOffset = 3 * kApiPointerSize;
- static const int kOddballKindOffset = 4 * kApiPointerSize;
+ static const int kOddballKindOffset = 5 * kApiPointerSize;
static const int kForeignAddressOffset = kApiPointerSize;
static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
@@ -7168,11 +7349,12 @@
static const int kIsolateRootsOffset =
kAmountOfExternalAllocatedMemoryAtLastGlobalGCOffset + kApiInt64Size +
kApiPointerSize;
- static const int kUndefinedValueRootIndex = 5;
- static const int kNullValueRootIndex = 7;
- static const int kTrueValueRootIndex = 8;
- static const int kFalseValueRootIndex = 9;
- static const int kEmptyStringRootIndex = 10;
+ static const int kUndefinedValueRootIndex = 4;
+ static const int kTheHoleValueRootIndex = 5;
+ static const int kNullValueRootIndex = 6;
+ static const int kTrueValueRootIndex = 7;
+ static const int kFalseValueRootIndex = 8;
+ static const int kEmptyStringRootIndex = 9;
// The external allocation limit should be below 256 MB on all architectures
// to avoid that resource-constrained embedders run low on memory.
@@ -7188,7 +7370,7 @@
static const int kNodeIsPartiallyDependentShift = 4;
static const int kNodeIsActiveShift = 4;
- static const int kJSObjectType = 0xb5;
+ static const int kJSObjectType = 0xb8;
static const int kFirstNonstringType = 0x80;
static const int kOddballType = 0x83;
static const int kForeignType = 0x87;
@@ -7492,6 +7674,13 @@
V8::ClearWeak(reinterpret_cast<internal::Object**>(this->val_)));
}
+template <class T>
+void PersistentBase<T>::RegisterExternalReference(Isolate* isolate) {
+ if (IsEmpty()) return;
+ V8::RegisterExternallyReferencedObject(
+ reinterpret_cast<internal::Object**>(this->val_),
+ reinterpret_cast<internal::Isolate*>(isolate));
+}
template <class T>
void PersistentBase<T>::MarkIndependent() {
@@ -7641,14 +7830,22 @@
*value_ = *I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
}
-template<typename T>
-Isolate* ReturnValue<T>::GetIsolate() {
+template <typename T>
+Isolate* ReturnValue<T>::GetIsolate() const {
// Isolate is always the pointer below the default value on the stack.
return *reinterpret_cast<Isolate**>(&value_[-2]);
}
-template<typename T>
-template<typename S>
+template <typename T>
+Local<Value> ReturnValue<T>::Get() const {
+ typedef internal::Internals I;
+ if (*value_ == *I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex))
+ return Local<Value>(*Undefined(GetIsolate()));
+ return Local<Value>::New(GetIsolate(), reinterpret_cast<Value*>(value_));
+}
+
+template <typename T>
+template <typename S>
void ReturnValue<T>::Set(S* whatever) {
// Uncompilable to prevent inadvertent misuse.
TYPE_CHECK(S*, Primitive);