File Explorer

1// Copyright 2021 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4 5#ifndef INCLUDE_V8_FUNCTION_CALLBACK_H_6#define INCLUDE_V8_FUNCTION_CALLBACK_H_7 8#include <cstdint>9#include <limits>10 11#include "v8-internal.h"      // NOLINT(build/include_directory)12#include "v8-local-handle.h"  // NOLINT(build/include_directory)13#include "v8-primitive.h"     // NOLINT(build/include_directory)14#include "v8config.h"         // NOLINT(build/include_directory)15 16namespace v8 {17 18template <typename T>19class BasicTracedReference;20template <typename T>21class Global;22class Object;23class Value;24 25namespace internal {26class FunctionCallbackArguments;27class PropertyCallbackArguments;28class Builtins;29}  // namespace internal30 31namespace debug {32class ConsoleCallArguments;33}  // namespace debug34 35namespace api_internal {36V8_EXPORT v8::Local<v8::Value> GetFunctionTemplateData(37    v8::Isolate* isolate, v8::Local<v8::Data> raw_target);38}  // namespace api_internal39 40template <typename T>41class ReturnValue {42 public:43  template <class S>44  V8_INLINE ReturnValue(const ReturnValue<S>& that) : value_(that.value_) {45    static_assert(std::is_base_of<T, S>::value, "type check");46  }47  // Handle-based setters.48  template <typename S>49  V8_INLINE void Set(const Global<S>& handle);50  template <typename S>51  V8_INLINE void SetNonEmpty(const Global<S>& handle);52  template <typename S>53  V8_INLINE void Set(const BasicTracedReference<S>& handle);54  template <typename S>55  V8_INLINE void SetNonEmpty(const BasicTracedReference<S>& handle);56  template <typename S>57  V8_INLINE void Set(const Local<S> handle);58  template <typename S>59  V8_INLINE void SetNonEmpty(const Local<S> handle);60  // Fast primitive number setters.61  V8_INLINE void Set(bool value);62  V8_INLINE void Set(double i);63  V8_INLINE void Set(int16_t i);64  V8_INLINE void Set(int32_t i);65  V8_INLINE void Set(int64_t i);66  V8_INLINE void Set(uint16_t i);67  V8_INLINE void Set(uint32_t i);68  V8_INLINE void Set(uint64_t i);69  // Fast JS primitive setters70  V8_INLINE void SetNull();71  V8_INLINE void SetUndefined();72  V8_INLINE void SetFalse();73  V8_INLINE void SetEmptyString();74  // Convenience getter for Isolate75  V8_INLINE Isolate* GetIsolate() const;76 77  // Pointer setter: Uncompilable to prevent inadvertent misuse.78  template <typename S>79  V8_INLINE void Set(S* whatever);80 81  // Getter. Creates a new Local<> so it comes with a certain performance82  // hit. If the ReturnValue was not yet set, this will return the undefined83  // value.84  V8_INLINE Local<Value> Get() const;85 86 private:87  template <class F>88  friend class ReturnValue;89  template <class F>90  friend class FunctionCallbackInfo;91  template <class F>92  friend class PropertyCallbackInfo;93  template <class F, class G, class H>94  friend class PersistentValueMapBase;95  V8_INLINE void SetInternal(internal::Address value);96  // Default value depends on <T>:97  //  - <void> -> true_value,98  //  - <v8::Boolean> -> true_value,99  //  - <v8::Integer> -> 0,100  //  - <v8::Value> -> undefined_value,101  //  - <v8::Array> -> undefined_value.102  V8_INLINE void SetDefaultValue();103  V8_INLINE explicit ReturnValue(internal::Address* slot);104 105  // See FunctionCallbackInfo.106  static constexpr int kIsolateValueIndex = -2;107 108  internal::Address* value_;109};110 111/**112 * The argument information given to function call callbacks.  This113 * class provides access to information about the context of the call,114 * including the receiver, the number and values of arguments, and115 * the holder of the function.116 */117template <typename T>118class FunctionCallbackInfo {119 public:120  /** The number of available arguments. */121  V8_INLINE int Length() const;122  /**123   * Accessor for the available arguments. Returns `undefined` if the index124   * is out of bounds.125   */126  V8_INLINE Local<Value> operator[](int i) const;127  /** Returns the receiver. This corresponds to the "this" value. */128  V8_INLINE Local<Object> This() const;129  /** For construct calls, this returns the "new.target" value. */130  V8_INLINE Local<Value> NewTarget() const;131  /** Indicates whether this is a regular call or a construct call. */132  V8_INLINE bool IsConstructCall() const;133  /** The data argument specified when creating the callback. */134  V8_INLINE Local<Value> Data() const;135  /** The current Isolate. */136  V8_INLINE Isolate* GetIsolate() const;137  /** The ReturnValue for the call. */138  V8_INLINE ReturnValue<T> GetReturnValue() const;139 140 private:141  friend class internal::FunctionCallbackArguments;142  friend class internal::CustomArguments<FunctionCallbackInfo>;143  friend class debug::ConsoleCallArguments;144  friend void internal::PrintFunctionCallbackInfo(void*);145 146  // TODO(ishell, http://crbug.com/326505377): in case of non-constructor147  // call, don't pass kNewTarget and kUnused. Add IsConstructCall flag to148  // kIsolate field.149  static constexpr int kUnusedIndex = 0;150  static constexpr int kIsolateIndex = 1;151  static constexpr int kContextIndex = 2;152  static constexpr int kReturnValueIndex = 3;153  static constexpr int kTargetIndex = 4;154  static constexpr int kNewTargetIndex = 5;155  static constexpr int kArgsLength = 6;156 157  static constexpr int kArgsLengthWithReceiver = kArgsLength + 1;158 159  // Codegen constants:160  static constexpr int kSize = 3 * internal::kApiSystemPointerSize;161  static constexpr int kImplicitArgsOffset = 0;162  static constexpr int kValuesOffset =163      kImplicitArgsOffset + internal::kApiSystemPointerSize;164  static constexpr int kLengthOffset =165      kValuesOffset + internal::kApiSystemPointerSize;166 167  static constexpr int kThisValuesIndex = -1;168  static_assert(ReturnValue<Value>::kIsolateValueIndex ==169                kIsolateIndex - kReturnValueIndex);170 171  V8_INLINE FunctionCallbackInfo(internal::Address* implicit_args,172                                 internal::Address* values, int length);173 174  // TODO(https://crbug.com/326505377): flatten the v8::FunctionCallbackInfo175  // object to avoid indirect loads through values_ and implicit_args_ and176  // reduce the number of instructions in the CallApiCallback builtin.177  internal::Address* implicit_args_;178  internal::Address* values_;179  internal::Address length_;180};181 182/**183 * The information passed to a property callback about the context184 * of the property access.185 */186template <typename T>187class PropertyCallbackInfo {188 public:189  /**190   * \return The isolate of the property access.191   */192  V8_INLINE Isolate* GetIsolate() const;193 194  /**195   * \return The data set in the configuration, i.e., in196   * `NamedPropertyHandlerConfiguration` or197   * `IndexedPropertyHandlerConfiguration.`198   */199  V8_INLINE Local<Value> Data() const;200 201  /**202   * \return The receiver. In many cases, this is the object on which the203   * property access was intercepted. When using204   * `Reflect.get`, `Function.prototype.call`, or similar functions, it is the205   * object passed in as receiver or thisArg.206   *207   * \code208   *  void GetterCallback(Local<Name> name,209   *                      const v8::PropertyCallbackInfo<v8::Value>& info) {210   *     auto context = info.GetIsolate()->GetCurrentContext();211   *212   *     v8::Local<v8::Value> a_this =213   *         info.This()214   *             ->GetRealNamedProperty(context, v8_str("a"))215   *             .ToLocalChecked();216   *     v8::Local<v8::Value> a_holder =217   *         info.Holder()218   *             ->GetRealNamedProperty(context, v8_str("a"))219   *             .ToLocalChecked();220   *221   *    CHECK(v8_str("r")->Equals(context, a_this).FromJust());222   *    CHECK(v8_str("obj")->Equals(context, a_holder).FromJust());223   *224   *    info.GetReturnValue().Set(name);225   *  }226   *227   *  v8::Local<v8::FunctionTemplate> templ =228   *  v8::FunctionTemplate::New(isolate);229   *  templ->InstanceTemplate()->SetHandler(230   *      v8::NamedPropertyHandlerConfiguration(GetterCallback));231   *  LocalContext env;232   *  env->Global()233   *      ->Set(env.local(), v8_str("obj"), templ->GetFunction(env.local())234   *                                           .ToLocalChecked()235   *                                           ->NewInstance(env.local())236   *                                           .ToLocalChecked())237   *      .FromJust();238   *239   *  CompileRun("obj.a = 'obj'; var r = {a: 'r'}; Reflect.get(obj, 'x', r)");240   * \endcode241   */242  V8_INLINE Local<Object> This() const;243 244  /**245   * \return The object in the prototype chain of the receiver that has the246   * interceptor. Suppose you have `x` and its prototype is `y`, and `y`247   * has an interceptor. Then `info.This()` is `x` and `info.Holder()` is `y`.248   * The Holder() could be a hidden object (the global object, rather249   * than the global proxy).250   *251   * \note For security reasons, do not pass the object back into the runtime.252   */253  V8_DEPRECATE_SOON(254      "V8 will stop providing access to hidden prototype (i.e. "255      "JSGlobalObject). Use HolderV2() instead. \n"256      "DO NOT try to workaround this by accessing JSGlobalObject via "257      "v8::Object::GetPrototype() - it'll be deprecated soon too. \n"258      "See http://crbug.com/333672197. ")259  V8_INLINE Local<Object> Holder() const;260 261  /**262   * \return The object in the prototype chain of the receiver that has the263   * interceptor. Suppose you have `x` and its prototype is `y`, and `y`264   * has an interceptor. Then `info.This()` is `x` and `info.Holder()` is `y`.265   * In case the property is installed on the global object the Holder()266   * would return the global proxy.267   */268  V8_INLINE Local<Object> HolderV2() const;269 270  /**271   * \return The return value of the callback.272   * Can be changed by calling Set().273   * \code274   * info.GetReturnValue().Set(...)275   * \endcode276   *277   */278  V8_INLINE ReturnValue<T> GetReturnValue() const;279 280  /**281   * \return True if the intercepted function should throw if an error occurs.282   * Usually, `true` corresponds to `'use strict'`.283   *284   * \note Always `false` when intercepting `Reflect.set()`285   * independent of the language mode.286   */287  V8_INLINE bool ShouldThrowOnError() const;288 289 private:290  template <typename U>291  friend class PropertyCallbackInfo;292  friend class MacroAssembler;293  friend class internal::PropertyCallbackArguments;294  friend class internal::CustomArguments<PropertyCallbackInfo>;295  friend void internal::PrintPropertyCallbackInfo(void*);296 297  static constexpr int kPropertyKeyIndex = 0;298  static constexpr int kShouldThrowOnErrorIndex = 1;299  static constexpr int kHolderIndex = 2;300  static constexpr int kIsolateIndex = 3;301  static constexpr int kHolderV2Index = 4;302  static constexpr int kReturnValueIndex = 5;303  static constexpr int kDataIndex = 6;304  static constexpr int kThisIndex = 7;305  static constexpr int kArgsLength = 8;306 307  static constexpr int kSize = kArgsLength * internal::kApiSystemPointerSize;308 309  PropertyCallbackInfo() = default;310 311  mutable internal::Address args_[kArgsLength];312};313 314using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>& info);315 316// --- Implementation ---317 318template <typename T>319ReturnValue<T>::ReturnValue(internal::Address* slot) : value_(slot) {}320 321template <typename T>322void ReturnValue<T>::SetInternal(internal::Address value) {323#if V8_STATIC_ROOTS_BOOL324  using I = internal::Internals;325  // Ensure that the upper 32-bits are not modified. Compiler should be326  // able to optimize this to a store of a lower 32-bits of the value.327  // This is fine since the callback can return only JavaScript values which328  // are either Smis or heap objects allocated in the main cage.329  *value_ = I::DecompressTaggedField(*value_, I::CompressTagged(value));330#else331  *value_ = value;332#endif  // V8_STATIC_ROOTS_BOOL333}334 335template <typename T>336template <typename S>337void ReturnValue<T>::Set(const Global<S>& handle) {338  static_assert(std::is_base_of<T, S>::value, "type check");339  if (V8_UNLIKELY(handle.IsEmpty())) {340    SetDefaultValue();341  } else {342    SetInternal(handle.ptr());343  }344}345 346template <typename T>347template <typename S>348void ReturnValue<T>::SetNonEmpty(const Global<S>& handle) {349  static_assert(std::is_base_of<T, S>::value, "type check");350#ifdef V8_ENABLE_CHECKS351  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());352#endif  // V8_ENABLE_CHECKS353  SetInternal(handle.ptr());354}355 356template <typename T>357template <typename S>358void ReturnValue<T>::Set(const BasicTracedReference<S>& handle) {359  static_assert(std::is_base_of<T, S>::value, "type check");360  if (V8_UNLIKELY(handle.IsEmpty())) {361    SetDefaultValue();362  } else {363    SetInternal(handle.ptr());364  }365}366 367template <typename T>368template <typename S>369void ReturnValue<T>::SetNonEmpty(const BasicTracedReference<S>& handle) {370  static_assert(std::is_base_of<T, S>::value, "type check");371#ifdef V8_ENABLE_CHECKS372  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());373#endif  // V8_ENABLE_CHECKS374  SetInternal(handle.ptr());375}376 377template <typename T>378template <typename S>379void ReturnValue<T>::Set(const Local<S> handle) {380  // "V8_DEPRECATE_SOON" this method if |T| is |void|.381#ifdef V8_IMMINENT_DEPRECATION_WARNINGS382  static constexpr bool is_allowed_void = false;383  static_assert(!std::is_void<T>::value,384                "ReturnValue<void>::Set(const Local<S>) is deprecated. "385                "Do nothing to indicate that the operation succeeded or use "386                "SetFalse() to indicate that the operation failed (don't "387                "forget to handle info.ShouldThrowOnError()). "388                "See http://crbug.com/348660658 for details.");389#else390  static constexpr bool is_allowed_void = std::is_void<T>::value;391#endif  // V8_IMMINENT_DEPRECATION_WARNINGS392  static_assert(is_allowed_void || std::is_base_of<T, S>::value, "type check");393  if (V8_UNLIKELY(handle.IsEmpty())) {394    SetDefaultValue();395  } else if constexpr (is_allowed_void) {396    // Simulate old behaviour for "v8::AccessorSetterCallback" for which397    // it was possible to set the return value even for ReturnValue<void>.398    Set(handle->BooleanValue(GetIsolate()));399  } else {400    SetInternal(handle.ptr());401  }402}403 404template <typename T>405template <typename S>406void ReturnValue<T>::SetNonEmpty(const Local<S> handle) {407  // "V8_DEPRECATE_SOON" this method if |T| is |void|.408#ifdef V8_IMMINENT_DEPRECATION_WARNINGS409  static constexpr bool is_allowed_void = false;410  static_assert(!std::is_void<T>::value,411                "ReturnValue<void>::SetNonEmpty(const Local<S>) is deprecated. "412                "Do nothing to indicate that the operation succeeded or use "413                "SetFalse() to indicate that the operation failed (don't "414                "forget to handle info.ShouldThrowOnError()). "415                "See http://crbug.com/348660658 for details.");416#else417  static constexpr bool is_allowed_void = std::is_void<T>::value;418#endif  // V8_IMMINENT_DEPRECATION_WARNINGS419  static_assert(is_allowed_void || std::is_base_of<T, S>::value, "type check");420#ifdef V8_ENABLE_CHECKS421  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());422#endif  // V8_ENABLE_CHECKS423  if constexpr (is_allowed_void) {424    // Simulate old behaviour for "v8::AccessorSetterCallback" for which425    // it was possible to set the return value even for ReturnValue<void>.426    Set(handle->BooleanValue(GetIsolate()));427  } else {428    SetInternal(handle.ptr());429  }430}431 432template <typename T>433void ReturnValue<T>::Set(double i) {434  static_assert(std::is_base_of<T, Number>::value, "type check");435  SetNonEmpty(Number::New(GetIsolate(), i));436}437 438template <typename T>439void ReturnValue<T>::Set(int16_t i) {440  static_assert(std::is_base_of<T, Integer>::value, "type check");441  using I = internal::Internals;442  static_assert(I::IsValidSmi(std::numeric_limits<int16_t>::min()));443  static_assert(I::IsValidSmi(std::numeric_limits<int16_t>::max()));444  SetInternal(I::IntegralToSmi(i));445}446 447template <typename T>448void ReturnValue<T>::Set(int32_t i) {449  static_assert(std::is_base_of<T, Integer>::value, "type check");450  if (const auto result = internal::Internals::TryIntegralToSmi(i)) {451    SetInternal(*result);452    return;453  }454  SetNonEmpty(Integer::New(GetIsolate(), i));455}456 457template <typename T>458void ReturnValue<T>::Set(int64_t i) {459  static_assert(std::is_base_of<T, Integer>::value, "type check");460  if (const auto result = internal::Internals::TryIntegralToSmi(i)) {461    SetInternal(*result);462    return;463  }464  SetNonEmpty(Number::New(GetIsolate(), static_cast<double>(i)));465}466 467template <typename T>468void ReturnValue<T>::Set(uint16_t i) {469  static_assert(std::is_base_of<T, Integer>::value, "type check");470  using I = internal::Internals;471  static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::min()));472  static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::max()));473  SetInternal(I::IntegralToSmi(i));474}475 476template <typename T>477void ReturnValue<T>::Set(uint32_t i) {478  static_assert(std::is_base_of<T, Integer>::value, "type check");479  if (const auto result = internal::Internals::TryIntegralToSmi(i)) {480    SetInternal(*result);481    return;482  }483  SetNonEmpty(Integer::NewFromUnsigned(GetIsolate(), i));484}485 486template <typename T>487void ReturnValue<T>::Set(uint64_t i) {488  static_assert(std::is_base_of<T, Integer>::value, "type check");489  if (const auto result = internal::Internals::TryIntegralToSmi(i)) {490    SetInternal(*result);491    return;492  }493  SetNonEmpty(Number::New(GetIsolate(), static_cast<double>(i)));494}495 496template <typename T>497void ReturnValue<T>::Set(bool value) {498  static_assert(std::is_void<T>::value || std::is_base_of<T, Boolean>::value,499                "type check");500  using I = internal::Internals;501#if V8_STATIC_ROOTS_BOOL502#ifdef V8_ENABLE_CHECKS503  internal::PerformCastCheck(504      internal::ValueHelper::SlotAsValue<Value, true>(value_));505#endif  // V8_ENABLE_CHECKS506  SetInternal(value ? I::StaticReadOnlyRoot::kTrueValue507                    : I::StaticReadOnlyRoot::kFalseValue);508#else509  int root_index;510  if (value) {511    root_index = I::kTrueValueRootIndex;512  } else {513    root_index = I::kFalseValueRootIndex;514  }515  *value_ = I::GetRoot(GetIsolate(), root_index);516#endif  // V8_STATIC_ROOTS_BOOL517}518 519template <typename T>520void ReturnValue<T>::SetDefaultValue() {521  using I = internal::Internals;522  if constexpr (std::is_same_v<void, T> || std::is_same_v<v8::Boolean, T>) {523    Set(true);524  } else if constexpr (std::is_same_v<v8::Integer, T>) {525    SetInternal(I::IntegralToSmi(0));526  } else {527    static_assert(std::is_same_v<v8::Value, T> || std::is_same_v<v8::Array, T>);528#if V8_STATIC_ROOTS_BOOL529    SetInternal(I::StaticReadOnlyRoot::kUndefinedValue);530#else531    *value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);532#endif  // V8_STATIC_ROOTS_BOOL533  }534}535 536template <typename T>537void ReturnValue<T>::SetNull() {538  static_assert(std::is_base_of<T, Primitive>::value, "type check");539  using I = internal::Internals;540#if V8_STATIC_ROOTS_BOOL541#ifdef V8_ENABLE_CHECKS542  internal::PerformCastCheck(543      internal::ValueHelper::SlotAsValue<Value, true>(value_));544#endif  // V8_ENABLE_CHECKS545  SetInternal(I::StaticReadOnlyRoot::kNullValue);546#else547  *value_ = I::GetRoot(GetIsolate(), I::kNullValueRootIndex);548#endif  // V8_STATIC_ROOTS_BOOL549}550 551template <typename T>552void ReturnValue<T>::SetUndefined() {553  static_assert(std::is_base_of<T, Primitive>::value, "type check");554  using I = internal::Internals;555#if V8_STATIC_ROOTS_BOOL556#ifdef V8_ENABLE_CHECKS557  internal::PerformCastCheck(558      internal::ValueHelper::SlotAsValue<Value, true>(value_));559#endif  // V8_ENABLE_CHECKS560  SetInternal(I::StaticReadOnlyRoot::kUndefinedValue);561#else562  *value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);563#endif  // V8_STATIC_ROOTS_BOOL564}565 566template <typename T>567void ReturnValue<T>::SetFalse() {568  static_assert(std::is_void<T>::value || std::is_base_of<T, Boolean>::value,569                "type check");570  using I = internal::Internals;571#if V8_STATIC_ROOTS_BOOL572#ifdef V8_ENABLE_CHECKS573  internal::PerformCastCheck(574      internal::ValueHelper::SlotAsValue<Value, true>(value_));575#endif  // V8_ENABLE_CHECKS576  SetInternal(I::StaticReadOnlyRoot::kFalseValue);577#else578  *value_ = I::GetRoot(GetIsolate(), I::kFalseValueRootIndex);579#endif  // V8_STATIC_ROOTS_BOOL580}581 582template <typename T>583void ReturnValue<T>::SetEmptyString() {584  static_assert(std::is_base_of<T, String>::value, "type check");585  using I = internal::Internals;586#if V8_STATIC_ROOTS_BOOL587#ifdef V8_ENABLE_CHECKS588  internal::PerformCastCheck(589      internal::ValueHelper::SlotAsValue<Value, true>(value_));590#endif  // V8_ENABLE_CHECKS591  SetInternal(I::StaticReadOnlyRoot::kEmptyString);592#else593  *value_ = I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);594#endif  // V8_STATIC_ROOTS_BOOL595}596 597template <typename T>598Isolate* ReturnValue<T>::GetIsolate() const {599  return *reinterpret_cast<Isolate**>(&value_[kIsolateValueIndex]);600}601 602template <typename T>603Local<Value> ReturnValue<T>::Get() const {604  return Local<Value>::New(GetIsolate(),605                           internal::ValueHelper::SlotAsValue<Value>(value_));606}607 608template <typename T>609template <typename S>610void ReturnValue<T>::Set(S* whatever) {611  static_assert(sizeof(S) < 0, "incompilable to prevent inadvertent misuse");612}613 614template <typename T>615FunctionCallbackInfo<T>::FunctionCallbackInfo(internal::Address* implicit_args,616                                              internal::Address* values,617                                              int length)618    : implicit_args_(implicit_args), values_(values), length_(length) {}619 620template <typename T>621Local<Value> FunctionCallbackInfo<T>::operator[](int i) const {622  // values_ points to the first argument (not the receiver).623  if (i < 0 || Length() <= i) return Undefined(GetIsolate());624  return Local<Value>::FromSlot(values_ + i);625}626 627template <typename T>628Local<Object> FunctionCallbackInfo<T>::This() const {629  // values_ points to the first argument (not the receiver).630  return Local<Object>::FromSlot(values_ + kThisValuesIndex);631}632 633template <typename T>634Local<Value> FunctionCallbackInfo<T>::NewTarget() const {635  return Local<Value>::FromSlot(&implicit_args_[kNewTargetIndex]);636}637 638template <typename T>639Local<Value> FunctionCallbackInfo<T>::Data() const {640  auto target = Local<v8::Data>::FromSlot(&implicit_args_[kTargetIndex]);641  return api_internal::GetFunctionTemplateData(GetIsolate(), target);642}643 644template <typename T>645Isolate* FunctionCallbackInfo<T>::GetIsolate() const {646  return *reinterpret_cast<Isolate**>(&implicit_args_[kIsolateIndex]);647}648 649template <typename T>650ReturnValue<T> FunctionCallbackInfo<T>::GetReturnValue() const {651  return ReturnValue<T>(&implicit_args_[kReturnValueIndex]);652}653 654template <typename T>655bool FunctionCallbackInfo<T>::IsConstructCall() const {656  return !NewTarget()->IsUndefined();657}658 659template <typename T>660int FunctionCallbackInfo<T>::Length() const {661  return static_cast<int>(length_);662}663 664template <typename T>665Isolate* PropertyCallbackInfo<T>::GetIsolate() const {666  return *reinterpret_cast<Isolate**>(&args_[kIsolateIndex]);667}668 669template <typename T>670Local<Value> PropertyCallbackInfo<T>::Data() const {671  return Local<Value>::FromSlot(&args_[kDataIndex]);672}673 674template <typename T>675Local<Object> PropertyCallbackInfo<T>::This() const {676  return Local<Object>::FromSlot(&args_[kThisIndex]);677}678 679template <typename T>680Local<Object> PropertyCallbackInfo<T>::Holder() const {681  return Local<Object>::FromSlot(&args_[kHolderIndex]);682}683 684namespace api_internal {685// Returns JSGlobalProxy if holder is JSGlobalObject or unmodified holder686// otherwise.687V8_EXPORT internal::Address ConvertToJSGlobalProxyIfNecessary(688    internal::Address holder);689}  // namespace api_internal690 691template <typename T>692Local<Object> PropertyCallbackInfo<T>::HolderV2() const {693  using I = internal::Internals;694  if (!I::HasHeapObjectTag(args_[kHolderV2Index])) {695    args_[kHolderV2Index] =696        api_internal::ConvertToJSGlobalProxyIfNecessary(args_[kHolderIndex]);697  }698  return Local<Object>::FromSlot(&args_[kHolderV2Index]);699}700 701template <typename T>702ReturnValue<T> PropertyCallbackInfo<T>::GetReturnValue() const {703  return ReturnValue<T>(&args_[kReturnValueIndex]);704}705 706template <typename T>707bool PropertyCallbackInfo<T>::ShouldThrowOnError() const {708  using I = internal::Internals;709  if (args_[kShouldThrowOnErrorIndex] !=710      I::IntegralToSmi(I::kInferShouldThrowMode)) {711    return args_[kShouldThrowOnErrorIndex] != I::IntegralToSmi(I::kDontThrow);712  }713  return v8::internal::ShouldThrowOnError(714      reinterpret_cast<v8::internal::Isolate*>(GetIsolate()));715}716 717}  // namespace v8718 719#endif  // INCLUDE_V8_FUNCTION_CALLBACK_H_720