1 files changed, 288 insertions, 0 deletions
diff --git a/deps/v8/test/cctest/test-api-fast-accessor-builder.cc b/deps/v8/test/cctest/test-api-fast-accessor-builder.cc
new file mode 100644
index 0000000000..1e1c972694
--- /dev/null
+++ b/deps/v8/test/cctest/test-api-fast-accessor-builder.cc
@@ -0,0 +1,288 @@
+// 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.
+
+#include <stdlib.h>
+
+#include "include/v8.h"
+#include "include/v8-experimental.h"
+
+#include "src/api.h"
+#include "test/cctest/cctest.h"
+
+namespace {
+
+// These tests mean to exercise v8::FastAccessorBuilder. Since initially the
+// "native" accessor will get called, we need to "warmup" any accessor first,
+// to make sure we're actually testing the v8::FastAccessorBuilder result.
+// To accomplish this, we will
+// - call each accesssor N times before the actual test.
+// - wrap that call in a function, so that all such calls will go
+//   through a single call site.
+// - bloat that function with a very long comment to prevent its inlining.
+// - register a native accessor which is different from the build one
+//   (so that our tests will always fail if we don't end up in the 'fast'
+//    accessor).
+//
+// FN_WARMUP(name, src) define a JS function "name" with body "src".
+// It adds the INLINE_SPOILER to prevent inlining and will call name()
+// repeatedly to guarantee it's "warm".
+//
+// Use:
+//   CompileRun(FN_WARMUP("fn", "return something();"));
+//   ExpectXXX("fn(1234)", 5678);
+
+#define INLINE_SPOILER                                           \
+  " /* "                                                         \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
+  "*/ "  // 16 lines * 64 'X' =~ 1024 character comment.
+#define FN_WARMUP(name, src)                  \
+  "function " name "() { " src INLINE_SPOILER \
+  " }; for(i = 0; i < 2; i++) { " name "() } "
+
+static void NativePropertyAccessor(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(v8_num(123));
+}
+
+}  // anonymous namespace
+
+
+// Build a simple "fast accessor" and verify that it is being called.
+TEST(FastAccessor) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
+
+  v8::Local<v8::FunctionTemplate> foo = v8::FunctionTemplate::New(isolate);
+
+  // Native accessor, bar, returns 123.
+  foo->PrototypeTemplate()->SetAccessorProperty(
+      v8_str("bar"),
+      v8::FunctionTemplate::New(isolate, NativePropertyAccessor));
+
+  // Fast accessor, barf, returns 124.
+  auto fab = v8::experimental::FastAccessorBuilder::New(isolate);
+  fab->ReturnValue(fab->IntegerConstant(124));
+  foo->PrototypeTemplate()->SetAccessorProperty(
+      v8_str("barf"), v8::FunctionTemplate::NewWithFastHandler(
+                          isolate, NativePropertyAccessor, fab));
+
+  // Install foo on the global object.
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("foo"),
+                  foo->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
+
+  // Wrap f.barf + IC warmup.
+  CompileRun(FN_WARMUP("barf", "f = new foo(); return f.barf"));
+
+  ExpectInt32("f = new foo(); f.bar", 123);
+  ExpectInt32("f = new foo(); f.barf", 123);  // First call in this call site.
+  ExpectInt32("barf()", 124);                 // Call via warmed-up callsite.
+}
+
+
+void AddInternalFieldAccessor(v8::Isolate* isolate,
+                              v8::Local<v8::Template> templ, const char* name,
+                              int field_no) {
+  auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
+  builder->ReturnValue(
+      builder->LoadInternalField(builder->GetReceiver(), field_no));
+  templ->SetAccessorProperty(v8_str(name),
+                             v8::FunctionTemplate::NewWithFastHandler(
+                                 isolate, NativePropertyAccessor, builder));
+}
+
+
+// "Fast" accessor that accesses an internal field.
+TEST(FastAccessorWithInternalField) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
+
+  v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
+  foo->SetInternalFieldCount(3);
+  AddInternalFieldAccessor(isolate, foo, "field0", 0);
+  AddInternalFieldAccessor(isolate, foo, "field1", 1);
+  AddInternalFieldAccessor(isolate, foo, "field2", 2);
+
+  // Create an instance w/ 3 internal fields, put in a string, a Smi, nothing.
+  v8::Local<v8::Object> obj = foo->NewInstance(env.local()).ToLocalChecked();
+  obj->SetInternalField(0, v8_str("Hi there!"));
+  obj->SetInternalField(1, v8::Integer::New(isolate, 4321));
+  CHECK(env->Global()->Set(env.local(), v8_str("obj"), obj).FromJust());
+
+  // Warmup.
+  CompileRun(FN_WARMUP("field0", "return obj.field0"));
+  CompileRun(FN_WARMUP("field1", "return obj.field1"));
+  CompileRun(FN_WARMUP("field2", "return obj.field2"));
+
+  // Access fields.
+  ExpectString("field0()", "Hi there!");
+  ExpectInt32("field1()", 4321);
+  ExpectUndefined("field2()");
+}
+
+
+// "Fast" accessor with control flow via ...OrReturnNull methods.
+TEST(FastAccessorOrReturnNull) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
+
+  v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
+  foo->SetInternalFieldCount(2);
+  {
+    // accessor "nullcheck": Return null if field 0 is non-null object; else 5.
+    auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
+    auto val = builder->LoadInternalField(builder->GetReceiver(), 0);
+    builder->CheckNotZeroOrReturnNull(val);
+    builder->ReturnValue(builder->IntegerConstant(5));
+    foo->SetAccessorProperty(v8_str("nullcheck"),
+                             v8::FunctionTemplate::NewWithFastHandler(
+                                 isolate, NativePropertyAccessor, builder));
+  }
+  {
+    // accessor "maskcheck": Return null if field 1 has 3rd bit set.
+    auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
+    auto val = builder->LoadInternalField(builder->GetReceiver(), 1);
+    builder->CheckFlagSetOrReturnNull(val, 0x4);
+    builder->ReturnValue(builder->IntegerConstant(42));
+    foo->SetAccessorProperty(v8_str("maskcheck"),
+                             v8::FunctionTemplate::NewWithFastHandler(
+                                 isolate, NativePropertyAccessor, builder));
+  }
+
+  // Create an instance.
+  v8::Local<v8::Object> obj = foo->NewInstance(env.local()).ToLocalChecked();
+  CHECK(env->Global()->Set(env.local(), v8_str("obj"), obj).FromJust());
+
+  // CheckNotZeroOrReturnNull:
+  CompileRun(FN_WARMUP("nullcheck", "return obj.nullcheck"));
+  obj->SetAlignedPointerInInternalField(0, /* anything != nullptr */ isolate);
+  ExpectInt32("nullcheck()", 5);
+  obj->SetAlignedPointerInInternalField(0, nullptr);
+  ExpectNull("nullcheck()");
+
+  // CheckFlagSetOrReturnNull:
+  CompileRun(FN_WARMUP("maskcheck", "return obj.maskcheck"));
+  obj->SetAlignedPointerInInternalField(1, reinterpret_cast<void*>(0xf0));
+  ExpectInt32("maskcheck()", 42);
+  obj->SetAlignedPointerInInternalField(1, reinterpret_cast<void*>(0xfe));
+  ExpectNull("maskcheck()");
+}
+
+
+// "Fast" accessor with simple control flow via explicit labels.
+TEST(FastAccessorControlFlowWithLabels) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
+
+  v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
+  foo->SetInternalFieldCount(1);
+  {
+    // accessor isnull: 0 for nullptr, else 1.
+    auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
+    auto label = builder->MakeLabel();
+    auto val = builder->LoadInternalField(builder->GetReceiver(), 0);
+    builder->CheckNotZeroOrJump(val, label);
+    builder->ReturnValue(builder->IntegerConstant(0));
+    builder->SetLabel(label);
+    builder->ReturnValue(builder->IntegerConstant(1));
+    foo->SetAccessorProperty(v8_str("isnull"),
+                             v8::FunctionTemplate::NewWithFastHandler(
+                                 isolate, NativePropertyAccessor, builder));
+  }
+
+  // Create an instance.
+  v8::Local<v8::Object> obj = foo->NewInstance(env.local()).ToLocalChecked();
+  CHECK(env->Global()->Set(env.local(), v8_str("obj"), obj).FromJust());
+
+  // CheckNotZeroOrReturnNull:
+  CompileRun(FN_WARMUP("isnull", "return obj.isnull"));
+  obj->SetAlignedPointerInInternalField(0, /* anything != nullptr */ isolate);
+  ExpectInt32("isnull()", 1);
+  obj->SetAlignedPointerInInternalField(0, nullptr);
+  ExpectInt32("isnull()", 0);
+}
+
+
+// "Fast" accessor, loading things.
+TEST(FastAccessorLoad) {
+  LocalContext env;
+  v8::Isolate* isolate = env->GetIsolate();
+  v8::HandleScope scope(isolate);
+
+  v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
+  foo->SetInternalFieldCount(1);
+
+  // Internal field 0 is a pointer to a C++ data structure that we wish to load
+  // field values from.
+  struct {
+    size_t intval;
+    v8::Local<v8::String> v8val;
+  } val = {54321, v8_str("Hello")};
+
+  {
+    // accessor intisnonzero
+    int intval_offset =
+        static_cast<int>(reinterpret_cast<intptr_t>(&val.intval) -
+                         reinterpret_cast<intptr_t>(&val));
+    auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
+    auto label = builder->MakeLabel();
+    auto val = builder->LoadValue(
+        builder->LoadInternalField(builder->GetReceiver(), 0), intval_offset);
+    builder->CheckNotZeroOrJump(val, label);
+    builder->ReturnValue(builder->IntegerConstant(0));
+    builder->SetLabel(label);
+    builder->ReturnValue(builder->IntegerConstant(1));
+    foo->SetAccessorProperty(v8_str("nonzero"),
+                             v8::FunctionTemplate::NewWithFastHandler(
+                                 isolate, NativePropertyAccessor, builder));
+  }
+  {
+    // accessor loadval
+    int v8val_offset = static_cast<int>(reinterpret_cast<intptr_t>(&val.v8val) -
+                                        reinterpret_cast<intptr_t>(&val));
+    auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
+    builder->ReturnValue(builder->LoadObject(
+        builder->LoadInternalField(builder->GetReceiver(), 0), v8val_offset));
+    foo->SetAccessorProperty(v8_str("loadval"),
+                             v8::FunctionTemplate::NewWithFastHandler(
+                                 isolate, NativePropertyAccessor, builder));
+  }
+
+  // Create an instance.
+  v8::Local<v8::Object> obj = foo->NewInstance(env.local()).ToLocalChecked();
+  obj->SetAlignedPointerInInternalField(0, &val);
+  CHECK(env->Global()->Set(env.local(), v8_str("obj"), obj).FromJust());
+
+  // Access val.intval:
+  CompileRun(FN_WARMUP("nonzero", "return obj.nonzero"));
+  ExpectInt32("nonzero()", 1);
+  val.intval = 0;
+  ExpectInt32("nonzero()", 0);
+  val.intval = 27;
+  ExpectInt32("nonzero()", 1);
+
+  // Access val.v8val:
+  CompileRun(FN_WARMUP("loadval", "return obj.loadval"));
+  ExpectString("loadval()", "Hello");
+}