Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp

   1 /*
   2  * Copyright (C) 2016 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "WebAssemblyInstanceConstructor.h"
  28
  29 #if ENABLE(WEBASSEMBLY)
  30
  31 #include "FunctionPrototype.h"
  32 #include "JSCInlines.h"
  33 #include "JSModuleEnvironment.h"
  34 #include "JSModuleNamespaceObject.h"
  35 #include "JSWebAssemblyInstance.h"
  36 #include "JSWebAssemblyMemory.h"
  37 #include "JSWebAssemblyModule.h"
  38 #include "WebAssemblyFunction.h"
  39 #include "WebAssemblyInstancePrototype.h"
  40 #include "WebAssemblyModuleRecord.h"
  41
  42 #include "WebAssemblyInstanceConstructor.lut.h"
  43
  44 namespace JSC {
  45
  46 static const bool verbose = false;
  47
  48 const ClassInfo WebAssemblyInstanceConstructor::s_info = { "Function", &Base::s_info, &constructorTableWebAssemblyInstance, CREATE_METHOD_TABLE(WebAssemblyInstanceConstructor) };
  49
  50 /* Source for WebAssemblyInstanceConstructor.lut.h
  51  @begin constructorTableWebAssemblyInstance
  52  @end
  53  */
  54
  55 static EncodedJSValue JSC_HOST_CALL constructJSWebAssemblyInstance(ExecState* exec)
  56 {
  57     auto& vm = exec->vm();
  58     auto throwScope = DECLARE_THROW_SCOPE(vm);
  59     auto* globalObject = exec->lexicalGlobalObject();
  60
  61     // If moduleObject is not a WebAssembly.Module instance, a TypeError is thrown.
  62     JSWebAssemblyModule* jsModule = jsDynamicCast<JSWebAssemblyModule*>(exec->argument(0));
  63     if (!jsModule)
  64         return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("first argument to WebAssembly.Instance must be a WebAssembly.Module"), defaultSourceAppender, runtimeTypeForValue(exec->argument(0)))));
  65     const Wasm::ModuleInformation& moduleInformation = jsModule->moduleInformation();
  66
  67     // If the importObject parameter is not undefined and Type(importObject) is not Object, a TypeError is thrown.
  68     JSValue importArgument = exec->argument(1);
  69     JSObject* importObject = importArgument.getObject();
  70     if (!importArgument.isUndefined() && !importObject)
  71         return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("second argument to WebAssembly.Instance must be undefined or an Object"), defaultSourceAppender, runtimeTypeForValue(importArgument))));
  72
  73     // If the list of module.imports is not empty and Type(importObject) is not Object, a TypeError is thrown.
  74     if (moduleInformation.imports.size() && !importObject)
  75         return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("second argument to WebAssembly.Instance must be Object because the WebAssembly.Module has imports"), defaultSourceAppender, runtimeTypeForValue(importArgument))));
  76
  77     Identifier moduleKey = Identifier::fromUid(PrivateName(PrivateName::Description, "WebAssemblyInstance"));
  78     WebAssemblyModuleRecord* moduleRecord = WebAssemblyModuleRecord::create(exec, vm, globalObject->webAssemblyModuleRecordStructure(), moduleKey, moduleInformation);
  79     RETURN_IF_EXCEPTION(throwScope, { });
  80
  81     Structure* instanceStructure = InternalFunction::createSubclassStructure(exec, exec->newTarget(), globalObject->WebAssemblyInstanceStructure());
  82     RETURN_IF_EXCEPTION(throwScope, { });
  83
  84     JSWebAssemblyInstance* instance = JSWebAssemblyInstance::create(vm, instanceStructure, jsModule, moduleRecord->getModuleNamespace(exec), moduleInformation.imports.size());
  85     RETURN_IF_EXCEPTION(throwScope, { });
  86
  87     // Let funcs, memories and tables be initially-empty lists of callable JavaScript objects, WebAssembly.Memory objects and WebAssembly.Table objects, respectively.
  88     // Let imports be an initially-empty list of external values.
  89     unsigned numImportFunctions = 0;
  90
  91     // FIXME implement Table https://bugs.webkit.org/show_bug.cgi?id=164135
  92     // FIXME implement Global https://bugs.webkit.org/show_bug.cgi?id=164133
  93
  94     bool hasMemoryImport = false;
  95     // For each import i in module.imports:
  96     for (auto& import : moduleInformation.imports) {
  97         // 1. Let o be the resultant value of performing Get(importObject, i.module_name).
  98         JSValue importModuleValue = importObject->get(exec, import.module);
  99         RETURN_IF_EXCEPTION(throwScope, { });
 100         // 2. If Type(o) is not Object, throw a TypeError.
 101         if (!importModuleValue.isObject())
 102             return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("import must be an object"), defaultSourceAppender, runtimeTypeForValue(importModuleValue))));
 103
 104         // 3. Let v be the value of performing Get(o, i.item_name)
 105         JSObject* object = jsCast<JSObject*>(importModuleValue);
 106         JSValue value = object->get(exec, import.field);
 107         RETURN_IF_EXCEPTION(throwScope, { });
 108
 109         switch (import.kind) {
 110         case Wasm::External::Function: {
 111             // 4. If i is a function import:
 112             // i. If IsCallable(v) is false, throw a TypeError.
 113             if (!value.isFunction())
 114                 return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("import function must be callable"), defaultSourceAppender, runtimeTypeForValue(value))));
 115             JSCell* cell = value.asCell();
 116             // ii. If v is an Exported Function Exotic Object:
 117             if (WebAssemblyFunction* importedExports = jsDynamicCast<WebAssemblyFunction*>(object)) {
 118                 // FIXME handle Function Exotic Object properly. https://bugs.webkit.org/show_bug.cgi?id=165282
 119                 // a. If the signature of v does not match the signature of i, throw a TypeError.
 120                 // b. Let closure be v.[[Closure]].
 121                 RELEASE_ASSERT_NOT_REACHED();
 122                 UNUSED_PARAM(importedExports);
 123                 break;
 124             }
 125             // iii. Otherwise:
 126             // a. Let closure be a new host function of the given signature which calls v by coercing WebAssembly arguments to JavaScript arguments via ToJSValue and returns the result, if any, by coercing via ToWebAssemblyValue.
 127             // Note: done as part of Plan compilation.
 128             // iv. Append v to funcs.
 129             instance->setImportFunction(vm, cell, numImportFunctions++);
 130             // v. Append closure to imports.
 131             break;
 132         }
 133         case Wasm::External::Table: {
 134             // 7. Otherwise (i is a table import):
 135             // FIXME implement Table https://bugs.webkit.org/show_bug.cgi?id=164135
 136             // i. If v is not a WebAssembly.Table object, throw a TypeError.
 137             // ii. Append v to tables.
 138             // iii. Append v.[[Table]] to imports.
 139             RELEASE_ASSERT_NOT_REACHED();
 140             break;
 141         }
 142         case Wasm::External::Memory: {
 143             // 6. If i is a memory import:
 144             RELEASE_ASSERT(!hasMemoryImport); // This should be guaranteed by a validation failure.
 145             RELEASE_ASSERT(moduleInformation.memory);
 146             hasMemoryImport = true;
 147             JSWebAssemblyMemory* memory = jsDynamicCast<JSWebAssemblyMemory*>(value);
 148             // i. If v is not a WebAssembly.Memory object, throw a TypeError.
 149             if (!memory)
 150                 return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("Memory import is not an instance of WebAssembly.Memory"))));
 151
 152             Wasm::PageCount expectedInitial = moduleInformation.memory.initial();
 153             Wasm::PageCount actualInitial = memory->memory()->initial();
 154             if (actualInitial < expectedInitial)
 155                 return JSValue::encode(throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("Memory import provided an 'initial' that is too small"))));
 156
 157             if (Wasm::PageCount expectedMaximum = moduleInformation.memory.maximum()) {
 158                 Wasm::PageCount actualMaximum = memory->memory()->maximum();
 159                 if (!actualMaximum) {
 160                     return JSValue::encode(
 161                         throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("Memory import did not have a 'maximum' but the module requires that it does"))));
 162                 }
 163
 164                 if (actualMaximum > expectedMaximum) {
 165                     return JSValue::encode(
 166                         throwException(exec, throwScope, createTypeError(exec, ASCIILiteral("Memory imports 'maximum' is larger than the module's expected 'maximum"))));
 167                 }
 168             }
 169             // ii. Append v to memories.
 170             // iii. Append v.[[Memory]] to imports.
 171             instance->setMemory(vm, memory);
 172             break;
 173         }
 174         case Wasm::External::Global: {
 175             // 5. If i is a global import:
 176             // FIXME implement Global https://bugs.webkit.org/show_bug.cgi?id=164133
 177             // i. If i is not an immutable global, throw a TypeError.
 178             // ii. If Type(v) is not Number, throw a TypeError.
 179             // iii. Append ToWebAssemblyValue(v) to imports.
 180             RELEASE_ASSERT_NOT_REACHED();
 181             break;
 182         }
 183         }
 184     }
 185
 186     {
 187         if (!!moduleInformation.memory && moduleInformation.memory.isImport()) {
 188             // We should either have an import or we should have thrown an exception.
 189             RELEASE_ASSERT(hasMemoryImport);
 190         }
 191
 192         if (moduleInformation.memory && !hasMemoryImport) {
 193             RELEASE_ASSERT(!moduleInformation.memory.isImport());
 194             // We create a memory when it's a memory definition.
 195             std::unique_ptr<Wasm::Memory> memory = std::make_unique<Wasm::Memory>(moduleInformation.memory.initial(), moduleInformation.memory.maximum());
 196             instance->setMemory(vm,
 197                JSWebAssemblyMemory::create(vm, exec->lexicalGlobalObject()->WebAssemblyMemoryStructure(), WTFMove(memory)));
 198         }
 199     }
 200
 201     moduleRecord->link(exec, instance);
 202     RETURN_IF_EXCEPTION(throwScope, { });
 203     if (verbose)
 204         moduleRecord->dump();
 205     JSValue startResult = moduleRecord->evaluate(exec);
 206     UNUSED_PARAM(startResult);
 207     RETURN_IF_EXCEPTION(throwScope, { });
 208
 209     return JSValue::encode(instance);
 210 }
 211
 212 static EncodedJSValue JSC_HOST_CALL callJSWebAssemblyInstance(ExecState* state)
 213 {
 214     VM& vm = state->vm();
 215     auto scope = DECLARE_THROW_SCOPE(vm);
 216     return JSValue::encode(throwConstructorCannotBeCalledAsFunctionTypeError(state, scope, "WebAssembly.Instance"));
 217 }
 218
 219 WebAssemblyInstanceConstructor* WebAssemblyInstanceConstructor::create(VM& vm, Structure* structure, WebAssemblyInstancePrototype* thisPrototype)
 220 {
 221     auto* constructor = new (NotNull, allocateCell<WebAssemblyInstanceConstructor>(vm.heap)) WebAssemblyInstanceConstructor(vm, structure);
 222     constructor->finishCreation(vm, thisPrototype);
 223     return constructor;
 224 }
 225
 226 Structure* WebAssemblyInstanceConstructor::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
 227 {
 228     return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
 229 }
 230
 231 void WebAssemblyInstanceConstructor::finishCreation(VM& vm, WebAssemblyInstancePrototype* prototype)
 232 {
 233     Base::finishCreation(vm, ASCIILiteral("Instance"));
 234     putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, DontEnum | DontDelete | ReadOnly);
 235     putDirectWithoutTransition(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontEnum | DontDelete);
 236 }
 237
 238 WebAssemblyInstanceConstructor::WebAssemblyInstanceConstructor(VM& vm, Structure* structure)
 239     : Base(vm, structure)
 240 {
 241 }
 242
 243 ConstructType WebAssemblyInstanceConstructor::getConstructData(JSCell*, ConstructData& constructData)
 244 {
 245     constructData.native.function = constructJSWebAssemblyInstance;
 246     return ConstructType::Host;
 247 }
 248
 249 CallType WebAssemblyInstanceConstructor::getCallData(JSCell*, CallData& callData)
 250 {
 251     callData.native.function = callJSWebAssemblyInstance;
 252     return CallType::Host;
 253 }
 254
 255 void WebAssemblyInstanceConstructor::visitChildren(JSCell* cell, SlotVisitor& visitor)
 256 {
 257     auto* thisObject = jsCast<WebAssemblyInstanceConstructor*>(cell);
 258     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
 259     Base::visitChildren(thisObject, visitor);
 260 }
 261
 262 } // namespace JSC
 263
 264 #endif // ENABLE(WEBASSEMBLY)
 265