Skip to content

Latest commit

 

History

History
625 lines (383 loc) · 41 KB

JS.md

File metadata and controls

625 lines (383 loc) · 41 KB

JavaScript API

在中MVP，在 Web 上访问 WebAssembly 的唯一方法是通过下面定义的显式 JS API.（在 Future:unicorn: 中，WebAssembly 也可以作为的ES6 模块集成一部分直接从 HTML <script type='module'> 标记（以及通过 URL 加载 ES6 模块的任何其他 Web API）加载和运行。）

可以找到here用于 TypeScript 的 WebAssembly JS API 声明文件，该文件支持自动完成并使 TypeScript 编译器满意。

陷阱

只要 WebAssembly 语义指定了trap，就会抛出一个 WebAssembly.RuntimeError 对象。WebAssembly 代码（目前）无法捕获此异常，因此该异常必然会传播到封闭的非 WebAssembly 调用方（浏览器或 JavaScript），在那里它会像普通的 JavaScript 异常一样被处理。

如果 WebAssembly 通过导入调用 JavaScript，并且 JavaScript 抛出异常，则该异常将通过 WebAssembly 激活传播到封闭调用方。

由于可以处理 JavaScript 异常，并且 JavaScript 可以在处理陷阱后继续调用 WebAssembly 导出，因此陷阱通常不会阻止将来的执行。

堆栈溢出

每当堆栈溢出WebAssembly 代码中发生异常时，都会抛出与 JavaScript 中的堆栈溢出相同的异常。

WebAssembly 对象

WebAssembly 对象是全局对象的 WebAssembly 属性的初始值。 Math 与和 JSON 对象一样，该 WebAssembly 对象是一个普通的 JS 对象（不是构造函数或函数），其作用类似于命名空间，并具有以下属性：

WebAssembly [ @@toStringTag] 财产。

[ @@toStringTag]（https：//tc39.github.io/ecma262/#sec-well-known-symbols）属性的初始值是字符串值 "WebAssembly"。

