Revert of Initialize maths result array in JS.

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 179 matching lines @@
   // The native context has a ScriptContextTable that store declarative bindings
   // made in script scopes.  Add a "this" binding to that table pointing to the
   // global proxy.
   void InstallGlobalThisBinding();
   void HookUpGlobalThisBinding(Handle<FixedArray> outdated_contexts);
   // New context initialization.  Used for creating a context from scratch.
   void InitializeGlobal(Handle<GlobalObject> global_object,
                         Handle<JSFunction> empty_function,
                         ContextType context_type);
   void InitializeExperimentalGlobal();
+  // Typed arrays are not serializable and have to initialized afterwards.
+  bool InitializeBuiltinTypedArrays();
   // Depending on the situation, expose and/or get rid of the utils object.
   void ConfigureUtilsObject(ContextType context_type);
 
 #define DECLARE_FEATURE_INITIALIZATION(id, descr) \
   void InitializeGlobal_##id();
 
   HARMONY_INPROGRESS(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_STAGED(DECLARE_FEATURE_INITIALIZATION)
   HARMONY_SHIPPING(DECLARE_FEATURE_INITIALIZATION)
 #undef DECLARE_FEATURE_INITIALIZATION
@@ skipping 1570 matching lines @@
     *data = reinterpret_cast<Data*>(
         isolate->array_buffer_allocator()->Allocate(byte_length));
   }
   JSArrayBuffer::Setup(buffer, isolate, is_external, *data, byte_length,
                        SharedFlag::kNotShared);
   return isolate->factory()->NewJSTypedArray(type, buffer, 0, num_elements,
                                              TENURED);
 }
 
 
+bool Genesis::InitializeBuiltinTypedArrays() {
+  HandleScope scope(isolate());
+  const size_t num_elements = 2;
+  double* data = NULL;
+  Handle<JSTypedArray> rempio2result =
+      CreateTypedArray(isolate(), kExternalFloat64Array, num_elements, &data);
+  for (size_t i = 0; i < num_elements; i++) data[i] = 0;
+
+  Handle<JSObject> utils =
+      Handle<JSObject>::cast(isolate()->natives_utils_object());
+  Handle<String> name_string = isolate()->factory()->NewStringFromAsciiChecked(
+      "InitializeBuiltinTypedArrays");
+  Handle<Object> fun = JSObject::GetDataProperty(utils, name_string);
+  Handle<Object> receiver = isolate()->factory()->undefined_value();
+  Handle<Object> args[] = {utils, rempio2result};
+  return !Execution::Call(isolate(), fun, receiver, arraysize(args), args)
+              .is_null();
+}
+
+
 void Genesis::ConfigureUtilsObject(ContextType context_type) {
   switch (context_type) {
     // We still need the utils object to find debug functions.
     case DEBUG_CONTEXT:
       return;
     // Expose the natives in global if a valid name for it is specified.
     case FULL_CONTEXT: {
       // We still need the utils object after deserialization.
       if (isolate()->serializer_enabled()) return;
       if (FLAG_expose_natives_as == NULL) break;
@@ skipping 1424 matching lines @@
       if (!InstallExtraNatives()) return;
       if (!ConfigureGlobalObjects(global_proxy_template)) return;
     }
     isolate->counters()->contexts_created_from_scratch()->Increment();
   }
 
   // Install experimental natives. Do not include them into the
   // snapshot as we should be able to turn them off at runtime. Re-installing
   // them after they have already been deserialized would also fail.
   if (context_type == FULL_CONTEXT) {
+    if (!InitializeBuiltinTypedArrays()) return;
     if (!isolate->serializer_enabled()) {
       InitializeExperimentalGlobal();
       if (!InstallExperimentalNatives()) return;
 
       if (FLAG_experimental_extras) {
         if (!InstallExperimentalExtraNatives()) return;
       }
     }
     // The serializer cannot serialize typed arrays. Reset those typed arrays
     // for each new context.
   } else if (context_type == DEBUG_CONTEXT) {
     DCHECK(!isolate->serializer_enabled());
+    if (!InitializeBuiltinTypedArrays()) return;
     InitializeExperimentalGlobal();
     if (!InstallDebuggerNatives()) return;
   }
 
   ConfigureUtilsObject(context_type);
 
   // Check that the script context table is empty except for the 'this' binding.
   // We do not need script contexts for native scripts.
   if (!FLAG_global_var_shortcuts) {
     DCHECK_EQ(1, native_context()->script_context_table()->used());
@@ skipping 26 matching lines @@
 }
 
 
 // Called when the top-level V8 mutex is destroyed.
 void Bootstrapper::FreeThreadResources() {
   DCHECK(!IsActive());
 }
 
 }  // namespace internal
 }  // namespace v8