[api] Add v8::Object::SetAlignedPointerInInternalFields

include/v8.h

 // Copyright 2012 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.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 2873 matching lines @@
   V8_INLINE static void* GetAlignedPointerFromInternalField(
       const PersistentBase<Object>& object, int index) {
     return object.val_->GetAlignedPointerFromInternalField(index);
   }
 
   /**
    * Sets a 2-byte-aligned native pointer in an internal field. To retrieve such
    * a field, GetAlignedPointerFromInternalField must be used, everything else
    * leads to undefined behavior.
    */
-  void SetAlignedPointerInInternalField(int index, void* value);
+  V8_INLINE void SetAlignedPointerInInternalField(int index, void* value);
+  V8_INLINE void SetAlignedPointerInInternalFields(int argc, int indices[],
+                                                   void* values[]);
 
   // Testers for local properties.
   V8_DEPRECATED("Use maybe version", bool HasOwnProperty(Local<String> key));
   V8_WARN_UNUSED_RESULT Maybe<bool> HasOwnProperty(Local<Context> context,
                                                    Local<Name> key);
   V8_WARN_UNUSED_RESULT Maybe<bool> HasOwnProperty(Local<Context> context,
                                                    uint32_t index);
   V8_DEPRECATE_SOON("Use maybe version",
                     bool HasRealNamedProperty(Local<String> key));
   V8_WARN_UNUSED_RESULT Maybe<bool> HasRealNamedProperty(Local<Context> context,
@@ skipping 119 matching lines @@
 
   static Local<Object> New(Isolate* isolate);
 
   V8_INLINE static Object* Cast(Value* obj);
 
  private:
   Object();
   static void CheckCast(Value* obj);
   Local<Value> SlowGetInternalField(int index);
   void* SlowGetAlignedPointerFromInternalField(int index);
+  void SlowSetAlignedPointerInInternalField(int index, void* value);
+  void SlowSetAlignedPointerInInternalFields(int argc, int indices[],
+                                             void* values[]);
 };
 
 
 /**
  * An instance of the built-in array constructor (ECMA-262, 15.4.2).
  */
 class V8_EXPORT Array : public Object {
  public:
   uint32_t Length() const;
 
@@ skipping 4650 matching lines @@
     return reinterpret_cast<internal::Object**>(addr + index * kApiPointerSize);
   }
 
   template <typename T>
   V8_INLINE static T ReadField(const internal::Object* ptr, int offset) {
     const uint8_t* addr =
         reinterpret_cast<const uint8_t*>(ptr) + offset - kHeapObjectTag;
     return *reinterpret_cast<const T*>(addr);
   }
 
+  V8_INLINE static void WriteField(internal::Object* ptr, int offset,
+                                   void* value) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(ptr) + offset - kHeapObjectTag;
+    *reinterpret_cast<void**>(addr) = value;
+  }
+
   template <typename T>
   V8_INLINE static T ReadEmbedderData(const v8::Context* context, int index) {
     typedef internal::Object O;
     typedef internal::Internals I;
     O* ctx = *reinterpret_cast<O* const*>(context);
     int embedder_data_offset = I::kContextHeaderSize +
         (internal::kApiPointerSize * I::kContextEmbedderDataIndex);
     O* embedder_data = I::ReadField<O*>(ctx, embedder_data_offset);
     int value_offset =
         I::kFixedArrayHeaderSize + (internal::kApiPointerSize * index);
@@ skipping 517 matching lines @@
   auto instance_type = I::GetInstanceType(obj);
   if (V8_LIKELY(instance_type == I::kJSObjectType ||
                 instance_type == I::kJSApiObjectType)) {
     int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
     return I::ReadField<void*>(obj, offset);
   }
 #endif
   return SlowGetAlignedPointerFromInternalField(index);
 }
 
+void Object::SetAlignedPointerInInternalField(int index, void* value) {
+#ifndef V8_ENABLE_CHECKS
+  typedef internal::Object O;
+  typedef internal::Internals I;
+  O* object = *reinterpret_cast<O**>(this);
+  // Fast path: If the object is a plain JSObject, which is the common case, we
+  // know where to find the internal fields and can set the value directly.
+  auto instance_type = I::GetInstanceType(object);
+  if (V8_LIKELY(instance_type == I::kJSObjectType ||
+                instance_type == I::kJSApiObjectType)) {
+    int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
+    I::WriteField(object, offset, value);

[Michael Starzinger, 2016/07/29 09:50:53]

Isn't this missing a return? Otherwise the slow case will always be run.

+  }
+#endif
+  return SlowSetAlignedPointerInInternalField(index, value);
+}
+
+void Object::SetAlignedPointerInInternalFields(int argc, int indices[],
+                                               void* values[]) {
+#ifndef V8_ENABLE_CHECKS
+  typedef internal::Object O;
+  typedef internal::Internals I;
+  O* object = *reinterpret_cast<O**>(this);
+  // Fast path: If the object is a plain JSObject, which is the common case, we
+  // know where to find the internal fields and can set the value directly.
+  auto instance_type = I::GetInstanceType(object);
+  if (V8_LIKELY(instance_type == I::kJSObjectType ||
+                instance_type == I::kJSApiObjectType)) {
+    for (int i = 0; i < argc; i++) {
+      int index = indices[i];
+      void* value = values[i];
+      int offset = I::kJSObjectHeaderSize + (internal::kApiPointerSize * index);
+      I::WriteField(object, offset, value);

[Michael Starzinger, 2016/07/29 09:50:53]

Isn't this missing a return? Otherwise the slow case will always be run.

+    }
+  }
+#endif
+  return SlowSetAlignedPointerInInternalFields(argc, indices, values);
+}
 
 String* String::Cast(v8::Value* value) {
 #ifdef V8_ENABLE_CHECKS
   CheckCast(value);
 #endif
   return static_cast<String*>(value);
 }
 
 
 Local<String> String::Empty(Isolate* isolate) {
@@ skipping 704 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_