Add faster, but unsafe version of LoadInternalField.

test/cctest/test-api-fast-accessor-builder.cc

 // 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"
@@ skipping 95 matching lines @@
             .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) {
+                              int field_no, bool useUnsafeLoader) {
   auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
-  builder->ReturnValue(
-      builder->LoadInternalField(builder->GetReceiver(), field_no));
+
+  if (useUnsafeLoader) {
+    builder->ReturnValue(
+        builder->LoadInternalFieldUnsafe(builder->GetReceiver(), field_no));
+  } else {
+    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) {
   // Crankshaft support for fast accessors is not implemented; crankshafted
   // code uses the slow accessor which breaks this test's expectations.
   v8::internal::FLAG_always_opt = false;
   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);
+  AddInternalFieldAccessor(isolate, foo, "field0", 0, false);
+  AddInternalFieldAccessor(isolate, foo, "field1", 1, false);
+  AddInternalFieldAccessor(isolate, foo, "field2", 2, false);
 
   // 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 that accesses an internal field using the fast(er) but unsafe
+// implementation of LoadInternalField.
+TEST(FastAccessorLoadInternalFieldUnsafe) {

[vogelheim, 2016/07/27 09:50:56]

nitpick: If we add the Unsafe-with-crash-when-FLAG_debug_code-is-true option,
we'll have a third variant of this test. If so, it'd probably be best to factor
this out into helper function(s). (I'll leave the decision to you, though.)

[Alfonso, 2016/07/28 14:39:13]

Refactoring away the common part for the 3 tests.

+  // Crankshaft support for fast accessors is not implemented; crankshafted
+  // code uses the slow accessor which breaks this test's expectations.
+  v8::internal::FLAG_always_opt = false;
+  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, true);
+  AddInternalFieldAccessor(isolate, foo, "field1", 1, true);
+  AddInternalFieldAccessor(isolate, foo, "field2", 2, true);
+
+  // 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.
@@ skipping 221 matching lines @@
   // Callbacks:
   CompileRun(FN_WARMUP("callbackint", "return obj.int"));
   ExpectInt32("callbackint()", 12345);
 
   CompileRun(FN_WARMUP("callbackstr", "return obj.str"));
   ExpectString("callbackstr()", kApiCallbackStringValue);
 
   CompileRun(FN_WARMUP("callbackparam", "return obj.param"));
   ExpectInt32("callbackparam()", 1000);
 }