Implement Fast Accessor Builder

src/api-experimental.cc

Index: src/api-experimental.cc
diff --git a/src/api-experimental.cc b/src/api-experimental.cc
new file mode 100644
index 0000000000000000000000000000000000000000..621b779f93a9e727360877a38a5d0faac7a48938
--- /dev/null
+++ b/src/api-experimental.cc
@@ -0,0 +1,129 @@
+// 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.
+
+/**
+ * Implementation for v8-experimental.h.
+ */
+
+#include "src/api-experimental.h"
+
+#include "include/v8.h"
+#include "include/v8-experimental.h"
+#include "src/api.h"
+#include "src/compiler/fast-accessor-assembler.h"
+
+
+namespace v8 {
+namespace internal {
+namespace experimental {
+
+
+v8::internal::MaybeHandle<v8::internal::Code> BuildCodeFromFastAccessorBuilder(

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

You're already in v8::internal, there's no need to fully qualify it in this
block.

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

Done.

+    v8::experimental::FastAccessorBuilder* fast_handler) {
+  i::MaybeHandle<i::Code> code;
+  if (fast_handler != nullptr) {
+    auto faa = *reinterpret_cast<internal::compiler::FastAccessorAssembler**>(
+        fast_handler);
+    code = faa->Build();
+    CHECK(!code.is_null());
+    delete fast_handler;
+  }
+  return code;
+}
+
+}  // namespace experimental
+}  // namespace internal
+
+namespace experimental {
+
+
+FastAccessorBuilder::FastAccessorBuilder() : impl_(nullptr) {}
+
+
+FastAccessorBuilder::~FastAccessorBuilder() {
+  CHECK_NOT_NULL(impl_);
+  delete reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_);
+}
+
+
+FastAccessorBuilder* FastAccessorBuilder::New(Isolate* isolate) {
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  internal::compiler::FastAccessorAssembler* faa =
+      new internal::compiler::FastAccessorAssembler(i_isolate);
+  FastAccessorBuilder* fab = new FastAccessorBuilder;
+  fab->impl_ = faa;
+  return fab;
+}
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::IntegerConstant(
+    int const_value) {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->IntegerConstant(const_value);
+}
+
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::GetReceiver() {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->GetReceiver();
+}
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::LoadInternalField(
+    ValueId value, int field_no) {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->LoadInternalField(value, field_no);
+}
+
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::LoadValue(ValueId value_id,
+                                                            int offset) {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->LoadValue(value_id, offset);
+}
+
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::LoadObject(ValueId value_id,
+                                                             int offset) {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->LoadObject(value_id, offset);
+}
+
+
+void FastAccessorBuilder::ReturnValue(ValueId value) {
+  reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->ReturnValue(value);
+}
+
+
+void FastAccessorBuilder::CheckFlagSetOrReturnNull(ValueId value_id, int mask) {
+  reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->CheckFlagSetOrReturnNull(value_id, mask);
+}
+
+
+void FastAccessorBuilder::CheckNotZeroOrReturnNull(ValueId value_id) {
+  reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->CheckNotZeroOrReturnNull(value_id);
+}
+
+
+FastAccessorBuilder::LabelId FastAccessorBuilder::MakeLabel() {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->MakeLabel();
+}
+
+
+void FastAccessorBuilder::SetLabel(LabelId label_id) {
+  reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->SetLabel(label_id);
+}
+
+
+void FastAccessorBuilder::CheckNotZeroOrJump(ValueId value_id,
+                                             LabelId label_id) {
+  reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->CheckNotZeroOrJump(value_id, label_id);
+}
+
+}  // namespace experimental
+}  // namespace v8