Adding support for asm.js foreign globals.

src/wasm/wasm-js.cc

 // Copyright 2015 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/api.h"
 #include "src/api-natives.h"
 #include "src/assert-scope.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/factory.h"
@@ skipping 81 matching lines @@
                                                 buffer.start, buffer.end);
   }
 
   if (result.failed()) {
     thrower.Failed("", result);
   }
 
   if (result.val) delete result.val;
 }
 
-
-v8::internal::wasm::WasmModuleIndex* TranslateAsmModule(i::ParseInfo* info,
-                                                        ErrorThrower* thrower) {
+v8::internal::wasm::WasmModuleIndex* TranslateAsmModule(
+    i::ParseInfo* info, i::Handle<i::Object> foreign, ErrorThrower* thrower) {
   info->set_global();
   info->set_lazy(false);
   info->set_allow_lazy_parsing(false);
   info->set_toplevel(true);
 
   if (!i::Compiler::ParseAndAnalyze(info)) {
     return nullptr;
   }
 
   info->set_literal(
       info->scope()->declarations()->at(0)->AsFunctionDeclaration()->fun());
 
   v8::internal::AsmTyper typer(info->isolate(), info->zone(), *(info->script()),
                                info->literal());
   if (i::FLAG_enable_simd_asmjs) {
     typer.set_allow_simd(true);
   }
   if (!typer.Validate()) {
     thrower->Error("Asm.js validation failed: %s", typer.error_message());
     return nullptr;
   }
 
   auto module = v8::internal::wasm::AsmWasmBuilder(
-                    info->isolate(), info->zone(), info->literal())
+                    info->isolate(), info->zone(), info->literal(), foreign)
                     .Run();
   return module;
 }
 
 
 void InstantiateModuleCommon(const v8::FunctionCallbackInfo<v8::Value>& args,
                              const byte* start, const byte* end,
                              ErrorThrower* thrower, bool must_decode) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
 
@@ skipping 43 matching lines @@
     thrower.Error("Asm module text should be a string");
     return;
   }
 
   i::Factory* factory = isolate->factory();
   i::Zone zone;
   Local<String> source = Local<String>::Cast(args[0]);
   i::Handle<i::Script> script = factory->NewScript(Utils::OpenHandle(*source));
   i::ParseInfo info(&zone, script);
 
-  auto module = TranslateAsmModule(&info, &thrower);
+  i::Handle<i::Object> foreign;
+  if (args.Length() > 1 && args[1]->IsObject()) {
+    Local<Object> local_foreign = Local<Object>::Cast(args[1]);
+    foreign = v8::Utils::OpenHandle(*local_foreign);
+  }
+
+  auto module = TranslateAsmModule(&info, foreign, &thrower);
   if (module == nullptr) {
     return;
   }
 
   InstantiateModuleCommon(args, module->Begin(), module->End(), &thrower, true);
 }
 
 
 void InstantiateModule(const v8::FunctionCallbackInfo<v8::Value>& args) {
   HandleScope scope(args.GetIsolate());
@@ skipping 65 matching lines @@
   if (!context->get(Context::WASM_FUNCTION_MAP_INDEX)->IsMap()) {
     Handle<Map> wasm_function_map = isolate->factory()->NewMap(
         JS_FUNCTION_TYPE, JSFunction::kSize + kPointerSize);
     wasm_function_map->set_is_callable();
     context->set_wasm_function_map(*wasm_function_map);
   }
 }
 
 }  // namespace internal
 }  // namespace v8