[wasm] asm.js - Check stdlib.NaN is valid, prepare for the rest.

src/asmjs/asm-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/asmjs/asm-js.h"
 
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/asmjs/asm-typer.h"
 #include "src/asmjs/asm-wasm-builder.h"
@@ skipping 35 matching lines @@
   } else if (result.failed()) {
     thrower->Failed("", result);
   } else {
     compiled_module = result.val->CompileFunctions(isolate, thrower);
   }
 
   if (result.val) delete result.val;
   return compiled_module;
 }
 
+bool IsStdlibMemberValid(i::Isolate* isolate, Handle<JSReceiver> stdlib,
+                         i::Handle<i::Object> member_id) {
+  int32_t member_kind;
+  if (!member_id->ToInt32(&member_kind)) {
+    UNREACHABLE();
+  }
+  switch (member_kind) {
+    case wasm::AsmTyper::StandardMember::kNone:
+    case wasm::AsmTyper::StandardMember::kModule:
+    case wasm::AsmTyper::StandardMember::kStdlib: {
+      // Nothing to check for these.
+      return true;
+    }
+    case wasm::AsmTyper::StandardMember::kNaN: {
+      i::Handle<i::Name> name(isolate->factory()->InternalizeOneByteString(
+          STATIC_CHAR_VECTOR("NaN")));
+      i::MaybeHandle<i::Object> maybe_value =
+          i::Object::GetProperty(stdlib, name);
+      if (maybe_value.is_null()) {
+        return false;
+      }
+      i::Handle<i::Object> value = maybe_value.ToHandleChecked();
+      if (!value->IsNaN()) {
+        return false;
+      }
+      return true;
+    }
+    case wasm::AsmTyper::StandardMember::kHeap:
+    case wasm::AsmTyper::StandardMember::kFFI:
+    case wasm::AsmTyper::StandardMember::kInfinity:
+    case wasm::AsmTyper::StandardMember::kMathAcos:
+    case wasm::AsmTyper::StandardMember::kMathAsin:
+    case wasm::AsmTyper::StandardMember::kMathAtan:
+    case wasm::AsmTyper::StandardMember::kMathCos:
+    case wasm::AsmTyper::StandardMember::kMathSin:
+    case wasm::AsmTyper::StandardMember::kMathTan:
+    case wasm::AsmTyper::StandardMember::kMathExp:
+    case wasm::AsmTyper::StandardMember::kMathLog:
+    case wasm::AsmTyper::StandardMember::kMathCeil:
+    case wasm::AsmTyper::StandardMember::kMathFloor:
+    case wasm::AsmTyper::StandardMember::kMathSqrt:
+    case wasm::AsmTyper::StandardMember::kMathAbs:
+    case wasm::AsmTyper::StandardMember::kMathClz32:
+    case wasm::AsmTyper::StandardMember::kMathMin:
+    case wasm::AsmTyper::StandardMember::kMathMax:
+    case wasm::AsmTyper::StandardMember::kMathAtan2:
+    case wasm::AsmTyper::StandardMember::kMathPow:
+    case wasm::AsmTyper::StandardMember::kMathImul:
+    case wasm::AsmTyper::StandardMember::kMathFround:
+    case wasm::AsmTyper::StandardMember::kMathE:
+    case wasm::AsmTyper::StandardMember::kMathLN10:
+    case wasm::AsmTyper::StandardMember::kMathLN2:
+    case wasm::AsmTyper::StandardMember::kMathLOG2E:
+    case wasm::AsmTyper::StandardMember::kMathLOG10E:
+    case wasm::AsmTyper::StandardMember::kMathPI:
+    case wasm::AsmTyper::StandardMember::kMathSQRT1_2:
+    case wasm::AsmTyper::StandardMember::kMathSQRT2:
+      // TODO(bradnelson) Actually check these.
+      return true;
+    default: { UNREACHABLE(); }
+  }
+  return false;
+}
+
 }  // namespace
 
 MaybeHandle<FixedArray> AsmJs::ConvertAsmToWasm(ParseInfo* info) {
   ErrorThrower thrower(info->isolate(), "Asm.js -> WebAssembly conversion");
   wasm::AsmTyper typer(info->isolate(), info->zone(), *(info->script()),
                        info->literal());
   if (!typer.Validate()) {
     DCHECK(!info->isolate()->has_pending_exception());
     PrintF("Validation of asm.js module failed: %s", typer.error_message());
     return MaybeHandle<FixedArray>();
   }
   v8::internal::wasm::AsmWasmBuilder builder(info->isolate(), info->zone(),
                                              info->literal(), &typer);
   i::Handle<i::FixedArray> foreign_globals;
   auto module = builder.Run(&foreign_globals);
 
   i::MaybeHandle<i::FixedArray> compiled =
       CompileModule(info->isolate(), module->begin(), module->end(), &thrower,
                     internal::wasm::kAsmJsOrigin);
   DCHECK(!compiled.is_null());
 
-  Handle<FixedArray> result = info->isolate()->factory()->NewFixedArray(2);
+  wasm::AsmTyper::StdlibSet uses = typer.StdlibUses();
+  Handle<FixedArray> uses_array =
+      info->isolate()->factory()->NewFixedArray(static_cast<int>(uses.size()));
+  int count = 0;
+  for (auto i : uses) {
+    uses_array->set(count++, Smi::FromInt(i));
+  }
+
+  Handle<FixedArray> result = info->isolate()->factory()->NewFixedArray(3);
   result->set(0, *compiled.ToHandleChecked());
   result->set(1, *foreign_globals);
+  result->set(2, *uses_array);
   return result;
 }
 
+bool AsmJs::IsStdlibValid(i::Isolate* isolate, Handle<FixedArray> wasm_data,
+                          Handle<JSReceiver> stdlib) {
+  i::Handle<i::FixedArray> uses(i::FixedArray::cast(wasm_data->get(2)));
+  for (int i = 0; i < uses->length(); ++i) {
+    if (!IsStdlibMemberValid(isolate, stdlib,
+                             uses->GetValueChecked<i::Object>(isolate, i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
 MaybeHandle<Object> AsmJs::InstantiateAsmWasm(i::Isolate* isolate,
                                               Handle<FixedArray> wasm_data,
                                               Handle<JSArrayBuffer> memory,
-                                              Handle<JSObject> foreign) {
+                                              Handle<JSReceiver> foreign) {
   i::Handle<i::FixedArray> compiled(i::FixedArray::cast(wasm_data->get(0)));
   i::Handle<i::FixedArray> foreign_globals(
       i::FixedArray::cast(wasm_data->get(1)));
 
   ErrorThrower thrower(isolate, "Asm.js -> WebAssembly instantiation");
 
   i::MaybeHandle<i::JSObject> maybe_module_object =
       i::wasm::WasmModule::Instantiate(isolate, compiled, foreign, memory);
   if (maybe_module_object.is_null()) {
     return MaybeHandle<Object>();
@@ skipping 33 matching lines @@
   if (retval.is_null()) {
     thrower.Error(
         "WASM.instantiateModuleFromAsm(): foreign init function failed");
     return MaybeHandle<Object>();
   }
   return maybe_module_object;
 }
 
 }  // namespace internal
 }  // namespace v8