Implement Fast Accessor Builder

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 118 matching lines @@
 class Data;
 template<typename T> class FunctionCallbackInfo;
 template<typename T> class PropertyCallbackInfo;
 class StackTrace;
 class StackFrame;
 class Isolate;
 class CallHandlerHelper;
 class EscapableHandleScope;
 template<typename T> class ReturnValue;
 
+namespace experimental {
+class FastAccessorBuilder;
+}  // namespace experimental
+
 namespace internal {
 class Arguments;
 class Heap;
 class HeapObject;
 class Isolate;
 class Object;
 struct StreamedSource;
 template<typename T> class CustomArguments;
 class PropertyCallbackArguments;
 class FunctionCallbackArguments;
@@ skipping 4260 matching lines @@
   static Local<FunctionTemplate> New(
       Isolate* isolate, FunctionCallback callback = 0,
       Local<Value> data = Local<Value>(),
       Local<Signature> signature = Local<Signature>(), int length = 0);
 
   /**
    * Creates a function template with a fast handler. If a fast handler is set,
    * the callback cannot be null.
    */
   static Local<FunctionTemplate> NewWithFastHandler(
+      Isolate* isolate, FunctionCallback callback,
+      experimental::FastAccessorBuilder* fast_handler = nullptr,
+      Local<Value> data = Local<Value>(),
+      Local<Signature> signature = Local<Signature>(), int length = 0);
+
+  /**
+   * Creates a function template with a fast handler. If a fast handler is set,
+   * the callback cannot be null.
+   */
+  static Local<FunctionTemplate> NewWithFastHandler(
       Isolate* isolate, FunctionCallback callback, Local<Value> fast_handler,
       Local<Value> data = Local<Value>(),
       Local<Signature> signature = Local<Signature>(), int length = 0);
 
   /** Returns the unique function instance in the current execution context.*/
   V8_DEPRECATE_SOON("Use maybe version", Local<Function> GetFunction());
   V8_WARN_UNUSED_RESULT MaybeLocal<Function> GetFunction(
       Local<Context> context);
 
   /**
    * Set the call-handler callback for a FunctionTemplate.  This
    * callback is called whenever the function created from this
    * FunctionTemplate is called.
    */
-  void SetCallHandler(FunctionCallback callback,
-                      Local<Value> data = Local<Value>(),
-                      Local<Value> fast_handler = Local<Value>());
+  void SetCallHandler(
+      FunctionCallback callback, Local<Value> data = Local<Value>(),
+      experimental::FastAccessorBuilder* fast_handler = nullptr);
 
   /** Set the predefined length property for the FunctionTemplate. */
   void SetLength(int length);
 
   /** Get the InstanceTemplate. */
   Local<ObjectTemplate> InstanceTemplate();
 
   /** Causes the function template to inherit from a parent function template.*/
   void Inherit(Local<FunctionTemplate> parent);
 
@@ skipping 2512 matching lines @@
   bool has_lock_;
   bool top_level_;
   internal::Isolate* isolate_;
 
   // Disallow copying and assigning.
   Locker(const Locker&);
   void operator=(const Locker&);
 };
 
 
+namespace experimental {

[jochen (gone - plz use gerrit), 2015/11/27 08:33:45]

i wonder whether we should move this to a separate header?

[Michael Starzinger, 2015/11/27 09:15:52]

+1

[vogelheim, 2015/11/30 13:41:54]

Done.

In a separate CL, I'll also move the api-* files into a separate API directory.
Do I need to check on v8-team first?

+
+class V8_EXPORT FastAccessorBuilder {
+ public:
+  struct ValueId {

[jochen (gone - plz use gerrit), 2015/11/27 08:33:45]

why not using size_t = ValudId or typedef?

[epertoso, 2015/11/27 09:13:13]

It was my suggestion. We don't want to pass ValueIds instead of LabelIds.
Typedef is not strong enough.

[vogelheim, 2015/11/27 16:24:50]

^^^ This.

The original version used a single typedef for both, and then dis-ambiguated
this internally. Alternatively, we could use a typedef to the same type, but
since in C++ those are mutually assignable, that's not very nice to use. Among
those alternatives, I like the current version the best.

Let me know if you disagree strongly.

+    size_t value_id;
+  };
+  struct LabelId {
+    size_t label_id;
+  };
+
+  ~FastAccessorBuilder();
+  static FastAccessorBuilder* New(Isolate* isolate);
+
+  ValueId IntegerConstant(int int_constant);
+  ValueId GetCallTarget();
+  ValueId GetParameter(size_t parameter_no);
+  ValueId GetInternalField(ValueId value_id, int field_no);
+  ValueId LoadValue(ValueId value_id, int offset);
+  ValueId LoadObject(ValueId value_id, int offset);
+  void ReturnValue(ValueId value_id);
+  void CheckFlagSetOrReturnNull(ValueId value_id, int mask);
+  void CheckNotNullOrReturnNull(ValueId value_id);
+  ValueId SetLabel();
+  void CheckNotNullOrJump(ValueId value_id, ValueId label_id);
+
+ private:
+  FastAccessorBuilder();
+
+  void* impl_;
+};

[jochen (gone - plz use gerrit), 2015/11/27 08:33:45]

disallow copy/assign

[vogelheim, 2015/11/27 16:24:50]

Done.

v8.h can't include macros.h, so done manually.

+
+}  // namespace experimental
+
+
 // --- Implementation ---
 
 
 namespace internal {
 
 const int kApiPointerSize = sizeof(void*);  // NOLINT
 const int kApiIntSize = sizeof(int);  // NOLINT
 const int kApiInt64Size = sizeof(int64_t);  // NOLINT
 
 // Tag information for HeapObject.
@@ skipping 1498 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_