[wasm] Avoid double-serializing the wire bytes

src/d8.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 <errno.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 
 #include <algorithm>
@@ skipping 1375 matching lines @@
           .ToLocalChecked(),
       FunctionTemplate::New(isolate, Write));
   global_template->Set(
       String::NewFromUtf8(isolate, "read", NewStringType::kNormal)
           .ToLocalChecked(),
       FunctionTemplate::New(isolate, Read));
   global_template->Set(
       String::NewFromUtf8(isolate, "readbuffer", NewStringType::kNormal)
           .ToLocalChecked(),
       FunctionTemplate::New(isolate, ReadBuffer));
+  Local<FunctionTemplate> experimental =
+      FunctionTemplate::New(isolate, ExperimentalDoubleAdder);
+  experimental->Set(isolate, "native_variant",
+                    External::New(isolate, reinterpret_cast<void*>(
+                                               ExperimentalNativeDoubleAdder)));
+  global_template->Set(String::NewFromUtf8(isolate, "experimentalDoubleAdder",
+                                           NewStringType::kNormal)
+                           .ToLocalChecked(),
+                       experimental);
   global_template->Set(
       String::NewFromUtf8(isolate, "readline", NewStringType::kNormal)
           .ToLocalChecked(),
       FunctionTemplate::New(isolate, ReadLine));
   global_template->Set(
       String::NewFromUtf8(isolate, "load", NewStringType::kNormal)
           .ToLocalChecked(),
       FunctionTemplate::New(isolate, Load));
   // Some Emscripten-generated code tries to call 'quit', which in turn would
   // call C's exit(). This would lead to memory leaks, because there is no way
@@ skipping 312 matching lines @@
   Local<v8::ArrayBuffer> buffer = ArrayBuffer::New(isolate, data->data, length);
   data->handle.Reset(isolate, buffer);
   data->handle.SetWeak(data, ReadBufferWeakCallback,
                        v8::WeakCallbackType::kParameter);
   data->handle.MarkIndependent();
   isolate->AdjustAmountOfExternalAllocatedMemory(length);
 
   args.GetReturnValue().Set(buffer);
 }
 
+void Shell::ExperimentalDoubleAdder(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  DCHECK(sizeof(char) == sizeof(uint8_t));  // NOLINT
+  Local<Number> a = Local<Number>::Cast(args[0]);
+  Local<Number> b = Local<Number>::Cast(args[1]);
+  Local<Number> ret = Number::New(args.GetIsolate(), a->Value() + b->Value());
+  args.GetReturnValue().Set(ret);
+}
+
+double Shell::ExperimentalNativeDoubleAdder(double a, double b) {
+  return a + b;
+}
 
 // Reads a file into a v8 string.
 Local<String> Shell::ReadFile(Isolate* isolate, const char* name) {
   int size = 0;
   char* chars = ReadChars(isolate, name, &size);
   if (chars == NULL) return Local<String>();
   Local<String> result =
       String::NewFromUtf8(isolate, chars, NewStringType::kNormal, size)
           .ToLocalChecked();
   delete[] chars;
@@ skipping 1076 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif