libv8-node 20.2.0.0-x86_64-linux-musl → 21.7.2.0-x86_64-linux-musl

data/vendor/v8/include/cppgc/visitor.h

@@ -5,10 +5,13 @@
 #ifndef INCLUDE_CPPGC_VISITOR_H_
 #define INCLUDE_CPPGC_VISITOR_H_
 
+#include <type_traits>
+
 #include "cppgc/custom-space.h"
 #include "cppgc/ephemeron-pair.h"
 #include "cppgc/garbage-collected.h"
 #include "cppgc/internal/logging.h"
+#include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/pointer-policies.h"
 #include "cppgc/liveness-broker.h"
 #include "cppgc/member.h"
@@ -113,6 +116,30 @@ class V8_EXPORT Visitor {
   }
 #endif  // defined(CPPGC_POINTER_COMPRESSION)
 
+  template <typename T>
+  void TraceMultiple(const subtle::UncompressedMember<T>* start, size_t len) {
+    static_assert(sizeof(T), "Pointee type must be fully defined.");
+    static_assert(internal::IsGarbageCollectedOrMixinType<T>::value,
+                  "T must be GarbageCollected or GarbageCollectedMixin type");
+    VisitMultipleUncompressedMember(start, len,
+                                    &TraceTrait<T>::GetTraceDescriptor);
+  }
+
+  template <typename T,
+            std::enable_if_t<!std::is_same_v<
+                Member<T>, subtle::UncompressedMember<T>>>* = nullptr>
+  void TraceMultiple(const Member<T>* start, size_t len) {
+    static_assert(sizeof(T), "Pointee type must be fully defined.");
+    static_assert(internal::IsGarbageCollectedOrMixinType<T>::value,
+                  "T must be GarbageCollected or GarbageCollectedMixin type");
+#if defined(CPPGC_POINTER_COMPRESSION)
+    static_assert(std::is_same_v<Member<T>, subtle::CompressedMember<T>>,
+                  "Member and CompressedMember must be the same.");
+    VisitMultipleCompressedMember(start, len,
+                                  &TraceTrait<T>::GetTraceDescriptor);
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+  }
+
   /**
    * Trace method for inlined objects that are not allocated themselves but
    * otherwise follow managed heap layout and have a Trace() method.
@@ -131,6 +158,26 @@ class V8_EXPORT Visitor {
     TraceTrait<T>::Trace(this, &object);
   }
 
+  template <typename T>
+  void TraceMultiple(const T* start, size_t len) {
+#if V8_ENABLE_CHECKS
+    // This object is embedded in potentially multiple nested objects. The
+    // outermost object must not be in construction as such objects are (a) not
+    // processed immediately, and (b) only processed conservatively if not
+    // otherwise possible.
+    CheckObjectNotInConstruction(start);
+#endif  // V8_ENABLE_CHECKS
+    for (size_t i = 0; i < len; ++i) {
+      const T* object = &start[i];
+      if constexpr (std::is_polymorphic_v<T>) {
+        // The object's vtable may be uninitialized in which case the object is
+        // not traced.
+        if (*reinterpret_cast<const uintptr_t*>(object) == 0) continue;
+      }
+      TraceTrait<T>::Trace(this, object);
+    }
+  }
+
   /**
    * Registers a weak callback method on the object of type T. See
    * LivenessBroker for an usage example.
@@ -314,6 +361,39 @@ class V8_EXPORT Visitor {
                                   WeakCallback callback, const void* data) {}
   virtual void HandleMovableReference(const void**) {}
 
+  virtual void VisitMultipleUncompressedMember(
+      const void* start, size_t len,
+      TraceDescriptorCallback get_trace_descriptor) {
+    // Default implementation merely delegates to Visit().
+    const char* it = static_cast<const char*>(start);
+    const char* end = it + len * internal::kSizeOfUncompressedMember;
+    for (; it < end; it += internal::kSizeOfUncompressedMember) {
+      const auto* current = reinterpret_cast<const internal::RawPointer*>(it);
+      const void* object = current->LoadAtomic();
+      if (!object) continue;
+
+      Visit(object, get_trace_descriptor(object));
+    }
+  }
+
+#if defined(CPPGC_POINTER_COMPRESSION)
+  virtual void VisitMultipleCompressedMember(
+      const void* start, size_t len,
+      TraceDescriptorCallback get_trace_descriptor) {
+    // Default implementation merely delegates to Visit().
+    const char* it = static_cast<const char*>(start);
+    const char* end = it + len * internal::kSizeofCompressedMember;
+    for (; it < end; it += internal::kSizeofCompressedMember) {
+      const auto* current =
+          reinterpret_cast<const internal::CompressedPointer*>(it);
+      const void* object = current->LoadAtomic();
+      if (!object) continue;
+
+      Visit(object, get_trace_descriptor(object));
+    }
+  }
+#endif  // defined(CPPGC_POINTER_COMPRESSION)
+
  private:
   template <typename T, void (T::*method)(const LivenessBroker&)>
   static void WeakCallbackMethodDelegate(const LivenessBroker& info,
@@ -326,8 +406,7 @@ class V8_EXPORT Visitor {
   template <typename PointerType>
   static void HandleWeak(const LivenessBroker& info, const void* object) {
     const PointerType* weak = static_cast<const PointerType*>(object);
-    auto* raw_ptr = weak->GetFromGC();
-    if (!info.IsHeapObjectAlive(raw_ptr)) {
+    if (!info.IsHeapObjectAlive(weak->GetFromGC())) {
       weak->ClearFromGC();
     }
   }
@@ -413,8 +492,7 @@ class V8_EXPORT RootVisitor {
   template <typename PointerType>
   static void HandleWeak(const LivenessBroker& info, const void* object) {
     const PointerType* weak = static_cast<const PointerType*>(object);
-    auto* raw_ptr = weak->GetFromGC();
-    if (!info.IsHeapObjectAlive(raw_ptr)) {
+    if (!info.IsHeapObjectAlive(weak->GetFromGC())) {
       weak->ClearFromGC();
     }
   }

data/vendor/v8/include/libplatform/libplatform.h

@@ -23,6 +23,8 @@ enum class MessageLoopBehavior : bool {
   kWaitForWork = true
 };
 
+enum class PriorityMode : bool { kDontApply, kApply };
+
 /**
  * Returns a new instance of the default v8::Platform implementation.
  *
@@ -35,13 +37,17 @@ enum class MessageLoopBehavior : bool {
  * calling v8::platform::RunIdleTasks to process the idle tasks.
  * If |tracing_controller| is nullptr, the default platform will create a
  * v8::platform::TracingController instance and use it.
+ * If |priority_mode| is PriorityMode::kApply, the default platform will use
+ * multiple task queues executed by threads different system-level priorities
+ * (where available) to schedule tasks.
  */
 V8_PLATFORM_EXPORT std::unique_ptr<v8::Platform> NewDefaultPlatform(
     int thread_pool_size = 0,
     IdleTaskSupport idle_task_support = IdleTaskSupport::kDisabled,
     InProcessStackDumping in_process_stack_dumping =
         InProcessStackDumping::kDisabled,
-    std::unique_ptr<v8::TracingController> tracing_controller = {});
+    std::unique_ptr<v8::TracingController> tracing_controller = {},
+    PriorityMode priority_mode = PriorityMode::kDontApply);
 
 /**
  * The same as NewDefaultPlatform but disables the worker thread pool.

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

@@ -147,14 +147,18 @@ using JitCodeEventHandler = void (*)(const JitCodeEvent* event);
  * the callback functions, you therefore cannot manipulate objects (set or
  * delete properties for example) since it is possible such operations will
  * result in the allocation of objects.
+ * TODO(v8:12612): Deprecate kGCTypeMinorMarkSweep after updating blink.
  */
 enum GCType {
   kGCTypeScavenge = 1 << 0,
-  kGCTypeMinorMarkCompact = 1 << 1,
+  kGCTypeMinorMarkSweep = 1 << 1,
+  kGCTypeMinorMarkCompact V8_DEPRECATE_SOON(
+      "Use kGCTypeMinorMarkSweep instead of kGCTypeMinorMarkCompact.") =
+      kGCTypeMinorMarkSweep,
   kGCTypeMarkSweepCompact = 1 << 2,
   kGCTypeIncrementalMarking = 1 << 3,
   kGCTypeProcessWeakCallbacks = 1 << 4,
-  kGCTypeAll = kGCTypeScavenge | kGCTypeMinorMarkCompact |
+  kGCTypeAll = kGCTypeScavenge | kGCTypeMinorMarkSweep |
                kGCTypeMarkSweepCompact | kGCTypeIncrementalMarking |
                kGCTypeProcessWeakCallbacks
 };
