[SAB] Move Atomics builtins to C++

This patch refactors the Atomics builtins so that they are implemented
as C++ builtins rather than experimental JS builtins. Previously, each
of these functions called out to a runtime function, so no significant
change in performance is anticipated. The goal of this patch is to
remove the last user of experimental JS builtins so that the mechanism
can be removed, for performance reasons. The patch includes a drive-by
fix of a check-fail. For the most part, the patch is just moving code
without modification from runtime-atomics.cc to
builtins-sharedarraybuffer.cc .

BUG=v8:5880

Review-Url: https://codereview.chromium.org/2698813004
Cr-Commit-Position: refs/heads/master@{#43335}

BUILD.gn

@@ -491,7 +491,6 @@ action("js2c_experimental") {
   sources = [
     "src/js/macros.py",
     "src/messages.h",
-    "src/js/harmony-atomics.js",
   ]
 
   outputs = [

src/bootstrapper.cc

@@ -3584,11 +3584,36 @@ void Genesis::InitializeGlobal_harmony_sharedarraybuffer() {
   Handle<JSObject> atomics_object = factory->NewJSObject(cons, TENURED);
   DCHECK(atomics_object->IsJSObject());
   JSObject::AddProperty(global, name, atomics_object, DONT_ENUM);
+  JSObject::AddProperty(atomics_object, factory->to_string_tag_symbol(), name,
+                        static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
 
   SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("load"),
                         Builtins::kAtomicsLoad, 2, true);
   SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("store"),
                         Builtins::kAtomicsStore, 3, true);
+  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("add"),
+                        Builtins::kAtomicsAdd, 3, true);
+  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("sub"),
+                        Builtins::kAtomicsSub, 3, true);
+  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("and"),
+                        Builtins::kAtomicsAnd, 3, true);
+  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("or"),
+                        Builtins::kAtomicsOr, 3, true);
+  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("xor"),
+                        Builtins::kAtomicsXor, 3, true);
+  SimpleInstallFunction(atomics_object,
+                        factory->InternalizeUtf8String("exchange"),
+                        Builtins::kAtomicsExchange, 3, true);
+  SimpleInstallFunction(atomics_object,
+                        factory->InternalizeUtf8String("compareExchange"),
+                        Builtins::kAtomicsCompareExchange, 4, true);
+  SimpleInstallFunction(atomics_object,
+                        factory->InternalizeUtf8String("isLockFree"),
+                        Builtins::kAtomicsIsLockFree, 1, true);
+  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("wait"),
+                        Builtins::kAtomicsWait, 4, true);
+  SimpleInstallFunction(atomics_object, factory->InternalizeUtf8String("wake"),
+                        Builtins::kAtomicsWake, 3, true);
 }
 
 void Genesis::InitializeGlobal_harmony_array_prototype_values() {
@@ -4195,8 +4220,7 @@ bool Genesis::InstallNatives(GlobalContextType context_type) {
 
 bool Genesis::InstallExperimentalNatives() {
   static const char* harmony_tailcalls_natives[] = {nullptr};
-  static const char* harmony_sharedarraybuffer_natives[] = {
-      "native harmony-atomics.js", NULL};
+  static const char* harmony_sharedarraybuffer_natives[] = {nullptr};
   static const char* harmony_do_expressions_natives[] = {nullptr};
   static const char* harmony_regexp_lookbehind_natives[] = {nullptr};
   static const char* harmony_regexp_named_captures_natives[] = {nullptr};

src/builtins/builtins.h

@@ -733,6 +733,16 @@ class Isolate;
   CPP(SharedArrayBufferPrototypeGetByteLength)                                 \
   TFJ(AtomicsLoad, 2)                                                          \
   TFJ(AtomicsStore, 3)                                                         \
+  CPP(AtomicsCompareExchange)                                                  \
+  CPP(AtomicsAdd)                                                              \
+  CPP(AtomicsSub)                                                              \
+  CPP(AtomicsAnd)                                                              \
+  CPP(AtomicsOr)                                                               \
+  CPP(AtomicsXor)                                                              \
+  CPP(AtomicsExchange)                                                         \
+  CPP(AtomicsIsLockFree)                                                       \
+  CPP(AtomicsWait)                                                             \
+  CPP(AtomicsWake)                                                             \
                                                                                \
   /* String */                                                                 \
   ASM(StringConstructor)                                                       \

src/js/harmony-atomics.js

-// 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.
-
-(function(global, utils) {
-
-"use strict";
-
-%CheckIsBootstrapping();
-
-// -------------------------------------------------------------------
-// Imports
-
-var GlobalObject = global.Object;
-var MaxSimple;
-var MinSimple;
-var toStringTagSymbol = utils.ImportNow("to_string_tag_symbol");
-
-utils.Import(function(from) {
-  MaxSimple = from.MaxSimple;
-  MinSimple = from.MinSimple;
-});
-
-// -------------------------------------------------------------------
-
-
-function CheckSharedIntegerTypedArray(ia) {
-  if (!%IsSharedIntegerTypedArray(ia)) {
-    throw %make_type_error(kNotIntegerSharedTypedArray, ia);
-  }
-}
-
-function CheckSharedInteger32TypedArray(ia) {
-  CheckSharedIntegerTypedArray(ia);
-  if (!%IsSharedInteger32TypedArray(ia)) {
-    throw %make_type_error(kNotInt32SharedTypedArray, ia);
-  }
-}
-
-// https://tc39.github.io/ecmascript_sharedmem/shmem.html#Atomics.ValidateAtomicAccess
-function ValidateIndex(index, length) {
-  var numberIndex = TO_NUMBER(index);
-  var accessIndex = TO_INTEGER(numberIndex);
-  if (numberIndex !== accessIndex) {
-    throw %make_range_error(kInvalidAtomicAccessIndex);
-  }
-  if (accessIndex < 0 || accessIndex >= length) {
-    throw %make_range_error(kInvalidAtomicAccessIndex);
-  }
-  return accessIndex;
-}
-
-//-------------------------------------------------------------------
-
-function AtomicsCompareExchangeJS(sta, index, oldValue, newValue) {
-  CheckSharedIntegerTypedArray(sta);
-  index = ValidateIndex(index, %_TypedArrayGetLength(sta));
-  oldValue = TO_NUMBER(oldValue);
-  newValue = TO_NUMBER(newValue);
-  return %_AtomicsCompareExchange(sta, index, oldValue, newValue);
-}
-
-function AtomicsAddJS(ia, index, value) {
-  CheckSharedIntegerTypedArray(ia);
-  index = ValidateIndex(index, %_TypedArrayGetLength(ia));
-  value = TO_NUMBER(value);
-  return %_AtomicsAdd(ia, index, value);
-}
-
-function AtomicsSubJS(ia, index, value) {
-  CheckSharedIntegerTypedArray(ia);
-  index = ValidateIndex(index, %_TypedArrayGetLength(ia));
-  value = TO_NUMBER(value);
-  return %_AtomicsSub(ia, index, value);
-}
-
-function AtomicsAndJS(ia, index, value) {
-  CheckSharedIntegerTypedArray(ia);
-  index = ValidateIndex(index, %_TypedArrayGetLength(ia));
-  value = TO_NUMBER(value);
-  return %_AtomicsAnd(ia, index, value);
-}
-
-function AtomicsOrJS(ia, index, value) {
-  CheckSharedIntegerTypedArray(ia);
-  index = ValidateIndex(index, %_TypedArrayGetLength(ia));
-  value = TO_NUMBER(value);
-  return %_AtomicsOr(ia, index, value);
-}
-
-function AtomicsXorJS(ia, index, value) {
-  CheckSharedIntegerTypedArray(ia);
-  index = ValidateIndex(index, %_TypedArrayGetLength(ia));
-  value = TO_NUMBER(value);
-  return %_AtomicsXor(ia, index, value);
-}
-
-function AtomicsExchangeJS(ia, index, value) {
-  CheckSharedIntegerTypedArray(ia);
-  index = ValidateIndex(index, %_TypedArrayGetLength(ia));
-  value = TO_NUMBER(value);
-  return %_AtomicsExchange(ia, index, value);
-}
-
-function AtomicsIsLockFreeJS(size) {
-  return %_AtomicsIsLockFree(TO_INTEGER(size));
-}
-
-function AtomicsWaitJS(ia, index, value, timeout) {
-  CheckSharedInteger32TypedArray(ia);
-  index = ValidateIndex(index, %_TypedArrayGetLength(ia));
-  if (IS_UNDEFINED(timeout)) {
-    timeout = INFINITY;
-  } else {
-    timeout = TO_NUMBER(timeout);
-    if (NUMBER_IS_NAN(timeout)) {
-      timeout = INFINITY;
-    } else {
-      timeout = MaxSimple(0, timeout);
-    }
-  }
-  return %AtomicsWait(ia, index, value, timeout);
-}
-
-function AtomicsWakeJS(ia, index, count) {
-  CheckSharedInteger32TypedArray(ia);
-  index = ValidateIndex(index, %_TypedArrayGetLength(ia));
-  if (IS_UNDEFINED(count)) {
-    count = kMaxUint32;
-  } else {
-    // Clamp to [0, kMaxUint32].
-    count = MinSimple(MaxSimple(0, TO_INTEGER(count)), kMaxUint32);
-  }
-  return %AtomicsWake(ia, index, count);
-}
-
-// -------------------------------------------------------------------
-
-var Atomics = global.Atomics;
-
-// The Atomics global is defined by the bootstrapper.
-
-%AddNamedProperty(Atomics, toStringTagSymbol, "Atomics", READ_ONLY | DONT_ENUM);
-
-utils.InstallFunctions(Atomics, DONT_ENUM, [
-  // TODO(binji): remove the rest of the (non futex) Atomics functions as they
-  // become builtins.
-  "compareExchange", AtomicsCompareExchangeJS,
-  "add", AtomicsAddJS,
-  "sub", AtomicsSubJS,
-  "and", AtomicsAndJS,
-  "or", AtomicsOrJS,
-  "xor", AtomicsXorJS,
-  "exchange", AtomicsExchangeJS,
-  "isLockFree", AtomicsIsLockFreeJS,
-  "wait", AtomicsWaitJS,
-  "wake", AtomicsWakeJS,
-]);
-
-})

src/runtime/runtime-futex.cc

@@ -17,44 +17,6 @@
 namespace v8 {
 namespace internal {
 
-RUNTIME_FUNCTION(Runtime_AtomicsWait) {
-  HandleScope scope(isolate);
-  DCHECK_EQ(4, args.length());
-  CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, sta, 0);
-  CONVERT_SIZE_ARG_CHECKED(index, 1);
-  CONVERT_INT32_ARG_CHECKED(value, 2);
-  CONVERT_DOUBLE_ARG_CHECKED(timeout, 3);
-  CHECK(sta->GetBuffer()->is_shared());
-  CHECK_LT(index, NumberToSize(sta->length()));
-  CHECK_EQ(sta->type(), kExternalInt32Array);
-  CHECK(timeout == V8_INFINITY || !std::isnan(timeout));
-
-  if (!isolate->allow_atomics_wait()) {
-    THROW_NEW_ERROR_RETURN_FAILURE(
-        isolate, NewTypeError(MessageTemplate::kAtomicsWaitNotAllowed));
-  }
-
-  Handle<JSArrayBuffer> array_buffer = sta->GetBuffer();
-  size_t addr = (index << 2) + NumberToSize(sta->byte_offset());
-
-  return FutexEmulation::Wait(isolate, array_buffer, addr, value, timeout);
-}
-
-RUNTIME_FUNCTION(Runtime_AtomicsWake) {
-  HandleScope scope(isolate);
-  DCHECK_EQ(3, args.length());
-  CONVERT_ARG_HANDLE_CHECKED(JSTypedArray, sta, 0);
-  CONVERT_SIZE_ARG_CHECKED(index, 1);
-  CONVERT_UINT32_ARG_CHECKED(count, 2);
-  CHECK(sta->GetBuffer()->is_shared());
-  CHECK_LT(index, NumberToSize(sta->length()));
-  CHECK_EQ(sta->type(), kExternalInt32Array);
-
-  Handle<JSArrayBuffer> array_buffer = sta->GetBuffer();
-  size_t addr = (index << 2) + NumberToSize(sta->byte_offset());
-
-  return FutexEmulation::Wake(isolate, array_buffer, addr, count);
-}
 
 RUNTIME_FUNCTION(Runtime_AtomicsNumWaitersForTesting) {
   HandleScope scope(isolate);

src/runtime/runtime.h

@@ -63,16 +63,6 @@ namespace internal {
   F(ThrowNotIntegerSharedTypedArrayError, 1, 1) \
   F(ThrowNotInt32SharedTypedArrayError, 1, 1)   \
   F(ThrowInvalidAtomicAccessIndexError, 0, 1)   \
-  F(AtomicsCompareExchange, 4, 1)               \
-  F(AtomicsAdd, 3, 1)                           \
-  F(AtomicsSub, 3, 1)                           \
-  F(AtomicsAnd, 3, 1)                           \
-  F(AtomicsOr, 3, 1)                            \
-  F(AtomicsXor, 3, 1)                           \
-  F(AtomicsExchange, 3, 1)                      \
-  F(AtomicsIsLockFree, 1, 1)                    \
-  F(AtomicsWait, 4, 1)                          \
-  F(AtomicsWake, 3, 1)                          \
   F(AtomicsNumWaitersForTesting, 2, 1)          \
   F(SetAllowAtomicsWait, 1, 1)
 

src/v8.gyp

@@ -2285,7 +2285,6 @@
         'experimental_library_files': [
           'js/macros.py',
           'messages.h',
-          'js/harmony-atomics.js',
         ],
         'libraries_bin_file': '<(SHARED_INTERMEDIATE_DIR)/libraries.bin',
         'libraries_experimental_bin_file': '<(SHARED_INTERMEDIATE_DIR)/libraries-experimental.bin',

test/mjsunit/harmony/futex.js

@@ -109,6 +109,14 @@
   Atomics.wake(i32a, 0, Number.POSITIVE_INFINITY);
 })();
 
+// In a previous version, this test caused a check failure
+(function TestObjectWaitValue() {
+  var sab = new SharedArrayBuffer(16);
+  var i32a = new Int32Array(sab);
+  assertEquals("timed-out", Atomics.wait(i32a, 0, Math, 0));
+})();
+
+
 //// WORKER ONLY TESTS
 
 if (this.Worker) {