Revert of [SAB] Move Atomics builtins to C++

src/builtins/builtins-sharedarraybuffer.cc

 // Copyright 2016 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 "src/base/macros.h"
 #include "src/base/platform/mutex.h"
 #include "src/base/platform/time.h"
 #include "src/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
@@ skipping 620 matching lines @@
 }
 
 template <typename T>
 inline Object* DoExchange(Isolate* isolate, void* buffer, size_t index,
                           Handle<Object> obj) {
   T value = FromObject<T>(obj);
   T result = ExchangeSeqCst(static_cast<T*>(buffer) + index, value);
   return ToObject(isolate, result);
 }
 
+// Uint8Clamped functions
+
+uint8_t ClampToUint8(int32_t value) {
+  if (value < 0) return 0;
+  if (value > 255) return 255;
+  return value;
+}
+
+inline Object* DoCompareExchangeUint8Clamped(Isolate* isolate, void* buffer,
+                                             size_t index,
+                                             Handle<Object> oldobj,
+                                             Handle<Object> newobj) {
+  typedef int32_t convert_type;
+  uint8_t oldval = ClampToUint8(FromObject<convert_type>(oldobj));
+  uint8_t newval = ClampToUint8(FromObject<convert_type>(newobj));
+  uint8_t result = CompareExchangeSeqCst(static_cast<uint8_t*>(buffer) + index,
+                                         oldval, newval);
+  return ToObject(isolate, result);
+}
+
+#define DO_UINT8_CLAMPED_OP(name, op)                                        \
+  inline Object* Do##name##Uint8Clamped(Isolate* isolate, void* buffer,      \
+                                        size_t index, Handle<Object> obj) {  \
+    typedef int32_t convert_type;                                            \
+    uint8_t* p = static_cast<uint8_t*>(buffer) + index;                      \
+    convert_type operand = FromObject<convert_type>(obj);                    \
+    uint8_t expected;                                                        \
+    uint8_t result;                                                          \
+    do {                                                                     \
+      expected = *p;                                                         \
+      result = ClampToUint8(static_cast<convert_type>(expected) op operand); \
+    } while (CompareExchangeSeqCst(p, expected, result) != expected);        \
+    return ToObject(isolate, expected);                                      \
+  }
+
+DO_UINT8_CLAMPED_OP(Add, +)
+DO_UINT8_CLAMPED_OP(Sub, -)
+DO_UINT8_CLAMPED_OP(And, &)
+DO_UINT8_CLAMPED_OP(Or, |)
+DO_UINT8_CLAMPED_OP(Xor, ^)
+
+#undef DO_UINT8_CLAMPED_OP
+
+inline Object* DoExchangeUint8Clamped(Isolate* isolate, void* buffer,
+                                      size_t index, Handle<Object> obj) {
+  typedef int32_t convert_type;
+  uint8_t* p = static_cast<uint8_t*>(buffer) + index;
+  uint8_t result = ClampToUint8(FromObject<convert_type>(obj));
+  uint8_t expected;
+  do {
+    expected = *p;
+  } while (CompareExchangeSeqCst(p, expected, result) != expected);
+  return ToObject(isolate, expected);
+}
+
 }  // anonymous namespace
 
 // Duplicated from objects.h
 // V has parameters (Type, type, TYPE, C type, element_size)
 #define INTEGER_TYPED_ARRAYS(V)          \
   V(Uint8, uint8, UINT8, uint8_t, 1)     \
   V(Int8, int8, INT8, int8_t, 1)         \
   V(Uint16, uint16, UINT16, uint16_t, 2) \
   V(Int16, int16, INT16, int16_t, 2)     \
   V(Uint32, uint32, UINT32, uint32_t, 4) \
@@ skipping 28 matching lines @@
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size)            \
   case kExternal##Type##Array:                                         \
     return DoCompareExchange<ctype>(isolate, source, i, expectedValue, \
                                     replacementValue);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
     case kExternalUint8ClampedArray:
-      UNREACHABLE();
+      return DoCompareExchangeUint8Clamped(isolate, source, i, expectedValue,
+                                           replacementValue);
 
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 // ES #sec-atomics.add
@@ skipping 20 matching lines @@
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoAdd<ctype>(isolate, source, i, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
     case kExternalUint8ClampedArray:
-      UNREACHABLE();
+      return DoAddUint8Clamped(isolate, source, i, value);
 
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 // ES #sec-atomics.sub
@@ skipping 20 matching lines @@
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoSub<ctype>(isolate, source, i, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
     case kExternalUint8ClampedArray:
-      UNREACHABLE();
+      return DoSubUint8Clamped(isolate, source, i, value);
 
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 // ES #sec-atomics.and
@@ skipping 20 matching lines @@
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoAnd<ctype>(isolate, source, i, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
     case kExternalUint8ClampedArray:
-      UNREACHABLE();
+      return DoAndUint8Clamped(isolate, source, i, value);
 
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 // ES #sec-atomics.or
@@ skipping 20 matching lines @@
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoOr<ctype>(isolate, source, i, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
     case kExternalUint8ClampedArray:
-      UNREACHABLE();
+      return DoOrUint8Clamped(isolate, source, i, value);
 
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 // ES #sec-atomics.xor
@@ skipping 20 matching lines @@
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoXor<ctype>(isolate, source, i, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
     case kExternalUint8ClampedArray:
-      UNREACHABLE();
+      return DoXorUint8Clamped(isolate, source, i, value);
 
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 // ES #sec-atomics.exchange
@@ skipping 20 matching lines @@
 
   switch (sta->type()) {
 #define TYPED_ARRAY_CASE(Type, typeName, TYPE, ctype, size) \
   case kExternal##Type##Array:                              \
     return DoExchange<ctype>(isolate, source, i, value);
 
     INTEGER_TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
 
     case kExternalUint8ClampedArray:
-      UNREACHABLE();
+      return DoExchangeUint8Clamped(isolate, source, i, value);
 
     default:
       break;
   }
 
   UNREACHABLE();
   return isolate->heap()->undefined_value();
 }
 
 }  // namespace internal
 }  // namespace v8