[Atomics] code stubs for atomic operations

src/builtins.cc

 // Copyright 2012 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/builtins.h"
 
 #include "src/api.h"
 #include "src/api-natives.h"
 #include "src/arguments.h"
 #include "src/base/once.h"
 #include "src/bootstrapper.h"
+#include "src/compiler/code-stub-assembler.h"
 #include "src/dateparser-inl.h"
 #include "src/elements.h"
 #include "src/frames-inl.h"
 #include "src/gdb-jit.h"
 #include "src/ic/handler-compiler.h"
 #include "src/ic/ic.h"
 #include "src/isolate-inl.h"
 #include "src/messages.h"
 #include "src/profiler/cpu-profiler.h"
 #include "src/property-descriptor.h"
@@ skipping 4141 matching lines @@
 void Builtins::Generate_InterruptCheck(MacroAssembler* masm) {
   masm->TailCallRuntime(Runtime::kInterrupt);
 }
 
 
 void Builtins::Generate_StackCheck(MacroAssembler* masm) {
   masm->TailCallRuntime(Runtime::kStackGuard);
 }
 
 
+void Builtins::Generate_AtomicsLoadCheck(MacroAssembler* masm) {
+  using namespace compiler;
+  Isolate* isolate = masm->isolate();
+  Zone zone;
+  CodeStubAssembler a(isolate, &zone, 2, Code::ComputeFlags(Code::STUB),
+                      "AtomicsLoadCheck");
+
+  Node* param0 = a.Parameter(0);
+
+  // Check if param0 is a heap object.
+  CodeStubAssembler::Label is_heap_object, not_heap_object;
+  a.Branch(a.IsHeapObject(param0), &is_heap_object, &not_heap_object);
+  a.Bind(&not_heap_object);
+  a.TailCallRuntime(Runtime::kThrowNotIntegerSharedTypedArrayError, param0);
+  a.Bind(&is_heap_object);
+
+  // Check if param0's instance type is JSTypedArray.
+  CodeStubAssembler::Label is_typed_array, not_typed_array;
+  a.Branch(
+      a.WordEqual(a.InstanceType(param0), a.Int32Constant(JS_TYPED_ARRAY_TYPE)),
+      &is_typed_array, &not_typed_array);
+  a.Bind(&not_typed_array);
+  a.TailCallRuntime(Runtime::kThrowNotIntegerSharedTypedArrayError, param0);
+  a.Bind(&is_typed_array);
+
+  // Check if param0's JSArrayBuffer is shared.
+  CodeStubAssembler::Label is_shared, not_shared;
+  Node* is_buffer_shared = a.BitFieldValue<JSArrayBuffer::IsShared>(
+      a.LoadObjectField(a.LoadObjectField(param0, JSTypedArray::kBufferOffset),
+                        JSArrayBuffer::kBitFieldOffset));
+  a.Branch(is_buffer_shared, &is_shared, &not_shared);
+  a.Bind(&not_shared);
+  a.TailCallRuntime(Runtime::kThrowNotIntegerSharedTypedArrayError, param0);
+  a.Bind(&is_shared);
+
+  // Check if param0's JSTypedArray element type is float32 or float64.
+  CodeStubAssembler::Label is_float, not_float;
+  Node* elements_instance_type =
+      a.InstanceType(a.LoadObjectField(param0, JSObject::kElementsOffset));
+  a.Branch(a.WordOr(a.WordEqual(elements_instance_type,
+                                a.Int32Constant(FIXED_FLOAT32_ARRAY_TYPE)),
+                    a.WordEqual(elements_instance_type,
+                                a.Int32Constant(FIXED_FLOAT64_ARRAY_TYPE))),
+           &is_float, &not_float);
+  a.Bind(&is_float);
+  a.TailCallRuntime(Runtime::kThrowNotIntegerSharedTypedArrayError, param0);
+  a.Bind(&not_float);
+
+  // Check if the index is in bounds. If not, return undefined.
+  CodeStubAssembler::Label in_bounds, not_in_bounds;
+  Node* param1_int =
+      a.SmiUntag(a.CallRuntime(Runtime::kToInteger, a.Parameter(1)));

[Jarin, 2016/02/08 10:25:04]

How do you know that ToInteger returns a Smi? You probably want
ChangeTaggedToInt32 here.

+  // TODO(binji): is length always a smi?
+  Node* array_length =
+      a.SmiUntag(a.LoadObjectField(param0, JSTypedArray::kLengthOffset));

[Jarin, 2016/02/08 10:25:04]

Same here.

+  a.Branch(a.WordOr(a.Int32LessThan(param1_int, a.Int32Constant(0)),
+                    a.Int32GreaterThanOrEqual(param1_int, array_length)),
+           &not_in_bounds, &in_bounds);
+  a.Bind(&not_in_bounds);
+  a.Return(a.UndefinedConstant());
+  a.Bind(&in_bounds);
+
+  a.Return(a.SmiTag(a.Int32Constant(42)));
+
+  masm->Jump(a.GenerateCode(), RelocInfo::CODE_TARGET);
+}
+
+
 #define DEFINE_BUILTIN_ACCESSOR_C(name, ignore)               \
 Handle<Code> Builtins::name() {                               \
   Code** code_address =                                       \
       reinterpret_cast<Code**>(builtin_address(k##name));     \
   return Handle<Code>(code_address);                          \
 }
 #define DEFINE_BUILTIN_ACCESSOR_A(name, kind, state, extra) \
 Handle<Code> Builtins::name() {                             \
   Code** code_address =                                     \
       reinterpret_cast<Code**>(builtin_address(k##name));   \
   return Handle<Code>(code_address);                        \
 }
 #define DEFINE_BUILTIN_ACCESSOR_H(name, kind)               \
 Handle<Code> Builtins::name() {                             \
   Code** code_address =                                     \
       reinterpret_cast<Code**>(builtin_address(k##name));   \
   return Handle<Code>(code_address);                        \
 }
 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C)
 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A)
 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 
 
 }  // namespace internal
 }  // namespace v8