diff options
Diffstat (limited to 'deps/v8/include/v8.h')
| -rw-r--r-- | deps/v8/include/v8.h | 255 |
1 files changed, 226 insertions, 29 deletions
diff --git a/deps/v8/include/v8.h b/deps/v8/include/v8.h index 9ccbc6eb18..703a4f4f4a 100644 --- a/deps/v8/include/v8.h +++ b/deps/v8/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 @@ class Local { 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 @@ template <class T> class PersistentBase { 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 @@ enum AccessControl { 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 @@ class V8_EXPORT Object : public Value { */ 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 @@ class ReturnValue { 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<Primitive> Null(Isolate* isolate); 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 @@ V8_INLINE Local<Boolean> False(Isolate* isolate); * 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 @@ class V8_EXPORT ResourceConstraints { 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 @@ class PromiseRejectMessage { 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 @@ class V8_EXPORT HeapStatistics { 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 @@ class V8_EXPORT HeapStatistics { 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 @@ class V8_EXPORT PersistentHandleVisitor { // NOLINT 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 @@ class V8_EXPORT Isolate { 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 @@ class V8_EXPORT Isolate { 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 @@ class V8_EXPORT Isolate { 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 @@ class V8_EXPORT Isolate { */ 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 @@ class V8_EXPORT V8 { 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 @@ class V8_EXPORT V8 { 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 @@ class Internals { 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 @@ class Internals { 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 @@ class Internals { 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 @@ P* PersistentBase<T>::ClearWeak() { 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 @@ void ReturnValue<T>::SetEmptyString() { *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); |