@@ -323,20 +327,21 @@ using WasmAsyncResolvePromiseCallback = void (*)(
 using WasmLoadSourceMapCallback = Local<String> (*)(Isolate* isolate,
                                                     const char* name);
 
-// --- Callback for checking if WebAssembly Simd is enabled ---
-using WasmSimdEnabledCallback = bool (*)(Local<Context> context);
-
-// --- Callback for checking if WebAssembly exceptions are enabled ---
-using WasmExceptionsEnabledCallback = bool (*)(Local<Context> context);
-
 // --- Callback for checking if WebAssembly GC is enabled ---
 // If the callback returns true, it will also enable Wasm stringrefs.
 using WasmGCEnabledCallback = bool (*)(Local<Context> context);
 
+// --- Callback for checking if WebAssembly imported strings are enabled ---
+using WasmImportedStringsEnabledCallback = bool (*)(Local<Context> context);
+
 // --- Callback for checking if the SharedArrayBuffer constructor is enabled ---
 using SharedArrayBufferConstructorEnabledCallback =
     bool (*)(Local<Context> context);
 
+// --- Callback for checking if the compile hints magic comments are enabled ---
+using JavaScriptCompileHintsMagicEnabledCallback =
+    bool (*)(Local<Context> context);
+
 /**
  * HostImportModuleDynamicallyCallback is called when we
  * require the embedder to load a module. This is used as part of the dynamic
@@ -419,6 +424,45 @@ using PrepareStackTraceCallback = MaybeLocal<Value> (*)(Local<Context> context,
                                                         Local<Value> error,
                                                         Local<Array> sites);
 
+#if defined(V8_OS_WIN)
+/**
+ * Callback to selectively enable ETW tracing based on the document URL.
+ * Implemented by the embedder, it should never call back into V8.
+ *
+ * Windows allows passing additional data to the ETW EnableCallback:
+ * https://learn.microsoft.com/en-us/windows/win32/api/evntprov/nc-evntprov-penablecallback
+ *
+ * This data can be configured in a WPR (Windows Performance Recorder)
+ * profile, adding a CustomFilter to an EventProvider like the following:
+ *
+ * <EventProvider Id=".." Name="57277741-3638-4A4B-BDBA-0AC6E45DA56C" Level="5">
+ *   <CustomFilter Type="0x80000000" Value="AQABAAAAAAA..." />
+ * </EventProvider>
+ *
+ * Where:
+ * - Name="57277741-3638-4A4B-BDBA-0AC6E45DA56C" is the GUID of the V8
+ *     ETW provider, (see src/libplatform/etw/etw-provider-win.h),
+ * - Type="0x80000000" is EVENT_FILTER_TYPE_SCHEMATIZED,
+ * - Value="AQABAAAAAA..." is a base64-encoded byte array that is
+ *     base64-decoded by Windows and passed to the ETW enable callback in
+ *     the 'PEVENT_FILTER_DESCRIPTOR FilterData' argument; see:
+ * https://learn.microsoft.com/en-us/windows/win32/api/evntprov/ns-evntprov-event_filter_descriptor.
+ *
+ * This array contains a struct EVENT_FILTER_HEADER followed by a
+ * variable length payload, and as payload we pass a string in JSON format,
+ * with a list of regular expressions that should match the document URL
+ * in order to enable ETW tracing:
+ *   {
+ *     "version": "1.0",
+ *     "filtered_urls": [
+ *         "https:\/\/.*\.chromium\.org\/.*", "https://v8.dev/";, "..."
+ *     ]
+ *  }
+ */
+using FilterETWSessionByURLCallback =
+    bool (*)(Local<Context> context, const std::string& etw_filter_payload);
+#endif  // V8_OS_WIN
+
 }  // namespace v8
 
 #endif  // INCLUDE_V8_ISOLATE_CALLBACKS_H_

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