此属性具有属性 {[[Writable]： false，[[Enumerable]： false，[[Configurable]： true}。

对象的 WebAssembly 构造函数属性

添加了以下内部对象：

  • WebAssembly.Module：[ WebAssembly.Module 构造函数]（#WebAssemblyModule-Constructor）
  • WebAssembly.Instance：[ WebAssembly.Instance 构造函数]（#WebAssemblyInstance-constructor）
  • WebAssembly.Memory：[ WebAssembly.Memory 构造函数]（#WebAssemblyMemory-Constructor）
  • WebAssembly.Table：[ WebAssembly.Table 构造函数]（#WebAssemblyTable-Constructor）
  • WebAssembly.CompileError：A本地错误 它指示 WebAssembly 解码或验证过程中的错误
  • WebAssembly.LinkError：A本地错误 它指示 WebAssembly 实例化模块期间的错误（而不是来自 start 函数的陷阱）
  • WebAssembly.RuntimeError：A本地错误 每当 WebAssembly 指定trap时就会抛出。

对象的 WebAssembly 函数属性

WebAssembly.Validate

validate 函数的签名为：

Boolean validate(BufferSource bytes)

如果给定 bytes 的参数不是 [ BufferSource]（https：//heycam.github.io/webidl/#common-buffersource），则 TypeError 引发。

否则，此函数将按照定义WebAssembly 规范执行验证， true 如果验证成功 false，则返回；如果验证失败，则返回。

WebAssembly.Compile

compile 函数的签名为：

Promise<WebAssembly.Module> compile(BufferSource bytes)

如果给定 bytes 的参数不是 [ BufferSource]（https：//heycam.github.io/webidl/#common-buffersource），则返回的 Promise 值rejected带有 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

否则，此函数将启动一个异步任务来编译 WebAssembly.Module，如 [ WebAssembly.Module constructor]（#WebAssemblyModule-Constructor）中所述。成功时，将 Promise fulfilled与结果 WebAssembly.Module 对象一起使用。失败时， Promise rejected带有 WebAssembly.CompileError。

的调用 compile 期间捕获的给定 BufferSource 的状态的副本上逻辑地执行异步编译。返回后 compile 的 BufferSource 后续突变不会影响正在进行的编译。

在 Future:unicorn: 中，此函数可以扩展为接受 Astream，从而实现异步、后台、流式编译。

WebAssembly.Instantiate

该 instantiate 函数根据其参数的类型进行重载。如果以下两个重载都不匹配，则返回 Promise rejected带有 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）的。

dictionary WebAssemblyInstantiatedSource {
   required WebAssembly.Module module;
   required WebAssembly.Instance instance;
};

Promise<WebAssemblyInstantiatedSource>
  instantiate(BufferSource bytes [, importObject])

如果给定 bytes 的参数不是 [ BufferSource]（https：//heycam.github.io/webidl/#common-buffersource），则返回的 Promise 值rejected带有 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

此函数启动一个异步任务，该任务首先 bytes 按照 [ WebAssembly.Module Constructor]（#WebAssemblyModule-Constructor）中的说明编译 WebAssembly.Module，然后按照 [ WebAssembly.Instance Constructor]（#WebAssemblyInstance-Constructor）中的说明对任务进行排队以实例化结果 Module importObject。在实例化任务运行之后并且在采取任何后续步骤之前，可以运行其他未指定的异步任务。如果成功，则 Promise fulfilled具有包含结果 WebAssembly.Module 和 WebAssembly.Instance 的纯 JavaScript 对象对 {module, instance}。返回对的 2 个属性 module 和 instance 是可配置的、可枚举的和可写的。

失败 Promise 时，根据失败的原因，rejected带有 WebAssembly.CompileError、 WebAssembly.LinkError 或 WebAssembly.RuntimeError。

异步编译在逻辑上是对调用 instantiate 期间捕获的给定 BufferSource 状态的副本执行的。返回后 instantiate 的 BufferSource 后续突变不会影响正在进行的编译。

Promise<WebAssembly.Instance> instantiate(moduleObject [, importObject])

如果第一个参数是 WebAssembly.Module 实例，则此描述适用。

此函数异步排队实例化 WebAssembly.Instance from moduleObject 和 importObject 的任务，如 [ WebAssembly.Instance Constructor]（#WebAssemblyInstance-Constructor）中所述。在实例化任务运行之后并且在采取任何后续步骤之前，可以运行其他未指定的异步任务。成功时，将 Promise fulfilled与结果 WebAssembly.Instance 对象一起使用。失败 Promise 时，根据失败的原因，rejected带有 WebAssembly.CompileError、 WebAssembly.LinkError 或 WebAssembly.RuntimeError。

WebAssembly.Module 对象

WebAssembly.Module 对象表示编译 WebAssembly 二进制格式模块的无状态结果，并包含一个内部槽：

  • [[Module]]：[ Ast.module]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/ast.ml#l176）是模块的规范定义。

WebAssembly.Module 构造函数

WebAssembly.Module 构造函数的签名为：

new Module(BufferSource bytes)

如果 newTarget 是 undefined，则抛出 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）异常（即，如果没有 new，则无法将此构造函数作为函数调用）。

如果给定 bytes 的参数不是 [ BufferSource]（https：//heycam.github.io/webidl/#common-buffersource），则会引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）异常。

否则，此函数将执行以下 BufferSource 内容的同步编译：

  1. 由 BufferSource 限定的字节范围首先根据二进制编码.MD进行逻辑解码，然后根据中规范/有效.ml的规则进行验证。
  2. 如中Web.md所述，内部 Ast.module 的等级值 string 被解码为 UTF8。
  3. 成功时，将返回一个新 WebAssembly.Module 对象，并将 [[Module]] 设置为 Validated Ast.module。
  4. 失败时，将抛出一个新 WebAssembly.CompileError 的。

WebAssembly.Module.prototype [ @@toStringTag] 财产。

[ @@toStringTag]（https：//tc39.github.io/ecma262/#sec-well-known-symbols）属性的初始值是字符串值 "WebAssembly.Module"。

此属性具有属性 {[[Writable]： false，[[Enumerable]： false，[[Configurable]： true}。

WebAssembly.Module.Exports

exports 函数的签名为：

Array exports(moduleObject)

如果 moduleObject 不 WebAssembly.Module 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

每次调用此函数时，它都会返回一个 new Array。通过将 [ModuleObject.[[Module]].Exports]（HTTPS：/github.com/webassembly/spec/blob/master/interpreter/spec/AST.ml#L187）的每个 [ Ast.export]（HTTPS：/github.com/webassembly/spec/blob/master/interpreter/specification/AST.ml#L152） e 映射到对象 { name: String(e.name), kind: e.ekind} 来生成每个这样 Array 的字符串，其中 e.name 是解码为 UTF8和 e.ekind 映射到其中一个字符串值 "function"、 "table"、 "memory"、 "global"。

注意：将来可能会添加类似 signature 的其他字段。

返回 Array 的填充顺序与导出在 WebAssembly 二进制文件的导出表中出现的顺序相同。

WebAssembly.Module.Imports

imports 函数的签名为：

Array imports(moduleObject)

如果 moduleObject 不 WebAssembly.Module 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

每次调用此函数时，它都会返回一个 new Array。通过将 [ModuleObject.[[Module]].Imports]（HTTPS：/github.com/WebAssembly/Spec/Blob/Master/Interpreter/Spec/AST.ml#L203）的每个 [ Ast.import]（HTTPS：/github.com/WebAssembly/Specs/Blob/Master/Interpreter/Specs/AST.ml#L167） i 映射到对象来生成每个这样的 Array 对象 { module: String(i.module_name), name: String(i.item_name), kind: i.ikind}，其中 i.module_name i.item_name 解码为 UTF8和 i.ikind 映射到其中一个字符串值 "function"、 "table"、 "memory"、 "global"。

注意：将来可能会添加类似 signature 的其他字段。

返回 Array 的填充顺序与导入在 WebAssembly 二进制文件的导入表中出现的顺序相同。

WebAssembly.Module.CustomSections

customSections 函数的签名为：

Array customSections(moduleObject, sectionName)

如果 moduleObject 不 WebAssembly.Module 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

设 sectionNameString 为 [ ToString]（https：//tc39.github.io/ecma262/#sec-tostring）（ sectionName）的结果。

每次调用此函数时，它都会返回一个 new Array。通过将字段（解码为 UTF-8）等于 sectionNameString 的每个自定义部分部分（即，具有 id 0 的部分） name 映射到 ArrayBuffer 包含该部分 payload_data 的副本，来产生每个这样 Array 的部分。（注： payload_data 不包括 name 或 name_len。）

Array 填充的顺序与 WebAssembly 二进制文件中自定义部分出现的顺序相同。

A WebAssembly.Module 的结构化克隆

A WebAssembly.Module 是 A可克隆对象，这意味着它可以在 Windows/Workers 之间克隆，也可以存储/检索到/从IDBObjectStore。结构化克隆的语义就像编译的 WebAssembly.Module 二进制源代码被克隆并重新编译到目标领域中一样。在执行结构化克隆时，引擎应尝试共享/重用内部编译代码，但在 CPU 升级或浏览器更新等特殊情况下，这可能无法实现，并且可能需要完全重新编译。

考虑到上述引擎优化，结构化克隆为开发人员提供了对编译代码缓存和跨窗口/工作者代码共享的显式控制。

WebAssembly.Instance 对象

WebAssembly.Instance 对象表示从的 WebAssembly.Module 实例化到的realm实例化，并且具有一个内部插槽：

  • [[instance]]：[ Instance.instance]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/instance.ml#l17），是实例的 WebAssembly 规范定义
  • [[Exports]]：在实例化过程中创建的 Exports 对象

WebAssembly.Instance 构造函数

WebAssembly.Instance 构造函数的签名为：

new Instance(moduleObject [, importObject])

如果 newTarget 是 undefined，则抛出 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）异常（即，如果没有 new，则无法将此构造函数作为函数调用）。

如果 moduleObject 不 WebAssembly.Module 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

设 module 为 [ Ast.module]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/ast.ml#l176） moduleObject.[[Module]]。

如果 importObject 参数不 undefined 是并且 Type(importObject) 不是对象，则抛出 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。如果 [ module.imports]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/ast.ml#l186）的列表不为空且 Type(importObject) 不是对象，则抛出 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

注意：在下面的算法中，导入的 JavaScript 函数被包装为主机功能值。出于算法的目的，新的主机功能值始终是新生成的，并且被认为与任何其他先前创建的宿主函数值（包括包装相同 JavaScript 函数对象的那些值）不同。因此，当且仅当满足以下条件时，才认为两个closure值相等：

  • 要么它们都是同一实例的 WebAssembly 函数，并引用相同的函数定义。
  • 或者它们是相同的主机函数值。

设 funcs、 memories 和 tables 分别为可调用 JavaScript 对象、 WebAssembly.Memory 对象和 WebAssembly.Table 对象的初始空列表。

设 imports 为 [ external]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/instance.ml#l11）值的初始空列表。

对于每个 [ import]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/ast.ml#l168） i module.imports：

  1. 设 o 为执行 [ Get]（http：//tc39.github.io/ecma262/#sec-get-o-p）（ importObject，[ i.module_name]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/ast.ml#l170））的结果值。
  2. 如果 Type(o) 不是对象，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。
  3. 设 v 为执行 [ Get]（http：//tc39.github.io/ecma262/#sec-get-o-p）（ o，[ i.item_name]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/ast.ml#l171））的值
  4. 如果 i 是函数导入：
    1. 如果 [ IsCallable(v)]（https：//tc39.github.io/ecma262/#sec-iscallable）为 false，则引发 WebAssembly.LinkError。
    2. 如果 v 是导出函数外来对象：
      1. （的 v.[[Closure]] 签名由 Eval.init 以下人员根据进口申报的 [ func_type]（https：//github.com/webassembly/design/blob/master/binaryencoding.md#func_type）进行核对。）
      2. 让我们 closure v.[[Closure]]。
    3. 否则：
      1. 设 closure 为给定签名的新主机功能值和以下行为：
      2. 如果签名包含 i64（作为参数或结果），则调用宿主函数时会立即引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。
      3. 否则，宿主函数将通过 [ ToJSValue]（#toJSValue）使用 undefined 强制为 JavaScript 参数的接收器和 WebAssembly 参数进行调用 v。通过 [ ToWebAssemblyValue]（#ToWebAssemblyValue）强制返回结果。
    4. 附加 v 到 funcs。
    5. 附加 closure 到 imports。
  5. 如果 i 是全局导入：
    1. Assert：通过 MVP 验证约束，全局是不可变的。
    2. 如果 global_type of i 是 i64 或 Type(v) 不是数字，则抛出 WebAssembly.LinkError。
    3. 将 [ ToWebAssemblyValue]（#ToWebAssemblyValue） (v) 附加到 imports。
  6. 如果 i 是内存导入：
    1. 如果 v 不是 [ WebAssembly.Memory Object]（#WebAssemblyMemory-Objects），则抛出 WebAssembly.LinkError。
    2. （导入 Memory 的 length 和 maximum 属性将通过 Eval.init 以下方式对照导入声明的 [ memory_type]（https：//github.com/webassembly/design/blob/master/binaryencoding.md#memory_type）进行检查。
    3. 附加 v 到 memories。
    4. 附加 v.[[Memory]] 到 imports。
  7. 否则（ i 是表导入）：
    1. 如果 v 不是 [ WebAssembly.Table Object]（#WebAssemblyTable-Objects），则抛出 WebAssembly.LinkError。
    2. （导入 Table 的 length、 maximum 和 element 属性将根据导入的声明 [ table_type]（https：//github.com/webassembly/design/blob/master/binaryencoding.md#table_type） Eval.init 进行检查。）
    3. 附加 v 到 tables。
    4. 附加 v.[[Table]] 到 imports。
    5. 对于以下各项 i 的 v.[[Table]] 每个指数：
      1. 设 e 为 i 的元素 v.[[Table]]。
    6. 如果 e 是 [ closure]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/instance.ml#l7） c：
      1. 将的 i v.[[Values]] 第个元素附加到 funcs。

假设 instance 是通过调用 [ Eval.init]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/eval.ml#l416）Given module 和 imports 创建新 [ instance]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/instance.ml#l17）的结果。如果这以 Link 错误终止，则抛出 WebAssembly.LinkError。如果它导致一个陷阱，抛出一个 WebAssembly.RuntimeError；所有其他异常都将传播到调用方。其中，此函数执行以下可观察的步骤：

  • 如果在计算每个Data和Element段的 offset 初始化表达式之后，有任何段不适合它们各自的内存或表，则抛出 WebAssembly.LinkError。

  • 将所有数据和元素段按照它们在模块中出现的顺序应用到它们各自的内存或表中。段可能会重叠，如果重叠，则最终值是按顺序写入的最后一个值。注意：应该不存在可能导致此操作中途失败的错误。此操作完成后，即使 start 失败，也可以通过导入的表查看和调用的 instance 元素。

  • 如果存在 [ start]（modules.MD#module-start-function），则对其求值。引发的 start 任何错误都会传播到调用方。

_以前_该 start 函数执行以下步骤：

  1. 对于 [ instance.tables] 中的每个表' T '（https：//github.com/webassembly/spec/blob/master/interpreter/spec/instance.ml#l17）：
    1. 如果其中 tables table.[[Table]] 没有元素，则为 t：
      1. 设 table 为一个新 WebAssembly.Table 对象，[[Table] 设置为 t，[[Values] 设置为一个相同长度的新列表，其所有条目都是 null。
      2. 附加 table 到 tables。
    2. 否则：
      1. 设 table 是其中 tables table.[[Table]] 的元素是 t
    3. （注意：最多为任何表创建一个 WebAssembly.Table 对象，因此即使列表中有多个实例，上述 table 对象也是唯一的。此外，如果项目是导入，则会找到原始对象。）
    4. 对于以下各项 i 的 t 每个指数：
      1. 设 c 为 i 的 t 第个元素
      2. 如果 c 是 [ closure]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/instance.ml#l7） c：
        1. 如果在 funcs 导出函数外来对象其 [[Closure]] 等号 c 中有：
          1. 设 func 为函数对象。
        2. （注意：最多为任何闭包创建一个包装器，因此 func 是唯一确定的。此外，如果项是已经导出函数外来对象是的导入，则将找到原始函数对象。对于常规 JS 函数的导入，将创建一个新的包装器。）
        3. 否则：
          1. 设 func 为导出函数外来对象创建自 c。
          2. 附加 func 到 funcs。
        4. 将的 i table.[[Values]] 第个元素设置为 func。

（注意：通过上述步骤创建的表和元素函数对象仅适用于导入或导出的表。）

设 exports 为从中的 instance.exports 每个external值 e 映射的（字符串，JS 值）对的列表，如下所示：

  1. 如果 e 是 Aclosure c：
    1. 如果在其 func.[[Closure]] 等号 c 中有一个导出函数外来对象 func funcs，则返回 func。
    2. （注意：最多为任何闭包创建一个包装器，因此 func 是唯一的，即使列表中有多个实例。此外，如果项是已经导出函数外来对象是的导入，则将找到原始函数对象。对于常规 JS 函数的导入，将创建一个新的包装器。）
    3. 否则：
      1. 设 func 为导出函数外来对象创建自 c。
      2. 附加 func 到 funcs。
      3. 返回 func。
  2. 如果 e 是 Aglobal v：
    1. Assert：通过 MVP 验证约束，全局是不可变的。
    2. 如果 v 是一个 i64，则抛出一个 WebAssembly.LinkError。
    3. 返回 [ ToJSValue]（#toJSVALUE） (v)。
  3. 如果 e 是 Amemory m：
    1. 如果其中 memories memory.[[Memory]] 有一个元素 memory m，则返回 memory。
    2. （注意：最多为任何内存创建一个 WebAssembly.Memory 对象，因此即使列表中有多个事件，上述 memory 内容也是唯一的。此外，如果项目是导入，则会找到原始对象。）
    3. 否则：
      1. 设 memory 为通过 [ CreateMemoryObject]（#createMemoryObject） m 创建的新 WebAssembly.Memory 对象。
      2. 附加 memory 到 memories。
      3. 返回 memory。
  4. 否则 e 必须为table t：
    1. 断言：其中 tables table.[[Table]] 有一个元素 table 是 t。
    2. 把 table 那个还回去。

假设 exportsObject 是一个新frozen的普通 JS 对象，[[prototype]] 设置为 null，并通过将每个导出 exports 映射到一个可枚举、不可写、不可配置的数据属性来定义属性。注意：在期间模块验证执行的有效性和唯一性检查确保每个属性名称都是有效的，并且没有属性被定义两次。

设 instanceObject 为新 WebAssembly.Instance 对象，将内部 [[Instance]] 插槽设置为 instance，将 [[Exports]] 插槽设置为 exportsObject。

返回 instanceObject。

WebAssembly.Instance.prototype [ @@toStringTag] 财产。

[ @@toStringTag]（https：//tc39.github.io/ecma262/#sec-well-known-symbols）属性的初始值是字符串值 "WebAssembly.Instance"。

此属性具有属性 {[[Writable]： false，[[Enumerable]： false，[[Configurable]： true}。

WebAssembly.Instance.prototype.exports 性质

这是一个访问器属性，其 [[set] 未定义，其 [[get] 访问器函数执行以下步骤：

设 T 为 this 值。如果 T 不 WebAssembly.Instance 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

返回 T.[[Exports]]。

导出函数外来对象

一个来自 An Instance inst 的函数功能索引 index 通过一种新的导出函数奇异的物体反射到 JS.与有界函数外来对象一样，导出的函数不具有正常的函数内部插槽，而是具有：

  • [[闭包]]：closure（ index， inst）

以及所有内置功能所需的内部插槽：

  • [[原型]]：% 函数原型 %
  • [[可扩展]]： true
  • [[领域]]：当前领域记录
  • [[ScriptorModule]]：[ GetActiveScriptOrModule]（http：//tc39.github.io/ecma262/#sec-getactivescriptormodule）

导出的函数还具有以下数据属性：

  • 该 length 属性设置为导出函数的签名的 arity
  • name 已设置为 [ ToString]（https：//tc39.github.io/ecma262/#sec-tostring）（ index）

WebAssembly 导出函数的 [[Call]](this, argValues) 方法定义为：

  1. 设 sig 为函数 [[闭包]] 的 [ function type]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/eval.ml#l106）。
  2. 如果 sig 包含 i64（作为参数或结果），则每次调用 [[Call]] 方法时都会引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。
  3. 设 args 为强制值的空列表。
  4. 设 inArity 为参数的数量， outArity 为中 sig 结果的数量。
  5. 对于中的 argValues 所有值 v，按其出现顺序：
  6. 如果的 args 长度小于 inArity，则将 [ ToWebAssemblyValue]（#ToWebAssemblyValue） (v) 附加到 args。
  7. 当的 args 长度小于 inArity 时，将 [ ToWebAssemblyValue]（#ToWebAssemblyValue） (undefined) 附加到 args。
  8. 假设 ret 是调用 [ Eval.invoke]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/eval.ml#l443）传递 [[closure]] 的结果，并且 args。
  9. 如果 outArity 为 0，则返回 undefined。
  10. 否则，返回 [ ToJSValue]（#toJSValue） (v)，其中 v 是的 ret 单数元素。

在被调用方导出函数的 [领域] 中 [[Call]](this, argValues) 执行。这对应于JavaScript 中内置函数对象的要求。

导出的函数没有 [[Construct]] 方法，因此无法使用 new 运算符调用。

WebAssembly.Memory 对象

一个 WebAssembly.Memory 对象包含一个线性存储器可以同时被多个 Instance 对象引用的。每个 Memory 对象都有两个内部插槽：

  • [[内存]]：A[ Memory.memory]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/memory.mli）
  • BufferObject：其 [[ArrayBufferByteLength] 与 [[Memory] 的当前字节长度匹配的当前对象 ArrayBuffer

WebAssembly.Memory 构造函数

WebAssembly.Memory 构造函数的签名为：

new Memory(memoryDescriptor)

如果 newTarget 是 undefined，则抛出 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）异常（即，如果没有 new，则无法将此构造函数作为函数调用）。

如果 Type(memoryDescriptor) 不是对象，则抛出 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

设 initial 为 [ ToNonWrappingUint32]（#ToNonWrappingGuint32）（ [ Get]（http：//tc39.github.io/ecma262/#sec-get-o-p）（ memoryDescriptor， "initial"））。

如果 [ HasProperty]（http：//tc39.github.io/ecma262/#sec-hasproperty）（ "maximum"），则设 maximum 为 [ ToNonWrappingUint32]（#ToNonWrappingGuint32）（ [ Get]（http：//tc39.github.io/ecma262/#sec-get-o-p）（ memoryDescriptor， "maximum"））。如果 maximum 小于 initial，则引发 [ RangeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-rangeerror）。否则，让 maximum 是 None。

设 memory 为调用 [ Memory.create]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/memory.ml#l68）给定参数 initial 和 maximum 的结果。请注意， initial 和 maximum 是以 WebAssembly 页面（64KiB）为单位指定的。

返回 [ CreateMemoryObject]（#createMemoryObject）（ memory）的结果。

CreateMoryObject

给定 [ Memory.memory]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/memory.mli#l1） m，要创建 WebAssembly.Memory：

设 buffer 为新 ArrayBuffer 的，其 [[[ArrayBufferData]（http：//tc39.github.io/ecma262/#sec-properties-of-the-arraybuffer-prototype-object）别名 m 和其 [[[ArrayBufferByteLength]（http：//tc39.github.io/ecma262/#sec-properties-of-the-arraybuffer-prototype-object）设置为字节长度 m。

任何对 [ detach]（http：//tc39.github.io/ecma262/#sec-detacharraybuffer） buffer 其他的的尝试，而不是 [ m.grow]（#WebAssemblyMemoryPrototypeGrow）执行的分离，都将引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）

返回一个新 WebAssembly.Memory 实例，[[Memory] 设置为 m，[[BufferObject] 设置为 buffer。

WebAssembly.Memory.prototype [ @@toStringTag] 财产。

[ @@toStringTag]（https：//tc39.github.io/ecma262/#sec-well-known-symbols）属性的初始值是字符串值 "WebAssembly.Memory"。

此属性具有属性 {[[Writable]： false，[[Enumerable]： false，[[Configurable]： true}。

webassembly.memory.prototype.grow

该 grow 方法的签名为：

grow(delta)

设 M 为 this 值。如果 M 不 WebAssembly.Memory 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

设 d 为 [ ToNonWrappingUint32]（#tonOnWrappingGuint32）（ delta）。

设 ret 为页面中内存的当前大小（在调整大小之前）。

使用增量 d 执行 [ Memory.grow]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/memory.mli#l27）。失败时，将抛出 [ RangeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-rangeerror）。

执行 [ DetachArrayBuffer]（http：//tc39.github.io/ecma262/#sec-detacharraybuffer）（ M.[[BufferObject]]）。

赋值给 M.[[BufferObject]] 其 [[[ArrayBufferData]（http：//tc39.github.io/ecma262/#sec-properties-of-the-arraybuffer-prototype-object）别名 M.[[Memory]] 和其 [[[ArrayBufferByteLength]（http：//tc39.github.io/ecma262/#sec-properties-of-the-arraybuffer-prototype-object）设置为新字节长度的 M.[[Memory]] 新 ArrayBuffer。

以数值形式返回 ret。

WebAssembly.Memory.Prototype.Buffer

这是一个访问器属性，其 [[set] 未定义，其 [[get] 访问器函数执行以下步骤：

如果 this 不 WebAssembly.Memory 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。否则返回 M.[[BufferObject]]。

WebAssembly.Table 对象

一个 WebAssembly.Table 对象包含一个table可以同时被多个 Instance 对象引用的。每个 Table 对象都有两个内部插槽：

  • [[表格]]：A[ Table.table]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/table.mli#l1）
  • [[values]]：一个数组，其元素为 null 或导出函数外来对象

WebAssembly.Table 构造函数

WebAssembly.Table 构造函数的签名为：

new Table(tableDescriptor)

如果 newTarget 是 undefined，则抛出 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）异常（即，如果没有 new，则无法将此构造函数作为函数调用）。

如果 Type(tableDescriptor) 不是对象，则抛出 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

设 element 为调用 [ Get]（http：//tc39.github.io/ecma262/#sec-get-o-p）（ tableDescriptor， "element"）的结果。如果 element 不是字符串 "anyfunc"，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。（注意：此检查在 Future:unicorn: 中将被放宽，以允许不同的元素类型。）

设 initial 为 [ ToNonWrappingUint32]（#ToNonWrappingGuint32）（ [ Get]（http：//tc39.github.io/ecma262/#sec-get-o-p）（ tableDescriptor， "initial"））。

如果 [ HasProperty]（http：//tc39.github.io/ecma262/#sec-hasproperty）（ "maximum"），则设 maximum 为 [ ToNonWrappingUint32]（#ToNonWrappingGuint32）（ [ Get]（http：//tc39.github.io/ecma262/#sec-get-o-p）（ tableDescriptor， "maximum"））。否则，设 maximum 为无。

如果 maximum 不是 None 且小于 initial，则引发 [ RangeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-rangeerror）。

设 table 为调用 [ Table.create]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/table.ml#l68）给定参数 AnyFuncType 的结果， initial 且 maximum。

设 values 为一个新的 initial 空元素数组，所有元素都有值 null。

返回一个新 WebAssemby.Table 实例，[[表] 设置为 table，[[值] 设置为 values。

webassembly.table.prototype.length

这是一个访问器属性，其 [[set] 未定义，其 [[get] 访问器函数执行以下步骤：

设 T 为 this 值。如果 T 不 WebAssembly.Table 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

返回 T.[[Values]].length。

webassembly.table.prototype.grow

该 grow 方法的签名为：

grow(delta)

设 T 为 this 值。如果 T 不 WebAssembly.Table 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

设 d 为 [ ToNonWrappingUint32]（#tonOnWrappingGuint32）（ delta）。

设 ret 为表的当前长度（调整大小之前）。

执行 [ Table.grow]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/table.ml#l40），使用 delta d。失败时，将抛出 [ RangeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-rangeerror）。

以数值形式返回 ret。

webassembly.table.prototype.get

此方法具有以下签名

get(index)

设 T 为 this 值。如果 T 不 WebAssembly.Table 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

设 i 为 [ ToNonWrappingUint32]（#ToNonWrappingGuint32）（ index）的结果。

如果 i 大于或等于的 T.[[Values]] 长度，则引发 [ RangeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-rangeerror）。

返回 T.[[Values]][i]。

webassembly.table.prototype.set

此方法具有以下签名

set(index, value)

设 T 为 this 值。如果 T 不 WebAssembly.Table 是，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

如果 value 不是导出函数外来对象或 null，则引发 [ TypeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-typeerror）。

设 i 为 [ ToNonWrappingUint32]（#ToNonWrappingGuint32）（ index）的结果。

如果 i 大于或等于的 T.[[Values]] 长度，则引发 [ RangeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-rangeerror）。

如果 value 是 null，就让 elem 是 Uninitialized；否则，让 elem 是 value.[[Closure]]。

设置 T.[[Table]][i] 为 elem。

设置 T.[[Values]][i] 为 value。

返回 undefined。

WebAssembly.Table.prototype [ @@toStringTag] 财产。

[ @@toStringTag]（https：//tc39.github.io/ecma262/#sec-well-known-symbols）属性的初始值是字符串值 "WebAssembly.Table"。

此属性具有属性 {[[Writable]： false，[[Enumerable]： false，[[Configurable]： true}。

到 JS 值

将 WebAssembly[ value]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/values.ml#l9）强制为 JavaScript 值：

断言：WebAssembly 值的类型不 i64 是。

  1. 给定 WebAssembly i32 被解释为有符号整数，转换（无损）为 IEEE754 加倍，然后作为 JavaScript 号返回
  2. 给定 WebAssembly f32（单精度 IEEE754），将其（无损）转换为 IEEE754 双精度，可能规范化 Nan并作为 JavaScript 数字返回
  3. 给定一个 WebAssembly f64，可能规范化 Nan并作为 JavaScript 编号返回

如果 WebAssembly 值是可选的，则给定 None，返回 JavaScript 值 undefined。

ToWebAssemblyValue

要将 JavaScript 值强制为给定的 WebAssembly[ value type]（https：//github.com/webassembly/spec/blob/master/interpreter/spec/types.ml#l3），

断言：目标值类型不 i64 是。

  1. 通过 [ ToInt32(v)] 强制到 i32（http：//tc39.github.io/ecma262/#sec-toint32）
  2. 强制为 f32，首先应用 [ ToNumber(v)]（http：//tc39.github.io/ecma262/#sec-tonumber），然后使用 roundTiesToEven
  3. 通过 [ ToNumber(v)] 强制到 f64（http：//tc39.github.io/ecma262/#sec-tonumber）

如果值类型是可选的，则给定 None，忽略 JavaScript 值。

TononwrappingUINT32

要将 JavaScript 值 v 转换为 [0 UINT32_MAX，] 范围内的无符号整数，请执行以下操作：

设 i 为 [ ToInteger]（http：//tc39.github.io/ecma262/#sec-tointeger）（ v）。

如果 i 为负数或大于 UINT32_MAX，则引发 [ RangeError]（https：//tc39.github.io/ecma262/#sec-native-error-types-used-in-this-standard-rangeerror）。

返回 i。

API 使用示例

给定 demo.was（编码为 demo.wasm）：

(module
    (import "js" "import1" (func $i1))
    (import "js" "import2" (func $i2))
    (func $main (call $i1))
    (start $main)
    (func (export "f") (call $i2))
)

和以下 JavaScript，在浏览器中运行：

var importObj = {js: {
    import1: () => console.log("hello,"),
    import2: () => console.log("world!")
}};
fetch('demo.wasm').then(response =>
    response.arrayBuffer()
).then(buffer =>
    WebAssembly.instantiate(buffer, importObj)
).then(({module, instance}) =>
    instance.exports.f()
);