Implement Fast Accessor Builder

include/v8-experimental.h

Index: include/v8-experimental.h
diff --git a/include/v8-experimental.h b/include/v8-experimental.h
new file mode 100644
index 0000000000000000000000000000000000000000..dbbf8ea4cc471b577b4d8fd36d5bb3c141ff11e4
--- /dev/null
+++ b/include/v8-experimental.h
@@ -0,0 +1,55 @@
+// Copyright 2015 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.
+
+/**
+ * This header contains a set of experimental V8 APIs. We hope these will
+ * become a part of standard V8, but they may also be removed if we deem the
+ * experiment to not be successul.
+ */
+#ifndef V8_INCLUDE_V8_EXPERIMENTAL_H_
+#define V8_INCLUDE_V8_EXPERIMENTAL_H_
+
+#include "include/v8.h"
+
+namespace v8 {
+namespace experimental {
+
+// Allow the embedder to construct accessors that V8 can compile and use
+// directly, without jumping into the runtime.
+class V8_EXPORT FastAccessorBuilder {
+ public:
+  struct ValueId {
+    size_t value_id;
+  };
+  struct LabelId {
+    size_t label_id;
+  };
+
+  ~FastAccessorBuilder();
+  static FastAccessorBuilder* New(Isolate* isolate);
+
+  ValueId IntegerConstant(int int_constant);
+  ValueId GetReceiver();
+  ValueId LoadInternalField(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 CheckNotZeroOrReturnNull(ValueId value_id);
+  LabelId MakeLabel();
+  void SetLabel(LabelId label_id);
+  void CheckNotZeroOrJump(ValueId value_id, LabelId label_id);
+
+ private:
+  FastAccessorBuilder();
+  FastAccessorBuilder(const FastAccessorBuilder&) = delete;
+  void operator=(const FastAccessorBuilder&) = delete;
+
+  void* impl_;

[epertoso, 2015/12/04 09:56:32]

Why don't you just forward-declare internal::compiler::FastAccessorAssembler?
You won't need to reinterpret_cast anything that way.

[vogelheim, 2015/12/08 12:52:56]

Well... I'm trying to emulate the rest of v8.h, which consistently exposes a
public data type, without any visible connection to the internal one and then
reinterpret_cast<>s the public type to the internal one (and vice versa). Note
how most API types don't have any data members at all.

Not sure what to do here... Jochen/Enrico, is this API type isolation thing
worthwhile?

[jochen (gone - plz use gerrit), 2015/12/08 13:00:42]

There are examples of both patterns, e.g.
v8::DisallowJavascriptExecutionScope::internal_ vs. the namespace internal {}
block at the top of v8.h

I don't have a strong opinion for either

+};
+
+}  // namespace experimental
+}  // namespace v8
+
+#endif  // V8_INCLUDE_V8_EXPERIMENTAL_H_