@@ -395,7 +395,7 @@ Local<Value> Context::GetEmbedderData(int index) {
 #ifndef V8_ENABLE_CHECKS
   using A = internal::Address;
   using I = internal::Internals;
-  A ctx = *reinterpret_cast<const A*>(this);
+  A ctx = internal::ValueHelper::ValueAsAddress(this);
   A embedder_data =
       I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
   int value_offset =
@@ -407,15 +407,9 @@ Local<Value> Context::GetEmbedderData(int index) {
   value = I::DecompressTaggedField(embedder_data, static_cast<uint32_t>(value));
 #endif
 
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
-  return Local<Value>(reinterpret_cast<Value*>(value));
-#else
-  internal::Isolate* isolate = internal::IsolateFromNeverReadOnlySpaceObject(
-      *reinterpret_cast<A*>(this));
-  A* result = HandleScope::CreateHandle(isolate, value);
-  return Local<Value>(reinterpret_cast<Value*>(result));
-#endif
-
+  auto isolate = reinterpret_cast<v8::Isolate*>(
+      internal::IsolateFromNeverReadOnlySpaceObject(ctx));
+  return Local<Value>::New(isolate, value);
 #else
   return SlowGetEmbedderData(index);
 #endif
@@ -442,9 +436,12 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
 
 template <class T>
 MaybeLocal<T> Context::GetDataFromSnapshotOnce(size_t index) {
-  T* data = reinterpret_cast<T*>(GetDataFromSnapshotOnce(index));
-  if (data) internal::PerformCastCheck(data);
-  return Local<T>(data);
+  auto slot = GetDataFromSnapshotOnce(index);
+  if (slot) {
+    internal::PerformCastCheck(
+        internal::ValueHelper::SlotAsValue<T, false>(slot));
+  }
+  return Local<T>::FromSlot(slot);
 }
 
 Context* Context::Cast(v8::Data* data) {

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

@@ -177,6 +177,11 @@ class V8_EXPORT CppHeap {
   void CollectGarbageInYoungGenerationForTesting(
       cppgc::EmbedderStackState stack_state);
 
+  /**
+   * \returns the wrapper descriptor of this CppHeap.
+   */
+  v8::WrapperDescriptor wrapper_descriptor() const;
+
  private:
   CppHeap() = default;
 

data/vendor/v8/include/v8-embedder-heap.h

@@ -34,6 +34,8 @@ class V8_EXPORT EmbedderRootsHandler {
    * for retaining the object. The embedder may use |WrapperClassId()| to
    * distinguish cases where it wants handles to be treated as roots from not
    * being treated as roots.
+   *
+   * The concrete implementations must be thread-safe.
    */
   virtual bool IsRoot(const v8::TracedReference<v8::Value>& handle) = 0;
 
@@ -47,6 +49,16 @@ class V8_EXPORT EmbedderRootsHandler {
    * handle via the object or class id.
    */
   virtual void ResetRoot(const v8::TracedReference<v8::Value>& handle) = 0;
+
+  /**
+   * Similar to |ResetRoot()|, but opportunistic. The function is called in
+   * parallel for different handles and as such must be thread-safe. In case,
+   * |false| is returned, |ResetRoot()| will be recalled for the same handle.
+   */
+  virtual bool TryResetRoot(const v8::TracedReference<v8::Value>& handle) {
+    ResetRoot(handle);
+    return true;
+  }
 };
 
 }  // namespace v8

data/vendor/v8/include/v8-fast-api-calls.h

@@ -388,13 +388,19 @@ struct FastOneByteString {
 
 class V8_EXPORT CFunctionInfo {
  public:
+  enum class Int64Representation : uint8_t {
+    kNumber = 0,  // Use numbers to represent 64 bit integers.
+    kBigInt = 1,  // Use BigInts to represent 64 bit integers.
+  };
+
   // Construct a struct to hold a CFunction's type information.
   // |return_info| describes the function's return type.
   // |arg_info| is an array of |arg_count| CTypeInfos describing the
   //   arguments. Only the last argument may be of the special type
   //   CTypeInfo::kCallbackOptionsType.
   CFunctionInfo(const CTypeInfo& return_info, unsigned int arg_count,
-                const CTypeInfo* arg_info);
+                const CTypeInfo* arg_info,
+                Int64Representation repr = Int64Representation::kNumber);
 
   const CTypeInfo& ReturnInfo() const { return return_info_; }
 
@@ -404,6 +410,8 @@ class V8_EXPORT CFunctionInfo {
     return HasOptions() ? arg_count_ - 1 : arg_count_;
   }
 
+  Int64Representation GetInt64Representation() const { return repr_; }
+
   // |index| must be less than ArgumentCount().
   //  Note: if the last argument passed on construction of CFunctionInfo
   //  has type CTypeInfo::kCallbackOptionsType, it is not included in
@@ -418,6 +426,7 @@ class V8_EXPORT CFunctionInfo {
 
  private:
   const CTypeInfo return_info_;
+  const Int64Representation repr_;
   const unsigned int arg_count_;
   const CTypeInfo* arg_info_;
 };
@@ -469,6 +478,9 @@ class V8_EXPORT CFunction {
   unsigned int ArgumentCount() const { return type_info_->ArgumentCount(); }
 
   const void* GetAddress() const { return address_; }
+  CFunctionInfo::Int64Representation GetInt64Representation() const {
+    return type_info_->GetInt64Representation();
+  }
   const CFunctionInfo* GetTypeInfo() const { return type_info_; }
 
   enum class OverloadResolution { kImpossible, kAtRuntime, kAtCompileTime };
@@ -598,7 +610,8 @@ struct count<T, T, Args...>
 template <typename T, typename U, typename... Args>
 struct count<T, U, Args...> : count<T, Args...> {};
 
-template <typename RetBuilder, typename... ArgBuilders>
+template <CFunctionInfo::Int64Representation Representation,
+          typename RetBuilder, typename... ArgBuilders>
 class CFunctionInfoImpl : public CFunctionInfo {
   static constexpr int kOptionsArgCount =
       count<FastApiCallbackOptions&, ArgBuilders...>();
@@ -613,18 +626,20 @@ class CFunctionInfoImpl : public CFunctionInfo {
  public:
   constexpr CFunctionInfoImpl()
       : CFunctionInfo(RetBuilder::Build(), sizeof...(ArgBuilders),
-                      arg_info_storage_),
+                      arg_info_storage_, Representation),
         arg_info_storage_{ArgBuilders::Build()...} {
     constexpr CTypeInfo::Type kReturnType = RetBuilder::Build().GetType();
     static_assert(kReturnType == CTypeInfo::Type::kVoid ||
                       kReturnType == CTypeInfo::Type::kBool ||
                       kReturnType == CTypeInfo::Type::kInt32 ||
                       kReturnType == CTypeInfo::Type::kUint32 ||
+                      kReturnType == CTypeInfo::Type::kInt64 ||
+                      kReturnType == CTypeInfo::Type::kUint64 ||
                       kReturnType == CTypeInfo::Type::kFloat32 ||
                       kReturnType == CTypeInfo::Type::kFloat64 ||
                       kReturnType == CTypeInfo::Type::kPointer ||
                       kReturnType == CTypeInfo::Type::kAny,
-                  "64-bit int, string and api object values are not currently "
+                  "String and api object values are not currently "
                   "supported return types.");
   }
 
@@ -845,8 +860,11 @@ class CFunctionBuilderWithFunction {
     return *this;
   }
 
+  template <CFunctionInfo::Int64Representation Representation =
+                CFunctionInfo::Int64Representation::kNumber>
   auto Build() {
-    static CFunctionInfoImpl<RetBuilder, ArgBuilders...> instance;
+    static CFunctionInfoImpl<Representation, RetBuilder, ArgBuilders...>
+        instance;
     return CFunction(fn_, &instance);
   }
 

data/vendor/v8/include/v8-function-callback.h

@@ -78,7 +78,6 @@ class ReturnValue {
 
   // See FunctionCallbackInfo.
   static constexpr int kIsolateValueIndex = -2;
-  static constexpr int kDefaultValueValueIndex = -1;
 
   internal::Address* value_;
 };
@@ -127,16 +126,16 @@ class FunctionCallbackInfo {
   friend class internal::FunctionCallbackArguments;
   friend class internal::CustomArguments<FunctionCallbackInfo>;
   friend class debug::ConsoleCallArguments;
-  friend class internal::Builtins;
+
   static constexpr int kHolderIndex = 0;
   static constexpr int kIsolateIndex = 1;
-  static constexpr int kReturnValueDefaultValueIndex = 2;
+  static constexpr int kUnusedIndex = 2;
   static constexpr int kReturnValueIndex = 3;
   static constexpr int kDataIndex = 4;
   static constexpr int kNewTargetIndex = 5;
-
   static constexpr int kArgsLength = 6;
-  static constexpr int kArgsLengthWithReceiver = 7;
+
+  static constexpr int kArgsLengthWithReceiver = kArgsLength + 1;
 
   // Codegen constants:
   static constexpr int kSize = 3 * internal::kApiSystemPointerSize;
@@ -147,8 +146,6 @@ class FunctionCallbackInfo {
       kValuesOffset + internal::kApiSystemPointerSize;
 
   static constexpr int kThisValuesIndex = -1;
-  static_assert(ReturnValue<Value>::kDefaultValueValueIndex ==
-                kReturnValueDefaultValueIndex - kReturnValueIndex);
   static_assert(ReturnValue<Value>::kIsolateValueIndex ==
                 kIsolateIndex - kReturnValueIndex);
 
@@ -258,17 +255,17 @@ class PropertyCallbackInfo {
   static constexpr int kShouldThrowOnErrorIndex = 0;
   static constexpr int kHolderIndex = 1;
   static constexpr int kIsolateIndex = 2;
-  static constexpr int kReturnValueDefaultValueIndex = 3;
+  static constexpr int kUnusedIndex = 3;
   static constexpr int kReturnValueIndex = 4;
   static constexpr int kDataIndex = 5;
   static constexpr int kThisIndex = 6;
-
   static constexpr int kArgsLength = 7;
 
   static constexpr int kSize = 1 * internal::kApiSystemPointerSize;
 
   V8_INLINE explicit PropertyCallbackInfo(internal::Address* args)
       : args_(args) {}
+
   internal::Address* args_;
 };
 
@@ -286,7 +283,7 @@ void ReturnValue<T>::Set(const Global<S>& handle) {
   if (V8_UNLIKELY(handle.IsEmpty())) {
     *value_ = GetDefaultValue();
   } else {
-    *value_ = *reinterpret_cast<internal::Address*>(*handle);
+    *value_ = handle.ptr();
   }
 }
 
@@ -297,7 +294,7 @@ void ReturnValue<T>::Set(const BasicTracedReference<S>& handle) {
   if (V8_UNLIKELY(handle.IsEmpty())) {
     *value_ = GetDefaultValue();
   } else {
-    *value_ = *reinterpret_cast<internal::Address*>(handle.val_);
+    *value_ = handle.ptr();
   }
 }
 
@@ -309,7 +306,7 @@ void ReturnValue<T>::Set(const Local<S> handle) {
   if (V8_UNLIKELY(handle.IsEmpty())) {
     *value_ = GetDefaultValue();
   } else {
-    *value_ = internal::ValueHelper::ValueAsAddress(*handle);
+    *value_ = handle.ptr();
   }
 }
 
@@ -378,7 +375,6 @@ void ReturnValue<T>::SetEmptyString() {
 
 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_[kIsolateValueIndex]);
 }
 
@@ -403,8 +399,8 @@ void ReturnValue<T>::Set(S* whatever) {
 
 template <typename T>
 internal::Address ReturnValue<T>::GetDefaultValue() {
-  // Default value is always the pointer below value_ on the stack.
-  return value_[kDefaultValueValueIndex];
+  using I = internal::Internals;
+  return I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex);
 }
 
 template <typename T>

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

@@ -87,6 +87,12 @@ class V8_EXPORT Function : public Object {
    */
   int GetScriptColumnNumber() const;
 
+  /**
+   * Returns zero based start position (character offset) of function body and
+   * kLineOffsetNotFound if no information available.
+   */
+  int GetScriptStartPosition() const;
+
   /**
    * Returns scriptId.
    */