WIP SharedArrayBuffer implementation

src/bootstrapper.cc

 // Copyright 2014 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/bootstrapper.h"
 
 #include "src/accessors.h"
 #include "src/api-natives.h"
 #include "src/code-stubs.h"
 #include "src/extensions/externalize-string-extension.h"
@@ skipping 171 matching lines @@
   HARMONY_INPROGRESS(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_STAGED(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_SHIPPING(DECLARE_FEATURE_INITIALIZATION)
 #undef DECLARE_FEATURE_INITIALIZATION
 
   Handle<JSFunction> InstallInternalArray(Handle<JSBuiltinsObject> builtins,
                                           const char* name,
                                           ElementsKind elements_kind);
   bool InstallNatives();
 
-  void InstallTypedArray(
-      const char* name,
-      ElementsKind elements_kind,
-      Handle<JSFunction>* fun,
-      Handle<Map>* external_map);
+  void InstallTypedArray(const char* name, ElementsKind elements_kind,
+                         Handle<JSFunction>* fun, Handle<Map>* external_map,
+                         bool is_shared);

[Jarin, 2015/04/16 14:55:28]

Could you introduce an enum for the various places where you pass the is_shared
flag? That would make it easier to read the code at call sites.

[binji, 2015/04/16 21:00:33]

Done.

   bool InstallExperimentalNatives();
   void InstallBuiltinFunctionIds();
   void InstallJSFunctionResultCaches();
   void InitializeNormalizedMapCaches();
 
   enum ExtensionTraversalState {
     UNVISITED, VISITED, INSTALLED
   };
 
   class ExtensionStates {
@@ skipping 939 matching lines @@
     Handle<JSFunction> array_buffer_fun =
         InstallFunction(
             global, "ArrayBuffer", JS_ARRAY_BUFFER_TYPE,
             JSArrayBuffer::kSizeWithInternalFields,
             isolate->initial_object_prototype(),
             Builtins::kIllegal);
     native_context()->set_array_buffer_fun(*array_buffer_fun);
   }
 
   {  // -- T y p e d A r r a y s
-#define INSTALL_TYPED_ARRAY(Type, type, TYPE, ctype, size)                    \
-    {                                                                         \
-      Handle<JSFunction> fun;                                                 \
-      Handle<Map> external_map;                                               \
-      InstallTypedArray(#Type "Array",                                        \
-          TYPE##_ELEMENTS,                                                    \
-          &fun,                                                               \
-          &external_map);                                                     \
-      native_context()->set_##type##_array_fun(*fun);                         \
-      native_context()->set_##type##_array_external_map(*external_map);       \
-    }
+#define INSTALL_TYPED_ARRAY(Type, type, TYPE, ctype, size)                 \
+  {                                                                        \
+    Handle<JSFunction> fun;                                                \
+    Handle<Map> external_map;                                              \
+    InstallTypedArray(#Type "Array", TYPE##_ELEMENTS, &fun, &external_map, \
+                      false);                                              \
+    native_context()->set_##type##_array_fun(*fun);                        \
+    native_context()->set_##type##_array_external_map(*external_map);      \
+  }
     TYPED_ARRAYS(INSTALL_TYPED_ARRAY)
 #undef INSTALL_TYPED_ARRAY
 
     Handle<JSFunction> data_view_fun =
         InstallFunction(
             global, "DataView", JS_DATA_VIEW_TYPE,
             JSDataView::kSizeWithInternalFields,
             isolate->initial_object_prototype(),
             Builtins::kIllegal);
     native_context()->set_data_view_fun(*data_view_fun);
   }
 
+  {  // -- S h a r e d A r r a y B u f f e r
+    Handle<JSFunction> shared_array_buffer_fun = InstallFunction(
+        global, "SharedArrayBuffer", JS_SHARED_ARRAY_BUFFER_TYPE,
+        JSArrayBuffer::kSizeWithInternalFields,
+        isolate->initial_object_prototype(), Builtins::kIllegal);
+    native_context()->set_shared_array_buffer_fun(*shared_array_buffer_fun);
+  }
+
+  {  // -- S h a r e d T y p e d A r r a y s
+#define INSTALL_SHARED_TYPED_ARRAY(Type, type, TYPE, ctype, size)            \
+  {                                                                          \
+    Handle<JSFunction> fun;                                                  \
+    Handle<Map> external_map;                                                \
+    InstallTypedArray("Shared" #Type "Array", TYPE##_ELEMENTS, &fun,         \
+                      &external_map, true);                                  \
+    native_context()->set_shared_##type##_array_fun(*fun);                   \
+    native_context()->set_shared_##type##_array_external_map(*external_map); \
+  }
+    TYPED_ARRAYS(INSTALL_SHARED_TYPED_ARRAY)
+#undef INSTALL_SHARED_TYPED_ARRAY
+  }
+
   // -- M a p
   InstallFunction(global, "Map", JS_MAP_TYPE, JSMap::kSize,
                   isolate->initial_object_prototype(), Builtins::kIllegal);
 
   // -- S e t
   InstallFunction(global, "Set", JS_SET_TYPE, JSSet::kSize,
                   isolate->initial_object_prototype(), Builtins::kIllegal);
 
   {  // Set up the iterator result object
     STATIC_ASSERT(JSGeneratorObject::kResultPropertyCount == 2);
@@ skipping 175 matching lines @@
     native_context()->set_call_as_constructor_delegate(*delegate);
     delegate->shared()->DontAdaptArguments();
   }
 
   // Initialize the embedder data slot.
   Handle<FixedArray> embedder_data = factory->NewFixedArray(3);
   native_context()->set_embedder_data(*embedder_data);
 }
 
 
-void Genesis::InstallTypedArray(
-    const char* name,
-    ElementsKind elements_kind,
-    Handle<JSFunction>* fun,
-    Handle<Map>* external_map) {
+void Genesis::InstallTypedArray(const char* name, ElementsKind elements_kind,
+                                Handle<JSFunction>* fun,
+                                Handle<Map>* external_map, bool is_shared) {
+  InstanceType type =
+      is_shared ? JS_SHARED_TYPED_ARRAY_TYPE : JS_TYPED_ARRAY_TYPE;
   Handle<JSObject> global = Handle<JSObject>(native_context()->global_object());
   Handle<JSFunction> result = InstallFunction(
-      global, name, JS_TYPED_ARRAY_TYPE, JSTypedArray::kSize,
+      global, name, type, JSTypedArray::kSize,
       isolate()->initial_object_prototype(), Builtins::kIllegal);
 
   Handle<Map> initial_map = isolate()->factory()->NewMap(
-      JS_TYPED_ARRAY_TYPE,
-      JSTypedArray::kSizeWithInternalFields,
-      elements_kind);
+      type, JSTypedArray::kSizeWithInternalFields, elements_kind);
   JSFunction::SetInitialMap(result, initial_map,
                             handle(initial_map->prototype(), isolate()));
   *fun = result;
 
   ElementsKind external_kind = GetNextTransitionElementsKind(elements_kind);
   *external_map = Map::AsElementsKind(initial_map, external_kind);
 }
 
 
 void Genesis::InitializeExperimentalGlobal() {
@@ skipping 1565 matching lines @@
   return from + sizeof(NestingCounterType);
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 } }  // namespace v8::internal