WebAssembly 核心规范

1. 简介

1.1. 简介

WebAssembly（缩写为 Wasm [1]）是一种为高效执行和紧凑表示而设计的安全、可移植、低级代码格式。它的主要目标是在 Web 上启用高性能应用程序，但它不做出任何特定于 Web 的假设或提供特定于 Web 的功能，因此它也可以在其他环境中使用。

WebAssembly 是一种由 W3C 社区小组开发的开放标准。

本文档描述了 WebAssembly 核心标准的 2.0 版（2024-09-13 草案）。它旨在被未来的增量版本取代，这些版本将包含更多新功能。

1.1.1. 设计目标

WebAssembly 的设计目标如下

快速、安全、可移植的语义
- 快速：以接近原生代码的性能执行，利用所有当代硬件通用的功能。
- 安全：代码在内存安全的 [2]、沙盒环境中执行，以防止数据损坏或安全漏洞。
- 定义明确：以易于非正式和正式推理的方式完整准确地定义有效程序及其行为。
- 硬件无关：可以在所有现代架构上编译，包括台式机或移动设备和嵌入式系统。
- 语言无关：不偏袒任何特定语言、编程模型或对象模型。
- 平台无关：可以嵌入到浏览器中，作为独立的 VM 运行，或集成到其他环境中。
- 开放：程序可以通过简单通用的方式与其环境进行交互。
高效、可移植的表示
- 紧凑：具有二进制格式，该格式速度快，因为比典型的文本或原生代码格式更小。
- 模块化：程序可以分成更小的部分，这些部分可以分别传输、缓存和使用。
- 高效：可以在快速单次传递中进行解码、验证和编译，无论是即时 (JIT) 还是提前 (AOT) 编译。
- 可流式传输：允许在看到所有数据之前尽早开始解码、验证和编译。
- 可并行化：允许将解码、验证和编译分成许多独立的并行任务。
- 可移植：不做出现代硬件普遍支持的架构假设。

WebAssembly 代码还旨在易于检查和调试，尤其是在像 Web 浏览器这样的环境中，但这些功能超出了本规范的范围。

1.1.2. 范围

本质上，WebAssembly 是一种虚拟指令集架构（虚拟 ISA）。因此，它有许多用例，可以嵌入到许多不同的环境中。为了涵盖它们的各种用途并实现最大程度的重复使用，WebAssembly 规范被分成多个文档并分层。

本文档关注 WebAssembly 的核心 ISA 层。它定义了指令集、二进制编码、验证和执行语义，以及文本表示。但是，它没有定义 WebAssembly 程序如何与其执行的特定环境交互，也没有定义如何从这样的环境中调用它们。

相反，本规范由其他文档补充，这些文档定义了与特定嵌入环境（例如 Web）的接口。这些将分别定义适合给定环境的 WebAssembly 应用程序编程接口（API）。

1.1.3. 安全注意事项

WebAssembly 并没有提供访问代码执行环境的任何环境访问权限。任何与环境的交互，例如 I/O、访问资源或操作系统调用，只能通过调用由嵌入器提供并导入到 WebAssembly 模块的函数来执行。嵌入器可以通过控制或限制其提供导入的函数功能来建立适合相应环境的安全策略。这些考虑因素是嵌入器的责任，也是特定环境 API 定义的主题。

由于 WebAssembly 旨在被翻译成直接在主机硬件上运行的机器代码，因此它可能容易受到硬件级别侧信道攻击。在存在此问题的环境中，嵌入器可能需要采取适当的缓解措施来隔离 WebAssembly 计算。

1.1.4. 依赖项

WebAssembly 依赖于两个现有标准

[IEEE-754-2019]，用于表示浮点数据和相应数值运算的语义。
[UNICODE]，用于表示导入/导出名称和文本格式。

但是，为了使本规范自包含，上述标准的相关方面在本规范中定义并形式化，例如二进制表示和舍入浮点值，以及值范围和 UTF-8 编码 Unicode 字符。

注意

上述标准是所有相应定义的权威来源。本规范中给出的形式化旨在与这些定义相匹配。描述的语法或语义中存在的任何差异应视为错误。

1.2. 概述

1.2.1. 概念

WebAssembly 编码了一种低级、类似汇编的编程语言。这种语言围绕以下概念构建。

值

WebAssembly 只提供四种基本数字类型。这些是整数和 [IEEE-754-2019] 数字，每种类型都具有 32 位和 64 位宽度。32 位整数也用作布尔值和内存地址。这些类型上的常见运算可用，包括它们之间所有转换的完整矩阵。没有区分有符号和无符号整数类型。相反，整数由各自的运算解释为二进制补码表示中的无符号或有符号。

除了这些基本数字类型之外，还有一个单一的 128 位宽向量类型，表示不同类型的打包数据。支持的表示形式是 4 个 32 位或 2 个 64 位 [IEEE-754-2019] 数字，或不同宽度的打包整数值，特别是 2 个 64 位整数、4 个 32 位整数、8 个 16 位整数或 16 个 8 位整数。

最后，值可以由表示指向不同类型实体的指针的不透明引用组成。与其他类型不同，它们的大小或表示形式不可观察。

指令: WebAssembly 的计算模型基于堆栈机。代码由按顺序执行的指令序列组成。指令操作隐式操作数堆栈 [1] 上的值，并分为两大类。简单指令对数据执行基本操作。它们从操作数堆栈中弹出参数，并将结果压回堆栈。控制指令改变控制流。控制流是结构化的，这意味着它用嵌套良好的结构（例如块、循环和条件语句）来表达。分支只能针对此类结构。

陷阱: 在某些情况下，某些指令可能会产生陷阱，这会立即中止执行。陷阱无法由 WebAssembly 代码处理，而是报告给外部环境，在那里它们通常可以被捕获。

函数: 代码被组织成单独的函数。每个函数都接受一系列值作为参数，并返回一系列值作为结果。函数可以相互调用，包括递归调用，从而产生一个无法直接访问的隐式调用堆栈。函数还可以声明可变的局部变量，这些变量可用作虚拟寄存器。

表: 表是具有特定元素类型的不透明值的数组。它允许程序通过动态索引操作数间接选择这些值。目前，唯一可用的元素类型是无类型函数引用或对外部主机值的引用。因此，程序可以通过对表的动态索引间接调用函数。例如，这允许通过表索引模拟函数指针。

线性内存: 线性内存是原始字节的连续可变数组。这种内存是在初始大小下创建的，但可以动态增长。程序可以在任何字节地址（包括未对齐的地址）从线性内存加载值或存储值。整数加载和存储可以指定一个比相应值类型大小更小的存储大小。如果访问超出当前内存大小的范围，则会发生陷阱。

模块: WebAssembly 二进制文件采用模块的形式，其中包含函数、表和线性内存的定义，以及可变或不可变的全局变量。定义也可以被导入，指定一个模块/名称对以及合适的类型。每个定义可以选择在多个名称下被导出。除了定义之外，模块还可以定义其内存或表的初始化数据，这些数据采用复制到给定偏移量的段的形式。它们还可以定义一个启动函数，该函数会自动执行。

嵌入器: WebAssembly 实现通常会嵌入到主机环境中。此环境定义了如何启动模块加载、如何提供导入（包括主机端定义）以及如何访问导出。但是，任何特定嵌入的细节超出了本规范的范围，而是由补充的、环境特定的 API 定义提供。

1.2.2. 语义阶段

从概念上讲，WebAssembly 的语义分为三个阶段。对于语言的每个部分，规范都指定了每个阶段。

解码: WebAssembly 模块以二进制格式分发。解码处理该格式并将其转换为模块的内部表示。在本规范中，此表示形式由抽象语法建模，但实际实现可以改为直接编译为机器代码。

验证: 已解码的模块必须是有效的。验证检查许多良好格式条件，以保证模块是有意义且安全的。特别是，它执行函数及其主体中指令序列的类型检查，确保例如操作数堆栈始终一致地使用。

执行

最后，有效的模块可以被执行。执行可以进一步分为两个阶段

实例化。模块实例是模块的动态表示，包含其自己的状态和执行堆栈。实例化执行模块主体本身，为其所有导入提供定义。它初始化全局变量、内存和表，并在定义的情况下调用模块的启动函数。它返回模块导出的实例。

调用。实例化后，可以通过调用模块实例上的导出函数来启动进一步的 WebAssembly 计算。给定必需的参数，这将执行相应函数并返回其结果。

实例化和调用是嵌入环境中的操作。

2. 结构

2.1. 约定

WebAssembly 是一种编程语言，具有多种具体表示形式（其二进制格式和文本格式）。两者都映射到一个通用结构。为了简洁起见，这种结构以抽象语法的形式描述。本规范的所有部分都根据此抽象语法定义。

2.1.1. 语法表示法

在定义抽象语法的语法规则时，采用以下约定。

终结符（原子）以无衬线字体或符号形式编写： $i32, end, \to, [,]$ .
非终结符以斜体形式编写： $valtype, instr$ .
$A^{n}$ 是 $n \geq 0$ 次 $A$ 的序列。
$A^{*}$ 是一个可能是空的 $A$ 迭代序列。 (这是 $A^{n}$ 的简写，在 $n$ 不相关的情况下使用。)
$A^{+}$ 是一个非空的 $A$ 迭代序列。 (这是 $A^{n}$ 的简写，其中 $n \geq 1$ 。)
$A^{?}$ 是 $A$ 的可选出现。 (这是 $A^{n}$ 的简写，其中 $n \leq 1$ 。)
产生式写作 $sym ::= A_{1} ∣ \dots ∣ A_{n}$ .
大型产生式可以拆分为多个定义，用显式省略号 ( $sym ::= A_{1} ∣ \dots$ ) 结束第一个定义，并用省略号 ( $sym ::= \dots ∣ A_{2}$ ) 开始后续定义。
有些产生式用圆括号 (“ $(if condition)$ ”) 附加了边条件，用于简化将产生式组合扩展为多个独立情况的写法。
如果同一个元变量或非终结符在产生式中多次出现，则所有这些出现必须具有相同的实例化。 (这是对多个不同变量相等的要求的简写。)

2.1.2. 辅助符号

在处理语法结构时，还会使用以下符号

$ϵ$ 表示空序列。
$∣s∣$ 表示序列 $s$ 的长度。
$s [i]$ 表示序列 $s$ 的第 $i$ 个元素，从 $0$ 开始。
$s [i : n]$ 表示序列 $s [i] \dots s [i + n - 1]$ 的子序列。
$s with [i] = A$ 表示与 $s$ 相同的序列，但将第 $i$ 个元素替换为 $A$ 。
$s with [i : n] = A^{n}$ 表示与 $s$ 相同的序列，除了子序列 $s [i : n]$ 被替换为 $A^{n}$ .
$concat (s^{*})$ 表示通过连接所有序列 $s_{i}$ （在 $s^{*}$ 中）而形成的扁平序列。

此外，采用以下约定。

符号 $x^{n}$ ，其中 $x$ 是一个非终结符，被视为一个元变量，它遍历 $x$ 的相应序列（类似于 $x^{*}$ ， $x^{+}$ ， $x^{?}$ ）。
当给定一个序列 $x^{n}$ 时，则假设序列 $(A_{1} x A_{2})^{n}$ 中的 $x$ 的出现与 $x^{n}$ 呈逐点对应关系（类似于 $x^{*}$ ， $x^{+}$ ， $x^{?}$ ）。这隐式地表达了一种在序列上映射语法结构的形式。

以下形式的产生式被解释为记录，它们将一组固定的字段 $field_{i}$ 分别映射到“值” $A_{i}$ .

r ::= {field_{1} A_{1}, field_{2} A_{2}, \dots}

采用以下符号来操作这些记录。

$r. field$ 表示 $field$ 组件在 $r$ 中的内容。
$r with field = A$ 表示与 $r$ 相同的记录，只是 $field$ 组件的内容被替换为 $A$ .
$r_{1} \oplus r_{2}$ 表示两个具有相同字段序列的记录的组合，通过逐点追加每个序列来完成。

${field_{1} A_{1}^{*}, field_{2} A_{2}^{*}, \dots} \oplus {field_{1} B_{1}^{*}, field_{2} B_{2}^{*}, \dots} = {field_{1} A_{1}^{*} B_{1}^{*}, field_{2} A_{2}^{*} B_{2}^{*}, \dots}$
$⨁ r^{*}$ 表示对一个记录序列进行组合，按顺序进行；如果序列为空，则结果记录的所有字段都为空。

序列和记录的更新符号递归地推广到通过“路径”访问的嵌套组件 $pth ::= ([\dots] ∣ . field)^{+}$

$s with [i] pth = A$ 是 $s with [i] = (s [i] with pth = A)$ 的简写形式，
$r with field pth = A$ 是 $r with field = (r. field with pth = A)$ 的简写形式，

其中 $r with . field = A$ 简化为 $r with field = A$ 。

2.1.3. 向量

向量是形式为 $A^{n}$ （或 $A^{*}$ ）的有界序列，其中 $A$ 可以是值或复杂结构。一个向量最多可以有 $2^{32} - 1$ 个元素。

vec (A) ::= A^{n} (if n < 2^{32})

2.2. 值

WebAssembly 程序操作原始数值值。此外，在程序的定义中，值的不变序列用来表示更复杂的数据，例如文本字符串或其他向量。

2.2.1. 字节

最简单的值形式是原始的未解释字节。在抽象语法中，它们用十六进制文字表示。

byte ::= 0x 00 ∣ \dots ∣ 0x FF

2.2.1.1. 约定

元变量 $b$ 代表字节。
字节有时被解释为自然数 $n < 256$ 。

2.2.2. 整数

不同类别的整数具有不同的值范围，它们由它们的位宽 $N$ 以及它们是无符号还是有符号来区分。

u N s N i N ::= ::= ::= 0 ∣ 1 ∣ \dots ∣ 2^{N} - 1 - 2^{N - 1} ∣ \dots ∣ - 1 ∣ 0 ∣ 1 ∣ \dots ∣ 2^{N - 1} - 1 u N

类 $i N$ 定义了未解释的整数，其有符号解释可能根据上下文而有所不同。在抽象语法中，它们表示为无符号值。但是，某些操作会转换它们为基于二进制补码解释的有符号值。

注意

本规范中出现的主要整数类型是 $u32$ 、 $u64$ 、 $s32$ 、 $s64$ 、 $i8$ 、 $i16$ 、 $i32$ 、 $i64$ 。但是，其他大小作为辅助结构出现，例如，在浮点数的定义中。

2.2.2.1. 约定

元变量 $m, n, i$ 表示整数。
数字可以用简单的算术表示，如上面的语法所示。为了区分 $2^{N}$ 这样的算术运算和 $(1)^{N}$ 这样的序列，后者用括号来区分。

2.2.3. 浮点数

浮点数数据表示与 [IEEE-754-2019] 标准（第 3.3 节）中相应的二进制格式相对应的 32 位或 64 位值。

每个值都有一个符号和一个大小。大小可以表示为形式为 $m_{0} . m_{1} m_{2} \dots m_{M} \cdot 2^{e}$ , 其中 $e$ 是指数， $m$ 是尾数，其最高有效位 $m_{0}$ 是 $1$ ，或者表示为非规格化数，其中指数固定为最小可能值， $m_{0}$ 是 $0$ ；非规格化数中包括正零和负零值。由于尾数是二进制值，因此规格化数表示为 $(1 + m \cdot 2^{- M}) \cdot 2^{e}$ , 其中 $M$ 是 $m$ 的位宽；非规格化数也是如此。

可能的大小还包括特殊值 $\infty$ （无穷大）和 $nan$ （NaN，非数字）。 NaN 值具有一个有效载荷，它描述了底层二进制表示中的尾数位。信号 NaN 和安静 NaN 之间没有区别。

f N f Nmag ::= ::= ∣ ∣ ∣ + f Nmag ∣ - f Nmag (1 + u M \cdot 2^{- M}) \cdot 2^{e} (0 + u M \cdot 2^{- M}) \cdot 2^{e} \infty nan (n) (if - 2^{E - 1} + 2 \leq e \leq 2^{E - 1} - 1) (if e = - 2^{E - 1} + 2) (if 1 \leq n < 2^{M})

其中 $M = signif (N)$ 且 $E = expon (N)$ ，

signif (32) signif (64) = = 2352 expon (32) expon (64) = = 811

规范 NaN 是一个浮点值 $\pm nan (canon_{N})$ ，其中 $canon_{N}$ 是一个有效载荷，其最高有效位为 $1$ ，而其他所有位都为 $0$ 。

canon_{N} = 2^{signif (N) - 1}

算术 NaN 是一个浮点值 $\pm nan (n)$ ，其中 $n \geq canon_{N}$ ，使得最高有效位为 $1$ ，而其他所有位都为任意值。

注意

在抽象语法中，次正规数通过尾数的开头 0 来区分。次正规数的指数与正规数的最小可能指数相同。仅在二进制表示中，次正规数的指数以与任何正规数的指数不同的方式编码。

这里定义的规范 NaN 概念与 [IEEE-754-2019] 标准（第 3.5.2 节）为十进制交换格式定义的规范 NaN 概念无关。

2.2.3.1. 约定

元变量 $z$ 涵盖浮点值，其含义从上下文中清楚。

2.2.4. 向量

数值向量 是 128 位值，由向量指令（也称为 SIMD 指令，单指令多数据）处理。它们在抽象语法中使用 $i128$ 表示。通道类型（整数或浮点数）和通道大小的解释由对它们进行操作的特定指令确定。

2.2.5. 名称

名称是字符的序列，字符是 [UNICODE]（第 2.4 节）中定义的标量值。

name char ::= ::= char^{*} (if ∣ utf8 (char^{*}) ∣ < 2^{32}) U + 00 ∣ \dots ∣ U + D7FF ∣ U + E000 ∣ \dots ∣ U + 10FFFF

由于二进制格式的限制，名称的长度受其 UTF-8 编码长度的限制。

2.2.5.1. 约定

字符（Unicode 标量值）有时与自然数 $n < 1114112$ 可互换使用。

2.3. 类型

WebAssembly 中的各种实体按类型分类。类型在验证、实例化以及可能执行期间进行检查。

2.3.1. 数值类型

数值类型 用于对数值进行分类。

numtype ::= i32 ∣ i64 ∣ f32 ∣ f64

类型 $i32$ 和 $i64$ 分别对应于 32 位和 64 位整数。整数本身并非有符号或无符号，它们的解释由各个操作决定。

类型 $f32$ 和 $f64$ 分别对应于 32 位和 64 位浮点数。它们分别对应于二进制浮点数表示，也称为单精度和双精度，如 [IEEE-754-2019] 标准（第 3.3 节）中所定义。

数值类型是透明的，这意味着它们的位模式是可以观察到的。数值类型的值可以存储在内存中。

2.3.1.1. 约定

符号 $∣t∣$ 表示数值类型 $t$ 的位宽。也就是说， $∣ i32 ∣ = ∣ f32 ∣ = 32$ 和 $∣ i64 ∣ = ∣ f64 ∣ = 64$ .

2.3.2. 向量类型

向量类型 用于对由向量指令处理的数值向量进行分类（也称为SIMD 指令，单指令多数据）。

vectype ::= v128

类型 $v128$ 对应一个包含128位整型或浮点型数据的打包向量。打包数据可以解释为有符号或无符号整型，单精度或双精度浮点型值，或单个128位类型。解释方式由各个操作确定。

向量类型，如同数字类型，是透明的，这意味着它们的位模式是可以观察到的。向量类型的值可以存储在内存中。

2.3.2.1. 约定

符号 $∣t∣$ 用于表示位宽，它也适用于向量类型，也就是说， $∣ v128 ∣ = 128$ .

2.3.3. 引用类型

引用类型对运行时存储中对象的的一级引用进行分类。

reftype ::= funcref ∣ externref

类型 $funcref$ 表示所有对函数的引用的无限并集，无论它们的函数类型是什么。

类型 $externref$ 表示所有由嵌入器拥有并可以以这种类型传递到 WebAssembly 中的引用的无限并集。

引用类型是不透明的，这意味着它们的尺寸或位模式都无法观察到。引用类型的值可以存储在表格中。

2.3.4. 值类型

值类型对 WebAssembly 代码可以计算的值和变量接受的值进行分类。它们要么是数字类型，要么是向量类型，要么是引用类型。

valtype ::= numtype ∣ vectype ∣ reftype

2.3.4.1. 约定

元变量 $t$ 在上下文中明确的情况下，表示值类型或其子类。

2.3.5. 结果类型

结果类型对执行指令或函数的结果进行分类，结果是一个值序列，用方括号表示。

resulttype ::= [vec (valtype)]

2.3.6. 函数类型

函数类型对函数的签名进行分类，将参数向量映射到结果向量。它们也用于对指令的输入和输出进行分类。

functype ::= resulttype \to resulttype

2.3.7. 限制

限制用于对与内存类型和表格类型相关的可调整大小的存储的大小范围进行分类。

limits ::= {min u32, max u32^{?}}

如果没有指定最大值，则相应的存储可以增长到任何大小。

2.3.8. 内存类型

内存类型 用于对线性内存及其大小范围进行分类。

memtype ::= limits

这些限制会约束内存的最小大小以及可选的最大大小。限制以页面大小为单位。

2.3.9. 表格类型

表格类型 用于对在给定大小范围内包含引用类型元素的表格进行分类。

tabletype ::= limits reftype

与内存类似，表格也会受到限制，用于约束其最小大小和可选的最大大小。限制以条目数为单位。

注意

在 WebAssembly 的未来版本中，可能会引入其他元素类型。

2.3.10. 全局类型

全局类型 用于对全局变量进行分类，这些变量会保存一个值，并且可以是可变的，也可以是不可变的。

globaltype mut ::= ::= mut valtype const ∣ var

2.3.11. 外部类型

外部类型 用于对导入和外部值及其相应的类型进行分类。

externtype ::= func functype ∣ table tabletype ∣ mem memtype ∣ global globaltype

2.3.11.1. 约定

以下辅助符号用于外部类型序列。它以保留顺序的方式筛选出特定类型的条目。

$funcs (externtype^{*}) = [functype ∣ (func functype) \in externtype^{*}]$
$tables (externtype^{*}) = [tabletype ∣ (table tabletype) \in externtype^{*}]$
$mems (externtype^{*}) = [memtype ∣ (mem memtype) \in externtype^{*}]$
$globals (externtype^{*}) = [globaltype ∣ (global globaltype) \in externtype^{*}]$

2.4. 指令

WebAssembly 代码由一系列指令组成。其计算模型基于堆栈机，指令在隐式操作数堆栈上操作值，消耗（弹出）参数值并生成或返回（压入）结果值。

除了来自堆栈的动态操作数之外，一些指令还具有静态立即参数，通常是索引或类型注释，它们是指令本身的一部分。

一些指令在结构上是结构化的，因为它们对嵌套的指令序列进行括号。

以下部分将指令分为多个不同的类别。

2.4.1. 数值指令

数值指令提供对特定类型的数值值的基本操作。这些操作与硬件中可用的相应操作密切匹配。

nn, mm sx instr iunop ibinop funop fbinop itestop irelop frelop ::= ::= ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ::= ::= ∣ ::= ::= ::= ::= ::= 32 ∣ 64 u ∣ s i nn . const u nn ∣ f nn . const f nn i nn . iunop ∣ f nn . funop i nn . ibinop ∣ f nn . fbinop i nn . itestop i nn . irelop ∣ f nn . frelop i nn . extend 8_s ∣ i nn . extend 16_s ∣ i64. extend 32_s i32. wrap_i64 ∣ i64. extend_i32_sx ∣ i nn . trunc_f mm_sx i nn . trunc_sat_f mm_sx f32. demote_f64 ∣ f64. promote_f32 ∣ f nn . convert_i mm_sx i nn . reinterpret_f nn ∣ f nn . reinterpret_i nn \dots clz ∣ ctz ∣ popcnt add ∣ sub ∣ mul ∣ div_sx ∣ rem_sx and ∣ or ∣ xor ∣ shl ∣ shr_sx ∣ rotl ∣ rotr abs ∣ neg ∣ sqrt ∣ ceil ∣ floor ∣ trunc ∣ nearest add ∣ sub ∣ mul ∣ div ∣ min ∣ max ∣ copysign eqz eq ∣ ne ∣ lt_sx ∣ gt_sx ∣ le_sx ∣ ge_sx eq ∣ ne ∣ lt ∣ gt ∣ le ∣ ge

数值指令按数值类型划分。对于每种类型，可以区分几个子类别

常量：返回一个静态常量。
一元运算：消耗一个操作数并生成一个相应类型的结果。
二元运算：消耗两个操作数并生成一个相应类型的结果。
测试：消耗一个相应类型的操作数并生成一个布尔整型结果。
比较：消耗两个相应类型的操作数并生成一个布尔整型结果。
转换：消耗一个类型的值并生成另一个类型的结果（转换的源类型是“ $_$ ”之后的那个）。

一些整型指令有两种形式，其中一个符号位注释 $sx$ 区分操作数是作为解释为无符号还是有符号整数。对于其他整型指令，使用二进制补码进行有符号解释意味着它们的行为相同，无论符号位如何。

2.4.1.1. 约定

有时，根据以下语法简写将运算符分组在一起会很方便。

unop binop testop relop cvtop ::= ::= ::= ::= ::= iunop ∣ funop ∣ extend N_s ibinop ∣ fbinop itestop irelop ∣ frelop wrap ∣ extend ∣ trunc ∣ trunc_sat ∣ convert ∣ demote ∣ promote ∣ reinterpret

2.4.2. 向量指令

向量指令（也称为SIMD 指令，即单指令多数据）提供了对值的基本操作向量类型.

ishape fshape shape half laneidx ::= ::= ::= ::= ::= i8x16 ∣ i16x8 ∣ i32x4 ∣ i64x2 f32x4 ∣ f64x2 ishape ∣ fshape low ∣ high u8

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots v128. const i128 v128. vvunop v128. vvbinop v128. vvternop v128. vvtestop i8x16. shuffle laneidx^{16} i8x16. swizzle shape . splat i8x16. extract_lane_sx laneidx ∣ i16x8. extract_lane_sx laneidx i32x4. extract_lane laneidx ∣ i64x2. extract_lane laneidx fshape . extract_lane laneidx shape . replace_lane laneidx i8x16 . virelop ∣ i16x8 . virelop ∣ i32x4 . virelop i64x2. eq ∣ i64x2. ne ∣ i64x2. lt_s ∣ i64x2. gt_s ∣ i64x2. le_s ∣ i64x2. ge_s fshape . vfrelop ishape . viunop ∣ i8x16. popcnt i16x8. q15mulr_sat_s i32x4. dot_i16x8_s fshape . vfunop ishape . vitestop ishape . bitmask i8x16. narrow_i16x8_sx ∣ i16x8. narrow_i32x4_sx i16x8. extend_half_i8x16_sx ∣ i32x4. extend_half_i16x8_sx i64x2. extend_half_i32x4_sx ishape . vishiftop ishape . vibinop i8x16. viminmaxop ∣ i16x8. viminmaxop ∣ i32x4. viminmaxop i8x16. visatbinop ∣ i16x8. visatbinop i16x8. mul ∣ i32x4. mul ∣ i64x2. mul i8x16. avgr_u ∣ i16x8. avgr_u i16x8. extmul_half_i8x16_sx ∣ i32x4. extmul_half_i16x8_sx ∣ i64x2. extmul_half_i32x4_sx i16x8. extadd_pairwise_i8x16_sx ∣ i32x4. extadd_pairwise_i16x8_sx fshape . vfbinop i32x4. trunc_sat_f32x4_sx ∣ i32x4. trunc_sat_f64x2_sx_zero f32x4. convert_i32x4_sx ∣ f32x4. demote_f64x2_zero f64x2. convert_low_i32x4_sx ∣ f64x2. promote_low_f32x4 \dots

vvunop vvbinop vvternop vvtestop vitestop virelop vfrelop viunop vibinop viminmaxop visatbinop vishiftop vfunop vfbinop ::= ::= ::= ::= ::= ::= ::= ::= ::= ::= ::= ::= ::= ::= not and ∣ andnot ∣ or ∣ xor bitselect any_true all_true eq ∣ ne ∣ lt_sx ∣ gt_sx ∣ le_sx ∣ ge_sx eq ∣ ne ∣ lt ∣ gt ∣ le ∣ ge abs ∣ neg add ∣ sub min_sx ∣ max_sx add_sat_sx ∣ sub_sat_sx shl ∣ shr_sx abs ∣ neg ∣ sqrt ∣ ceil ∣ floor ∣ trunc ∣ nearest add ∣ sub ∣ mul ∣ div ∣ min ∣ max ∣ pmin ∣ pmax

向量指令的命名约定包括一个前缀，该前缀决定了操作数的解释方式。该前缀描述了操作数的 *形状*，写成 $t x N$ ，由一个打包的数值类型 $t$ 和该类型的 *通道* 数 $N$ 组成。操作在每个通道的值上逐点执行。

注意

例如，形状 $i32x4$ 将操作数解释为四个 $i32$ 值，打包成一个 $i128$ 。数值类型 $t$ 的位宽乘以 $N$ 始终为 128。

以 $v128$ 为前缀的指令不涉及特定解释，并将 $v128$ 视为 $i128$ 值或 128 个独立位的向量。

向量指令可以分组到几个子类别中

常量：返回一个静态常量。
一元运算：消耗一个 $v128$ 操作数并生成一个 $v128$ 结果。
二元运算：消耗两个 $v128$ 操作数并生成一个 $v128$ 结果。
三元运算：消耗三个 $v128$ 操作数并生成一个 $v128$ 结果。
测试：消耗一个 $v128$ 操作数并生成一个布尔整型结果。
移位：消耗一个 $v128$ 操作数和一个 $i32$ 操作数，生成一个 $v128$ 结果。
扩展：消耗一个数值类型的值并生成一个指定形状的 $v128$ 结果。
提取通道：消耗一个 $v128$ 操作数并返回给定通道中的数值。
替换通道：消耗一个 $v128$ 操作数和给定通道的数值，并生成一个 $v128$ 结果。

一些向量指令有一个有符号性注释 $sx$ ，它区分操作数中的元素是解释为无符号还是有符号整数。对于其他向量指令，使用二进制补码进行有符号解释意味着它们的行为相同，无论有符号性如何。

2.4.2.1. 约定

有时，根据以下语法简写将运算符分组在一起会很方便。

vunop vbinop vtestop vrelop vcvtop ::= ::= ∣ ∣ ::= ::= ::= viunop ∣ vfunop ∣ popcnt vibinop ∣ vfbinop viminmaxop ∣ visatbinop mul ∣ avgr_u ∣ q15mulr_sat_s vitestop virelop ∣ vfrelop extend ∣ trunc_sat ∣ convert ∣ demote ∣ promote

2.4.3. 引用指令

此组指令与访问引用相关。

instr ::= ∣ ∣ ∣ \dots ref . null reftype ref . is_null ref . func funcidx

这些指令分别生成空值、检查空值或生成对给定函数的引用。

2.4.4. 参数指令

此组指令可以在任何值类型的操作数上进行操作。

instr ::= ∣ ∣ \dots drop select (valtype^{*})^{?}

The $drop$ instruction simply throws away a single operand.

The $select$ instruction selects one of its first two operands based on whether its third operand is zero or not. It may include a value type determining the type of these operands. If missing, the operands must be of numeric type.

注意

In future versions of WebAssembly, the type annotation on $select$ may allow for more than a single value being selected at the same time.

2.4.5. 变量指令

变量指令与访问局部变量或全局变量相关。

instr ::= ∣ ∣ ∣ ∣ ∣ \dots local.get localidx local.set localidx local.tee localidx global.get globalidx global.set globalidx

这些指令分别获取或设置变量的值。The $local.tee$ instruction is like $local.set$ but also returns its argument.

2.4.6. 表指令

这组指令与表 table 相关。

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots table.get tableidx table.set tableidx table.size tableidx table.grow tableidx table.fill tableidx table.copy tableidx tableidx table.init tableidx elemidx elem.drop elemidx

指令 $table.get$ 和 $table.set$ 分别用于加载或存储表中的元素。

指令 $table.size$ 返回表的当前大小。指令 $table.grow$ 按给定的增量扩展表，并返回之前的大小，如果无法分配足够的空间，则返回 $- 1$ 。它还接受新分配的条目的初始化值。

指令 $table.fill$ 将指定范围内所有条目设置为给定值。

指令 $table.copy$ 将元素从源表区域复制到可能重叠的目标区域；第一个索引表示目标。指令 $table.init$ 将元素从被动元素段复制到表中。指令 $elem.drop$ 防止进一步使用被动元素段。此指令旨在用作优化提示。在元素段被丢弃后，其元素将无法再被检索，因此此段使用的内存可能会被释放。

另一个访问表的指令是控制指令 $call_indirect$ 。

2.4.7. 内存指令

这组指令涉及线性内存。

memarg ww instr ::= ::= ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ {offset u32, align u32} 8 ∣ 16 ∣ 32 ∣ 64 \dots i nn . load memarg ∣ f nn . load memarg ∣ v128. load memarg i nn . store memarg ∣ f nn . store memarg ∣ v128. store memarg i nn . load 8_sx memarg ∣ i nn . load 16_sx memarg ∣ i64. load 32_sx memarg i nn . store 8 memarg ∣ i nn . store 16 memarg ∣ i64. store 32 memarg v128. load 8x8_sx memarg ∣ v128. load 16x4_sx memarg ∣ v128. load 32x2_sx memarg v128. load 32_zero memarg ∣ v128. load 64_zero memarg v128. load ww_splat memarg v128. load ww_lane memarg laneidx ∣ v128. store ww_lane memarg laneidx memory.size memory.grow memory.fill memory.copy memory.init dataidx data.drop dataidx

使用 $load$ 和 $store$ 指令访问内存，这些指令对应不同的数字类型。它们都接受一个 *内存立即数* $memarg$ ，其中包含地址 *偏移量* 和预期 *对齐方式*（用 2 的幂的指数表示）。整数加载和存储可以选择指定一个比相应值类型位宽更小的 *存储大小*。在加载的情况下，需要一个符号扩展模式 $sx$ 来选择适当的行为。

向量加载可以指定一个大小为 $v128$ 位宽一半的形状。每个车道的大小是其正常大小的一半，符号扩展模式 $sx$ 随后指定如何将较小的车道扩展到较大的车道。或者，向量加载可以执行 *splat*，这样只加载指定存储大小的单个车道，并将结果复制到所有车道。

静态地址偏移量加到动态地址操作数，产生一个 33 位 *有效地址*，该地址是访问内存的零基索引。所有值都以小端字节顺序读取和写入。如果任何被访问的内存字节位于内存当前大小暗示的地址范围之外，则会导致陷阱。

注意

WebAssembly 的未来版本可能会提供具有 64 位地址范围的内存指令。

指令 $memory.size$ 返回内存的当前大小。指令 $memory.grow$ 通过给定的增量扩展内存并返回之前的大小，如果无法分配足够的内存，则返回 $- 1$ 。这两个指令都以页大小为单位。

指令 $memory.fill$ 将区域中的所有值设置为给定的字节。指令 $memory.copy$ 将数据从源内存区域复制到可能重叠的目标区域。指令 $memory.init$ 将数据从被动数据段复制到内存中。指令 $data.drop$ 阻止进一步使用被动数据段。此指令旨在用作优化提示。在数据段被丢弃后，其数据将无法再检索，因此此段使用的内存可能会被释放。

注意

在 WebAssembly 的当前版本中，所有内存指令都隐式地对内存索引 $0$ 进行操作。此限制可能在未来版本中被解除。

2.4.8. 控制指令

此组中的指令影响控制流。

blocktype instr ::= ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ typeidx ∣ valtype^{?} \dots nop unreachable block blocktype instr^{*} end loop blocktype instr^{*} end if blocktype instr^{*} else instr^{*} end br labelidx br_if labelidx br_table vec (labelidx) labelidx return call funcidx call_indirect tableidx typeidx

指令 $nop$ 什么也不做。

$unreachable$ 指令会导致无条件的陷阱。

$block$ 、 $loop$ 和 $if$ 指令是结构化指令。它们将嵌套的指令序列（称为块）括起来，并以 $end$ 或 $else$ 伪指令终止或分隔。根据语法规定，它们必须是嵌套良好的。

结构化指令可以根据其注释的块类型在操作数栈上消耗输入并产生输出。它可以作为一个类型索引，该索引引用一个合适的函数类型，或者作为一个可选的值类型内联，这是一种函数类型 $[] \to [valtype^{?}]$ 的简写。

每个结构化控制指令都引入一个隐式的标签。标签是分支指令的目标，这些分支指令使用标签索引引用它们。与其他索引空间不同，标签的索引是按嵌套深度相对的，也就是说，标签 $0$ 指的是包围引用分支指令的最内层结构化控制指令，而增加的索引指的是更外层的那些指令。因此，标签只能从内部关联的结构化控制指令中引用。这也意味着分支只能被定向到外部，“中断”它们所针对的控制结构的块。确切的效果取决于该控制结构。在 $block$ 或 $if$ 的情况下，它是一个向前跳转，在匹配的 $end$ 之后恢复执行。在 $loop$ 的情况下，它是一个向后跳转到循环的开头。

注意

这强制执行结构化控制流。直观地，一个针对 $block$ 或 $if$ 的分支的行为类似于大多数类似 C 的语言中的 $break$ 语句，而一个针对 $loop$ 的分支的行为类似于 $continue$ 语句。

分支指令有几种形式： $br$ 执行无条件分支， $br_if$ 执行条件分支， $br_table$ 通过操作数索引到标签向量执行间接分支，该标签向量是指令的立即数，或者如果操作数越界，则索引到默认目标。 $return$ 指令是针对最外层块的无条件分支的快捷方式，该块隐式地是当前函数的主体。执行分支会展开操作数栈，直到到达目标结构化控制指令被输入的高度。但是，分支本身可能会额外消耗操作数，它们会在展开后将操作数压回操作数栈。向前分支需要根据目标块类型的输出来提供操作数，即代表已终止块所产生的值。向后分支需要根据目标块类型的输入来提供操作数，即代表已重新启动块所消耗的值。

$call$ 指令调用另一个函数，从栈中消耗必要的参数，并返回调用的结果值。 $call_indirect$ 指令通过操作数索引到一个表格间接调用函数，该表格由一个表格索引表示，并且必须具有类型 $funcref$ 。由于它可能包含不同类型的函数，因此被调用者会动态地与指令第二个立即数所索引的函数类型进行检查，如果它们不匹配，则调用会被中止并产生一个陷阱。

2.4.9. 表达式

函数主体、全局变量的初始化值、元素段的元素和偏移量以及数据段的偏移量都以表达式给出，表达式是指令的序列，以一个 $end$ 标记终止。

expr ::= instr^{*} end

在某些情况下，验证限制表达式为常量，这限制了允许指令集。

2.5. 模块

WebAssembly 程序被组织成模块，它们是部署、加载和编译的单元。模块收集类型、函数、表、内存和全局变量的定义。此外，它可以声明导入和导出，并以数据和元素段的形式提供初始化，或一个开始函数。

module ::= {types vec (functype), funcs vec (func), tables vec (table), mems vec (mem), globals vec (global), elems vec (elem), datas vec (data), start start^{?}, imports vec (import), exports vec (export)}

每个向量（以及整个模块）都可能是空的。

2.5.1. 索引

定义使用从零开始的索引进行引用。每类定义都有自己的索引空间，由以下类别区分。

typeidx funcidx tableidx memidx globalidx elemidx dataidx localidx labelidx ::= ::= ::= ::= ::= ::= ::= ::= ::= u32 u32 u32 u32 u32 u32 u32 u32 u32

函数、表格、内存和全局变量的索引空间包括同一模块中声明的相应导入。这些导入的索引位于同一索引空间中其他定义的索引之前。

元素索引引用元素段，数据索引引用数据段。

局部变量的索引空间仅在函数内部可访问，并且包括该函数的参数，参数位于局部变量之前。

标签索引引用指令序列内的结构化控制指令。

2.5.1.1. 约定

元变量 $l$ 指代标签索引。
元变量 $x, y$ 指代任何其他索引空间中的索引。
符号 $idx (A)$ 表示在 $idx$ 索引空间中自由出现的索引集。有时该集合被重新解释为其元素的向量。

注意

例如，如果 $instr^{*}$ 是 $(data.drop x) (memory.init y)$ , 那么 $dataidx (instr^{*}) = {x, y}$ , 或等效地，向量 $x y$ .

2.5.2. 类型

模块的 $types$ 组件定义了一个函数类型的向量。

模块中使用的所有函数类型都必须在此组件中定义。它们由类型索引引用。

注意

WebAssembly 的未来版本可能会添加其他形式的类型定义。

2.5.3. 函数

模块的 $funcs$ 组件定义了一个具有以下结构的函数向量

func ::= {type typeidx, locals vec (valtype), body expr}

函数的 $type$ 通过引用模块中定义的类型来声明其签名。函数的参数通过函数体中以 0 为基的局部索引来引用；它们是可变的。

The $locals$ 声明一个可变局部变量及其类型的向量。这些变量通过函数体中的局部索引来引用。第一个局部的索引是未引用参数的最小索引。

The $body$ 是一个指令序列，该序列在终止时必须生成与函数类型的结果类型匹配的堆栈。

Functions are referenced through function indices, starting with the smallest index not referencing a function import.

2.5.4. 表

模块的 $tables$ 组件定义了一个由其表类型描述的表向量。

table ::= {type tabletype}

表是特定引用类型的不透明值的向量。表类型中的 $min$ 大小指定了该表的初始大小，而其 $max$ （如果存在）限制了其以后可以增长的尺寸。

Tables can be initialized through element segments.

Tables are referenced through table indices, starting with the smallest index not referencing a table import. Most constructs implicitly reference table index $0$ .

2.5.5. 内存

模块的 $mems$ 组件定义了一个由其内存类型描述的线性内存（或简称内存）向量。

mem ::= {type memtype}

内存是原始未解释字节的向量。内存类型中的 $min$ 大小指定了该内存的初始大小，而其 $max$ （如果存在）限制了其以后可以增长的尺寸。两者都以页面大小为单位。

Memories can be initialized through data segments.

Memories are referenced through memory indices, starting with the smallest index not referencing a memory import. Most constructs implicitly reference memory index $0$ .

注意

在 WebAssembly 的当前版本中，单个模块中最多可以定义或导入一个内存，并且所有结构都隐式地引用了这个内存 $0$ 。此限制可能会在将来的版本中解除。

2.5.6. 全局变量

模块的 $globals$ 组件定义了一个全局变量（或简称全局变量）向量。

global ::= {type globaltype, init expr}

每个全局变量存储给定全局类型的单个值。其 $type$ 还指定全局变量是不可变还是可变的。此外，每个全局变量都使用 $init$ 值初始化，该值由常量初始化器表达式给出。

全局变量通过全局索引引用，从不引用全局导入的最小索引开始。

2.5.7. 元素段

表的初始内容未初始化。元素段可用于从静态向量元素中初始化表的子范围。

模块的 $elems$ 组件定义元素段向量。每个元素段定义一个引用类型以及相应的常量元素表达式列表。

元素段具有一个模式，用于将它们标识为被动、主动或声明式。被动元素段的元素可以使用 $table.init$ 指令复制到表中。主动元素段在实例化期间将元素复制到表中，如表索引和定义表中偏移量的常量表达式指定。声明式元素段在运行时不可用，但仅用于向前声明在代码中使用 $ref . func$ 等指令形成的引用。

elem elemmode ::= ::= ∣ ∣ {type reftype, init vec (expr), mode elemmode} passive active {table tableidx, offset expr} declarative

该 $offset$ 由常量表达式给出。

元素段通过元素索引引用。

2.5.8. 数据段

内存的初始内容为零字节。数据段可用于从静态向量字节中初始化内存范围。

模块的 $datas$ 组件定义数据段向量。

与元素段类似，数据段具有一个模式，用于将它们标识为被动或主动。被动数据段的内容可以使用 $memory.init$ 指令复制到内存中。主动数据段在实例化期间将内容复制到内存中，如内存索引和定义内存中偏移量的常量表达式指定。

data datamode ::= ::= ∣ {init vec (byte), mode datamode} passive active {memory memidx, offset expr}

数据段通过数据索引引用。

注意

在当前版本的 WebAssembly 中，模块中最多允许一个内存。因此，唯一有效的 $memidx$ 是 $0$ 。

2.5.9. 开始函数

模块的 $start$ 组件声明一个 开始函数 的函数索引，该函数在模块被实例化时自动调用，在表格和内存初始化之后。

start ::= {func funcidx}

注意

开始函数用于初始化模块的状态。在此初始化完成之前，模块及其导出无法从外部访问。

2.5.10. 导出

模块的 $exports$ 组件定义了一组导出，这些导出在模块被实例化后对主机环境可用。

export exportdesc ::= ::= ∣ ∣ ∣ {name name, desc exportdesc} func funcidx table tableidx mem memidx global globalidx

每个导出都由一个唯一的名称标记。可导出定义是函数、表格、内存和全局变量，它们通过相应的描述符引用。

2.5.10.1. 约定

以下辅助符号定义了导出序列，以按顺序保留的方式筛选出特定类型的索引

$funcs (export^{*}) = [funcidx ∣ func funcidx \in (export . desc)^{*}]$
$tables (export^{*}) = [tableidx ∣ table tableidx \in (export . desc)^{*}]$
$mems (export^{*}) = [memidx ∣ mem memidx \in (export . desc)^{*}]$
$globals (export^{*}) = [globalidx ∣ global globalidx \in (export . desc)^{*}]$

2.5.11. 导入

模块的 $imports$ 组件定义了一组用于实例化的导入。

import importdesc ::= ::= ∣ ∣ ∣ {module name, name name, desc importdesc} func typeidx table tabletype mem memtype global globaltype

每个导入都由一个两级名称空间标记，包括一个 $module$ 名称和一个 $name$ ，用于该模块中的一个实体。可导入的定义是函数、表、内存和全局变量。每个导入都由一个描述符指定，该描述符具有一个相应的类型，实例化期间提供的定义需要与该类型匹配。

每个导入都在相应的索引空间中定义一个索引。在每个索引空间中，导入的索引都位于模块本身包含的任何定义的第一个索引之前。

注意

与导出名称不同，导入名称不一定是唯一的。可以多次导入相同的 $module$ / $name$ 对；这些导入甚至可能具有不同的类型描述，包括不同类型的实体。具有此类导入的模块仍然可以实例化，具体取决于嵌入器如何允许解析和提供导入。但是，嵌入器不需要支持这种重载，并且 WebAssembly 模块本身不能实现重载的名称。

3. 验证

3.1. 约定

验证检查 WebAssembly 模块是否格式正确。只有有效的模块才能实例化。

有效性由抽象语法上的类型系统定义，该系统定义了模块及其内容。对于每个抽象语法，都有一个类型规则，指定适用于它的约束。所有规则都以两种等效形式给出

以散文形式描述直观的含义。
以正式符号形式描述规则，以数学形式表示。 [1]

注意

散文和正式规则是等效的，因此不需要理解正式符号就可以阅读本规范。形式主义提供了一种更简洁的描述，它使用的是编程语言语义中广泛使用的符号，并且很容易进行数学证明。

在这两种情况下，规则都是以声明式方式制定的。也就是说，它们只制定约束，并不定义算法。在附录中提供了根据本规范对指令序列进行类型检查的健全且完整的算法的框架。

3.1.1. 上下文

单个定义的有效性是相对于上下文指定的，上下文收集了有关周围模块和作用域内的定义的相关信息

类型：当前模块中定义的类型列表。
函数：当前模块中声明的函数列表，用它们的函数类型表示。
表：当前模块中声明的表列表，用它们的表类型表示。
内存：当前模块中声明的内存列表，用它们的内存类型表示。
全局变量：当前模块中声明的全局变量列表，用它们的全局变量类型表示。
元素段：当前模块中声明的元素段列表，用它们的元素类型表示。
数据段：当前模块中声明的数据段列表，每个数据段都用 $ok$ 条目表示。
局部变量：当前函数（包括参数）中声明的局部变量列表，用它们的值类型表示。
标签：从当前位置可以访问的标签堆栈，用它们的返回值类型表示。
返回值：当前函数的返回值类型，表示为可选的返回值类型，当不允许返回值时（如在独立表达式中）不存在。
引用：模块中函数外部出现的函数索引列表，因此可以在函数内部使用它们来形成引用。

换句话说，上下文包含一系列适合的类型，用于每个索引空间，描述该空间中每个定义的条目。局部变量、标签和返回值类型仅用于验证指令在函数体中，在其他地方为空。标签堆栈是上下文唯一在验证指令序列时发生变化的部分。

更具体地说，上下文被定义为记录 $C$ ，其抽象语法为

C ::= {types funcs tables mems globals elems datas locals labels return refs functype^{*}, functype^{*}, tabletype^{*}, memtype^{*}, globaltype^{*}, reftype^{*}, ok^{*}, valtype^{*}, resulttype^{*}, resulttype^{?}, funcidx^{*}}

除了以 $C. field$ 形式编写的字段访问之外，以下符号用于操作上下文。

当拼写出上下文时，空字段会被省略。
$C, field A^{*}$ 表示与 $C$ 相同的上下文，但元素 $A^{*}$ 被预先添加到其 $field$ 组件序列中。

注意

索引符号，如 $C. labels [i]$ 用于在上下文中各自的索引空间中查找索引。上下文扩展符号 $C, field A$ 主要用于局部扩展 *相对* 索引空间，如标签索引。因此，符号被定义为附加到相应序列的 *前面*，引入一个新的相对索引 $0$ 并移动现有的索引。

3.1.2. 散文符号

验证由针对抽象语法的每个相关部分的程式化规则指定。这些规则不仅陈述了定义何时短语有效的约束条件，还将其归类为一种类型。在陈述这些规则时，采用以下约定。

如果且仅当某个词组 $A$ 满足了相应规则所表达的所有约束，那么该词组就被称为“在类型 $T$ 下有效”。 $T$ 的形式取决于 $A$ 是什么。

注意

例如，如果 $A$ 是一个函数，那么 $T$ 是一个函数类型；对于一个 $A$ 是一个全局变量， $T$ 是一个全局变量类型；等等。
这些规则隐含地假设了给定的上下文 $C$ 。
在某些地方，该上下文被局部扩展为上下文 $C^{'}$ ，其中包含了额外的条目。 “在上下文 $C^{'}$ 下，… 语句 …” 这种表述用于表达以下语句必须在扩展上下文所蕴含的假设下适用。

3.1.3. 形式符号

注意

本节简要介绍了用于正式指定类型规则的符号。对于感兴趣的读者，可以在相应的教科书中找到更全面的介绍。 [2]

一个词组 $A$ 具有相应的类型 $T$ 的命题写成 $A : T$ 。然而，一般来说，类型取决于上下文 $C$ 。为了明确表达这一点，完整形式是判断 $C ⊢ A : T$ ，它表明 $A : T$ 在 $C$ 中编码的假设下成立。

形式类型规则采用了一种标准方法来指定类型系统，将其呈现为 推导规则。每个规则都有以下一般形式

\frac{前提 _{1} 前提 _{2} \dots 前提 _{n}}{结论}

这种规则被解读为一个大的蕴涵：如果所有前提都成立，那么结论就成立。有些规则没有前提；它们是结论无条件成立的公理。结论始终是一个判断 $C ⊢ A : T$ ，并且每个相关的抽象语法结构 $A$ 都对应一个规则。

注意

例如， $i32 . add$ 指令的类型规则可以作为一个公理给出

C ⊢ i32 . add : [ i32 i32 ] \to [ i32 ]

该指令始终在类型 $[i32 i32] \to [i32]$ 下有效（表明它消耗两个 $i32$ 值并生成一个），与任何辅助条件无关。

像 $local.get$ 这样的指令可以这样类型化

\frac{C. locals [ x ] = t}{C ⊢ local.get x : [ ] \to [ t ]}

这里，前提要求立即的局部索引 $x$ 存在于上下文中。指令会产生一个与其类型 $t$ 相对应的值（并且不会消耗任何值）。如果 $C. locals [x]$ 不存在，则前提不成立，指令类型错误。

最后，一个结构化指令需要一个递归规则，其中前提本身就是一个类型判断。

\frac{C ⊢ blocktype : [ t _{1}^{*} ] \to [ t _{2}^{*} ] C , label [ t _{2}^{*} ] ⊢ instr ^{*} : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}{C ⊢ block blocktype instr ^{*} end : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}

一个 $block$ 指令只有在它主体中的指令序列有效时才有效。此外，结果类型必须与块的注释 $blocktype$ 匹配。如果是这样，则 $block$ 指令具有与主体相同的类型。在主体内部，有一个额外的对应结果类型的标签可用，这可以通过将上下文 $C$ 扩展到前提中包含额外的标签信息来表达。

3.2. 类型

大多数类型都是普遍有效的。但是，对限制的限制适用，这些限制必须在验证期间进行检查。此外，块类型被转换为普通函数类型以便于处理。

3.2.1. 限制

限制必须具有有意义的边界，这些边界必须在给定范围内。

3.2.1.1. ${min n, max m^{?}}$

$n$ 的值不能大于 $k$ .
如果最大值 $m^{?}$ 非空，则
- 它的值不能大于 $k$ .
- 它的值不能小于 $n$ .
那么这个限制在 $k$ 范围内是有效的。

\frac{n \leq k ( m \leq k ) ^{?} ( n \leq m ) ^{?}}{⊢ { min n , max m ^{?} } : k}

3.2.2. 块类型

块类型可以用两种形式表示，这两种形式都将被以下规则转换为普通的函数类型。

3.2.2.1. $typeidx$

类型 $C. types [typeidx]$ 必须在上下文中定义。
那么块类型在函数类型 $C. types [typeidx]$ 中是有效的。

\frac{C. types [ typeidx ] = functype}{C ⊢ typeidx : functype}

3.2.2.2. $[valtype^{?}]$

块类型在函数类型 $[] \to [valtype^{?}]$ 中是有效的。

C ⊢ [ valtype ^{?} ] : [ ] \to [ valtype ^{?} ]

3.2.3. 函数类型

函数类型始终有效。

3.2.3.1. $[t_{1}^{n}] \to [t_{2}^{m}]$

函数类型是有效的。

⊢ [ t _{1}^{*} ] \to [ t _{2}^{*} ] ok

3.2.4. 表类型

3.2.4.1. $limits reftype$

限制 $limits$ 必须在范围 $2^{32} - 1$ 内有效。
然后表类型有效。

\frac{⊢ limits : 2 ^{32} - 1}{⊢ limits reftype ok}

3.2.5. 内存类型

3.2.5.1. $limits$

限制 $limits$ 必须在范围 $2^{16}$ 内有效。
然后内存类型有效。

\frac{⊢ limits : 2 ^{16}}{⊢ limits ok}

3.2.6. 全局类型

3.2.6.1. $mut valtype$

全局类型有效。

⊢ mut valtype ok

3.2.7. 外部类型

3.2.7.1. $func functype$

函数类型 $functype$ 必须有效。
然后外部类型有效。

\frac{⊢ functype ok}{⊢ func functype ok}

3.2.7.2. $table tabletype$

表类型 $tabletype$ 必须有效。
然后外部类型有效。

\frac{⊢ tabletype ok}{⊢ table tabletype ok}

3.2.7.3. $mem memtype$

内存类型 $memtype$ 必须有效。
然后外部类型有效。

\frac{⊢ memtype ok}{⊢ mem memtype ok}

3.2.7.4. $global globaltype$

The global type $globaltype$ must be valid.
然后外部类型有效。

\frac{⊢ globaltype ok}{⊢ global globaltype ok}

3.2.8. 导入子类型

当实例化模块时，外部值必须提供，其类型与每个导入所分类的相应外部类型相匹配。在某些情况下，这允许使用简单的子类型形式（正式写为“ $\leq$ ”），如这里所定义。

3.2.8.1. 限制

限制 ${min n_{1}, max m_{1}^{?}}$ 匹配限制 ${min n_{2}, max m_{2}^{?}}$ 当且仅当

$n_{1}$ 大于或等于 $n_{2}$ .
要么
- $m_{2}^{?}$ 为空。
或者
- 两者 $m_{1}^{?}$ 和 $m_{2}^{?}$ 均不为空。
- $m_{1}$ 小于或等于 $m_{2}$ .

\frac{n _{1} \geq n _{2}}{⊢ { min n _{1} , max m _{1}^{?} } \leq { min n _{2} , max ϵ }} \frac{n _{1} \geq n _{2} m _{1} \leq m _{2}}{⊢ { min n _{1} , max m _{1} } \leq { min n _{2} , max m _{2} }}

3.2.8.2. 函数

一个外部类型 $func functype_{1}$ 匹配 $func functype_{2}$ 当且仅当

两者 $functype_{1}$ 和 $functype_{2}$ 相同。

⊢ func functype \leq func functype

3.2.8.3. 表

一个外部类型 $table (limits_{1} reftype_{1})$ 与 $table (limits_{2} reftype_{2})$ 匹配，当且仅当

限制 $limits_{1}$ 匹配 $limits_{2}$ .
两个 $reftype_{1}$ 和 $reftype_{2}$ 相同。

\frac{⊢ limits _{1} \leq limits _{2}}{⊢ table ( limits _{1} reftype ) \leq table ( limits _{2} reftype )}

3.2.8.4. 内存

一个外部类型 $mem limits_{1}$ 与 $mem limits_{2}$ 匹配，当且仅当

限制 $limits_{1}$ 匹配 $limits_{2}$ .

\frac{⊢ limits _{1} \leq limits _{2}}{⊢ mem limits _{1} \leq mem limits _{2}}

3.2.8.5. 全局变量

一个外部类型 $global globaltype_{1}$ 与 $global globaltype_{2}$ 相匹配当且仅当

$globaltype_{1}$ 和 $globaltype_{2}$ 相同。

⊢ global globaltype \leq global globaltype

3.3. 指令

指令通过堆栈类型 $[t_{1}^{*}] \to [t_{2}^{*}]$ 进行分类，这些分类描述了指令如何操作操作数堆栈.

stacktype opdtype ::= ::= [opdtype^{*}] \to [opdtype^{*}] valtype ∣ ⊥

这些类型描述了指令弹出所需的输入栈，其中包含操作数类型 $t_{1}^{*}$ ，以及提供的输出栈，其中包含类型为 $t_{2}^{*}$ 的结果值，它会将这些值压回栈中。栈类型类似于函数类型，但它们允许将单个操作数分类为 $⊥$ （底部），表示该类型不受约束。作为辅助概念，操作数类型 $t_{1}$ 与另一个操作数类型 $t_{2}$ 匹配，如果 $t_{1}$ 是 $⊥$ 或等于 $t_{2}$ 。这以逐点方式扩展到栈类型。

⊢ t \leq t ⊢ ⊥ \leq t

\frac{( ⊢ t \leq t ^{'} ) ^{*}}{⊢ [ t ^{*} ] \leq [ t ^{'} ^{*} ]}

注意

例如，指令 $i32 . add$ 的类型为 $[i32 i32] \to [i32]$ ，它消耗两个 $i32$ 值并产生一个值。

输入扩展到指令序列 $instr^{*}$ . 这样的序列具有栈类型 $[t_{1}^{*}] \to [t_{2}^{*}]$ ，如果执行指令的累积效果是从操作数栈中消耗类型为 $t_{1}^{*}$ 的值，并将类型为 $t_{2}^{*}$ 的新值压入栈。

对于某些指令，类型规则并不能完全约束类型，因此允许多种类型。这些指令被称为多态。可以区分两种程度的多态性

值多态：值类型 $t$ 一个或多个单独的操作数不受约束。所有参数化指令都是如此，例如 $drop$ 和 $select$ .
栈多态：指令的整个（或大部分）栈类型 $[t_{1}^{*}] \to [t_{2}^{*}]$ 不受约束。所有执行无条件控制转移的控制指令都是如此，例如 $unreachable$ ， $br$ ， $br_table$ ，以及 $return$ .

在这两种情况下，只要满足程序周围部分施加的约束，就可以任意选择不受约束的类型或类型序列。

注意

例如， $select$ 指令在类型 $[t t i32] \to [t]$ 下有效，对于任何可能的数字类型 $t$ 。因此，这两个指令序列

(i32 . const 1) (i32 . const 2) (i32 . const 3) select

和

(f64 . const 1.0) (f64 . const 2.0) (i32 . const 3) select

是有效的，其中 $t$ 在 $select$ 的类型中分别实例化为 $i32$ 或 $f64$ .

指令 $unreachable$ 在任何可能的操作数类型序列 $t_{1}^{*}$ 和 $t_{2}^{*}$ 下都是有效的，类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ 。因此，

unreachable i32 . add

假设指令 $unreachable$ 的类型为 $[] \to [i32 i32]$ 是有效的。相反，

unreachable (i64 . const 0) i32 . add

是无效的，因为没有可以为指令 $unreachable$ 选择的类型可以使序列类型正确。

在附录中描述了一种类型检查算法，它可以有效地实现这里给出的规则所规定的指令序列验证。

3.3.1. 数值指令

3.3.1.1. $t . const c$

该指令的类型为 $[] \to [t]$ 是有效的。

C ⊢ t . const c : [ ] \to [ t ]

3.3.1.2. $t . unop$

该指令的类型为 $[t] \to [t]$ 是有效的。

C ⊢ t . unop : [ t ] \to [ t ]

3.3.1.3. $t . binop$

该指令的类型为 $[t t] \to [t]$ 是有效的。

C ⊢ t . binop : [ t t ] \to [ t ]

3.3.1.4. $t . testop$

该指令的类型为 $[t] \to [i32]$ 是有效的。

C ⊢ t . testop : [ t ] \to [ i32 ]

3.3.1.5. $t . relop$

该指令在类型 $[t t] \to [i32]$ 下有效。

C ⊢ t . relop : [ t t ] \to [ i32 ]

3.3.1.6. $t_{2} . cvtop_t_{1}_sx^{?}$

该指令在类型 $[t_{1}] \to [t_{2}]$ 下有效。

C ⊢ t _{2} . cvtop _ t _{1} _ sx ^{?} : [ t _{1} ] \to [ t _{2} ]

3.3.2. 引用指令

3.3.2.1. $ref . null t$

该指令的类型为 $[] \to [t]$ 是有效的。

C ⊢ ref . null t : [ ] \to [ t ]

注意

在未来的 WebAssembly 版本中，可能存在不允许空引用的引用类型。

3.3.2.2. $ref . is_null$

该指令在类型 $[t] \to [i32]$ 下有效，对于任何引用类型 $t$ 。

\frac{t = reftype}{C ⊢ ref . is_null : [ t ] \to [ i32 ]}

3.3.2.3. $ref . func x$

函数 $C. funcs [x]$ 必须在上下文中定义。
函数索引 $x$ 必须包含在 $C. refs$ 中。
该指令的类型有效为 $[] \to [funcref]$ .

\frac{C. funcs [ x ] = functype x \in C. refs}{C ⊢ ref . func x : [ ] \to [ funcref ]}

3.3.3. 向量指令

向量指令可以带有前缀来描述操作数的形状。打包数值类型， $i8$ 和 $i16$ , 不是值类型。辅助函数将这种打包类型形状映射到值类型

unpacked (i8x16) unpacked (i16x8) unpacked (t x N) = = = i32 i32 t

以下辅助函数表示向量形状的通道数，即其 *维度*

dim (t x N) = N

3.3.3.1. $v128 . const c$

该指令的类型有效为 $[] \to [v128]$ .

C ⊢ v128 . const c : [ ] \to [ v128 ]

3.3.3.2. $v128 . vvunop$

该指令的类型为 $[v128] \to [v128]$ 。

C ⊢ v128 . vvunop : [ v128 ] \to [ v128 ]

3.3.3.3. $v128 . vvbinop$

该指令的类型为 $[v128 v128] \to [v128]$ 。

C ⊢ v128 . vvbinop : [ v128 v128 ] \to [ v128 ]

3.3.3.4. $v128 . vvternop$

该指令的类型为 $[v128 v128 v128] \to [v128]$ 。

C ⊢ v128 . vvternop : [ v128 v128 v128 ] \to [ v128 ]

3.3.3.5. $v128 . vvtestop$

该指令的类型为 $[v128] \to [i32]$ 。

C ⊢ v128 . vvtestop : [ v128 ] \to [ i32 ]

3.3.3.6. $i8x16. swizzle$

该指令的类型为 $[v128 v128] \to [v128]$ 。

C ⊢ i8x16. swizzle : [ v128 v128 ] \to [ v128 ]

3.3.3.7. $i8x16. shuffle laneidx^{16}$

对于所有 $laneidx_{i}$ , 在 $laneidx^{16}$ , $laneidx_{i}$ 必须小于 $32$ .
该指令的类型为 $[v128 v128] \to [v128]$ 。

\frac{( laneidx < 32 ) ^{16}}{C ⊢ i8x16. shuffle laneidx ^{16} : [ v128 v128 ] \to [ v128 ]}

3.3.3.8. $shape . splat$

令 $t$ 为 $unpacked (shape)$ .
该指令在类型 $[t] \to [v128]$ 下有效。

C ⊢ shape . splat : [ unpacked ( shape )] \to [ v128 ]

3.3.3.9. $shape . extract_lane_sx^{?} laneidx$

车道索引 $laneidx$ 必须小于 $dim (shape)$ .
该指令在类型 $[v128] \to [unpacked (shape)]$ 下有效。

\frac{laneidx < dim ( shape )}{C ⊢ shape . extract_lane _ sx ^{?} laneidx : [ v128 ] \to [ unpacked ( shape )]}

3.3.3.10. $shape . replace_lane laneidx$

车道索引 $laneidx$ 必须小于 $dim (shape)$ .
令 $t$ 为 $unpacked (shape)$ .
该指令在类型 $[v128 t] \to [v128]$ 下有效。

\frac{laneidx < dim ( shape )}{C ⊢ shape . replace_lane laneidx : [ v128 unpacked ( shape )] \to [ v128 ]}

3.3.3.11. $shape . vunop$

该指令的类型为 $[v128] \to [v128]$ 。

C ⊢ shape . vunop : [ v128 ] \to [ v128 ]

3.3.3.12. $shape . vbinop$

该指令的类型为 $[v128 v128] \to [v128]$ 。

C ⊢ shape . vbinop : [ v128 v128 ] \to [ v128 ]

3.3.3.13. $shape . vrelop$

该指令的类型为 $[v128 v128] \to [v128]$ 。

C ⊢ shape . vrelop : [ v128 v128 ] \to [ v128 ]

3.3.3.14. $ishape . vishiftop$

该指令类型有效： $[v128 i32] \to [v128]$ .

C ⊢ ishape . vishiftop : [ v128 i32 ] \to [ v128 ]

3.3.3.15. $shape . vtestop$

该指令的类型为 $[v128] \to [i32]$ 。

C ⊢ shape . vtestop : [ v128 ] \to [ i32 ]

3.3.3.16. $shape . vcvtop_half^{?}_shape_sx^{?}_zero^{?}$

该指令的类型为 $[v128] \to [v128]$ 。

C ⊢ shape . vcvtop _ half ^{?} _ shape _ sx ^{?} _zero ^{?} : [ v128 ] \to [ v128 ]

3.3.3.17. $ishape_{1} . narrow_ishape_{2}_sx$

该指令的类型为 $[v128 v128] \to [v128]$ 。

C ⊢ ishape _{3.3.3.18. ishape . bitmask 该指令的类型为 [v128] \to [i32] 。 C ⊢ ishape . bitmask : [ v128 ] \to [ i32 ]}

3.3.3.19. $ishape_{1} . dot_ishape_{2}_s$

该指令的类型为 $[v128 v128] \to [v128]$ 。

C ⊢ ishape _{1} . dot _ ishape _{2} _s : [ v128 v128 ] \to [ v128 ]

3.3.3.20. $ishape_{1} . extmul_half_ishape_{2}_sx$

该指令的类型为 $[v128 v128] \to [v128]$ 。

C ⊢ ishape _{1} . extmul _ half _ ishape _{2} _ sx : [ v128 v128 ] \to [ v128 ]

3.3.3.21. $ishape_{1} . extadd_pairwise_ishape_{2}_sx$

该指令的类型为 $[v128] \to [v128]$ 。

C ⊢ ishape _{1} . extadd_pairwise _ ishape _{2} _ sx : [ v128 ] \to [ v128 ]

3.3.4. 参数指令

3.3.4.1. $drop$

该指令在类型 $[t] \to []$ 下有效，对于任何操作数类型 $t$ 。

C ⊢ drop : [ t ] \to [ ]

注意

$drop$ 和 $select$ 都是没有注释的值多态指令。

3.3.4.2. $select (t^{*})^{?}$

如果 $t^{*}$ 存在，那么
- $t^{*}$ 的长度必须为 $1$ 。
- 然后该指令在类型 $[t^{*} t^{*} i32] \to [t^{*}]$ 下有效。
否则
- 该指令在类型为 $[t t i32] \to [t]$ 时有效，对于任何匹配某个数字类型或向量类型的操作数类型 $t$ 均适用。

C ⊢ select t : [ t t i32 ] \to [ t ] \frac{⊢ t \leq numtype}{C ⊢ select : [ t t i32 ] \to [ t ]} \frac{⊢ t \leq vectype}{C ⊢ select : [ t t i32 ] \to [ t ]}

注意

在 WebAssembly 的未来版本中， $select$ 可能允许每个选择有多个值。

3.3.5. 变量指令

3.3.5.1. $local.get x$

局部变量 $C. locals [x]$ 必须在上下文中定义。
令 $t$ 为值类型 $C. locals [x]$ .
那么该指令在类型为 $[] \to [t]$ 时有效。

\frac{C. locals [ x ] = t}{C ⊢ local.get x : [ ] \to [ t ]}

3.3.5.2. $local.set x$

局部变量 $C. locals [x]$ 必须在上下文中定义。
令 $t$ 为值类型 $C. locals [x]$ .
那么该指令在类型为 $[t] \to []$ 时有效。

\frac{C. locals [ x ] = t}{C ⊢ local.set x : [ t ] \to [ ]}

3.3.5.3. $local.tee x$

局部变量 $C. locals [x]$ 必须在上下文中定义。
令 $t$ 为值类型 $C. locals [x]$ .
那么该指令在类型为 $[t] \to [t]$ 时有效。

\frac{C. locals [ x ] = t}{C ⊢ local.tee x : [ t ] \to [ t ]}

3.3.5.4. $global.get x$

全局变量 $C. globals [x]$ 必须在上下文环境中定义。
令 $mut t$ 为全局类型 global type $C. globals [x]$ .
那么该指令在类型为 $[] \to [t]$ 时有效。

\frac{C. globals [ x ] = mut t}{C ⊢ global.get x : [ ] \to [ t ]}

3.3.5.5. $global.set x$

全局变量 $C. globals [x]$ 必须在上下文环境中定义。
令 $mut t$ 为全局类型 global type $C. globals [x]$ .
可变性 $mut$ 必须为 $var$ .
那么该指令在类型为 $[t] \to []$ 时有效。

\frac{C. globals [ x ] = var t}{C ⊢ global.set x : [ t ] \to [ ]}

3.3.6. 表格指令

3.3.6.1. $table.get x$

表格 $C. tables [x]$ 必须在上下文环境中定义。
令 $limits t$ 为表格类型 table type $C. tables [x]$ .
然后该指令的类型为 $[i32] \to [t]$ .

\frac{C. tables [ x ] = limits t}{C ⊢ table.get x : [ i32 ] \to [ t ]}

3.3.6.2. $table.set x$

表格 $C. tables [x]$ 必须在上下文环境中定义。
令 $limits t$ 为表格类型 table type $C. tables [x]$ .
然后该指令的类型为 $[i32 t] \to []$ .

\frac{C. tables [ x ] = limits t}{C ⊢ table.set x : [ i32 t ] \to [ ]}

3.3.6.3. $table.size x$

表格 $C. tables [x]$ 必须在上下文环境中定义。
然后指令类型为 $[] \to [i32]$ 有效。

\frac{C. tables [ x ] = tabletype}{C ⊢ table.size x : [ ] \to [ i32 ]}

3.3.6.4. $table.grow x$

表格 $C. tables [x]$ 必须在上下文环境中定义。
令 $limits t$ 为表格类型 table type $C. tables [x]$ .
然后指令类型为 $[t i32] \to [i32]$ 有效。

\frac{C. tables [ x ] = limits t}{C ⊢ table.grow x : [ t i32 ] \to [ i32 ]}

3.3.6.5. $table.fill x$

表格 $C. tables [x]$ 必须在上下文环境中定义。
令 $limits t$ 为表格类型 table type $C. tables [x]$ .
然后指令类型为 $[i32 t i32] \to []$ 有效。

\frac{C. tables [ x ] = limits t}{C ⊢ table.fill x : [ i32 t i32 ] \to [ ]}

3.3.6.6. $table.copy x y$

表格 $C. tables [x]$ 必须在上下文环境中定义。
令 $limits_{1} t_{1}$ 为表类型 $C. tables [x]$ .
表 $C. tables [y]$ 必须在上下文中定义。
令 $limits_{2} t_{2}$ 为表类型 $C. tables [y]$ .
引用类型 $t_{1}$ 必须与 $t_{2}$ 相同。
那么该指令在类型 $[i32 i32 i32] \to []$ 下是有效的。

\frac{C. tables [ x ] = limits _{1} t C. tables [ y ] = limits _{2} t}{C ⊢ table.copy x y : [ i32 i32 i32 ] \to [ ]}

3.3.6.7. $table.init x y$

表格 $C. tables [x]$ 必须在上下文环境中定义。
令 $limits t_{1}$ 为表格类型 $C. tables [x]$ .
元素段 $C. elems [y]$ 必须在上下文中定义。
令 $t_{2}$ 为引用类型 $C. elems [y]$ .
引用类型 $t_{1}$ 必须与 $t_{2}$ 相同。
那么该指令在类型 $[i32 i32 i32] \to []$ 下是有效的。

\frac{C. tables [ x ] = limits t C. elems [ y ] = t}{C ⊢ table.init x y : [ i32 i32 i32 ] \to [ ]}

3.3.6.8. $elem.drop x$

元素段 $C. elems [x]$ 必须在上下文中定义。
那么该指令在类型 $[] \to []$ 下是有效的。

\frac{C. elems [ x ] = t}{C ⊢ elem.drop x : [ ] \to [ ]}

3.3.7. 内存指令

3.3.7.1. $t . load memarg$

内存 $C. mems [0]$ 必须在上下文中定义。
对齐 $2^{memarg . align}$ 不能大于位宽 $t$ 除以 $8$ .
然后该指令的类型为 $[i32] \to [t]$ .

\frac{C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq ∣t∣/8}{C ⊢ t .load memarg : [ i32 ] \to [ t ]}

3.3.7.2. $t . load N_sx memarg$

内存 $C. mems [0]$ 必须在上下文中定义。
对齐 $2^{memarg . align}$ 不能大于 $N/8$ .
然后该指令的类型为 $[i32] \to [t]$ .

\frac{C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq N/8}{C ⊢ t .load N _ sx memarg : [ i32 ] \to [ t ]}

3.3.7.3. $t . store memarg$

内存 $C. mems [0]$ 必须在上下文中定义。
对齐 $2^{memarg . align}$ 不能大于位宽 $t$ 除以 $8$ .
然后该指令的类型为 $[i32 t] \to []$ .

\frac{C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq ∣t∣/8}{C ⊢ t .store memarg : [ i32 t ] \to [ ]}

3.3.7.4. $t . store N memarg$

内存 $C. mems [0]$ 必须在上下文中定义。
对齐 $2^{memarg . align}$ 不能大于 $N/8$ .
然后该指令的类型为 $[i32 t] \to []$ .

\frac{C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq N/8}{C ⊢ t .store N memarg : [ i32 t ] \to [ ]}

3.3.7.5. $v128. load N x M_sx memarg$

内存 $C. mems [0]$ 必须在上下文中定义。
对齐方式 $2^{memarg . align}$ 不能大于 $N/8 \cdot M$ .
然后指令类型有效 $[i32] \to [v128]$ .

\frac{C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq N/8 \cdot M}{C ⊢ v128. load N x M_ sx memarg : [ i32 ] \to [ v128 ]}

3.3.7.6. $v128. load N_splat memarg$

内存 $C. mems [0]$ 必须在上下文中定义。
对齐 $2^{memarg . align}$ 不能大于 $N/8$ .
然后指令类型有效 $[i32] \to [v128]$ .

\frac{C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq N/8}{C ⊢ v128. load N _splat memarg : [ i32 ] \to [ v128 ]}

3.3.7.7. $v128. load N_zero memarg$

内存 $C. mems [0]$ 必须在上下文中定义。
对齐 $2^{memarg . align}$ 不能大于 $N/8$ .
然后指令类型有效 $[i32] \to [v128]$ .

\frac{C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq N/8}{C ⊢ v128. load N _zero memarg : [ i32 ] \to [ v128 ]}

3.3.7.8. $v128. load N_lane memarg laneidx$

车道索引 $laneidx$ 必须小于 $128/N$ .
内存 $C. mems [0]$ 必须在上下文中定义。
对齐 $2^{memarg . align}$ 不能大于 $N/8$ .
然后指令类型有效 $[i32 v128] \to [v128]$ .

\frac{laneidx < 128/N C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq N/8}{C ⊢ v128. load N _lane memarg laneidx : [ i32 v128 ] \to [ v128 ]}

3.3.7.9. $v128. store N_lane memarg laneidx$

车道索引 $laneidx$ 必须小于 $128/N$ .
内存 $C. mems [0]$ 必须在上下文中定义。
对齐 $2^{memarg . align}$ 不能大于 $N/8$ .
然后指令类型有效 $[i32 v128] \to [v128]$ .

\frac{laneidx < 128/N C. mems [ 0 ] = memtype 2 ^{memarg . align} \leq N/8}{C ⊢ v128. store N _lane memarg laneidx : [ i32 v128 ] \to [ ]}

3.3.7.10. $memory.size$

内存 $C. mems [0]$ 必须在上下文中定义。
然后指令类型为 $[] \to [i32]$ 有效。

\frac{C. mems [ 0 ] = memtype}{C ⊢ memory.size : [ ] \to [ i32 ]}

3.3.7.11. $memory.grow$

内存 $C. mems [0]$ 必须在上下文中定义。
然后这条指令是有效的，类型为 $[i32] \to [i32]$ .

\frac{C. mems [ 0 ] = memtype}{C ⊢ memory.grow : [ i32 ] \to [ i32 ]}

3.3.7.12. $memory.fill$

内存 $C. mems [0]$ 必须在上下文中定义。
那么该指令在类型 $[i32 i32 i32] \to []$ 下是有效的。

\frac{C. mems [ 0 ] = memtype}{C ⊢ memory.fill : [ i32 i32 i32 ] \to [ ]}

3.3.7.13. $memory.copy$

内存 $C. mems [0]$ 必须在上下文中定义。
那么该指令在类型 $[i32 i32 i32] \to []$ 下是有效的。

\frac{C. mems [ 0 ] = memtype}{C ⊢ memory.copy : [ i32 i32 i32 ] \to [ ]}

3.3.7.14. $memory.init x$

内存 $C. mems [0]$ 必须在上下文中定义。
数据段 $C. datas [x]$ 必须在上下文中定义。
那么该指令在类型 $[i32 i32 i32] \to []$ 下是有效的。

\frac{C. mems [ 0 ] = memtype C. datas [ x ] = ok}{C ⊢ memory.init x : [ i32 i32 i32 ] \to [ ]}

3.3.7.15. $data.drop x$

数据段 $C. datas [x]$ 必须在上下文中定义。
那么该指令在类型 $[] \to []$ 下是有效的。

\frac{C. datas [ x ] = ok}{C ⊢ data.drop x : [ ] \to [ ]}

3.3.8. 控制指令

3.3.8.1. $nop$

该指令类型有效 $[] \to []$ .

C ⊢ nop : [ ] \to [ ]

3.3.8.2. $unreachable$

该指令类型有效 $[t_{1}^{*}] \to [t_{2}^{*}]$ , 对于任何操作数类型序列 $t_{1}^{*}$ 和 $t_{2}^{*}$ .

C ⊢ unreachable : [ t _{1}^{*} ] \to [ t _{2}^{*} ]

注意

$unreachable$ 指令是栈多态的。

3.3.8.3. $block blocktype instr^{*} end$

块类型必须是有效的，作为一些函数类型 $[t_{1}^{*}] \to [t_{2}^{*}]$ .
令 $C^{'}$ 是与 $C$ 相同的上下文，但结果类型 $[t_{2}^{*}]$ 被添加到 $labels$ 向量。
在上下文 $C^{'}$ 下，指令序列 $instr^{*}$ 必须是有效的，类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ .
那么复合指令是有效的，类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ .

\frac{C ⊢ blocktype : [ t _{1}^{*} ] \to [ t _{2}^{*} ] C , labels [ t _{2}^{*} ] ⊢ instr ^{*} : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}{C ⊢ block blocktype instr ^{*} end : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}

注意

符号 $C, labels [t^{*}]$ 将新的标签类型插入到索引为 $0$ 的位置，并向后移动所有其他标签类型。

3.3.8.4. $loop blocktype instr^{*} end$

块类型必须是有效的，作为一些函数类型 $[t_{1}^{*}] \to [t_{2}^{*}]$ .
令 $C^{'}$ 是与 $C$ 相同的上下文，但将结果类型 $[t_{1}^{*}]$ 预先添加到 $labels$ 向量中。
在上下文 $C^{'}$ 下，指令序列 $instr^{*}$ 必须是有效的，类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ .
那么复合指令是有效的，类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ .

\frac{C ⊢ blocktype : [ t _{1}^{*} ] \to [ t _{2}^{*} ] C , labels [ t _{1}^{*} ] ⊢ instr ^{*} : [ t _{1}^{*} ] \to [ t}{C ⊢ loop blocktype instr ^{*} end : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}

3.3.8.5. $if blocktype instr_{1}^{} else instr_{2}^{} end$

块类型必须是有效的，作为一些函数类型 $[t_{1}^{*}] \to [t_{2}^{*}]$ .
令 $C^{'}$ 是与 $C$ 相同的上下文，但结果类型 $[t_{2}^{*}]$ 被添加到 $labels$ 向量。
在上下文 $C^{'}$ 下，指令序列 $instr_{1}^{*}$ 必须是有效的，类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ .
在上下文 $C^{'}$ 下，指令序列 $instr_{2}^{*}$ 必须是有效的类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ .
然后，复合指令是有效的，类型为 $[t_{1}^{*} i32] \to [t_{2}^{*}]$ .

\frac{C ⊢ blocktype : [ t _{1}^{*} ] \to [ t _{2}^{*} ] C , labels [ t _{2}^{*} ] ⊢ instr _{1}^{*} : [ t _{1}^{*} ] \to [ t _{2}^{*} ] C , labels [ t _{2}^{*} ] ⊢ instr _{2}^{*} : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}{C ⊢ if blocktype instr _{1}^{*} else instr _{2}^{*} end : [ t _{1}^{*} i32 ] \to [ t _{2}^{*} ]}

注意

符号 $C, labels [t^{*}]$ 将新的标签类型插入到索引为 $0$ 的位置，并向后移动所有其他标签类型。

3.3.8.6. $br l$

标签 $C. labels [l]$ 必须在上下文中定义。
令 $[t^{*}]$ 为结果类型 $C. labels [l]$ .
然后指令在类型 $[t_{1}^{*} t^{*}] \to [t_{2}^{*}]$ 下有效，对于任何操作数类型序列 $t_{1}^{*}$ 和 $t_{2}^{*}$ .

\frac{C. labels [ l ] = [ t ^{*} ]}{C ⊢ br l : [ t _{1}^{*} t ^{*} ] \to [ t _{2}^{*} ]}

注意

在上下文 $C$ 的标签索引空间中，最近的标签位于最前面，这样 $C. labels [l]$ 如预期那样执行相对查找。

指令 $br$ 是堆栈多态的。

3.3.8.7. $br_if l$

标签 $C. labels [l]$ 必须在上下文中定义。
令 $[t^{*}]$ 为结果类型 $C. labels [l]$ .
然后指令在类型 $[t^{*} i32] \to [t^{*}]$ 下有效。

\frac{C. labels [ l ] = [ t ^{*} ]}{C ⊢ br_if l : [ t ^{*} i32 ] \to [ t ^{*} ]}

注意

在上下文 $C$ 的标签索引空间中，最近的标签位于最前面，这样 $C. labels [l]$ 如预期那样执行相对查找。

3.3.8.8. $br_table l^{*} l_{N}$

标签 $C. labels [l_{N}]$ 必须在上下文中定义。
对于每个标签 $l_{i}$ 在 $l^{*}$ 中，标签 $C. labels [l_{i}]$ 必须在上下文中定义。
必须存在一个操作数类型序列 $t^{*}$ ，使得
- 序列 $t^{*}$ 的长度与序列 $C. labels [l_{N}]$ 的长度相同。
- 对于每个操作数类型 $t_{j}$ 在 $t^{*}$ 中，以及在 $C. labels [l_{N}]$ 中对应的类型 $t ’_{Nj}$ ， $t_{j}$ 匹配 $t ’_{Nj}$ .
- 对于每个标签 $l_{i}$ 在 $l^{*}$
  - 序列 $t^{*}$ 的长度与序列 $C. labels [l_{i}]$ 的长度相同。
  - 对于每个操作数类型 $t_{j}$ 在 $t^{*}$ 中，以及在 $C. labels [l_{i}]$ 中对应的类型 $t ’_{ij}$ ， $t_{j}$ 匹配 $t ’_{ij}$ .
然后该指令在类型 $[t_{1}^{*} t^{*} i32] \to [t_{2}^{*}]$ 下有效，对于任何操作数类型序列 $t_{1}^{*}$ 和 $t_{2}^{*}$ 。

\frac{( ⊢ [ t ^{*} ] \leq C. labels [ l ] ) ^{*} ⊢ [ t ^{*} ] \leq C. labels [ l _{N} ]}{C ⊢ br_table l ^{*} l _{N} : [ t _{1}^{*} t ^{*} i32 ] \to [ t _{2}^{*} ]}

注意

在上下文 $C$ 中的标签索引空间包含最新的标签，所以 $C. labels [l_{i}]$ 执行一个相对查找，如预期。

该 $br_table$ 指令是堆栈多态的。

3.3.8.9. $return$

返回类型 $C. return$ 在上下文中不能是缺失的。
设 $[t^{*}]$ 是 $C. return$ 的结果类型。
然后指令在类型 $[t_{1}^{*} t^{*}] \to [t_{2}^{*}]$ 下有效，对于任何操作数类型序列 $t_{1}^{*}$ 和 $t_{2}^{*}$ .

\frac{C. return = [ t ^{*} ]}{C ⊢ return : [ t _{1}^{*} t ^{*} ] \to [ t _{2}^{*} ]}

注意

指令 $return$ 是栈多态的。

$C. return$ 在验证一个非函数体的表达式时，是缺失的（设置为 $ϵ$ ）。这与将其设置为空结果类型 ( $[ϵ]$ ) 不同，后者是针对不返回任何内容的函数的。

3.3.8.10. $call x$

函数 $C. funcs [x]$ 必须在上下文中定义。
然后指令在类型 $C. funcs [x]$ 下是有效的。

\frac{C. funcs [ x ] = [ t _{1}^{*} ] \to [ t _{2}^{*} ]}{C ⊢ call x : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}

3.3.8.11. $call_indirect x y$

表格 $C. tables [x]$ 必须在上下文环境中定义。
令 $limits t$ 为表格类型 table type $C. tables [x]$ .
引用类型 $t$ 必须是 $funcref$ .
类型 $C. types [y]$ 必须在上下文中定义。
设 $[t_{1}^{*}] \to [t_{2}^{*}]$ 为函数类型 $C. types [y]$ .
然后指令在类型 $[t_{1}^{*} i32] \to [t_{2}^{*}]$ 下是有效的。

\frac{C. tables [ x ] = limits funcref C. types [ y ] = [ t _{1}^{*} ] \to [ t _{2}^{*} ]}{C ⊢ call_indirect x y : [ t _{1}^{*} i32 ] \to [ t _{2}^{*} ]}

3.3.9. 指令序列

指令序列的类型递归定义。

3.3.9.1. 空指令序列: $ϵ$

空指令序列对于任何操作数类型序列 $[t^{*}] \to [t^{*}]$ 都是有效的，且类型为 $[t^{*}] \to [t^{*}]$ .

C ⊢ ϵ : [ t ^{*} ] \to [ t ^{*} ]

3.3.9.2. 非空指令序列: $instr^{*} instr_{N}$

指令序列 $instr^{*}$ 必须是有效的，且类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ ，对于一些操作数类型序列 $t_{1}^{*}$ 和 $t_{2}^{*}$ .
指令 $instr_{N}$ 必须是有效的，类型为 $[t^{*}] \to [t_{3}^{*}]$ , 对于某些操作数类型 $t^{*}$ 和 $t_{3}^{*}$ 的序列。
必须有一个操作数类型序列 $t_{0}^{*}$ , 使得 $t_{2}^{*} = t_{0}^{*} t^{'}^{*}$ , 其中类型序列 $t^{'}^{*}$ 的长度与 $t^{*}$ 相同。
对于每个操作数类型 $t ’_{i}$ 在 $t^{'}^{*}$ 中，以及在 $t^{*}$ 中对应的类型 $t_{i}$ , $t ’_{i}$ 匹配 $t_{i}$ .
那么组合的指令序列将是有效的，类型为 $[t_{1}^{*}] \to [t_{0}^{*} t_{3}^{*}]$ .

\frac{C ⊢ instr ^{*} : [ t _{1}^{*} ] \to [ t _{0}^{*} t ^{'} ^{*} ] ⊢ [ t ^{'} ^{*} ] \leq [ t ^{*} ] C ⊢ instr _{N} : [ t ^{*} ] \to [ t _{3}^{*} ]}{C ⊢ instr ^{*} instr _{N} : [ t _{1}^{*} ] \to [ t _{0}^{*} t _{3}^{*} ]}

3.3.10. 表达式

表达式 $expr$ 通过结果类型进行分类，形式为 $[t^{*}]$ .

3.3.10.1. $instr^{*} end$

指令序列 $instr^{*}$ 必须与某个堆栈类型 $[] \to [t^{'}^{*}]$ 构成有效的。
对于每个操作数类型 $t ’_{i}$ 在 $t^{'}^{*}$ 中，以及对应的值类型 $t_{i}$ 在 $t^{*}$ 中， $t ’_{i}$ 匹配 $t_{i}$ .
那么该表达式有效，且结果类型为 $[t^{*}]$ .

\frac{C ⊢ instr ^{*} : [ ] \to [ t ^{'} ^{*} ] ⊢ [ t ^{'} ^{*} ] \leq [ t ^{*} ]}{C ⊢ instr ^{*} end : [ t ^{*} ]}

3.3.10.2. 常量表达式

在常量表达式 $instr^{*} end$ 中， $instr^{*}$ 中的所有指令都必须是常量。
常量指令 $instr$ 必须是
- 形式为 $t. const c$ 的指令，
- 或者形式为 $ref . null$ 的指令，
- 或者形式为 $ref . func x$ 的指令，
- 或者形式为 $global.get x$ 的指令，在这种情况下， $C. globals [x]$ 必须是形式为 $const t$ 的全局类型。

\frac{( C ⊢ instr const ) ^{*}}{C ⊢ instr ^{*} end const}

C ⊢ t. const c const C ⊢ ref . null t const C ⊢ ref . func x const

\frac{C. globals [ x ] = const t}{C ⊢ global.get x const}

注意

目前，出现在 globals、element 或 data 段的常量表达式受到进一步约束，因为其中包含的 $global.get$ 指令只能引用*导入的*全局变量。这在模块验证规则中通过相应地约束上下文 $C$ 来强制执行。

常量表达式的定义可能会在 WebAssembly 的未来版本中扩展。

3.4. 模块

模块在它们包含的所有组件都有效时才有效。此外，大多数定义本身都用合适的类型进行分类。

3.4.1. 函数

函数 $func$ 通过形式为 $[t_{1}^{*}] \to [t_{2}^{*}]$ 的函数类型进行分类。

3.4.1.1. ${type x, locals t^{*}, body expr}$

类型 $C. types [x]$ 必须在上下文中定义。
令 $[t_{1}^{*}] \to [t_{2}^{*}]$ 为函数类型 $C. types [x]$ .
令 $C^{'}$ 与 $C$ 相同的上下文，但
- $locals$ 设置为值类型的序列 $t_{1}^{*} t^{*}$ , 连接参数和局部变量，
- $labels$ 被设置为仅包含结果类型 $[t_{2}^{*}]$ 的单个序列。
- $return$ 被设置为结果类型 $[t_{2}^{*}]$ .
在上下文 $C^{'}$ 中，表达式 $expr$ 必须是有效的，类型为 $[t_{2}^{*}]$ .
然后函数定义是有效的，类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ .

\frac{C. types [ x ] = [ t _{1}^{*} ] \to [ t _{2}^{*} ] C , locals t _{1}^{*} t ^{*} , labels [ t _{2}^{*} ] , return [ t _{2}^{*} ] ⊢ expr : [ t _{2}^{*} ]}{C ⊢ { type x , locals t ^{*} , body expr } : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}

3.4.2. 表

表 $table$ 是按表类型分类。

3.4.2.1. ${type tabletype}$

The table type $tabletype$ 必须是 valid 的。
然后表格定义在类型为 $tabletype$ 时是有效的。

\frac{⊢ tabletype ok}{C ⊢ { type tabletype } : tabletype}

3.4.3. 内存

内存 $mem$ 是通过内存类型进行分类的。

3.4.5. Element Segments

Element segments $elem$ are classified by the reference type of their elements.

3.4.5.1. ${type t, init e^{*}, mode elemmode}$

对于每个 $e_{i}$ 在 $e^{*}$
- 表达式 $e_{i}$ 必须是有效的，并具有某种结果类型 $[t]$ .
- 表达式 $e_{i}$ 必须是常量。
元素模式 $elemmode$ 必须是有效的，并具有引用类型 $t$ .
然后元素段是有效的，并具有引用类型 $t$ .

\frac{( C ⊢ e : [ t ] ) ^{*} ( C ⊢ e const ) ^{*} C ⊢ elemmode : t}{C ⊢ { type t , init e ^{*} , mode elemmode } : t}

3.4.5.2. $passive$

元素模式对于任何引用类型都是有效的。

C ⊢ passive : reftype

3.4.5.3. $active {table x, offset expr}$

表格 $C. tables [x]$ 必须在上下文环境中定义。
令 $limits t$ 为表格类型 table type $C. tables [x]$ .
表达式 $expr$ 必须是有效的，并具有结果类型 $[i32]$ .
The expression $expr$ must be constant.
然后元素模式对于引用类型 $t$ 则是有效的。

\frac{C . tables [ x ] = limits t C ⊢ expr : [ i32 ] C ⊢ expr const}{C ⊢ active { table x , offset expr } : t}

3.4.5.4. $declarative$

元素模式对于任何引用类型都是有效的。

C ⊢ declarative : reftype

3.4.6. 数据段

数据段 $data$ 不按任何类型分类，只检查其是否格式正确。

3.4.6.1. ${init b^{*}, mode datamode}$

数据模式 $datamode$ 必须有效。
然后数据段就有效。

\frac{C ⊢ datamode ok}{C ⊢ { init b ^{*} , mode datamode } ok}

3.4.6.2. $passive$

数据模式有效。

C ⊢ passive ok

3.4.6.3. $active {memory x, offset expr}$

内存 $C. mems [x]$ 必须在上下文中定义。
表达式 $expr$ 必须是有效的，并具有结果类型 $[i32]$ .
The expression $expr$ must be constant.
然后数据模式有效。

\frac{C. mems [ x ] = limits C ⊢ expr : [ i32 ] C ⊢ expr const}{C ⊢ active { memory x , offset expr } ok}

3.4.7. 起始函数

起始函数声明 $start$ 不按任何类型分类。

3.4.7.1. ${func x}$

函数 $C. funcs [x]$ 必须在上下文中定义。
的类型 $C. funcs [x]$ 必须是 $[] \to []$ .
然后起始函数就有效。

\frac{C. funcs [ x ] = [ ] \to [ ]}{C ⊢ { func x } ok}

3.4.8. 导出

导出 $export$ 和导出描述 $exportdesc$ 按其外部类型进行分类。

3.4.8.1. ${name name, desc exportdesc}$

导出描述 $exportdesc$ 必须与外部类型 $externtype$ 匹配。
然后，导出与外部类型 $externtype$ 匹配。

\frac{C ⊢ exportdesc : externtype}{C ⊢ { name name , desc exportdesc } : externtype}

3.4.8.2. $func x$

函数 $C. funcs [x]$ 必须在上下文中定义。
然后，导出描述与外部类型 $func C. funcs [x]$ 匹配。

\frac{C. funcs [ x ] = functype}{C ⊢ func x : func functype}

3.4.8.3. $table x$

表格 $C. tables [x]$ 必须在上下文环境中定义。
然后，导出描述与外部类型 $table C. tables [x]$ 匹配。

\frac{C. tables [ x ] = tabletype}{C ⊢ table x : table tabletype}

3.4.8.4. $mem x$

内存 $C. mems [x]$ 必须在上下文中定义。
然后，导出描述与外部类型 $mem C. mems [x]$ 匹配。

\frac{C. mems [ x ] = memtype}{C ⊢ mem x : mem memtype}

3.4.8.5. $global x$

全局变量 $C. globals [x]$ 必须在上下文环境中定义。
然后，导出描述与外部类型 $global C. globals [x]$ 匹配。

\frac{C. globals [ x ] = globaltype}{C ⊢ global x : global globaltype}

3.4.9. 导入

导入 $import$ 和导入描述 $importdesc$ 由外部类型分类。

3.4.9.1. ${module name_{1}, name name_{2}, desc importdesc}$

导入描述 $importdesc$ 必须是有效的，类型为 $externtype$ .
那么，该导入就是有效的，类型为 $externtype$ .

\frac{C ⊢ importdesc : externtype}{C ⊢ { module name _{1} , name name _{2} , desc importdesc } : externtype}

3.4.9.2. $func x$

函数 $C. types [x]$ 必须在上下文中定义。
令 $[t_{1}^{*}] \to [t_{2}^{*}]$ 为函数类型 $C. types [x]$ .
那么，该导入描述是有效的，类型为 $func [t_{1}^{*}] \to [t_{2}^{*}]$ .

\frac{C. types [ x ] = [ t _{1}^{*} ] \to [ t _{2}^{*} ]}{C ⊢ func x : func [ t _{1}^{*} ] \to [ t _{2}^{*} ]}

3.4.9.3. $table tabletype$

表类型 $tabletype$ 必须是有效的。
然后导入描述的类型为 $table tabletype$ 的有效描述。

\frac{⊢ tabletype ok}{C ⊢ table tabletype : table tabletype}

3.4.9.4. $mem memtype$

内存类型 $memtype$ 必须是有效的。
然后导入描述的类型为 $mem memtype$ 的有效描述。

\frac{⊢ memtype ok}{C ⊢ mem memtype : mem memtype}

3.4.9.5. $global globaltype$

全局类型 $globaltype$ 必须是有效的。
然后导入描述的类型为 $global globaltype$ 的有效描述。

\frac{⊢ globaltype ok}{C ⊢ global globaltype : global globaltype}

3.4.10. 模块

模块通过其外部类型的导入到导出的映射来分类。

模块完全是*封闭*的，也就是说，其组件只能引用模块本身中出现的定义。因此，不需要任何初始上下文。相反，模块内容验证的上下文 $C$ 由模块中的定义构建。

令 $module$ 为要验证的模块。
令 $C$ 为一个上下文，其中
- $C. types$ 为 $module . types$ ，
- $C. funcs$ 是 $funcs (it^{*})$ 与 $ft^{*}$ 的连接，其中导入的外部类型为 $it^{*}$ ，内部函数类型为 $ft^{*}$ ，如下所示：
- $C. tables$ 是 $tables (it^{*})$ 与 $tt^{*}$ 的连接，其中导入的外部类型为 $it^{*}$ ，内部表格类型为 $tt^{*}$ ，如下所示：
- $C. mems$ 是 $mems (it^{*})$ 与 $mt^{*}$ 的连接，其中导入的外部类型为 $it^{*}$ ，内部内存类型为 $mt^{*}$ ，如下所示：
- $C. globals$ 是 $globals (it^{*})$ 与 $gt^{*}$ 的连接，其中导入的外部类型为 $it^{*}$ ，内部全局类型为 $gt^{*}$ ，如下所示：
- $C. elems$ 是 $rt^{*}$ ，如下所示：
- $C. datas$ 是 $ok^{n}$ , 其中 $n$ 是向量 $module . datas$ 的长度：
- $C. locals$ 是空的。
- $C. labels$ 是空的。
- $C. return$ 为空。
- $C. refs$ 是集合 $funcidx (module with funcs = ϵ with start = ϵ)$ ，即模块中出现的函数索引集合，但其函数或起始函数除外。
令 $C^{'}$ 与 $C$ 相同的上下文，除了 $C^{'} . globals$ 只是序列 $globals (it^{*})$ .
对于 $functype_{i}$ 在 $module . types$ 中的每个函数类型 $functype_{i}$ 必须是有效的。
在上下文 $C^{'}$ 下
- 对于 $table_{i}$ 在 $module . tables$ 中的每个 $table_{i}$ ，定义 $table_{i}$ 必须是具有表类型 $tt_{i}$ 的有效的。
- 对于 $mem_{i}$ 在 $module . mems$ 中的每个 $mem_{i}$ ，定义 $mem_{i}$ 必须是具有内存类型 $mt_{i}$ 的有效的。
- 对于 $global_{i}$ 在 $module . globals$ 中的每个 $global_{i}$ ，定义 $global_{i}$ 必须是具有全局类型 $gt_{i}$ 的有效的。
- 对于每个 $elem_{i}$ 在 $module . elems$ 中，片段 $elem_{i}$ 必须是有效的，并具有引用类型 $rt_{i}$ .
- 对于每个 $data_{i}$ 在 $module . datas$ 中，片段 $data_{i}$ 必须是有效的。
在上下文 $C$
- 对于每个 $func_{i}$ 在 $module . funcs$ 中，定义 $func_{i}$ 必须是有效的，并具有函数类型 $ft_{i}$ .
- 如果 $module . start$ 不为空，则 $module . start$ 必须是有效的。
- 对于每个 $import_{i}$ 在 $module . imports$ 中，片段 $import_{i}$ 必须是有效的，并具有外部类型 $it_{i}$ .
- 对于每个 $export_{i}$ 在 $module . exports$ 中，片段 $export_{i}$ 必须是有效的，并具有外部类型 $et_{i}$ .
的长度 $C. mems$ 必须不超过 $1$ .
所有导出名称 $export_{i} . name$ 必须不同。
令 $ft^{*}$ 为内部函数类型 $ft_{i}$ 的级联，按索引顺序。
令 $tt^{*}$ 为内部表格类型 $tt_{i}$ 的级联，按索引顺序。
令 $mt^{*}$ 为内部内存类型 $mt_{i}$ 的级联，按索引顺序。
令 $gt^{*}$ 为内部全局类型 $gt_{i}$ 的级联，按索引顺序。
令 $rt^{*}$ 为引用类型 $rt_{i}$ 的级联，按索引顺序。
令 $it^{*}$ 为外部类型 $it_{i}$ 在导入中的级联，按索引顺序。
令 $et^{*}$ 为外部类型 $et_{i}$ 在导出中的级联，按索引顺序。
那么，该模块使用外部类型 $it^{*} \to et^{*}$ 为有效。

\frac{( ⊢ type ok ) ^{*} ( C ⊢ func : ft ) ^{*} ( C ^{'} ⊢ table : tt ) ^{*} ( C ^{'} ⊢ mem : mt ) ^{*} ( C ^{'} ⊢ global : gt ) ^{*} ( C ^{'} ⊢ elem : rt ) ^{*} ( C ^{'} ⊢ data ok ) ^{n} ( C ⊢ start ok ) ^{?} ( C ⊢ import : it ) ^{*} ( C ⊢ export : et ) ^{*} ift ^{*} = funcs ( it ^{*} ) itt ^{*} = tables ( it ^{*} ) imt ^{*} = mems ( it ^{*} ) igt ^{*} = globals ( it ^{*} ) x ^{*} = funcidx ( module with funcs = ϵ with start = ϵ ) C = { types type ^{*} , funcs ift ^{*} ft ^{*} , tables itt ^{*} tt ^{*} , mems imt ^{*} mt ^{*} , globals igt ^{*} gt ^{*} , elems rt ^{*} , datas ok ^{n} , refs x ^{*} } C ^{'} = C with globals = igt ^{*} ∣ C . mems ∣ \leq 1 ( export . name ) ^{*} disjoint module = { types type ^{*} , funcs func ^{*} , tables table ^{*} , mems mem ^{*} , globals global ^{*} , elems elem ^{*} , datas data ^{n} , start start ^{?} , imports import ^{*} , exports export ^{*} }}{⊢ module : it ^{*} \to et ^{*}}

注意

模块中的大多数定义——特别是函数——是相互递归的。因此，此规则中上下文 $C$ 的定义是递归的：它依赖于模块中包含的函数、表格、内存和全局定义的验证结果，而这些验证结果本身又依赖于 $C$ 。然而，这种递归仅仅是一种规范手段。构建 $C$ 所需的所有类型都可以很容易地从模块上的一次简单的预处理中确定，该预处理不会执行任何实际的验证。

但是，全局变量不是递归的，并且在它们被局部定义时，不能在常量表达式中访问。定义有限上下文 $C^{'}$ 用于验证某些定义的效果是，它们只能访问函数和导入的全局变量，而不能访问其他任何内容。

注意

WebAssembly 的未来版本可能会取消对内存数量的限制。

4. 执行

4.1. 约定

当实例化模块或调用结果模块实例上的导出函数时，WebAssembly 代码就会被执行。

执行行为是在模拟程序状态的抽象机的术语中定义的。它包含一个堆栈，用于记录操作数的值和控制结构，以及一个包含全局状态的抽象存储。

对于每条指令，都有一个规则指定其执行对程序状态的影响。此外，还有一些规则描述了模块的实例化。与验证一样，所有规则都以两种等效形式给出

以散文形式描述执行，以直观的方式。
以形式化符号形式描述规则，以数学形式。 [1]

注意

与验证一样，散文和形式化规则是等效的，因此不需要理解形式化符号来阅读本规范。形式化符号以编程语言语义中广泛使用的符号提供了更简洁的描述，并且易于进行数学证明。

4.1.1. 散文符号

执行由针对指令的每种抽象语法的风格化、逐步规则来指定。在陈述这些规则时，采用了以下约定。

执行规则隐含地假设给定了一个存储 $S$ .
执行规则还假设存在一个隐式堆栈，它通过压入或弹出值、标签和帧来修改。
某些规则要求堆栈至少包含一个帧。最近的帧被称为当前帧。
存储和当前帧都通过替换其某些组件来进行修改。这种替换被假定为全局适用。
指令的执行可能陷入，在这种情况下，整个计算将被中止，并且它不会对存储进行进一步的修改。（之后仍然可以启动其他计算。）
指令的执行也可能以跳转到指定的目标结束，该目标定义了要执行的下一条指令。
执行可以进入和退出指令序列，这些序列形成了块。
指令序列隐式地按顺序执行，除非发生陷阱或跳转。
在各个地方，规则包含断言，表达了关于程序状态的关键不变式。

4.1.2. 形式符号

注意

本节简要解释了正式指定执行的符号。对于感兴趣的读者，可以在相应的教科书中找到更深入的介绍。 [2]

正式执行规则使用一种标准方法来指定操作语义，将它们呈现为规约规则。每个规则都有以下一般形式

配置 ↪ 配置

配置是对程序状态的句法描述。每个规则指定执行的一步。只要最多有一个规约规则适用于给定的配置，规约（从而执行）就是确定性的。WebAssembly 只有极少数例外，这些例外在本规范中明确指出。

对于 WebAssembly，配置通常是一个元组 $(S; F; instr^{*})$ ，它由当前存储 $S$ 、当前函数的调用帧 $F$ 以及要执行的指令序列组成。（更精确的定义稍后给出。）

为了避免不必要的混乱，存储 $S$ 和帧 $F$ 从不涉及它们的规约规则中省略。

没有堆栈的独立表示。相反，它很方便地表示为配置的指令序列的一部分。特别是，值被定义为与 $const$ 指令一致，并且 $const$ 指令的序列可以解释为一个向右增长的操作数“堆栈”。

注意

例如，规约规则用于 $i32 . add$ 指令可以给出如下：

(i32 . const n_{1}) (i32 . const n_{2}) i32 . add ↪ (i32 . const (n_{1} + n_{2}) mod 2^{32})

根据此规则，两个 $const$ 指令以及 $add$ 指令本身从指令流中删除，并用一个新的 $const$ 指令替换。这可以解释为从堆栈中弹出两个值并将结果压入。

当没有产生结果时，指令简化为空序列

nop ↪ ϵ

标签和帧类似地定义为指令序列的一部分。

规约的顺序由适当的求值上下文的定义决定。

当没有更多规约规则适用时，规约终止。WebAssembly 类型系统的健壮性保证这仅在原始指令序列已简化为 $const$ 指令序列（可以解释为结果操作数堆栈的值）或发生陷阱时才会发生。

注意

例如，以下指令序列：

(f64 . const x_{1}) (f64 . const x_{2}) f64 . neg (f64 . const x_{3}) f64 . add f64 . mul

在三个步骤后终止

↪ ↪ ↪ (f64 . const x_{1}) (f64 . const x_{2}) f64 . neg (f64 . const x_{3}) f64 . add f64 . mul (f64 . const x_{1}) (f64 . const x_{4}) (f64 . const x_{3}) f64 . add f64 . mul (f64 . const x_{1}) (f64 . const x_{5}) f64 . mul (f64 . const x_{6})

其中 $x_{4} = - x_{2}$ 且 $x_{5} = - x_{2} + x_{3}$ 以及 $x_{6} = x_{1} \cdot (- x_{2} + x_{3})$ .

4.2. 运行时结构

存储器、栈以及其他构成 WebAssembly 抽象机的运行时结构，例如值或模块实例，在额外的辅助语法中被精确定义。

4.2.1. 值

WebAssembly 计算操作四种基本数值类型的值，即整数和浮点数（分别为 32 位和 64 位），或向量（128 位），或引用类型。

在语义的大部分地方，不同类型的值可能出现。为了避免歧义，因此使用抽象语法表示值，该语法明确了值的类型。方便起见，可以使用与 $const$ 指令和 $ref . null$ 相同的符号来表示它们。

非空引用由附加的管理指令表示。它们要么是函数引用，指向特定的函数地址，要么是外部引用，指向外部地址的未解释形式，可由嵌入器定义以表示其自己的对象。

num vec ref val ::= ∣ ∣ ∣ ::= ::= ∣ ∣ ::= i32 . const i32 i64 . const i64 f32 . const f32 f64 . const f64 v128 . const i128 ref . null t ref funcaddr ref . extern externaddr num ∣ vec ∣ ref

注意

WebAssembly 的未来版本可能会添加其他形式的引用。

每个值类型都有一个关联的默认值；对于数值类型，它分别是 $0$ ；对于向量类型，它是 $0$ ；对于引用类型，它是 null。

default_{t} default_{t} default_{t} = = = t . const 0 t . const 0 ref . null t (if t = numtype) (if t = vectype) (if t = reftype)

4.2.1.1. 约定

元变量 $r$ 在上下文中清晰的情况下，表示引用值。

4.2.2. 结果

结果是计算的结果。它要么是一系列值，要么是一个陷阱。

result ::= ∣ val^{*} trap

4.2.3. 存储

存储表示 WebAssembly 程序可以操作的所有全局状态。它包含所有函数、表格、内存和全局变量、元素段以及数据段的运行时表示，这些实例在抽象机器的生命周期中已被分配。 [1]

语义的一个不变式是，没有任何元素或数据实例从除拥有模块实例以外的任何地方被寻址。

从语法上讲，存储被定义为一个记录，列出每种类型的现有实例。

store ::= {funcs tables mems globals elems datas funcinst^{*}, tableinst^{*}, meminst^{*}, globalinst^{*}, eleminst^{*}, datainst^{*}}

4.2.3.1. 约定

元变量 $S$ 在上下文中明确时，表示存储。

4.2.4. 地址

函数实例、表格实例、内存实例和全局变量实例、元素实例以及数据实例在存储中用抽象的地址引用。这些地址只是对各自存储组件的索引。此外，嵌入器可以提供一组未解释的主机地址。

addr funcaddr tableaddr memaddr globaladdr elemaddr dataaddr externaddr ::= ::= ::= ::= ::= ::= ::= ::= 0 ∣ 1 ∣ 2 ∣ \dots addr addr addr addr addr addr addr

一个嵌入器可以为与它们的地址相对应的导出的存储对象分配标识，即使此标识在 WebAssembly 代码本身内部不可观察（例如，对于函数实例或不可变的全局变量）。

注意

地址是动态的，全局唯一的对运行时对象的引用，与索引形成对比，后者是静态的，对它们原始定义的模块本地引用。内存地址 $memaddr$ 表示存储中内存实例的抽象地址，而不是内存实例内部的偏移量。

存储对象分配数量没有具体限制，因此逻辑地址可以是任意大的自然数。

4.2.5. 模块实例

模块实例是模块的运行时表示。它是通过实例化模块创建的，它收集了由模块导入、定义或导出的所有实体的运行时表示。

moduleinst ::= {types funcaddrs tableaddrs memaddrs globaladdrs elemaddrs dataaddrs exports functype^{*}, funcaddr^{*}, tableaddr^{*}, memaddr^{*}, globaladdr^{*}, elemaddr^{*}, dataaddr^{*}, exportinst^{*}}

每个组件引用其原始模块中相应声明（无论是导入还是定义）的运行时实例，按照其静态索引的顺序。函数实例、表实例、内存实例和全局实例通过它们各自在存储区中的地址进行间接引用。

语义的不变性要求给定模块实例中的所有导出实例具有不同的名称。

4.2.6. 函数实例

函数实例是函数的运行时表示。它实际上是对其原始函数的运行时模块实例（来自其原始模块）的闭包。模块实例用于在执行函数期间解析对其他定义的引用。

funcinst hostfunc ::= ∣ ::= {type functype, module moduleinst, code func} {type functype, hostcode hostfunc} \dots

宿主函数是在 WebAssembly 外部表达的函数，但作为导入传递给模块。宿主函数的定义和行为超出了本规范的范围。为了本规范的目的，假设当调用时，宿主函数的行为是不确定的，但在某些约束内，以确保运行时的完整性。

注意

函数实例是不可变的，并且它们的标识不能被 WebAssembly 代码观察到。但是，嵌入器可能会提供隐式或显式的方法来区分它们的地址。

4.2.7. 表实例

表实例是表的运行时表示。它记录了它的类型，并包含一个引用值向量。

tableinst ::= {type tabletype, elem vec (ref)}

表元素可以通过表指令、活动元素段的执行或由嵌入器提供的外部手段进行修改。

语义的不变性要求所有表元素的类型都等于 $tabletype$ 的元素类型。它也是一个不变性，即元素向量的长度永远不会超过 $tabletype$ 的最大大小（如果存在）。

4.2.8. 内存实例

内存实例是线性内存的运行时表示。它记录了它的类型，并包含一个字节向量。

meminst ::= {type memtype, data vec (byte)}

向量长度始终是 WebAssembly *页面大小* 的倍数，页面大小定义为常数 $65536$ ，简写为 $64 Ki$ .

字节可以通过内存指令、活动数据段的执行或由嵌入器提供的外部手段进行修改。

语义的不变性在于，字节向量长度除以页面大小，永远不会超过 $memtype$ 的最大大小（如果存在）。

4.2.9. 全局实例

全局实例 是全局变量的运行时表示。它记录了其类型并保存一个单独的值。

globalinst ::= {type globaltype, value val}

可变全局变量的值可以通过变量指令或由嵌入器提供的外部手段进行修改。

语义的不变性在于，该值具有与 $globaltype$ 的值类型相同的类型。

4.2.10. 元素实例

元素实例 是元素段的运行时表示。它保存引用向量及其共同的类型。

eleminst ::= {type reftype, elem vec (ref)}

4.2.11. 数据实例

数据实例 是数据段的运行时表示。它保存一个字节向量。

datainst ::= {data vec (byte)}

4.2.12. 导出实例

导出实例 是导出的运行时表示。它定义了导出的名称和关联的外部值。

exportinst ::= {name name, value externval}

4.2.13. 外部值

外部值 是可以导入或导出的实体的运行时表示。它是一个地址，表示共享存储中的函数实例、表格实例、内存实例或全局实例。

externval ::= ∣ ∣ ∣ func funcaddr table tableaddr mem memaddr global globaladdr

4.2.13.1. 约定

以下定义了用于外部值序列的辅助符号。它以保留顺序的方式过滤掉特定类型的条目

$funcs (externval^{*}) = [funcaddr ∣ (func funcaddr) \in externval^{*}]$
$tables (externval^{*}) = [tableaddr ∣ (table tableaddr) \in externval^{*}]$
$mems (externval^{*}) = [memaddr ∣ (mem memaddr) \in externval^{*}]$
$globals (externval^{*}) = [globaladdr ∣ (global globaladdr) \in externval^{*}]$

4.2.14. 堆栈

除了存储之外，大多数指令与隐式堆栈进行交互。堆栈包含三种类型的条目

值：指令的操作数。
标签：活动结构化控制指令，分支可以将其作为目标。
激活：活动函数调用的调用帧。

在程序执行期间，这些条目可以以任何顺序出现在堆栈中。堆栈条目由以下抽象语法描述。

注意

可以使用单独的操作数、控制结构和调用堆栈来对 WebAssembly 语义进行建模。但是，由于堆栈是相互依赖的，因此需要有关关联堆栈高度的额外簿记。为了便于本规范的目的，交错表示更简单。

4.2.14.1. 值

值由自身表示。

4.2.14.2. 标签

标签带有参数元数 $n$ ，以及它们关联的分支目标，在语法上表示为指令序列

label ::= label_{n} {instr^{*}}

直观地说， $instr^{*}$ 是分支被执行时要执行的延续，它将替换原始控制结构。

注意

例如，循环标签的形式为

label_{n} {loop \dots end}

当执行到该标签的分支时，会执行该循环，实际上是从头开始重新执行循环。相反，一个简单的块标签的形式为

label_{n} {ϵ}

当分支时，空延续会结束目标块，使得执行可以继续执行后续指令。

4.2.14.3. 激活帧

激活帧承载着相应函数的返回值元数 $n$ ，保存其局部变量（包括参数）的值，顺序对应于它们的静态局部变量索引，以及对该函数自身模块实例的引用。

frame framestate ::= ::= frame_{n} {framestate} {locals val^{*}, module moduleinst}

局部变量的值由各自的变量指令修改。

4.2.14.4. 约定

元变量 $L$ 表示标签，从上下文中可以清楚地识别。
元变量 $F$ 表示帧状态，从上下文中可以清楚地识别。
以下辅助定义接受一个块类型，并在当前帧中查找它所表示的函数类型

expand_{F} (typeidx) expand_{F} ([valtype^{?}]) = = F . module . types [typeidx] [] \to [valtype^{?}]

4.2.15. 管理指令

注意

本节仅与正式符号相关。

为了表达陷阱、调用和控制指令的规约，指令的语法扩展到包含以下管理指令

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ \dots trap ref funcaddr ref . extern externaddr invoke funcaddr label_{n} {instr^{*}} instr^{*} end frame_{n} {framestate} instr^{*} end

指令 $trap$ 表示发生陷阱。陷阱会通过嵌套的指令序列冒泡，最终将整个程序规约为单个 $trap$ 指令，表示程序突然终止。

指令 $ref$ 表示函数引用值。类似地， $ref . extern$ 表示外部引用.

指令 $invoke$ 表示即将调用一个函数实例，由其地址标识。它统一了不同形式的调用处理。

在 $label$ 和 $frame$ 指令中，标签和帧 “在堆栈上” 建模。此外，管理语法维护了原始结构化控制指令或函数体及其指令序列的嵌套结构，并使用 $end$ 标记。这样，当内部指令序列是外部序列的一部分时，便可以知道内部指令序列的结束位置。

注意

例如， $block$ 的规约规则为

block [t^{n}] instr^{*} end ↪ label_{n} {ϵ} instr^{*} end

这将块替换为一个标签指令，可以解释为将标签“压入”堆栈。当遇到 $end$ 时，即内部指令序列已规约为空序列 - 或者更确切地说，是一系列 $n$ 个 $const$ 指令，代表生成的数值 - 然后 $label$ 指令将根据其自身的规约规则被消除。

label_{m} {instr^{*}} val^{n} end ↪ val^{n}

这可以解释为从堆栈中移除标签，只保留本地累积的操作数。

4.2.15.1. 块上下文

为了指定分支的规约，定义了以下 块上下文 语法，以包围空洞 $[_]$ 的标签数量 $k$ 进行索引，该空洞标记着计算的下一步将要进行的位置。

B^{0} B^{k + 1} ::= ::= val^{*} [_] instr^{*} val^{*} label_{n} {instr^{*}} B^{k} end instr^{*}

此定义允许索引围绕分支或返回指令的活动标签。

注意

例如，简单分支的规约可以定义如下：

label_{0} {instr^{*}} B^{l} [br l] end ↪ instr^{*}

在此，上下文中的空洞 $[_]$ 由分支指令实例化。当发生分支时，此规则将用标签的延续替换目标标签和关联的指令序列。选定的标签通过标签索引 $l$ 进行识别，该索引对应于必须跳过的周围 $label$ 指令的数量 - 这恰好是块上下文索引中编码的计数。

4.2.15.2. 配置

配置由当前的存储和正在执行的线程组成。

线程是在指令上的计算，它相对于当前帧的状态进行操作，该帧引用了计算运行的模块实例，即当前函数源自的位置。

config thread ::= ::= store; thread framestate; instr^{*}

注意

当前版本的 WebAssembly 是单线程的，但在未来可能会支持多线程的配置。

4.2.15.3. 评估上下文

最后，评估上下文 的以下定义和相关的结构规则允许在指令序列和管理形式内部进行简化，以及陷阱的传播

E ::= [_] ∣ val^{*} E instr^{*} ∣ label_{n} {instr^{*}} E end

S; F; E [instr^{*}] S; F; frame_{n} {F^{'}} instr^{*} end S; F; frame_{n} {F^{'}} trap end ↪ ↪ ↪ S^{'}; F^{'}; E [instr^{'}^{*}] (if S; F; instr^{*} ↪ S^{'}; F^{'}; instr^{'}^{*}) S^{'}; F; frame_{n} {F^{''}} instr^{' *} end (if S; F^{'}; instr^{*} ↪ S^{'}; F^{''}; instr^{'}^{*}) 1 e x] S; F; E [trap] S; F; trap ↪ S; F; trap (if E \neq = [_])

当线程的指令序列简化为结果时，简化将终止，即为值序列或为 $trap$ .

注意

对评估上下文的限制排除了像 $[_]$ 和 $ϵ [_] ϵ$ 这样的上下文，对于这些上下文， $E [trap] = trap$ .

以下指令序列是评估上下文下简化示例。

(f64 . const x_{1}) (f64 . const x_{2}) f64 . neg (f64 . const x_{3}) f64 . add f64 . mul

可以将其分解为 $E [(f64 . const x_{2}) f64 . neg]$ ，其中

[E = (f64 . const x_{1}) [_] (f64 . const x_{3}) f64 . add f64 . mul

此外，这是唯一可能的评估上下文，其中孔的内容与缩减规则的左侧匹配。

4.3. 数值

数值基元以通用方式定义，通过按位宽索引的运算符 $N$ 进行定义。

一些运算符是非确定性的，因为它们可以返回几种可能结果之一（例如不同的 NaN 值）。从技术上讲，每个运算符因此返回一组允许的值。为了方便起见，确定性结果表示为普通值，这些值被假定为与相应的单元素集一致。

一些运算符是偏函数的，因为它们在某些输入上没有定义。从技术上讲，对于这些输入，返回一个空的结果集。

在形式化表示中，每个运算符都由等式子句定义，这些子句按优先级降序应用。也就是说，第一个适用于给定参数的子句定义了结果。在某些情况下，类似的子句使用 $\pm$ 或 $\mp$ 符号组合成一个。当多个这样的占位符出现在单个子句中时，它们必须一致地解析：要么为所有占位符选择上符号，要么选择下符号。

注意

例如， $fcopysign$ 运算符定义如下

fcopysign_{N} (\pm p_{1}, \pm p_{2}) fcopysign_{N} (\pm p_{1}, \mp p_{2}) = = \pm p_{1} \mp p_{1}

此定义应被视为每个子句扩展为两个独立子句的简写形式。

fcopysign_{N} (+ p_{1}, + p_{2}) fcopysign_{N} (- p_{1}, - p_{2}) fcopysign_{N} (+ p_{1}, - p_{2}) fcopysign_{N} (- p_{1}, + p_{2}) = = = = + p_{1} - p_{1} - p_{1} + p_{1}

数值运算符通过对输入序列逐元素应用运算符来提升到输入序列，返回结果序列。当有多个输入时，它们必须具有相同的长度。

o p (c_{1}^{n}, \dots, c_{k}^{n}) = o p (c_{1}^{n} [0], \dots, c_{k}^{n} [0]) \dots o p (c_{1}^{n} [n - 1], \dots, c_{k}^{n} [n - 1])

注意

例如，一元运算符 $fabs$ ，当给定一个浮点数序列时，会返回一个浮点数结果序列。

fabs_{N} (z^{n}) = fabs_{N} (z [0]) \dots fabs_{N} (z [n])

二元运算符 $iadd$ ，当给定两个长度相同的整数序列 $n$ 时，会返回一个整数结果序列。

iadd_{N} (i_{1}^{n}, i_{2}^{n}) = iadd_{N} (i_{1} [0], i_{2} [0]) \dots iadd_{N} (i_{1} [n], i_{2} [n])

约定

元变量 $d$ 用于遍历单个位。
元变量 $p$ 用于遍历浮点数的（无符号）幅度，包括 $nan$ 和 $\infty$ 。
元变量 $q$ 用于遍历（无符号）有理数幅度，不包括 $nan$ 或 $\infty$ 。
符号 $f^{- 1}$ 表示双射函数 $f$ 的逆。
有理数的截断写成 $trunc (\pm q)$ ，具有通常的数学定义。

$trunc (\pm q) = \pm i (if i \in N \land + q - 1 < i \leq + q)$

整数的饱和写成 $sat_u_{N} (i)$ 和 $sat_s_{N} (i)$ 。这两个函数的参数范围是任意有符号整数。
- 无符号饱和， $sat_u_{N} (i)$ 将 $i$ 限制在 $0$ 和 $2^{N} - 1$ 之间。
  
  $sat_u_{N} (i) sat_u_{N} (i) sat_u_{N} (i) = = = 2^{N} - 1 0 i (如果 i > 2^{N} - 1) (如果 i < 0) (否则)$
- 有符号饱和， $sat_s_{N} (i)$ 将 $i$ 限制在 $- 2^{N - 1}$ 和 $2^{N - 1} - 1$ 之间。
$sat_s_{N} (i) sat_s_{N} (i) sat_s_{N} (i) = = = signed_{N}^{- 1} (- 2^{N - 1}) signed_{N}^{- 1} (2^{N - 1} - 1) i (if i < - 2^{N - 1}) (if i > 2^{N - 1} - 1) (otherwise)$

4.3.1. 表示

数字和数值向量具有作为比特序列的底层二进制表示。

bits_{v N} (i) bits_{f N} (z) bits_{v N} (i) = = = ibits_{N} (i) fbits_{N} (z) ibits_{N} (i)

这些函数中的每一个都是双射，因此它们是可逆的。

4.3.1.1. 整数

整数被表示为二进制无符号数。

ibits_{N} (i) = d_{N - 1} \dots d_{0} (i = 2^{N - 1} \cdot d_{N - 1} + \dots + 2^{0} \cdot d_{0})

布尔运算符，如 $\land$ 、 $\lor$ 或 $⊻$ ，通过逐位应用于长度相等的比特序列来提升。

4.3.1.2. 浮点数

浮点值在 [IEEE-754-2019] (第 3.4 节) 定义的相应二进制格式中表示。

fbits_{N} (\pm (1 + m \cdot 2^{- M}) \cdot 2^{e}) fbits_{N} (\pm (0 + m \cdot 2^{- M}) \cdot 2^{e}) fbits_{N} (\pm \infty) fbits_{N} (\pm nan (n)) fsign (+) fsign (-) = = = = = = fsign (\pm) ibits_{E} (e + fbias_{N}) ibits_{M} (m) fsign (\pm) (0)^{E} ibits_{M} (m) fsign (\pm) (1)^{E} (0)^{M} fsign (\pm) (1)^{E} ibits_{M} (n) 1 e x] fbias_{N} 01 = 2^{E - 1} - 1

其中 $M = signif (N)$ 且 $E = expon (N)$ .

4.3.1.3. 向量

类型为 $v N$ 的数值向量具有与 $i N$ 相同的底层表示。它们也可以解释为打包到 $v N$ 中的数值序列，具有特定的 $shape$ $t x M$ ，前提是 $N = ∣t∣ \cdot M$ .

lanes_{t x M} (c) = c_{0} \dots c_{M - 1} (where \land \land w b^{*} c_{i} = = = ∣ t ∣/8 bytes_{i N} (c) bytes_{t}^{- 1} (b^{*} [i \cdot w : w]))

此函数是关于 $i N$ 的双射，因此它是可逆的。

4.3.1.4. 存储

当一个数字存储到内存中时，它将被转换为小端序的字节序列。

bytes_{t} (i) littleendian (d^{8} d^{'}^{*}) = = littleendian (bits_{t} (i)) 1 e x] littleendian (ϵ) littleendian (d^{'}^{*}) ibits_{8}^{- 1} (d^{8}) = ϵ

这些函数同样是可逆的双射。

4.3.2. 整数运算

4.3.2.1. 符号解释

整数运算符定义在 $i N$ 值上。使用有符号解释的运算符使用以下定义来转换值，当值位于值范围的上半部分时（即其最高有效位为 $1$ ），它采用二进制补码。

signed_{N} (i) signed_{N} (i) = = i i - 2^{N} (0 \leq i < 2^{N - 1}) (2^{N - 1} \leq i < 2^{N})

此函数是双射的，因此是可逆的。

4.3.2.2. 布尔解释

谓词的整数结果 - 即测试和关系运算符 - 使用以下辅助函数定义，该函数根据条件生成值 $1$ 或 $0$ 。

bool (C) bool (C) = = 10 (if C) (otherwise)

4.3.2.3. $iadd_{N} (i_{1}, i_{2})$

返回 $i_{1}$ 和 $i_{2}$ 模 $2^{N}$ 的结果。

iadd_{N} (i_{1}, i_{2}) = (i_{1} + i_{2}) mod 2^{N}

4.3.2.4. $isub_{N} (i_{1}, i_{2})$

返回从 $i_{1}$ 中减去 $i_{2}$ 模 $2^{N}$ 的结果。

isub_{N} (i_{1}, i_{2}) = (i_{1} - i_{2} + 2^{N}) mod 2^{N}

4.3.2.5. $imul_{N} (i_{1}, i_{2})$

返回 $i_{1}$ 和 $i_{2}$ 模 $2^{N}$ 的乘积的结果。

imul_{N} (i_{1}, i_{2}) = (i_{1} \cdot i_{2}) mod 2^{N}

4.3.2.6. $idiv_u_{N} (i_{1}, i_{2})$

如果 $i_{2}$ 为 $0$ , 则结果未定义。
否则，返回将 $i_{1}$ 除以 $i_{2}$ 的结果，向零取整。

idiv_u_{N} (i_{1}, 0) idiv_u_{N} (i_{1}, i_{2}) = = {} trunc (i_{1} / i_{2})

注意

此运算符是部分的。

4.3.2.7. $idiv_s_{N} (i_{1}, i_{2})$

令 $j_{1}$ 为 $i_{1}$ 的有符号解释。
令 $j_{2}$ 为 $i_{2}$ 的有符号解释。
如果 $j_{2}$ 为 $0$ , 则结果未定义。
否则，如果 $j_{1}$ 除以 $j_{2}$ 的结果为 $2^{N - 1}$ , 则结果未定义。
否则，返回将 $j_{1}$ 除以 $j_{2}$ 的结果，向零取整。

idiv_s_{N} (i_{1}, 0) idiv_s_{N} (i_{1}, i_{2}) idiv_s_{N} (i_{1}, i_{2}) = = = {} {} (if signed_{N} (i_{1}) / signed_{N} (i_{2}) = 2^{N - 1}) signed_{N}^{- 1} (trunc (signed_{N} (i_{1}) / signed_{N} (i_{2})))

注意

此运算符是部分的。除了被 $0$ 除外，结果 $(- 2^{N - 1}) / (- 1) = + 2^{N - 1}$ 不能表示为 $N$ 位带符号整数。

4.3.2.8. $irem_u_{N} (i_{1}, i_{2})$

如果 $i_{2}$ 为 $0$ , 则结果未定义。
否则，返回将 $i_{1}$ 除以 $i_{2}$ 的余数。

irem_u_{N} (i_{1}, 0) irem_u_{N} (i_{1}, i_{2}) = = {} i_{1} - i_{2} \cdot trunc (i_{1} / i_{2})

注意

此运算符是部分的。

只要两个操作数都已定义，则有 $i_{1} = i_{2} \cdot idiv_u (i_{1}, i_{2}) + irem_u (i_{1}, i_{2})$ .

4.3.2.9. $irem_s_{N} (i_{1}, i_{2})$

令 $j_{1}$ 为 $i_{1}$ 的有符号解释。
令 $j_{2}$ 为 $i_{2}$ 的有符号解释。
如果 $i_{2}$ 为 $0$ , 则结果未定义。
否则，返回将 $j_{1}$ 除以 $j_{2}$ 的余数，并保留被除数 $j_{1}$ 的符号。

irem_s_{N} (i_{1}, 0) irem_s_{N} (i_{1}, i_{2}) = = {} signed_{N}^{- 1} (j_{1} - j_{2} \cdot trunc (j_{1} / j_{2})) (where j_{1} = signed_{N} (i_{1}) \land j_{2} = signed_{N} (i_{2})

注意

此运算符是部分的。

只要两个操作数都被定义，则有 $i_{1} = i_{2} \cdot idiv_s (i_{1}, i_{2}) + irem_s (i_{1}, i_{2})$ .

4.3.2.10. $inot_{N} (i)$

返回 $i$ 的按位取反。

inot_{N} (i) = ibits_{N}^{- 1} (ibits_{N} (i) ⊻ ibits_{N} (2^{N} - 1))

4.3.2.11. $iand_{N} (i_{1}, i_{2})$

返回 $i_{1}$ 和 $i_{2}$ 的按位与。

iand_{N} (i_{1}, i_{2}) = ibits_{N}^{- 1} (ibits_{N} (i_{1}) \land ibits_{N} (i_{2}))

4.3.2.12. $iandnot_{N} (i_{1}, i_{2})$

返回 $i_{1}$ 和 $i_{2}$ 按位取反后的按位与。

iandnot_{N} (i_{1}, i_{2}) = iand_{N} (i_{1}, inot_{N} (i_{2}))

4.3.2.13. $ior_{N} (i_{1}, i_{2})$

返回 $i_{1}$ 和 $i_{2}$ 的按位或运算结果。

ior_{N} (i_{1}, i_{2}) = ibits_{N}^{- 1} (ibits_{N} (i_{1}) \lor ibits_{N} (i_{2}))

4.3.2.14. $ixor_{N} (i_{1}, i_{2})$

返回 $i_{1}$ 和 $i_{2}$ 的按位异或运算结果。

ixor_{N} (i_{1}, i_{2}) = ibits_{N}^{- 1} (ibits_{N} (i_{1}) ⊻ ibits_{N} (i_{2}))

4.3.2.15. $ishl_{N} (i_{1}, i_{2})$

设 $k$ 为 $i_{2}$ 模 $N$ 的结果。
返回将 $i_{1}$ 左移 $k$ 位的结果，模 $2^{N}$ .

ishl_{N} (i_{1}, i_{2}) = ibits_{N}^{- 1} (d_{2}^{N - k} 0^{k}) (if ibits_{N} (i_{1}) = d_{1}^{k} d_{2}^{N - k} \land k = i_{2} mod N)

4.3.2.16. $ishr_u_{N} (i_{1}, i_{2})$

设 $k$ 为 $i_{2}$ 模 $N$ 的结果。
返回将 $i_{1}$ 右移 $k$ 位的结果，并用 $0$ 位扩展。

ishr_u_{N} (i_{1}, i_{2}) = ibits_{N}^{- 1} (0^{k} d_{1}^{N - k}) (if ibits_{N} (i_{1}) = d_{1}^{N - k} d_{2}^{k} \land k = i_{2} mod N)

4.3.2.17. $ishr_s_{N} (i_{1}, i_{2})$

设 $k$ 为 $i_{2}$ 模 $N$ 的结果。
返回将 $i_{1}$ 右移 $k$ 位的结果，并使用原始值的最高有效位进行扩展。

ishr_s_{N} (i_{1}, i_{2}) = ibits_{N}^{- 1} (d_{0}^{k + 1} d_{1}^{N - k - 1}) (if ibits_{N} (i_{1}) = d_{0} d_{1}^{N - k - 1} d_{2}^{k} \land k = i_{2} mod N)

4.3.2.18. $irotl_{N} (i_{1}, i_{2})$

设 $k$ 为 $i_{2}$ 模 $N$ 的结果。
返回将 $i_{1}$ 左移 $k$ 位的结果。

irotl_{N} (i_{1}, i_{2}) = ibits_{N}^{- 1} (d_{2}^{N - k} d_{1}^{k}) (if ibits_{N} (i_{1}) = d_{1}^{k} d_{2}^{N - k} \land k = i_{2} mod N)

4.3.2.19. $irotr_{N} (i_{1}, i_{2})$

设 $k$ 为 $i_{2}$ 模 $N$ 的结果。
返回将 $i_{1}$ 右移 $k$ 位的结果。

irotr_{N} (i_{1}, i_{2}) = ibits_{N}^{- 1} (d_{2}^{k} d_{1}^{N - k}) (if ibits_{N} (i_{1}) = d_{1}^{N - k} d_{2}^{k} \land k = i_{2} mod N)

4.3.2.20. $iclz_{N} (i)$

返回 $i$ 中前导零位的数量；如果 $i$ 是 $0$ ，则所有位都算作前导零位。

iclz_{N} (i) = k (if ibits_{N} (i) = 0^{k} (1 d^{*})^{?})

4.3.2.21. $ictz_{N} (i)$

返回 $i$ 中尾随零位的数量；如果 $i$ 是 $0$ ，则所有位都算作尾随零位。

ictz_{N} (i) = k (if ibits_{N} (i) = (d^{*} 1)^{?} 0^{k})

4.3.2.22. $ipopcnt_{N} (i)$

返回 $i$ 中非零位的数量。

ipopcnt_{N} (i) = k (if ibits_{N} (i) = (0^{*} 1)^{k} 0^{*})

4.3.2.23. $ieqz_{N} (i)$

如果 $i$ 为零，则返回 $1$ ，否则返回 $0$ 。

ieqz_{N} (i) = bool (i = 0)

4.3.2.24. $ieq_{N} (i_{1}, i_{2})$

如果 $i_{1}$ 等于 $i_{2}$ ，则返回 $1$ ；否则返回 $0$ 。

ieq_{N} (i_{1}, i_{2}) = bool (i_{1} = i_{2})

4.3.2.25. $ine_{N} (i_{1}, i_{2})$

如果 $i_{1}$ 不等于 $i_{2}$ ，则返回 $1$ ；否则返回 $0$ 。

ine_{N} (i_{1}, i_{2}) = bool (i_{1} \neq = i_{2})

4.3.2.26. $ilt_u_{N} (i_{1}, i_{2})$

如果 $i_{1}$ 小于 $i_{2}$ ，则返回 $1$ ；否则返回 $0$ 。

ilt_u_{N} (i_{1}, i_{2}) = bool (i_{1} < i_{2})

4.3.2.27. $ilt_s_{N} (i_{1}, i_{2})$

令 $j_{1}$ 为 $i_{1}$ 的有符号解释。
令 $j_{2}$ 为 $i_{2}$ 的有符号解释。
如果 $j_{1}$ 小于 $j_{2}$ , 则返回 $1$ ，否则返回 $0$ .

ilt_s_{N} (i_{1}, i_{2}) = bool (signed_{N} (i_{1}) < signed_{N} (i_{2}))

4.3.2.28. $igt_u_{N} (i_{1}, i_{2})$

如果 $i_{1}$ 大于 $i_{2}$ , 则返回 $1$ ，否则返回 $0$ .

igt_u_{N} (i_{1}, i_{2}) = bool (i_{1} > i_{2})

4.3.2.29. $igt_s_{N} (i_{1}, i_{2})$

令 $j_{1}$ 为 $i_{1}$ 的有符号解释。
令 $j_{2}$ 为 $i_{2}$ 的有符号解释。
返回 $1$ 如果 $j_{1}$ 大于 $j_{2}$ , $0$ 否则。

igt_s_{N} (i_{1}, i_{2}) = bool (signed_{N} (i_{1}) > signed_{N} (i_{2}))

4.3.2.30. $ile_u_{N} (i_{1}, i_{2})$

返回 $1$ 如果 $i_{1}$ 小于或等于 $i_{2}$ , $0$ 否则。

ile_u_{N} (i_{1}, i_{2}) = bool (i_{1} \leq i_{2})

4.3.2.31. $ile_s_{N} (i_{1}, i_{2})$

令 $j_{1}$ 为 $i_{1}$ 的有符号解释。
令 $j_{2}$ 为 $i_{2}$ 的有符号解释。
返回 $1$ 如果 $j_{1}$ 小于或等于 $j_{2}$ , 否则返回 $0$ .

ile_s_{N} (i_{1}, i_{2}) = bool (signed_{N} (i_{1}) \leq signed_{N} (i_{2}))

4.3.2.32. $ige_u_{N} (i_{1}, i_{2})$

如果 $i_{1}$ 大于或等于 $i_{2}$ ，则返回 $1$ ；否则返回 $0$ 。

ige_u_{N} (i_{1}, i_{2}) = bool (i_{1} \geq i_{2})

4.3.2.33. $ige_s_{N} (i_{1}, i_{2})$

令 $j_{1}$ 为 $i_{1}$ 的有符号解释。
令 $j_{2}$ 为 $i_{2}$ 的有符号解释。
如果 $j_{1}$ 大于或等于 $j_{2}$ ，则返回 $1$ ；否则返回 $0$ 。

ige_s_{N} (i_{1}, i_{2}) = bool (signed_{N} (i_{1}) \geq signed_{N} (i_{2}))

4.3.2.34. $iextend M_s_{N} (i)$

令 $j$ 为计算 $wrap_{N, M} (i)$ 的结果。
返回 $extend^{s}_{M, N} (j)$ .

iextend M_s_{N} (i) = extend^{s}_{M, N} (wrap_{N, M} (i))

4.3.2.35. $ibitselect_{N} (i_{1}, i_{2}, i_{3})$

令 $j_{1}$ 为 $i_{1}$ 和 $i_{3}$ 的按位与运算结果。
令 $j_{3}^{'}$ 为 $i_{3}$ 的按位取反运算结果。
令 $j_{2}$ 为 $i_{2}$ 和 $j_{3}^{'}$ 的按位与运算结果。
返回 $j_{1}$ 和 $j_{2}$ 的按位或运算的结果。

ibitselect_{N} (i_{1}, i_{2}, i_{3}) = ior_{N} (iand_{N} (i_{1}, i_{3}), iand_{N} (i_{2}, inot_{N} (i_{3})))

4.3.2.36. $iabs_{N} (i)$

令 $j$ 为 $i$ 的有符号解释。
如果 $j$ 大于或等于 $0$ ，则返回 $i$ 。
否则返回 j 的负数，对 $2^{N}$ 取模。

iabs_{N} (i) iabs_{N} (i) = = i - signed_{N} (i) mod 2^{N} (if signed_{N} (i) \geq 0) (otherwise)

4.3.2.37. $ineg_{N} (i)$

返回对 $i$ 取反的结果，模 $2^{N}$ .

ineg_{N} (i) = (2^{N} - i) mod 2^{N}

4.3.2.38. $imin_u_{N} (i_{1}, i_{2})$

如果 $ilt_u_{N} (i_{1}, i_{2})$ 为 $1$ ，则返回 $i_{1}$ ，否则返回 $i_{2}$ .

imin_u_{N} (i_{1}, i_{2}) imin_u_{N} (i_{1}, i_{2}) = = i_{1} i_{2} (如果 ilt_u_{N} (i_{1}, i_{2}) = 1) (否则)

4.3.2.39. $imin_s_{N} (i_{1}, i_{2})$

返回 $i_{1}$ 如果 $ilt_s_{N} (i_{1}, i_{2})$ 为 $1$ , 否则返回 $i_{2}$ .

imin_s_{N} (i_{1}, i_{2}) imin_s_{N} (i_{1}, i_{2}) = = i_{1} i_{2} (if ilt_s_{N} (i_{1}, i_{2}) = 1) (otherwise)

4.3.2.40. $imax_u_{N} (i_{1}, i_{2})$

返回 $i_{1}$ 如果 $igt_u_{N} (i_{1}, i_{2})$ 为 $1$ , 返回 $i_{2}$ 否则。

imax_u_{N} (i_{1}, i_{2}) imax_u_{N} (i_{1}, i_{2}) = = i_{1} i_{2} (if igt_u_{N} (i_{1}, i_{2}) = 1) (otherwise)

4.3.2.41. $imax_s_{N} (i_{1}, i_{2})$

如果 $igt_s_{N} (i_{1}, i_{2})$ 为 $1$ , 则返回 $i_{1}$ , 否则返回 $i_{2}$ .

imax_s_{N} (i_{1}, i_{2}) imax_s_{N} (i_{1}, i_{2}) = = i_{1} i_{2} (如果 igt_s_{N} (i_{1}, i_{2}) = 1) (否则)

4.3.2.42. $iadd_sat_u_{N} (i_{1}, i_{2})$

设 $i$ 为 $i_{1}$ 和 $i_{2}$ 相加的结果。
返回 $sat_u_{N} (i)$ .

iadd_sat_u_{N} (i_{1}, i_{2}) = sat_u_{N} (i_{1} + i_{2})

4.3.2.43. $iadd_sat_s_{N} (i_{1}, i_{2})$

令 $j_{1}$ 为 $i_{1}$ 的有符号解释。
令 $j_{2}$ 为 $i_{2}$ 的有符号解释。
令 $j$ 为 $j_{1}$ 和 $j_{2}$ 相加的结果。
返回 $sat_s_{N} (j)$ .

iadd_sat_s_{N} (i_{1}, i_{2}) = sat_s_{N} (signed_{N} (i_{1}) + signed_{N} (i_{2}))

4.3.2.44. $isub_sat_u_{N} (i_{1}, i_{2})$

令 $i$ 为从 $i_{1}$ 中减去 $i_{2}$ 的结果。
返回 $sat_u_{N} (i)$ .

isub_sat_u_{N} (i_{1}, i_{2}) = sat_u_{N} (i_{1} - i_{2})

4.3.2.45. $isub_sat_s_{N} (i_{1}, i_{2})$

令 $j_{1}$ 为 $i_{1}$ 的有符号解释。
令 $j_{2}$ 为 $i_{2}$ 的有符号解释。
令 $j$ 为从 $j_{1}$ 中减去 $j_{2}$ 的结果。
返回 $sat_s_{N} (j)$ .

isub_sat_s_{N} (i_{1}, i_{2}) = sat_s_{N} (signed_{N} (i_{1}) - signed_{N} (i_{2}))

4.3.2.46. $iavgr_u_{N} (i_{1}, i_{2})$

令 $j$ 为 $i_{1}$ , $i_{2}$ , 和 $1$ 相加的结果。
返回 $j$ 除以 $2$ 的结果，向零取整。

iavgr_u_{N} (i_{1}, i_{2}) = trunc ((i_{1} + i_{2} + 1) /2)

4.3.2.47. $iq15mulrsat_s_{N} (i_{1}, i_{2})$

返回 $sat_s_{N} (ishr_s_{N} (i_{1} \cdot i_{2} + 2^{14}, 15))$ 的结果。

iq15mulrsat_s_{N} (i_{1}, i_{2}) = sat_s_{N} (ishr_s_{N} (i_{1} \cdot i_{2} + 2^{14}, 15))

4.3.3. 浮点运算

浮点运算遵循 [IEEE-754-2019] 标准，并具有以下限定条件

所有运算符使用舍入到最接近的偶数，除非另有说明。不支持非默认定向舍入属性。
遵循从操作数传播 NaN 负载的建议是允许的，但不是必需的。
所有运算符使用“不停”模式，并且浮点异常不会以其他方式被观察到。特别是，不支持备用浮点异常处理属性或状态标志上的运算符。安静的 NaN 和信号 NaN 之间没有可观察到的区别。

注意

WebAssembly 的未来版本可能会解除其中一些限制。

4.3.3.1. 舍入

舍入始终是舍入到最接近的偶数，与 [IEEE-754-2019]（第 4.3.1 节）一致。

精确浮点数是指可以被精确表示为给定位宽 $N$ 的浮点数的有理数。

给定浮点位宽 $N$ 的限制数是指其大小为不能被精确表示为位宽为 $N$ 的浮点数的 $2$ 的最小幂的正数或负数（该大小为 $2^{128}$ 对于 $N = 32$ 和 $2^{1024}$ 对于 $N = 64$ ）。

候选数是指给定位宽 $N$ 的精确浮点数或正数或负数限制数。

候选对是指候选数对 $z_{1}, z_{2}$ ，其中不存在位于两者之间的候选数。

实数 $r$ 转换为位宽为 $N$ 的浮点值如下

如果 $r$ 等于 $0$ ，则返回 $+ 0$ .
否则，如果 $r$ 是一个精确的浮点数，则返回 $r$ .
否则，如果 $r$ 大于或等于正极限，则返回 $+ \infty$ .
否则，如果 $r$ 小于或等于负极限，则返回 $- \infty$ .
否则，如果 $z_{1}$ 和 $z_{2}$ 是一个候选对，使得 $z_{1} < r < z_{2}$ ，则
- 如果 $∣r - z_{1} ∣ < ∣r - z_{2} ∣$ ，则设 $z$ 为 $z_{1}$ .
- 否则，如果 $∣r - z_{1} ∣ > ∣r - z_{2} ∣$ ，则设 $z$ 为 $z_{2}$ .
- 否则，如果 $∣r - z_{1} ∣ = ∣r - z_{2} ∣$ 且 $z_{1}$ 的尾数是偶数，则设 $z$ 为 $z_{1}$ .
- 否则，设 $z$ 为 $z_{2}$ .
如果 $z$ 等于 $0$ ，则
- 如果 $r < 0$ ，则返回 $- 0$ .
- 否则，返回 $+ 0$ .
否则如果 $z$ 是一个极限数，那么
- 如果 $r < 0$ ，则返回 $- \infty$ .
- 否则，返回 $+ \infty$ .
否则，返回 $z$ .

float_{N} (0) float_{N} (r) float_{N} (r) float_{N} (r) float_{N} (r) closest_{N} (r, z_{1}, z_{2}) closest_{N} (r, z_{1}, z_{2}) closest_{N} (r, z_{1}, z_{2}) rectify_{N} (r, 0) rectify_{N} (r, 0) rectify_{N} (r, z) = = = = = = = = = = = + 0 r + \infty - \infty closest_{N} (r, z_{1}, z_{2}) rectify_{N} (r, z_{2}) rectify_{N} (r, z_{1}) rectify_{N} (r, z_{2}) + 0 (r \geq 0) - 0 (r < 0) z (if r \in exact_{N}) (if r \geq + limit_{N}) (if r \leq - limit_{N}) (if z_{1} < r < z_{2} \land (z_{1}, z_{2}) \in candidatepair_{N}) 1 e x] closest_{N} (r, z_{1}, z_{2}) (if ∣ r - z_{1} ∣ > ∣ r - z_{2} ∣) (if ∣ r - z_{1} ∣ = ∣ r - z_{2} ∣ \land even_{N} (z_{1})) (if ∣ r - z_{1} ∣ = ∣ r - z_{2} ∣ \land even_{N} (z_{2})) 1 e x] rectify_{N} (r, \pm limit_{N}) = = rectify_{N} (r, z_{1}) \pm \infty (if ∣ r - z_{1} ∣ < ∣ r - z_{2} ∣)

其中

exact_{N} limit_{N} candidate_{N} candidatepair_{N} even_{N} (\pm limit_{N}) = = = = \Leftrightarrow f N \cap Q 2^{2^{expon (N) - 1}} exact_{N} \cup {+ limit_{N}, - limit_{N}} {(z_{1}, z_{2}) \in candidate_{N}^{2} ∣ z_{1} < z_{2} \land \forall z \in candidate_{N}, z \leq z_{1} \lor z \geq z_{2}} 1 e x] even_{N} ((d + m \cdot 2^{- M}) \cdot 2^{e}) true \Leftrightarrow m mod 2 = 0

4.3.3.2. NaN 传播

当浮点运算符（除 $fneg$ , $fabs$ , 或 $fcopysign$ 之外）的结果为 NaN 时，其符号是不确定的，而有效载荷则按以下方式计算

如果运算符的所有 NaN 输入的有效载荷都为规范的（包括没有 NaN 输入的情况），则输出的有效载荷也为规范的。
否则，有效载荷将在所有算术 NaN 中非确定性地选择；也就是说，其最高有效位为 $1$ ，而其他所有位则未指定。

此非确定性结果由以下辅助函数表示，该函数从一组输入生成一组允许的输出

nans_{N} {z^{*}} nans_{N} {z^{*}} = = {+ nan (n), - nan (n) ∣ n = canon_{N}} {+ nan (n), - nan (n) ∣ n \geq canon_{N}} (如果 \forall nan (n) \in z^{*}, n = canon_{N}) (否则)

4.3.3.3. $fadd_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 或 $z_{2}$ 是 NaN，则返回 $nans_{N} {z_{1}, z_{2}}$ 中的一个元素。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相反的无穷大，则返回 $nans_{N} {}$ 中的一个元素。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相同的无穷大，则返回该无穷大。
否则，如果 $z_{1}$ 或 $z_{2}$ 是无穷大，则返回该无穷大。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相反的零，则返回正零。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相同的零，则返回该零。
否则，如果 $z_{1}$ 或 $z_{2}$ 是零，则返回另一个操作数。
否则，如果 $z_{1}$ 和 $z_{2}$ 是大小相同但符号相反的值，则返回正零。
否则，返回 $z_{1}$ 和 $z_{2}$ 相加的结果，舍入到最接近的可表示值。

fadd_{N} (\pm nan (n), z_{2}) fadd_{N} (z_{1}, \pm nan (n)) fadd_{N} (\pm \infty, \mp \infty) fadd_{N} (\pm \infty, \pm \infty) fadd_{N} (z_{1}, \pm \infty) fadd_{N} (\pm \infty, z_{2}) fadd_{N} (\pm 0, \mp 0) fadd_{N} (\pm 0, \pm 0) fadd_{N} (z_{1}, \pm 0) fadd_{N} (\pm 0, z_{2}) fadd_{N} (\pm q, \mp q) fadd_{N} (z_{1}, z_{2}) = = = = = = = = = = = = nans_{N} {\pm nan (n), z_{2}} nans_{N} {\pm nan (n), z_{1}} nans_{N} {} \pm \infty \pm \infty \pm \infty + 0 \pm 0 z_{1} z_{2} + 0 float_{N} (z_{1} + z_{2})

4.3.3.4. $fsub_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 或 $z_{2}$ 是 NaN，则返回 $nans_{N} {z_{1}, z_{2}}$ 中的一个元素。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相同的无穷大，则返回 $nans_{N} {}$ .
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相反的无穷大，则返回 $z_{1}$ .
否则，如果 $z_{1}$ 是无穷大，则返回该无穷大。
否则，如果 $z_{2}$ 是无穷大，则返回该无穷大的负数。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相同的零，则返回正零。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相反的零，则返回 $z_{1}$ .
否则，如果 $z_{2}$ 是零，则返回 $z_{1}$ .
否则，如果 $z_{1}$ 是零，则返回 $z_{2}$ 的负数。
否则，如果 $z_{1}$ 和 $z_{2}$ 相同，则返回正零。
否则，返回从 $z_{1}$ 中减去 $z_{2}$ 的结果，四舍五入到最接近的可表示值。

fsub_{N} (\pm nan (n), z_{2}) fsub_{N} (z_{1}, \pm nan (n)) fsub_{N} (\pm \infty, \pm \infty) fsub_{N} (\pm \infty, \mp \infty) fsub_{N} (z_{1}, \pm \infty) fsub_{N} (\pm \infty, z_{2}) fsub_{N} (\pm 0, \pm 0) fsub_{N} (\pm 0, \mp 0) fsub_{N} (z_{1}, \pm 0) fsub_{N} (\pm 0, \pm q_{2}) fsub_{N} (\pm q, \pm q) fsub_{N} (z_{1}, z_{2}) = = = = = = = = = = = = nans_{N} {\pm nan (n), z_{2}} nans_{N} {\pm nan (n), z_{1}} nans_{N} {} \pm \infty \mp \infty \pm \infty + 0 \pm 0 z_{1} \mp q_{2} + 0 float_{N} (z_{1} - z_{2})

注意

除了关于 NaN 的非确定性之外，始终满足以下条件： $fsub_{N} (z_{1}, z_{2}) = fadd_{N} (z_{1}, fneg_{N} (z_{2}))$ .

4.3.3.5. $fmul_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 或 $z_{2}$ 是 NaN，则返回 $nans_{N} {z_{1}, z_{2}}$ 中的一个元素。
否则，如果 $z_{1}$ 和 $z_{2}$ 之一是零，另一个是无穷大，则返回 $nans_{N} {}$ 的一个元素。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相同的无穷大，则返回正无穷大。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相反的无穷大，则返回负无穷大。
否则，如果 $z_{1}$ 或 $z_{2}$ 是无穷大，而另一个是符号相同的数值，则返回正无穷大。
否则，如果 $z_{1}$ 或 $z_{2}$ 是无穷大，而另一个是符号相反的数值，则返回负无穷大。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相同的零，则返回正零。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是符号相反的零，则返回负零。
否则，返回 $z_{1}$ 和 $z_{2}$ 相乘的结果，四舍五入到最近的可表示的值。

fmul_{N} (\pm nan (n), z_{2}) fmul_{N} (z_{1}, \pm nan (n)) fmul_{N} (\pm \infty, \pm 0) fmul_{N} (\pm \infty, \mp 0) fmul_{N} (\pm 0, \pm \infty) fmul_{N} (\pm 0, \mp \infty) fmul_{N} (\pm \infty, \pm \infty) fmul_{N} (\pm \infty, \mp \infty) fmul_{N} (\pm q_{1}, \pm \infty) fmul_{N} (\pm q_{1}, \mp \infty) fmul_{N} (\pm \infty, \pm q_{2}) fmul_{N} (\pm \infty, \mp q_{2}) fmul_{N} (\pm 0, \pm 0) fmul_{N} (\pm 0, \mp 0) fmul_{N} (z_{1}, z_{2}) = = = = = = = = = = = = = = = nans_{N} {\pm nan (n), z_{2}} nans_{N} {\pm nan (n), z_{1}} nans_{N} {} nans_{N} {} nans_{N} {} nans_{N} {} + \infty - \infty + \infty - \infty + \infty - \infty + 0 - 0 float_{N} (z_{1} \cdot z_{2})

4.3.3.6. $fdiv_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 或 $z_{2}$ 是 NaN，则返回 $nans_{N} {z_{1}, z_{2}}$ 中的一个元素。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是无穷大，则返回 $nans_{N} {}$ 中的一个元素。
否则，如果 $z_{1}$ 和 $z_{2}$ 都是零，则返回 $nans_{N} {z_{1}, z_{2}}$ .
否则，如果 $z_{1}$ 是无穷大，而 $z_{2}$ 是一个符号相同的数值，则返回正无穷大。
否则，如果 $z_{1}$ 是无穷大，而 $z_{2}$ 是一个符号相反的数值，则返回负无穷大。
否则，如果 $z_{2}$ 是无穷大，而 $z_{1}$ 是一个符号相同的数值，则返回正零。
否则，如果 $z_{2}$ 是无穷大，而 $z_{1}$ 是一个符号相反的数值，则返回负零。
否则，如果 $z_{1}$ 是零，而 $z_{2}$ 是一个符号相同的数值，则返回正零。
否则，如果 $z_{1}$ 是零，而 $z_{2}$ 是一个符号相反的数值，则返回负零。
如果 $z_{2}$ 为零且 $z_{1}$ 为一个带有等号的值，则返回正无穷大。
如果 $z_{2}$ 为零且 $z_{1}$ 为一个带有相反符号的值，则返回负无穷大。
否则返回 $z_{1}$ 除以 $z_{2}$ 的结果，四舍五入到最接近的可表示值。

fdiv_{N} (\pm nan (n), z_{2}) fdiv_{N} (z_{1}, \pm nan (n)) fdiv_{N} (\pm \infty, \pm \infty) fdiv_{N} (\pm \infty, \mp \infty) fdiv_{N} (\pm 0, \pm 0) fdiv_{N} (\pm 0, \mp 0) fdiv_{N} (\pm \infty, \pm q_{2}) fdiv_{N} (\pm \infty, \mp q_{2}) fdiv_{N} (\pm q_{1}, \pm \infty) fdiv_{N} (\pm q_{1}, \mp \infty) fdiv_{N} (\pm 0, \pm q_{2}) fdiv_{N} (\pm 0, \mp q_{2}) fdiv_{N} (\pm q_{1}, \pm 0) fdiv_{N} (\pm q_{1}, \mp 0) fdiv_{N} (z_{1}, z_{2}) = = = = = = = = = = = = = = = nans_{N} {\pm nan (n), z_{2}} nans_{N} {\pm nan (n), z_{1}} nans_{N} {} nans_{N} {} nans_{N} {} nans_{N} {} + \infty - \infty + 0 - 0 + 0 - 0 + \infty - \infty float_{N} (z_{1} / z_{2})

4.3.3.7. $fmin_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 或 $z_{2}$ 是 NaN，则返回 $nans_{N} {z_{1}, z_{2}}$ 中的一个元素。
如果 $z_{1}$ 或 $z_{2}$ 为负无穷大，则返回负无穷大。
如果 $z_{1}$ 或 $z_{2}$ 为正无穷大，则返回另一个值。
如果 $z_{1}$ 和 $z_{2}$ 都是带有相反符号的零，则返回负零。
否则返回 $z_{1}$ 和 $z_{2}$ 中较小的值。

fmin_{N} (\pm nan (n), z_{2}) fmin_{N} (z_{1}, \pm nan (n)) fmin_{N} (+ \infty, z_{2}) fmin_{N} (- \infty, z_{2}) fmin_{N} (z_{1}, + \infty) fmin_{N} (z_{1}, - \infty) fmin_{N} (\pm 0, \mp 0) fmin_{N} (z_{1}, z_{2}) fmin_{N} (z_{1}, z_{2}) = = = = = = = = = nans_{N} {\pm nan (n), z_{2}} nans_{N} {\pm nan (n), z_{1}} z_{2} - \infty z_{1} - \infty - 0 z_{1} z_{2} (if z_{1} \leq z_{2}) (if z_{2} \leq z_{1})

4.3.3.8. $fmax_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 或 $z_{2}$ 是 NaN，则返回 $nans_{N} {z_{1}, z_{2}}$ 中的一个元素。
如果 $z_{1}$ 或 $z_{2}$ 为正无穷大，则返回正无穷大。
如果 $z_{1}$ 或 $z_{2}$ 是负无穷大，则返回另一个值。
如果 $z_{1}$ 和 $z_{2}$ 都是符号相反的零，则返回正零。
否则，返回 $z_{1}$ 和 $z_{2}$ 中较大的值。

fmax_{N} (\pm nan (n), z_{2}) fmax_{N} (z_{1}, \pm nan (n)) fmax_{N} (+ \infty, z_{2}) fmax_{N} (- \infty, z_{2}) fmax_{N} (z_{1}, + \infty) fmax_{N} (z_{1}, - \infty) fmax_{N} (\pm 0, \mp 0) fmax_{N} (z_{1}, z_{2}) fmax_{N} (z_{1}, z_{2}) = = = = = = = = = nans_{N} {\pm nan (n), z_{2}} nans_{N} {\pm nan (n), z_{1}} + \infty z_{2} + \infty z_{1} + 0 z_{1} z_{2} (if z_{1} \geq z_{2}) (if z_{2} \geq z_{1})

4.3.3.9. $fcopysign_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 和 $z_{2}$ 符号相同，则返回 $z_{1}$ .
否则，返回符号取反后的 $z_{1}$ .

fcopysign_{N} (\pm p_{1}, \pm p_{2}) fcopysign_{N} (\pm p_{1}, \mp p_{2}) = = \pm p_{1} \mp p_{1}

4.3.3.10. $fabs_{N} (z)$

如果 $z$ 是 NaN，则返回符号为正的 $z$ .
如果 $z$ 是无穷大，则返回正无穷大。
如果 $z$ 是零，则返回正零。
如果 $z$ 是正值，则 $z$ .
否则，返回取反后的 $z$ .

fabs_{N} (\pm nan (n)) fabs_{N} (\pm \infty) fabs_{N} (\pm 0) fabs_{N} (\pm q) = = = = + nan (n) + \infty + 0 + q

4.3.3.11. $fneg_{N} (z)$

如果 $z$ 是 NaN，则返回符号取反后的 $z$ 。
否则，如果 $z$ 是无穷大，则返回符号取反后的无穷大。
否则，如果 $z$ 是零，则返回符号取反后的零。
否则，返回取反后的 $z$ .

fneg_{N} (\pm nan (n)) fneg_{N} (\pm \infty) fneg_{N} (\pm 0) fneg_{N} (\pm q) = = = = \mp nan (n) \mp \infty \mp 0 \mp q

4.3.3.12. $fsqrt_{N} (z)$

如果 $z$ 是 NaN，则返回 $nans_{N} {z}$ 中的一个元素。
否则，如果 $z$ 是负无穷大，则返回 $nans_{N} {}$ 中的一个元素。
如果 $z$ 是正无穷大，则返回正无穷大。
如果 $z$ 是零，则返回该零。
如果 $z$ 有负号，则返回 $nans_{N} {}$ 中的元素。
否则，返回 $z$ 的平方根。

fsqrt_{N} (\pm nan (n)) fsqrt_{N} (- \infty) fsqrt_{N} (+ \infty) fsqrt_{N} (\pm 0) fsqrt_{N} (- q) fsqrt_{N} (+ q) = = = = = = nans_{N} {\pm nan (n)} nans_{N} {} + \infty \pm 0 nans_{N} {} float_{N} (q)

4.3.3.13. $fceil_{N} (z)$

如果 $z$ 是 NaN，则返回 $nans_{N} {z}$ 中的一个元素。
如果 $z$ 是无穷大，则返回 $z$ .
如果 $z$ 是零，则返回 $z$ .
如果 $z$ 小于 $0$ 但大于 $- 1$ , 则返回负零。
否则，返回不小于 $z$ 的最小整数。

fceil_{N} (\pm nan (n)) fceil_{N} (\pm \infty) fceil_{N} (\pm 0) fceil_{N} (- q) fceil_{N} (\pm q) = = = = = nans_{N} {\pm nan (n)} \pm \infty \pm 0 - 0 float_{N} (i) (if - 1 < - q < 0) (if \pm q \leq i < \pm q + 1)

4.3.3.14. $ffloor_{N} (z)$

如果 $z$ 是 NaN，则返回 $nans_{N} {z}$ 中的一个元素。
如果 $z$ 是无穷大，则返回 $z$ .
如果 $z$ 是零，则返回 $z$ .
如果 $z$ 大于 $0$ 但小于 $1$ ，则返回正零。
否则返回不大于 $z$ 的最大整数值。

ffloor_{N} (\pm nan (n)) ffloor_{N} (\pm \infty) ffloor_{N} (\pm 0) ffloor_{N} (+ q) ffloor_{N} (\pm q) = = = = = nans_{N} {\pm nan (n)} \pm \infty \pm 0 + 0 float_{N} (i) (if 0 < + q < 1) (if \pm q - 1 < i \leq \pm q)

4.3.3.15. $ftrunc_{N} (z)$

如果 $z$ 是 NaN，则返回 $nans_{N} {z}$ 中的一个元素。
如果 $z$ 是无穷大，则返回 $z$ .
如果 $z$ 是零，则返回 $z$ .
如果 $z$ 大于 $0$ 但小于 $1$ ，则返回正零。
如果 $z$ 小于 $0$ 但大于 $- 1$ , 则返回负零。
否则返回与 $z$ 符号相同的整数，且该整数的绝对值是小于或等于 $z$ 绝对值的最大整数。

ftrunc_{N} (\pm nan (n)) ftrunc_{N} (\pm \infty) ftrunc_{N} (\pm 0) ftrunc_{N} (+ q) ftrunc_{N} (- q) ftrunc_{N} (\pm q) = = = = = = nans_{N} {\pm nan (n)} \pm \infty \pm 0 + 0 - 0 float_{N} (\pm i) (if 0 < + q < 1) (if - 1 < - q < 0) (if + q - 1 < i \leq + q)

4.3.3.16. $fnearest_{N} (z)$

如果 $z$ 是 NaN，则返回 $nans_{N} {z}$ 中的一个元素。
如果 $z$ 是无穷大，则返回 $z$ .
如果 $z$ 是零，则返回 $z$ .
如果 $z$ 大于 $0$ 但小于或等于 $0.5$ , 则返回正零。
如果 $z$ 小于 $0$ 但大于或等于 $- 0.5$ , 则返回负零。
否则返回最接近 $z$ 的整数值；如果两个值一样接近，则返回偶数。

fnearest_{N} (\pm nan (n)) fnearest_{N} (\pm \infty) fnearest_{N} (\pm 0) fnearest_{N} (+ q) fnearest_{N} (- q) fnearest_{N} (\pm q) fnearest_{N} (\pm q) = = = 4.3.3.17. feq_{N} (z_{1}, z_{2}) 如果 z_{1} 或 z_{2} 是 NaN，则返回 0 . 否则，如果 z_{1} 和 z_{2} 都是零，则返回 1 . 否则，如果 z_{1} 和 z_{2} 值相同，则返回 1 . 否则返回 0 . feq_{N} (\pm nan (n), z_{2}) feq_{N} (z_{1}, \pm nan (n)) feq_{N} (\pm 0, \mp 0) feq_{N} (z_{1}, z_{2}) = = = = 001 bool (z_{1} = z_{2})

4.3.3.18. $fne_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 或 $z_{2}$ 是 NaN，则返回 $1$ .
否则如果 $z_{1}$ 和 $z_{2}$ 都是零，则返回 $0$ .
否则如果 $z_{1}$ 和 $z_{2}$ 值相同，则返回 $0$ .
否则返回 $1$ .

fne_{N} (\pm nan (n), z_{2}) fne_{N} (z_{1}, \pm nan (n)) fne_{N} (\pm 0, \mp 0) fne_{N} (z_{1}, z_{2}) = = = = 110 bool (z_{1} \neq = z_{2})

4.3.3.19. $flt_{N} (z_{1}, z_{2})$

如果 $z_{1}$ 或 $z_{2}$ 是 NaN，则返回 $0$ .
如果 $z_{1}$ 和 $z_{2}$ 值相同，则返回 $0$ .
如果 $z_{1}$ 是正无穷大，则返回 $0$ .
如果 $z_{1}$ 是负无穷大，则返回 $1$ .
如果 $z_{2}$ 是正无穷大，则返回 $1$ .
如果 $z_{2}$ 是负无穷大，则返回 $0$ .
否则如果 $z_{1}$ 和 $z_{2}$ 都是零，则返回 $0$ .
如果 $z_{1}$ 小于 $z_{2}$ , 则返回 $1$ .
否则返回 $0$ .

flt_{N} (\pm nan (n), z_{2}) flt_{N} (z_{1}, \pm nan (n)) flt_{N} (z, z) flt_{N} (+ \infty, z_{2}) flt_{4.3.3.20. fgt_{N} (z_{1}, z_{2}) 如果 z_{1} 或 z_{2} 是 NaN，则返回 0 . 如果 z_{1} 和 z_{2} 值相同，则返回 0 . 否则，如果 z_{1} 为正无穷大，则返回 1 . 否则，如果 z_{1} 为负无穷大，则返回 0 . 否则，如果 z_{2} 为正无穷大，则返回 0 . 否则，如果 z_{2} 为负无穷大，则返回 1 . 否则如果 z_{1} 和 z_{2} 都是零，则返回 0 . 否则，如果 z_{1} 大于 z_{2}, 则返回 1 . 否则返回 0 . fgt (\pm nan (n), z) fgt (z, \pm nan (n)) fgt}

4.3.3.23. $fpmin_{N} (z_{1}, z_{2})$

如果 $z_{2}$ 小于 $z_{1}$ ，则返回 $z_{2}$ .
否则返回 $z_{1}$ .

fpmin_{N} (z_{1}, z_{4.3.3.24. fpmax_{N} (z_{1}, z_{2}) 如果 z_{1} 小于 z_{2} ，则返回 z_{2} . 否则返回 z_{1} . fpmax_{N} (z_{1}, z_{2}) fpmax_{N} (z_{1}, z_{2}) = = z_{2} z_{1} (if flt_{N} (z_{1}, z_{2}) = 1) (otherwise)}

4.3.4. 转换

4.3.4.1. $extend^{u}_{M, N} (i)$

返回 $i$ .

extend^{u}_{M, N} (i) = i

注意

在抽象语法中，无符号扩展只是重新解释相同的值。

4.3.4.2. $extend^{s}_{M, N} (i)$

令 $j$ 为带符号解释的 $i$ ，大小为 $M$ .
返回 $j$ 相对于大小 $N$ 的二进制补码。

extend^{s}_{M, N} (i) = signed_{N}^{- 1} (signed_{M} (i))

4.3.4.3. $wrap_{M, N} (i)$

返回 $i$ 模 $2^{N}$ .

wrap_{M, N} (i) = i mod 2^{N}

4.3.4.4. $trunc^{u}_{M, N} (z)$

如果 $z$ 是 NaN，则结果未定义。
否则，如果 $z$ 是无穷大，则结果未定义。
否则，如果 $z$ 是一个数字，并且 $trunc (z)$ 是目标类型范围内的值，则返回该值。
否则，结果未定义。

trunc^{u}_{M, N} (\pm nan (n)) trunc^{u}_{M, N} (\pm \infty) trunc^{u}_{M, N} (\pm q) trunc^{u}_{M, N} (\pm q) = = = = {} {} trunc (\pm q) {} (if - 1 < trunc (\pm q) < 2^{N}) (otherwise)

注意

该运算符是部分的。它没有为 NaN、无穷大或结果超出范围的值定义。

4.3.4.5. $trunc^{s}_{M, N} (z)$

如果 $z$ 是 NaN，则结果未定义。
否则，如果 $z$ 是无穷大，则结果未定义。
如果 $z$ 是一个数字，并且 $trunc (z)$ 是目标类型范围内的一个值，则返回该值。
否则，结果未定义。

trunc^{s}_{M, N} (\pm nan (n)) trunc^{s}_{M, N} (\pm \infty) trunc^{s}_{M, N} (\pm q) trunc^{s}_{M, N} (\pm q) = = = = {} {} trunc (\pm q) {} (if - 2^{N - 1} - 1 < trunc (\pm q) < 2^{N - 1}) (otherwise)

注意

该运算符是部分的。它没有为 NaN、无穷大或结果超出范围的值定义。

4.3.4.6. $trunc_sat_u_{M, N} (z)$

如果 $z$ 是 NaN，则返回 $0$ .
否则如果 $z$ 是负无穷大，则返回 $0$ .
否则如果 $z$ 是正无穷大，则返回 $2^{N} - 1$ .
否则，返回 $sat_u_{N} (trunc (z))$ .

trunc_sat_u_{M, N} (\pm nan (n)) trunc_sat_u_{M, N} (- \infty) trunc_sat_u_{M, N} (+ \infty) trunc_sat_u_{M, N} (z) = = = = 00 2^{N} - 1 sat_u_{N} (trunc (z))

4.3.4.7. $trunc_sat_s_{M, N} (z)$

如果 $z$ 是 NaN，则返回 $0$ .
如果 $z$ 是负无穷大，则返回 $- 2^{N - 1}$ .
如果 $z$ 是正无穷大，则返回 $2^{N - 1} - 1$ .
否则，返回 $sat_s_{N} (trunc (z))$ .

trunc_sat_s_{M, N} (\pm nan (n)) trunc_sat_s_{M, N} (- \infty) trunc_sat_s_{M, N} (+ \infty) trunc_sat_s_{M, N} (z) = = = = 0 - 2^{N - 1} 2^{N - 1} - 1 sat_s_{N} (trunc (z))

4.3.4.8. $promote_{M, N} (z)$

如果 $z$ 是一个规范的 NaN，则返回 $nans_{N} {}$ 的一个元素（即大小为 $N$ 的规范的 NaN）。
否则如果 $z$ 是一个 NaN，则返回 $nans_{N} {\pm nan (1)}$ 的一个元素（即大小为 $N$ 的任何算术 NaN）。
否则，返回 $z$ .

promote_{M, N} (\pm nan (n)) promote_{M, N} (\pm nan (n)) promote_{M, N} (z) = = = nans_{N} {} nans_{N} {+ nan (1)} z (if n = canon_{N}) (otherwise)

4.3.4.9. $demote_{M, N} (z)$

如果 $z$ 是一个规范的 NaN，则返回 $nans_{N} {}$ 的一个元素（即大小为 $N$ 的规范的 NaN）。
否则，如果 $z$ 是一个 NaN，则返回 $nans_{N} {\pm nan (1)}$ 的一个元素（即任何大小为 $N$ 的 NaN）。
否则，如果 $z$ 是一个无穷大，则返回该无穷大。
如果 $z$ 是零，则返回该零。
否则，返回 $float_{N} (z)$ .

降级_{M, N} (\pm nan (n)) 降级_{M, N} (\pm nan (n)) 降级_{M, N} (\pm \infty) 降级_{M, N} (\pm 0) 降级_{M, N}

4.3.4.10. $convert^{u}_{M, N} (i)$

返回 $float_{N} (i)$ .

convert^{u}_{M, N} (i) = float_{N} (i)

4.3.4.11. $convert^{s}_{M, N} (i)$

令 $j$ 为 $i$ 的有符号解释。
返回 $float_{N} (j)$ .

convert^{s}_{M, N} (i) = float_{N} (signed_{M} (i))

4.3.4.12. $reinterpret_{t_{1}, t_{2}} (c)$

令 $d^{*}$ 为位序列 $bits_{t_{1}} (c)$ .
返回常量 $c^{'}$ ，对于它而言， $bits_{t_{2}} (c^{'}) = d^{*}$ .

reinterpret_{t_{1}, t_{2}} (c) = bits_{t_{2}}^{- 1} (bits_{t_{1}} (c))

4.3.4.13. $narrow^{s}_{M, N} (i)$

令 $j$ 为带符号解释的 $i$ ，大小为 $M$ .
返回 $sat_s_{N} (j)$ .

narrow^{s}_{M, N} (i) = sat_s_{N} (signed_{M} (i))

4.3.4.14. $narrow^{u}_{M, N} (i)$

令 $j$ 为带符号解释的 $i$ ，大小为 $M$ .
返回 $sat_u_{N} (j)$ .

narrow^{u}_{M, N} (i) = sat_u_{N} (signed_{M} (i))

4.4. 指令

WebAssembly 计算是通过执行单个指令来完成的。

4.4.1. 数值指令

数值指令是根据通用数值运算符来定义的。数值指令与其底层运算符的映射由以下定义表示

op_{i N} (i_{1}, \dots, i_{k}) op_{f N} (z_{1}, \dots, z_{k}) = = i op_{N} (i_{1}, \dots, i_{k}) f op_{N} (z_{1}, \dots, z_{k})

对于转换运算符

cvtop_{t_{1}, t_{2}}^{sx^{?}} (c) = cvtop_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx^{?}} (c)

当底层运算符为部分运算符时，当结果未定义时，相应的指令将陷入异常。当底层运算符为非确定性运算符时，因为它们可能返回多个可能的NaN 值，相应的指令也是非确定性的。

注意

例如，指令 $i32 . add$ 作用于操作数 $i_{1}, i_{2}$ 的结果调用了 $add_{i32} (i_{1}, i_{2})$ ，它根据上述定义映射到泛型 $iadd_{32} (i_{1}, i_{2})$ 。类似地， $i64 . trunc_f32_s$ 作用于 $z$ 调用了 $trunc_{f32, i64}^{s} (z)$ ，它根据上述定义映射到泛型 $trunc^{s}_{32, 64} (z)$ .

4.4.1.1. $t . const c$

将值 $t. const c$ 推入堆栈。

注意

此指令不需要正式的规约规则，因为 $const$ 指令本身就是值。

4.4.1.2. $t . unop$

断言：由于验证，堆栈顶端存在一个值类型为 $t$ 的值。
从堆栈中弹出值 $t. const c_{1}$ 。
如果 $unop_{t} (c_{1})$ 有定义，那么
1. 令 $c$ 为计算 $unop_{t} (c_{1})$ 的可能结果。
2. 将值 $t. const c$ 推入堆栈。
否则
1. 陷入陷阱。

(t . const c_{1}) t . unop (t . const c_{1}) t . unop ↪ ↪ (t . const c) trap (if c \in unop_{t} (c_{1})) (if unop_{t} (c_{1}) = {})

4.4.1.3. $t . binop$

断言：由于验证，栈顶有两个值类型为 $t$ 的值。
从栈中弹出值 $t. const c_{2}$ 。
从堆栈中弹出值 $t. const c_{1}$ 。
如果 $binop_{t} (c_{1}, c_{2})$ 已定义，则
1. 令 $c$ 为计算 $binop_{t} (c_{1}, c_{2})$ 的可能结果。
2. 将值 $t. const c$ 推入堆栈。
否则
1. 陷入陷阱。

(t . const c_{1}) (t . const c_{2}) t . binop (t . const c_{1}) (t . const c_{2}) t . binop ↪ ↪ (t . const c) trap (if c \in binop_{t} (c_{1}, c_{2})) (if binop_{t} (c_{1}, c_{2}) = {})

4.4.1.4. $t . testop$

断言：由于验证，值类型 $t$ 的一个值位于堆栈的顶部。
从堆栈中弹出值 $t. const c_{1}$ 。
令 $c$ 为计算 $testop_{t} (c_{1})$ 的结果。
将值 $i32 . const c$ 推入堆栈。

(t . const c_{1}) t . testop ↪ (i32 . const c) (if c = testop_{t} (c_{1}))

4.4.1.5. $t . relop$

断言：由于验证，两个值类型为 $t$ 的值位于堆栈顶部。
从栈中弹出值 $t. const c_{2}$ 。
从堆栈中弹出值 $t. const c_{1}$ 。
令 $c$ 为计算 $relop_{t} (c_{1}, c_{2})$ 的结果。
将值 $i32 . const c$ 推入堆栈。

(t . const c_{1}) (t . const c_{2}) t . relop ↪ (i32 . const c) (if c = relop_{t} (c_{1}, c_{2}))

4.4.1.6. $t_{2} . cvtop_t_{1}_sx^{?}$

断言：由于验证，一个值类型为 $t_{1}$ 的值位于堆栈顶部。
从堆栈中弹出值 $t_{1} . const c_{1}$ .
如果 $cvtop_{t_{1}, t_{2}}^{sx^{?}} (c_{1})$ 被定义
1. 令 $c_{2}$ 是计算 $cvtop_{t_{1}, t_{2}}^{sx^{?}} (c_{1})$ 的一个可能结果。
2. 将值 $t_{2} . const c_{2}$ 推入堆栈。
否则
1. 陷入陷阱。

(t_{1} . const c_{1}) t_{2} . cvtop_t_{1}_sx^{?} (t_{1} . const c_{1}) t_{2} . cvtop_t_{1}_sx^{?} (t_{1} . const c_{1}) t_{2} . cvtop_t_{1}_sx^{?} ↪ ↪ (t_{2} . const c_{2}) trap (if c_{2} \in cvtop_{t_{1}, t_{2}}^{sx^{?}} (c_{1})) (if cvtop_{t_{1}, t_{2}}^{sx^{?}} (c_{1}) = {})

4.4.2. 引用指令

4.4.2.1. $ref . null t$

将值 $ref . null t$ 推入堆栈。

注意

此指令不需要正式的约简规则，因为 $ref . null$ 指令本身就是值。

4.4.2.2. $ref . is_null$

断言：由于验证，一个引用值位于栈顶。
从栈中弹出值 $val$ 。
如果 $val$ 是 $ref . null t$ ，则
1. 将值 $i32 . const 1$ 压入栈。
否则
1. 将值 $i32 . const 0$ 压入栈。

val ref . is_null val ref . is_null ↪ ↪ (i32 . const 1) (i32 . const 0) (if val = ref . null t) (otherwise)

4.4.2.3. $ref . func x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . funcaddrs [x]$ 存在。
令 $a$ 为函数地址 $F. module . funcaddrs [x]$ 。
将值 $ref a$ 压入栈。

F; (ref . func x) ↪ F; (ref a) (if a = F . module . funcaddrs [x])

4.4.3. 向量指令

按位操作的向量指令被视为相应宽度的整数运算。

op_{v N} (i_{1}, \dots, i_{k}) = i op_{N} (i_{1}, \dots, i_{k})

大多数其他向量指令都是根据给定的形状按车道方式应用数值运算符来定义的。

op_{t x N} (n_{1}, \dots, n_{k}) = lanes_{t x N}^{- 1} (op_{t} (i_{1}, \dots, i_{k})^{*}) (if i_{1}^{*} = lanes_{t x N} (n_{1}) \land \dots \land i_{k}^{*} = lanes_{t x N} (n_{k})

注意

例如，指令 $i32x4 . add$ 应用于操作数 $v_{1}, v_{2}$ 的结果调用了 $add_{i32x4} (v_{1}, v_{2})$ , 它映射到 $lanes_{i32x4}^{- 1} (add_{i32} (i_{1}, i_{2})^{*})$ , 其中 $i_{1}^{*}$ 和 $i_{2}^{*}$ 分别是调用 $lanes_{i32x4} (v_{1})$ 和 $lanes_{i32x4} (v_{2})$ 所产生的序列。

4.4.3.1. $v128 . const c$

将值 $v128 . const c$ 压入堆栈。

注意

该指令不需要正式的归约规则，因为 $const$ 指令与值一致。

4.4.3.2. $v128 . vvunop$

断言：由于验证，堆栈顶部存在一个值类型为 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $c$ 为计算 $vvunop_{v128} (c_{1})$ 的结果。
将值 $v128 . const c$ 压入堆栈。

(v128 . const c_{1}) v128 . vvunop ↪ (v128 . const c) (if c = vvunop_{v128} (c_{1}))

4.4.3.3. $v128 . vvbinop$

断言：由于验证，堆栈顶部有两个值类型 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{2}$ 。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $c$ 为计算 $vvbinop_{v128} (c_{1}, c_{2})$ 的结果。
将值 $v128 . const c$ 压入堆栈。

(v128 . const c_{1}) (v128 . const c_{2}) v128 . vvbinop ↪ (v128 . const c) (if c = vvbinop_{v128} (c_{1}, c_{2}))

4.4.3.4. $v128 . vvternop$

断言：由于验证，堆栈顶部有三个值类型 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{3}$ 。
从堆栈中弹出值 $v128 . const c_{2}$ 。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $c$ 为计算 $vvternop_{v128} (c_{1}, c_{2}, c_{3})$ 的结果。
将值 $v128 . const c$ 压入堆栈。

(v128 . const c_{1}) (v128 . const c_{2}) (v128 . const c_{3}) v128 . vvternop ↪ (v128 . const c) (if c = vvternop_{v128} (c_{1}, c_{2}, c_{3}))

4.4.3.5. $v128 . any_true$

断言：由于验证，堆栈顶端存在一个值类型为 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i$ 为计算 $ine_{128} (c_{1}, 0)$ 的结果。
将值 $i32 . const i$ 压入堆栈。

(v128 . const c_{1}) v128 . any_true ↪ (i32 . const i) (if i = ine_{128} (c_{1}, 0))

4.4.3.6. $i8x16. swizzle$

断言：由于验证，堆栈顶部有两个值类型为 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{2}$ 。
令 $i^{*}$ 为计算 $lanes_{i8x16} (c_{2})$ 的结果。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $j^{*}$ 为计算 $lanes_{i8x16} (c_{1})$ 的结果。
令 $c^{*}$ 为序列 $j^{*}$ 和 $0^{240}$ 的连接。
令 $c^{'}$ 为计算 $lanes_{i8x16}^{- 1} (c^{*} [i^{*} [0]] \dots c^{*} [i^{*} [15]])$ .
将值 $v128 . const c^{'}$ 推送到堆栈。

(v128 . const c_{1}) (v128 . const c_{2}) i8x16 . swizzle ↪ (v128 . const c^{'}) (if \land \land i^{*} = lanes_{i8x16} (c_{2}) c^{*} = lanes_{i8x16} (c_{1}) 0^{240} c^{'} = lanes_{i8x16}^{- 1} (c^{*} [i^{*} [0]] \dots c^{*} [i^{*} [15]]))

4.4.3.7. $i8x16. shuffle x^{*}$

断言: 由于验证, 栈顶有两个值类型为 $v128$ 的值。
断言: 由于验证, 对于 $x_{i}$ 在 $x^{*}$ 中的所有值，都满足以下条件： $x_{i} < 32$ .
从堆栈中弹出值 $v128 . const c_{2}$ 。
令 $i_{2}^{*}$ 为计算 $lanes_{i8x16} (c_{2})$ 的结果。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i_{1}^{*}$ 为计算 $lanes_{i8x16} (c_{1})$ 的结果。
令 $i^{*}$ 为两个序列 $i_{1}^{*}$ 和 $i_{2}^{*}$ 的连接。
令 $c$ 为计算 $lanes_{i8x16}^{- 1} (i^{*} [x^{*} [0]] \dots i^{*} [x^{*} [15]])$ .
将值 $v128 . const c$ 推入堆栈。

(v128 . const c_{1}) (v128 . const c_{2}) (i8x16 . shuffle x^{*}) ↪ (v128 . const c) (if \land i^{*} = lanes_{i8x16} (c_{1}) lanes_{i8x16} (c_{2}) c = lanes_{i8x16}^{- 1} (i^{*} [x^{*} [0]] \dots i^{*} [x^{*} [15]]))

4.4.3.8. $shape . splat$

令 $t$ 为类型 $unpacked (shape)$ .
断言：根据验证，类型为值类型 $t$ 的值位于栈顶。
从堆栈中弹出值 $t. const c_{1}$ 。
令 $N$ 为整数 $dim (shape)$ .
令 $c$ 为计算结果 $lanes_{shape}^{- 1} (c_{1}^{N})$ .
将值 $v128 . const c$ 压入堆栈。

(t . const c_{1}) shape . splat ↪ (v128 . const c) (if t = unpacked (shape) \land c = lanes_{shape}^{- 1} (c_{1}^{dim (shape)}))

4.4.3.9. $t_{1} x N . extract_lane_sx^{?} x$

断言：由于验证， $x < N$ .
断言：由于验证，一个值类型为 $v128$ 的值位于堆栈顶端。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i^{*}$ 为计算 $lanes_{t_{1} x N} (c_{1})$ 的结果。
令 $t_{2}$ 为类型 $unpacked (t_{1} x N)$ .
令 $c_{2}$ 为计算 $extend_{t_{1}, t_{2}}^{s x^{?}} (i^{*} [x])$ .
将值 $t_{2} . const c_{2}$ 推入堆栈。

(v128 . const c_{1}) (t_{1} x N . extract_lane x) ↪ (t_{2} . const c_{2}) (if \land t_{2} = unpacked (t_{1} x N) c_{2} = extend_{t_{1}, t_{2}}^{s x^{?}} (lanes_{t_{1} x N} (c_{1}) [x]))

4.4.3.10. $shape . replace_lane x$

断言：由于验证， $x < dim (shape)$ .
令 $t_{2}$ 为类型 $unpacked (shape)$ .
断言：由于验证，一个类型为 $t_{1}$ 的值位于栈顶。
从栈顶弹出值 $t_{2} . const c_{2}$ .
断言：由于验证，一个类型为 $v128$ 的值位于栈顶。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i^{*}$ 为计算 $lanes_{shape} (c_{1})$ 的结果。
令 $c$ 为计算 $lanes_{shape}^{- 1} (i^{*} with [x] = c_{2})$ 的结果。
将 $v128 . const c$ 推入栈中。

(v128 . const c_{1}) (t_{2} . const c_{2}) (shape . replace_lane x) ↪ (v128 . const c) (if \land i^{*} = lanes_{shape} (c_{1}) c = lanes_{shape}^{- 1} (i^{*} with [x] = c_{2}))

4.4.3.11. $shape . vunop$

断言：由于验证，栈顶为一个值类型为 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $c$ 为计算 $vunop_{shape} (c_{1})$ 的结果。
将值 $v128 . const c$ 压入堆栈。

(v128 . const c_{1}) shape . vunop ↪ (v128 . const c) (if c = vunop_{shape} (c_{1}))

4.4.3.12. $shape . vbinop$

断言：由于验证，堆栈顶部有两个值类型为 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{2}$ 。
从堆栈中弹出值 $v128 . const c_{1}$ 。
如果 $vbinop_{shape} (c_{1}, c_{2})$ 被定义
1. 令 $c$ 是计算 $vbinop_{shape} (c_{1}, c_{2})$ 的一个可能结果。
2. 将值 $v128 . const c$ 压入堆栈。
否则
1. 陷入陷阱。

(v128 . const c_{1}) (v128 . const c_{2}) shape . vbinop (v128 . const c_{1}) (v128 . const c_{2}) shape . vbinop ↪ ↪ (v128 . const c) trap (if c \in vbinop_{shape} (c_{1}, c_{2}) (if vbinop_{shape} (c_{1}, c_{2}) = {})

4.4.3.13. $t x N . vrelop$

断言：由于验证，栈顶有两个值类型为 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{2}$ 。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i_{1}^{*}$ 为计算 $lanes_{t x N} (c_{1})$ 的结果。
令 $i_{2}^{*}$ 为计算 $lanes_{t x N} (c_{2})$ 的结果。
令 $i^{*}$ 为计算 $vrelop_{t} (i_{1}^{*}, i_{2}^{*})$ 的结果。
令 $j^{*}$ 为计算 $extend^{s}_{1, ∣t∣} (i^{*})$ 的结果。
令 $c$ 为计算 $lanes_{t x N}^{- 1} (j^{*})$ 的结果。
将值 $v128 . const c$ 压入堆栈。

(v128 . const c_{1}) (v128 . const c_{2}) t x N . vrelop ↪ (v128 . const c) (if c = lanes_{t x N}^{- 1} (extend^{s}_{1, ∣ t ∣} (vrelop_{t} (lanes_{t x N} (c_{1}), lanes_{t x N} (c_{2})))))

4.4.3.14. $t x N . vishiftop$

断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈顶弹出 $i32 . const s$ 值。
断言：由于验证，一个值类型为 $v128$ 的值位于栈顶。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i^{*}$ 是计算 $lanes_{t x N} (c_{1})$ 的结果。
令 $j^{*}$ 是计算 $vishiftop_{t} (i^{*}, s^{N})$ 的结果。
令 $c$ 为计算 $lanes_{t x N}^{- 1} (j^{*})$ 的结果。
将值 $v128 . const c$ 压入堆栈。

(v128 . const c_{1}) (i32 . const s) t x N . vishiftop ↪ (v128 . const c) (if \land i^{*} = lanes_{t x N} (c_{1}) c = lanes_{t x N}^{- 1} (vishiftop_{t} (i^{*}, s^{N})))

4.4.3.15. $shape . all_true$

断言: 由于验证，一个类型为值类型 $v128$ 的值位于栈顶。
从栈中弹出 $v128 . const c$ 值。
令 $i_{1}^{*}$ 是计算 $lanes_{shape} (c)$ 的结果。
令 $i$ 是计算 $bool (⋀ (i_{1} \neq = 0)^{*})$ 的结果。
将值 $i32 . const i$ 压入堆栈。

(v128 . const c) shape . all_true ↪ (i32 . const i) (if \land i_{1}^{*} = lanes_{shape} (c) i = bool (⋀ (i_{1} \neq = 0)^{*}))

4.4.3.16. $t x N . bitmask$

断言：由于验证，一个值类型为 $v128$ 的值位于堆栈顶部。
从栈中弹出 $v128 . const c$ 值。
令 $i_{1}^{N}$ 为计算 $lanes_{t x N} (c)$ 的结果。
令 $B$ 为位宽 $∣t∣$ 值类型 $t$ 。
令 $i_{2}^{N}$ 为计算 $ilt_s_{B} (i_{1}^{N}, 0^{N})$ 的结果。
令 $j^{*}$ 为两个序列 $i_{2}^{N}$ 和 $0^{32 - N}$ 的连接。
令 $i$ 为计算 $ibits_{32}^{- 1} (j^{*})$ 的结果。
将值 $i32 . const i$ 压入堆栈。

(v128 . const c) t x N . bitmask ↪ (i32 . const i) (if i = ibits_{32}^{- 1} (ilt_s_{∣ t ∣} (lanes_{t x N} (c), 0^{N})))

4.4.3.17. $t_{2} x N . narrow_t_{1} x M_sx$

断言：由于语法， $N = 2 \cdot M$ .
断言：由于验证，堆栈顶部有两个值类型为 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{2}$ 。
令 $i_{2}^{M}$ 为计算 $lanes_{t_{1} x M} (c_{2})$ 的结果。
令 $d_{2}^{M}$ 为计算 $narrow_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (i_{2}^{M})$ 的结果。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i_{1}^{M}$ 为计算 $lanes_{t_{1} x M} (c_{1})$ 的结果。
令 $d_{1}^{M}$ 为计算 $narrow_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (i_{1}^{M})$ 的结果。
令 $j^{N}$ 为两个序列 $d_{1}^{M}$ 和 $d_{2}^{M}$ 的连接。
令 $c$ 为计算 $lanes_{t_{2} x N}^{- 1} (j^{N})$ 的结果。
将值 $v128 . const c$ 推入堆栈。

(v128 . const c_{1}) (v128 . const c_{2}) t_{2} x N . narrow_t_{1} x M_sx ↪ (v128 . const c) (if \land \land d_{1}^{M} = narrow_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (lanes_{t_{1} x M} (c_{1})) d_{2}^{M} = narrow_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (lanes_{t_{1} x M} (c_{2})) c = lanes_{t_{2} x N}^{- 1} (d_{1}^{M} d_{2}^{M}))

4.4.3.18. $t_{2} x N . vcvtop_t_{1} x M_sx$

断言：由于语法， $N = M$ .
断言：由于验证，栈顶有一个值为值类型 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i^{*}$ 为计算 $lanes_{t_{1} x M} (c_{1})$ 的结果。
令 $j^{*}$ 为计算 $vcvtop_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (i^{*})$ 的结果。
令 $c$ 为计算 $lanes_{t_{2} x N}^{- 1} (j^{*})$ 的结果。
将值 $v128 . const c$ 推入堆栈。

(v128 . const c_{1}) t_{2} x N . vcvtop_t_{1} x M_sx ↪ (v128 . const c) (if c = lanes_{t_{2} x N}^{- 1} (vcvtop_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (lanes_{t_{1} x M} (c_{1}))))

4.4.3.19. $t_{2} x N . vcvtop_half_t_{1} x M_sx^{?}$

断言: 由于语法, $N = M/2$ .
断言：由于验证，栈顶有一个值为值类型 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i^{*}$ 为计算 $lanes_{t_{1} x M} (c_{1})$ 的结果。
如果 $half$ 是 $low$ , 那么
1. 令 $j^{*}$ 为序列 $i^{*} [0 : N]$ .
否则
1. 令 $j^{*}$ 为序列 $i^{*} [N : N]$ .
令 $k^{*}$ 为计算 $vcvtop_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx^{?}} (j^{*})$ .
令 $c$ 为计算 $lanes_{t_{2} x N}^{- 1} (k^{*})$ .
将值 $v128 . const c$ 推入堆栈。

(v128 . const c_{1}) t_{2} x N . vcvtop_half_t_{1} x M_sx^{?} ↪ (v128 . const c) (if

其中

low (x, y) high (x, y) = = x y

4.4.3.20. $t_{2} x N . vcvtop_t_{1} x M_sx^{?}_zero$

断言：由于语法， $N = 2 \cdot M$ .
断言：由于验证，栈顶有一个值为值类型 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i^{*}$ 为计算 $lanes_{t_{1} x M} (c_{1})$ 的结果。
令 $j^{*}$ 为计算 $vcvtop_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx^{?}} (i^{*})$ .
令 $k^{*}$ 为两个序列 $j^{*}$ 和 $0^{M}$ 的拼接。
令 $c$ 为计算 $lanes_{t_{2} x N}^{- 1} (k^{*})$ .
将值 $v128 . const c$ 推入堆栈。

(v128 . const c_{1}) t_{2} x N . vcvtop_t_{1} x M_sx^{?}_zero ↪ (v128 . const c) (if c = lanes_{t_{2} x N}^{- 1} (vcvtop_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx^{?}} (lanes_{t_{1} x M} (c_{1})) 0^{M}))

4.4.3.21. $i32x4. dot_i16x8_s$

断言：由于验证，堆栈顶部有两个值类型为 $v128$ 的值。
从堆栈中弹出值 $v128 . const c_{2}$ 。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i_{1}^{*}$ 是计算 $lanes_{i16x8} (c_{1})$ 的结果。
令 $j_{1}^{*}$ 为计算 $extend^{s}_{16, 32} (i_{1}^{*})$ 的结果。
令 $i_{2}^{*}$ 为计算 $lanes_{i16x8} (c_{2})$ 的结果。
令 $j_{2}^{*}$ 为计算 $extend^{s}_{16, 32} (i_{2}^{*})$ 的结果。
令 $(k_{1} k_{2})^{*}$ 为计算 $imul_{32} (j_{1}^{*}, j_{2}^{*})$ 的结果。
令 $k^{*}$ 为计算 $iadd_{32} (k_{1}, k_{2})^{*}$ 的结果。
令 $c$ 为计算 $lanes_{i32x4}^{- 1} (k^{*})$ 的结果。
将值 $v128 . const c$ 推入堆栈。

(v128 . const c_{1}) (v128 . const c_{2}) i32x4. dot_i16x8_s ↪ (v128 . const c) (if \land \land (i_{1} i_{2})^{*} = imul_{32} (extend^{s}_{16, 32} (lanes_{i16x8} (c_{1})), extend^{s}_{16, 32} (lanes_{i16x8} (c_{2}))) j^{*} = iadd_{32} (i_{1}, i_{2})^{*} c = lanes_{i32x4}^{- 1} (j^{*}))

4.4.3.22. $t_{2} x N . extmul_half_t_{1} x M_sx$

断言: 由于语法, $N = M/2$ .
断言：由于验证，两个值类型为 $v128$ 的值位于堆栈顶部。
从堆栈中弹出值 $v128 . const c_{2}$ 。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i_{1}^{*}$ 为计算 $lanes_{t_{1} x M} (c_{1})$ 的结果。
令 $i_{2}^{*}$ 为计算 $lanes_{t_{1} x M} (c_{2})$ 的结果。
如果 $half$ 是 $low$ , 那么
1. 令 $j_{1}^{*}$ 为序列 $i_{1}^{*} [0 : N]$ 。
2. 令 $j_{2}^{*}$ 为序列 $i_{2}^{*} [0 : N]$ 。
否则
1. 令 $j_{1}^{*}$ 为序列 $i_{1}^{*} [N : N]$ 。
2. 令 $j_{2}^{*}$ 为序列 $i_{2}^{*} [N : N]$ 。
令 $k_{1}^{*}$ 为计算 $extend_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (j_{1}^{*})$ 的结果。
令 $k_{2}^{*}$ 为计算 $extend_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (j_{2}^{*})$ 的结果。
令 $k^{*}$ 为计算 $imul_{∣ t_{2} ∣} (k_{1}^{*}, k_{2}^{*})$ 的结果。
令 $c$ 为计算 $lanes_{t_{2} x N}^{- 1} (k^{*})$ .
将值 $v128 . const c$ 推入堆栈。

(v128 . const c_{1}) (v128 . const c_{2}) t_{2} x N . extmul_half_t_{1} x M_sx ↪ (v128 . const c) (if \land \land i^{*} = lanes_{t_{1} x M} (c_{1}) [half (0, N) : N] j^{*} = lanes_{t_{1} x M} (c_{2}) [half (0, N) : N] c = lanes_{t_{2} x N}^{- 1} (imul_{∣ t_{2} ∣} (extend_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (i^{*}), extend_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (j^{*}))))

其中

low (x, y) high (x, y) = = x y

4.4.3.23. $t_{2} x N . extadd_pairwise_t_{1} x M_sx$

断言: 由于语法, $N = M/2$ .
断言：由于验证，一个值类型为 $v128$ 的值位于栈顶。
从堆栈中弹出值 $v128 . const c_{1}$ 。
令 $i^{*}$ 为计算 $lanes_{t_{1} x M} (c_{1})$ 的结果。
设 $(j_{1} j_{2})^{*}$ 为计算 $extend_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (i^{*})$ 的结果。
设 $k^{*}$ 为计算 $iadd_{∣ t_{2} ∣} (j_{1}, j_{2})^{*}$ 的结果。
令 $c$ 为计算 $lanes_{t_{2} x N}^{- 1} (k^{*})$ .
将值 $v128 . const c$ 压入堆栈。

(v128 . const c_{1}) t_{2} x N . extadd_pairwise_t_{1} x M_sx ↪ (v128 . const c) (if \land \land (i_{1} i_{2})^{*} = extend_{∣ t_{1} ∣, ∣ t_{2} ∣}^{sx} (lanes_{t_{1} x M} (c_{1})) j^{*} = iadd_{∣ t_{2} ∣} (i_{1}, i_{2})^{*} c = lanes_{t_{2} x N}^{- 1} (j^{*}))

4.4.4. 参数指令

4.4.4.1. $drop$

断言：由于验证，栈顶存在一个值。
从栈中弹出值 $val$ 。

val drop ↪ ϵ

4.4.4.2. $select (t^{*})^{?}$

断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈中弹出值 $i32 . const c$ 。
断言：由于验证，栈顶还有两个值（具有相同的值类型）。
从栈中弹出值 $val_{2}$ 。
从栈中弹出值 $val_{1}$ 。
如果 $c$ 不等于 $0$ ，则
1. 将值 $val_{1}$ 压回栈中。
否则
1. 将值 $val_{2}$ 压回栈中。

val_{1} val_{2} (i32 . const c) (select t^{?}) val_{1} val_{2} (i32 . const c) (select t^{?}) ↪ ↪ val_{1} val_{2} (if c \neq = 0) (if c = 0)

注意

在 WebAssembly 的未来版本中， $select$ 可能允许每个选择有多个值。

4.4.5. 变量指令

4.4.5.1. $local.get x$

令 $F$ 为当前帧。
断言：由于验证， $F. locals [x]$ 存在。
设 $val$ 为值 $F. locals [x]$ .
将值 $val$ 推入堆栈。

F; (local.get x) ↪ F; val (if F . locals [x] = val)

4.4.5.2. $local.set x$

令 $F$ 为当前帧。
断言：由于验证， $F. locals [x]$ 存在。
断言：由于验证，堆栈顶部有一个值。
从栈中弹出值 $val$ 。
用值 $val$ 替换 $F. locals [x]$ .

F; val (local.set x) ↪ F^{'}; ϵ (if F^{'} = F with locals [x] = val)

4.4.5.3. $local.tee x$

断言：由于验证，堆栈顶部有一个值。
从栈中弹出值 $val$ 。
将值 $val$ 推入堆栈。
将值 $val$ 推入堆栈。
执行指令 $local.set x$ .

val (local.tee x) ↪ val val (local.set x)

4.4.5.4. $global.get x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . globaladdrs [x]$ 存在。
设 $a$ 为全局地址 $F. module . globaladdrs [x]$ .
断言：由于验证， $S. globals [a]$ 存在。
令 $glob$ 为全局实例 $S. globals [a]$ .
令 $val$ 为值 $glob . value$ .
将值 $val$ 推入堆栈。

S; F; (global.get x) ↪ S; F; val (if S . globals [F . module . globaladdrs [x]] . value = val)

4.4.5.5. $global.set x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . globaladdrs [x]$ 存在。
设 $a$ 为全局地址 $F. module . globaladdrs [x]$ .
断言：由于验证， $S. globals [a]$ 存在。
令 $glob$ 为全局实例 $S. globals [a]$ .
断言：由于验证，堆栈顶部有一个值。
从栈中弹出值 $val$ 。
用值 $val$ 替换 $glob . value$ .

S; F; val (global.set x) ↪ S^{'}; F; ϵ (if S^{'} = S with globals [F . module . globaladdrs [x]] . value = val)

注意

验证确保全局变量实际上被标记为可变的。

4.4.6. 表格指令

4.4.6.1. $table.get x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . tableaddrs [x]$ 存在。
令 $a$ 为表格地址 $F. module . tableaddrs [x]$ .
断言：由于验证， $S. tables [a]$ 存在。
令 $tab$ 为表实例 $S. tables [a]$ .
断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈中弹出值 $i32 . const i$ .
如果 $i$ 不小于 $tab . elem$ 的长度，那么
1. 陷入陷阱。
令 $val$ 为值 $tab . elem [i]$ .
将值 $val$ 推入堆栈。

S; F; (i32 . const i) (table.get x) ↪ S; F; val (如果 S . tables [F . module . tableaddrs [x]] . elem [i] = val) S; F; (i32 . const i) (table.get x) ↪ S; F; trap (否则)

4.4.6.2. $table.set x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . tableaddrs [x]$ 存在。
令 $a$ 为表格地址 $F. module . tableaddrs [x]$ .
断言：由于验证， $S. tables [a]$ 存在。
令 $tab$ 为表实例 $S. tables [a]$ .
断言：由于验证，一个引用值位于栈顶。
从栈中弹出值 $val$ 。
断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈中弹出值 $i32 . const i$ .
如果 $i$ 不小于 $tab . elem$ 的长度，那么
1. 陷入陷阱。
将元素 $tab . elem [i]$ 替换为 $val$ .

S; F; (i32 . const i) val (table.set x) ↪ S^{'}; F; ϵ (if S^{'} = S with tables [F . module . tableaddrs [x]] . elem [i] = val) S; F; (i32 . const i) val (table.set x) ↪ S; F; trap (otherwise)

4.4.6.3. $table.size x$

令 $F$ 为当前帧。
断言：根据验证， $F. module . tableaddrs [x]$ 存在。
令 $a$ 为表格地址 $F. module . tableaddrs [x]$ .
断言：根据验证， $S. tables [a]$ 存在。
令 $tab$ 为表实例 $S. tables [a]$ .
令 $sz$ 为 $tab . elem$ 的长度。
将值 $i32 . const sz$ 推入栈中。

S; F; (table.size x) ↪ S; F; (i32 . const sz) (if ∣ S . tables [F . module . tableaddrs [x]] . elem ∣ = sz)

4.4.6.4. $table.grow x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . tableaddrs [x]$ 存在。
令 $a$ 为表格地址 $F. module . tableaddrs [x]$ .
断言：由于验证， $S. tables [a]$ 存在。
令 $tab$ 为表实例 $S. tables [a]$ .
令 $sz$ 为 $S. tables [a]$ 的长度。
断言：由于验证，栈顶有一个值类型为 $i32$ 的值。
从栈顶弹出值 $i32 . const n$ 。
断言：由于验证，栈顶有一个引用值。
从栈中弹出值 $val$ 。
令 $err$ 为 $i32$ 值 $2^{32} - 1$ ，对于它， $signed_{32} (err)$ 为 $- 1$ .
要么

如果增长 $tab$ $n$ 个条目，用初始化值 $val$ 成功，那么

将值 $i32 . const sz$ 推入栈中。

否则

将值 $i32 . const err$ 推入栈。

或者

将值 $i32 . const err$ 推入栈。

S; F; val (i32 . const n) (table.grow x) ↪ S^{'}; F; (i32 . const sz) (if \land \land F . module . tableaddrs [x] = a sz = ∣ S . tables [a] . elem ∣ S^{'} = S with tables [a] = growtable (S . tables [a], n, val)) 1 e x] 1 e x] S; F; val (i32 . const n) (table.grow x) ↪ S; F; (i32 . const signed_{32}^{- 1} (- 1))

注意

The $table.grow$ instruction is non-deterministic. It may either succeed, returning the old table size $sz$ , or fail, returning $- 1$ . Failure must occur if the referenced table instance has a maximum size defined that would be exceeded. However, failure can occur in other cases as well. In practice, the choice depends on the resources available to the embedder.

4.4.6.5. $table.fill x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . tableaddrs [x]$ 存在。
令 $ta$ 为表格地址 $F. module . tableaddrs [x]$ .
断言：由于验证， $S. tables [ta]$ 存在。
令 $tab$ 为表格实例 $S. tables [ta]$ .
断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈顶弹出值 $i32 . const n$ 。
断言：由于验证，栈顶有一个引用值。
从栈中弹出值 $val$ 。
断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈中弹出值 $i32 . const i$ .
如果 $i + n$ 大于 $tab . elem$ 的长度，则
1. 陷入陷阱。

如果 $0$ ，则
1. 返回。
将值 $i32 . const i$ 推入栈。
将值 $val$ 推入堆栈。
执行指令 $table.set x$ 。
将值 $i32 . const (i + 1)$ 推入栈。
将值 $val$ 推入堆栈。
将值 $i32 . const (n - 1)$ 推入栈。
执行指令 $table.fill x$ 。

S; F; (i32 . const i) val (i32 . const n) (table.fill x) ↪ S; F; trap (if i + n > ∣ S . tables [F . module . tableaddrs [x]] . elem ∣) 1 e x] 1 e x] S; F; (i32 . const i) val (i32 . const 0) (table.fill x) ↪ S; F; ϵ (otherwise) 1 e x] S; F; (i32 . const i) val (i32 . const n + 1) (table.fill x) ↪ S; F; (i32 . const i) val (table.set x) (i32 . const i + 1) val (i32 . const n) (table.fill x) (otherwise)

4.4.6.6. $table.copy x y$

令 $F$ 为当前帧。
断言：由于验证， $F. module . tableaddrs [x]$ 存在。
令 $ta_{x}$ 为表地址 $F. module . tableaddrs [x]$ .
断言：由于验证， $S. tables [ta_{x}]$ 存在。
令 $tab_{x}$ 为表实例 $S. tables [ta_{x}]$ .
断言：由于验证， $F. module . tableaddrs [y]$ 存在。
令 $ta_{y}$ 为表地址 $F. module . tableaddrs [y]$ .
断言：由于验证， $S. tables [ta_{y}]$ 存在。
令 $tab_{y}$ 为表实例 $S. tables [ta_{y}]$ .
断言：由于验证，一个值类型为 $i32$ 的值位于堆栈顶部。
从栈顶弹出值 $i32 . const n$ 。
断言：由于验证，一个值类型为 $i32$ 的值位于堆栈顶部。
从栈顶弹出 $i32 . const s$ 值。
断言：由于验证，一个值类型为 $i32$ 的值位于堆栈顶部。
从堆栈中弹出值 $i32 . const d$ .
如果 $s + n$ 大于 $tab_{y} . elem$ 的长度，或 $d + n$ 大于 $tab_{x} . elem$ 的长度，则
1. 陷入陷阱。
如果 $n = 0$ ，则

返回。

如果 $d \leq s$ ，则

将值 $i32 . const d$ 压入堆栈。

将值 $i32 . const s$ 压入堆栈。

执行指令 $table.get y$ .

执行指令 $table.set x$ 。

断言：由于之前对表格大小的检查， $d + 1 < 2^{32}$ .

将值 $i32 . const (d + 1)$ 推入堆栈。

断言：由于之前对表格大小的检查， $s + 1 < 2^{32}$ .

将值 $i32 . const (s + 1)$ 推入堆栈。

否则

断言：由于之前对表格大小的检查， $d + n - 1 < 2^{32}$ .

将值 $i32 . const (d + n - 1)$ 推入堆栈。

断言：由于之前对表格大小的检查， $s + n - 1 < 2^{32}$ .

将值 $i32 . const (s + n - 1)$ 推入堆栈。

执行指令 $table.get y$ .

执行指令 $table.set x$ 。

将值 $i32 . const d$ 压入堆栈。

将值 $i32 . const s$ 压入堆栈。

将值 $i32 . const (n - 1)$ 推入栈。
执行指令 $table.copy x y$ .

S; F; (i32 . const d) (i32 . const s) (i32 . const n) (table.copy x y) ↪ S; F; trap (if \lor s + n > ∣ S . tables [F . module . tableaddrs [y]] . elem ∣ d + n > ∣ S . tables [F . module . tableaddrs [x]] . elem ∣) 1 e x] 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const 0) (table.copy x y) ↪ S; F; ϵ (otherwise) 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const n + 1) (table.copy x y) ↪ S; F; (i32 . const d) (i32 . const s) (table.get y) (table.set x) (i32 . const d + 1) (i32 . const s + 1) (i32 . const n) (table.copy x y) (otherwise, if d \leq s) 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const n + 1) (table.copy x y) ↪ S; F; (i32 . const d + n) (i32 . const s + n) (table.get y) (table.set x) (i32 . const d) (i32 . const s) (i32 . const n) (table.copy x y) (otherwise, if d > s)

4.4.6.7. $table.init x y$

令 $F$ 为当前帧。
断言：由于验证， $F. module . tableaddrs [x]$ 存在。
令 $ta$ 为表格地址 $F. module . tableaddrs [x]$ .
断言：由于验证， $S. tables [ta]$ 存在。
令 $tab$ 为表格实例 $S. tables [ta]$ .
断言：由于验证， $F. module . elemaddrs [y]$ 存在。
设 $ea$ 为元素地址 $F. module . elemaddrs [y]$ .
断言：由于验证， $S. elems [ea]$ 存在。
设 $elem$ 为元素实例 $S. elems [ea]$ .
断言：由于验证，堆栈顶端有一个值为值类型 $i32$ 的值。
从栈顶弹出值 $i32 . const n$ 。
断言：由于验证，堆栈顶端有一个值为值类型 $i32$ 的值。
从栈顶弹出 $i32 . const s$ 值。
断言：由于验证，堆栈顶端有一个值为值类型 $i32$ 的值。
从堆栈中弹出值 $i32 . const d$ .
如果 $s + n$ 大于 $elem . elem$ 的长度，或者 $d + n$ 大于 $tab . elem$ 的长度，则
1. 陷入陷阱。
如果 $n = 0$ ，则
1. 返回。
设 $val$ 为参考值 $elem . elem [s]$ .
将值 $i32 . const d$ 压入堆栈。
将值 $val$ 推入堆栈。
执行指令 $table.set x$ 。
断言：由于之前对表格大小的检查， $d + 1 < 2^{32}$ .
将值 $i32 . const (d + 1)$ 推入堆栈。
断言：由于之前对段大小的检查， $s + 1 < 2^{32}$ .
将值 $i32 . const (s + 1)$ 推入堆栈。
将值 $i32 . const (n - 1)$ 推入栈。
执行指令 $table.init x y$ .

S; F; (i32 . const d) (i32 . const s) (i32 . const n) (table.init x y) ↪ S; F; trap (if \lor s + n > ∣ S . elems [F . module . elemaddrs [y]] . elem ∣ d + n > ∣ S . tables [F . module . tableaddrs [x]] . elem ∣) 1 e x] 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const 0) (table.init x y) ↪ S; F; ϵ (otherwise) 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const n + 1) (table.init x y) ↪ S; F; (i32 . const d) val (table.set x) (i32 . const d + 1) (i32 . const s + 1) (i32 . const n) (table.init x y) (otherwise, if val = S . elems [F . module . elemaddrs [y]] . elem [s])

4.4.6.8. $elem.drop x$

令 $F$ 为当前帧。
断言：根据验证， $F. module . elemaddrs [x]$ 存在。
设 $a$ 为元素地址 $F. module . elemaddrs [x]$ .
断言：根据验证， $S. elems [a]$ 存在。
用 $ϵ$ 替换 $S. elems [a] . elem$ .

S; F; (elem.drop x) ↪ S^{'}; F; ϵ (if S^{'} = S with elems [F . module . elemaddrs [x]] . elem = ϵ)

4.4.7. 内存指令

注意

在 load 和 store 指令中，对齐方式 $memarg . align$ 不会影响语义。它指示访问内存的偏移量 $ea$ 应该满足属性 $ea mod 2^{memarg . align} = 0$ . WebAssembly 实现可以使用此提示来优化预期用途。违反该属性的未对齐访问仍然允许，并且必须成功，无论注释如何。但是，在某些硬件上它可能明显更慢。

4.4.7.1. $t . load memarg$ 和 $t . load N_sx memarg$

令 $F$ 为当前帧。
断言：根据验证， $F. module . memaddrs [0]$ 存在。
设 $a$ 为内存地址 $F. module . memaddrs [0]$ .
断言：由于验证， $S. mems [a]$ 存在。
设 $mem$ 为内存实例 $S. mems [a]$ .
断言：由于验证，栈顶存在一个值类型 $i32$ 的值。
从栈中弹出值 $i32 . const i$ .
设 $ea$ 为整数 $i + memarg . offset$ .
如果 $N$ 不属于指令的一部分，那么
1. 设 $N$ 为位宽 $∣t∣$ 的数值类型 $t$ .
如果 $ea + N/8$ 大于 $mem . data$ 的长度，那么
1. 陷入陷阱。
设 $b^{*}$ 为字节序列 $mem . data [ea : N/8]$ .
如果 $N$ 和 $sx$ 是指令的一部分，那么
1. 设 $n$ 为整数，使得 $bytes_{i N} (n) = b^{*}$ .
2. 设 $c$ 为计算 $extend_{N, ∣t∣}^{sx} (n)$ 的结果。
否则
1. 设 $c$ 为常量，使得 $bytes_{t} (c) = b^{*}$ .
将值 $t. const c$ 推入堆栈。

S; F; (i32 . const i) (t . load memarg) ↪ S; F; (t . const c) (if \land \land ea = i + memarg . offset ea + ∣ t ∣/8 \leq ∣ S . mems [F . module . memaddrs [0]] . data ∣ bytes_{t} (c) = S . mems [F . module . memaddrs [0]] . data [ea : ∣ t ∣/8]) 1 e x] 1 e x] S; F; (i32 . const i) (t . load N_sx memarg) ↪ S; F; (t . const extend_{N, ∣ t ∣}^{sx} (n)) (if \land \land ea = i + memarg . offset ea + N /8 \leq ∣ S . mems [F . module . memaddrs [0]] . data ∣ bytes_{i N} (n) = S . mems [F . module . memaddrs [0]] . data [ea : N /8]) 1 e x] 1 e x] S; F; (i32 . const i) (t . load (N_sx)^{?} memarg) ↪ S; F; trap (otherwise)

4.4.7.2. $v128 . load M x N_sx memarg$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
设 $a$ 为内存地址 $F. module . memaddrs [0]$ .
断言：由于验证， $S. mems [a]$ 存在。
设 $mem$ 为内存实例 $S. mems [a]$ .
断言：由于验证，栈顶存在一个值类型 $i32$ 的值。
从栈中弹出值 $i32 . const i$ .
设 $ea$ 为整数 $i + memarg . offset$ .
如果 $ea + M \cdot N/8$ 大于 $mem . data$ 的长度，那么
1. 陷入陷阱。
令 $b^{*}$ 为字节序列 $mem . data [ea : M \cdot N/8]$ .
令 $m_{k}$ 为整数，其中 $bytes_{i M} (m_{k}) = b^{*} [k \cdot M/8 : M/8]$ .
令 $W$ 为整数 $M \cdot 2$ .
令 $n_{k}$ 为计算 $extend_{M, W}^{sx} (m_{k})$ 的结果。
令 $c$ 为计算 $lanes_{i W x N}^{- 1} (n_{0} \dots n_{N - 1})$ 的结果。
将值 $v128 . const c$ 推入栈中。

S; F; (i32 . const i) (v128 . load M x N_sx memarg) ↪ S; F; (v128 . const c) (if \land \land \land \land ea = i + memarg . offset ea + M \cdot N /8 \leq ∣ S . mems [F . module . memaddrs [0]] . data ∣ bytes_{i M} (m_{k}) = S . mems [F . module . memaddrs [0]] . data [ea + k \cdot M /8 : M /8] W = M \cdot 2 c = lanes_{i W x N}^{- 1} (extend_{M, W}^{sx} (m_{0}) \dots extend_{M, W}^{sx} (m_{N - 1}))) 1 e x] S; F; (i32 . const i) (v128 . load M x N_sx memarg) ↪ S; F; trap (otherwise)

4.4.7.3. $v128 . load N_splat memarg$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
设 $a$ 为内存地址 $F. module . memaddrs [0]$ .
断言：由于验证， $S. mems [a]$ 存在。
设 $mem$ 为内存实例 $S. mems [a]$ .
断言：由于验证，栈顶存在一个值类型 $i32$ 的值。
从栈中弹出值 $i32 . const i$ .
设 $ea$ 为整数 $i + memarg . offset$ .
如果 $ea + N/8$ 大于 $mem . data$ 的长度，那么
1. 陷入陷阱。
设 $b^{*}$ 为字节序列 $mem . data [ea : N/8]$ .
设 $n$ 为整数，使得 $bytes_{i N} (n) = b^{*}$ .
令 $L$ 为整数 $128/N$ .
令 $c$ 为计算 $lanes_{i N x L}^{- 1} (n^{L})$ 的结果。
将值 $v128 . const c$ 推入栈中。

S; F; (i32 . const i) (v128 . load N_splat memarg) ↪ S; F; (v128 . const c) (if \land \land \land ea = i + memarg . offset ea + N /8 \leq ∣ S . mems [F . module . memaddrs [0]] . data ∣ bytes_{i N}

4.4.7.5. $v128 . load N_lane memarg x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
设 $a$ 为内存地址 $F. module . memaddrs [0]$ .
断言：由于验证， $S. mems [a]$ 存在。
设 $mem$ 为内存实例 $S. mems [a]$ .
断言：由于验证，一个值类型为 $v128$ 的值位于堆栈顶端。
从堆栈中弹出值 $v128 . const v$ 。
断言：由于验证，栈顶存在一个值类型 $i32$ 的值。
从栈中弹出值 $i32 . const i$ .
设 $ea$ 为整数 $i + memarg . offset$ .
如果 $ea + N/8$ 大于 $mem . data$ 的长度，那么
1. 陷入陷阱。
设 $b^{*}$ 为字节序列 $mem . data [ea : N/8]$ .
令 $r$ 为常数，使得 $bytes_{i N} (r) = b^{*} .$
令 $L$ 为 $128/N$ .
令 $j^{*}$ 为计算 $lanes_{i N x L} (v)$ 的结果。
令 $c$ 为计算 $lanes_{i N x L}^{- 1} (j^{*} with [x] = r)$ .
将值 $v128 . const c$ 推入栈中。

S; F; (i32 . const i) (v128 . const v) (v128 . load N_lane memarg x) ↪ S; F; (v128 . const c) (if \land \land \land \land ea = i + memarg . offset ea + N /8 \leq ∣ S . mems [F . module . memaddrs [0]] . data ∣ bytes_{i N} (r) = S . mems [F . module . memaddrs [0]] . data [ea : N /8] L = 128/ N c = lanes_{i N x L}^{- 1} (lanes_{i N x L} (v) with [x] = r)) 1 e x] S; F; (i32 . const i) (v128 . const v) (v128 . load N_lane memarg x) ↪ S; F; trap (otherwise)

4.4.7.6. $t . store memarg$ 和 $t . store N memarg$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
设 $a$ 为内存地址 $F. module . memaddrs [0]$ .
断言：由于验证， $S. mems [a]$ 存在。
设 $mem$ 为内存实例 $S. mems [a]$ .
断言：由于验证，栈顶存在一个值类型为 $t$ 的值。
从栈顶弹出值 $t. const c$ .
断言：由于验证，栈顶存在一个值类型为 $i32$ 的值。
从栈中弹出值 $i32 . const i$ .
设 $ea$ 为整数 $i + memarg . offset$ .
如果 $N$ 不属于指令的一部分，那么
1. 设 $N$ 为位宽 $∣t∣$ 的数值类型 $t$ .
如果 $ea + N/8$ 大于 $mem . data$ 的长度，那么
1. 陷入陷阱。
如果 $N$ 是指令的一部分，则
1. 令 $n$ 为计算 $wrap_{∣t∣, N} (c)$ 的结果。
2. 令 $b^{*}$ 为字节序列 $bytes_{i N} (n)$ .
否则
1. 令 $b^{*}$ 为字节序列 $bytes_{t} (c)$ .
将字节 $mem . data [ea : N/8]$ 替换为 $b^{*}$ .

S; F; (i32 . const i) (t . const c) (t . store memarg) ↪ S^{'}; F; ϵ (if \land \land ea = i + memarg . offset ea + ∣ t ∣/8 \leq ∣ S . mems [F . module . memaddrs [0]] . data ∣ S^{'} = S with mems [F . module . memaddrs [0]] . data [ea : ∣ t ∣/8] = bytes_{t} (c)) 1 e x] 1 e x] S; F; (i32 . const i) (t . const c) (t . store N memarg) ↪ S^{'}; F; ϵ (if \land \land ea = i + memarg . offset ea + N /8 \leq ∣ S . mems [F . module . memaddrs [0]] . data ∣ S^{'} = S with mems [F . module . memaddrs [0]] . data [ea : N /8] = bytes_{i N} (wrap_{∣ t ∣, N} (c))) 1 e x] 1 e x] S; F; (i32 . const i) (t . const c) (t . store N^{?} memarg) ↪ S; F; trap (otherwise)

4.4.7.7. $v128 . store N_lane memarg x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
设 $a$ 为内存地址 $F. module . memaddrs [0]$ .
断言：由于验证， $S. mems [a]$ 存在。
设 $mem$ 为内存实例 $S. mems [a]$ .
断言：由于验证，一个值类型为 $v128$ 的值位于栈顶。
从栈中弹出值 $v128 . const c$ .
断言：由于验证，栈顶存在一个值类型为 $i32$ 的值。
从栈中弹出值 $i32 . const i$ .
设 $ea$ 为整数 $i + memarg . offset$ .
如果 $ea + N/8$ 大于 $mem . data$ 的长度，那么
1. 陷入陷阱。
令 $L$ 为 $128/N$ .
令 $j^{*}$ 为计算 $lanes_{i N x L} (c)$ 的结果。
令 $b^{*}$ 为计算 $bytes_{i N} (j^{*} [x])$ 的结果。
将字节 $mem . data [ea : N/8]$ 替换为 $b^{*}$ .

S; F; (i32 . const i) (v128 . const c) (v128 . store N_lane memarg x) ↪ S^{'}; F; ϵ (if \land \land \land ea = i + memarg . offset ea + N \leq ∣ S . mems [F . module . memaddrs [0]] . data ∣ L = 128/ N S^{'} = S with mems [F . module . memaddrs [0]] . data [ea : N /8] = bytes_{i N} (lanes_{i N x L} (c) [x])) 1 e x] S; F; (i32 . const i) (v128 . const c) (v128 . store N_lane memarg x) ↪ S; F; trap (otherwise)

4.4.7.8. $memory.size$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
设 $a$ 为内存地址 $F. module . memaddrs [0]$ .
断言：由于验证， $S. mems [a]$ 存在。
设 $mem$ 为内存实例 $S. mems [a]$ .
设 $sz$ 为 $mem . data$ 的长度除以页大小。
将值 $i32 . const sz$ 推入栈中。

S; F; memory.size ↪ S; F; (i32 . const sz) (if ∣ S . mems [F . module . memaddrs [0]] . data ∣ = sz \cdot 64 Ki)

4.4.7.9. $memory.grow$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
设 $a$ 为内存地址 $F. module . memaddrs [0]$ .
断言：由于验证， $S. mems [a]$ 存在。
设 $mem$ 为内存实例 $S. mems [a]$ .
设 $sz$ 为 $S. mems [a]$ 的长度除以页大小。
断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈顶弹出值 $i32 . const n$ 。
令 $err$ 为 $i32$ 值 $2^{32} - 1$ ，对于它， $signed_{32} (err)$ 为 $- 1$ .
要么

如果增长 $mem$ $n$ 个页成功，则

将值 $i32 . const sz$ 推入栈中。

否则

将值 $i32 . const err$ 推入栈。

或者

将值 $i32 . const err$ 推入栈。

S; F; (i32 . const n) memory.grow ↪ S^{'}; F; (i32 . const sz) (if \land \land F . module . memaddrs [0] = a sz = ∣ S . mems [a] . data ∣/64 Ki S^{'} = S with mems [a] = growmem (S . mems [a], n)) 1 e x] 1 e x] S; F; (i32 . const n) memory.grow ↪ S; F; (i32 . const signed_{32}^{- 1} (- 1))

注意

指令 $memory.grow$ 是非确定性的。它可能成功，返回旧的内存大小 $sz$ ，也可能失败，返回 $- 1$ 。如果引用的内存实例定义了最大大小，并且会超过该大小，则失败必须发生。然而，失败也可能在其他情况下发生。在实践中，选择取决于可供嵌入器使用的资源。

4.4.7.10. $memory.fill$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
令 $ma$ 为内存地址 $F. module . memaddrs [0]$ 。
断言：由于验证， $S. mems [ma]$ 存在。
令 $mem$ 为内存实例 $S. mems [ma]$ .
断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈顶弹出值 $i32 . const n$ 。
断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从栈中弹出值 $val$ 。
断言：由于验证，一个值类型为 $i32$ 的值位于栈顶。
从堆栈中弹出值 $i32 . const d$ .
如果 $d + n$ 大于 $mem . data$ 的长度，则
1. 陷入陷阱。
如果 $n = 0$ ，则
1. 返回。
将值 $i32 . const d$ 压入堆栈。
将值 $val$ 推入堆栈。
执行指令 $i32 . store 8 {offset 0, align 0}$ .
断言：由于之前对内存大小的检查， $d + 1 < 2^{32}$ .
将值 $i32 . const (d + 1)$ 推入堆栈。
将值 $val$ 推入堆栈。
将值 $i32 . const (n - 1)$ 推入栈。
执行指令 $memory.fill$ .

S; F; (i32 . const d) val (i32 . const n) memory.fill ↪ S; F; trap (如果 d + n > ∣ S . mems [F . module . memaddrs [0]] . data ∣) 1 e x] S; F; (i32 . const d) val (i32 . const 0) memory.fill ↪ S; F; ϵ (否则) 1 e x] S; F; (i32 . const d) val (i32 . const n + 1) memory.fill ↪ S; F; (i32 . const d) val (i32 . store 8 {offset 0, align 0}) (i32 . const d + 1) val (i32 . const n) memory.fill (否则)

4.4.7.11. $memory.copy$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
令 $ma$ 为内存地址 $F. module . memaddrs [0]$ 。
断言：由于验证， $S. mems [ma]$ 存在。
令 $mem$ 为内存实例 $S. mems [ma]$ .
断言：由于验证，堆栈顶端存在一个值类型为 $i32$ 的值。
从栈顶弹出值 $i32 . const n$ 。
断言：由于验证，堆栈顶端存在一个值类型为 $i32$ 的值。
从栈顶弹出 $i32 . const s$ 值。
断言：由于验证，堆栈顶端存在一个值类型为 $i32$ 的值。
从堆栈中弹出值 $i32 . const d$ .
如果 $s + n$ 大于 $mem . data$ 的长度，或者 $d + n$ 大于 $mem . data$ 的长度，则
1. 陷入陷阱。
如果 $n = 0$ ，则

返回。

如果 $d \leq s$ ，则

将值 $i32 . const d$ 压入堆栈。

将值 $i32 . const s$ 压入堆栈。

执行指令 $i32 . load 8_u {offset 0, align 0}$ .

执行指令 $i32 . store 8 {offset 0, align 0}$ .

断言：由于之前对内存大小的检查， $d + 1 < 2^{32}$ .

将值 $i32 . const (d + 1)$ 推入堆栈。

断言：由于先前对内存大小的检查， $s + 1 < 2^{32}$ .

将值 $i32 . const (s + 1)$ 推入堆栈。

否则

断言：由于先前对内存大小的检查， $d + n - 1 < 2^{32}$ .

将值 $i32 . const (d + n - 1)$ 推入堆栈。

断言：由于先前对内存大小的检查， $s + n - 1 < 2^{32}$ .

将值 $i32 . const (s + n - 1)$ 推入堆栈。

执行指令 $i32 . load 8_u {offset 0, align 0}$ .

执行指令 $i32 . store 8 {offset 0, align 0}$ .

将值 $i32 . const d$ 压入堆栈。

将值 $i32 . const s$ 压入堆栈。

将值 $i32 . const (n - 1)$ 推入栈。
执行指令 $memory.copy$ .

S; F; (i32 . const d) (i32 . const s) (i32 . const n) memory.copy ↪ S; F; trap (if \lor s + n > ∣ S . mems [F . module . memaddrs [0]] . data ∣ d + n > ∣ S . mems [F . module . memaddrs [0]] . data ∣) 1 e x] 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const 0) memory.copy ↪ S; F; ϵ (otherwise) 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const n + 1) memory.copy ↪ S; F; (i32 . const d) (i32 . const s) (i32 . load 8_u {offset 0, align 0}) (i32 . store 8 {offset 0, align 0}) (i32 . const d + 1) (i32 . const s + 1) (i32 . const n) memory.copy (otherwise, if d \leq s) 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const n + 1) memory.copy ↪ S; F; (i32 . const d + n) (i32 . const s + n) (i32 . load 8_u {offset 0, align 0}) (i32 . store 8 {offset 0, align 0}) (i32 . const d) (i32 . const s) (i32 . const n) memory.copy (otherwise, if d > s)

4.4.7.12. $memory.init x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . memaddrs [0]$ 存在。
令 $ma$ 为内存地址 $F. module . memaddrs [0]$ 。
断言：由于验证， $S. mems [ma]$ 存在。
令 $mem$ 为内存实例 $S. mems [ma]$ .
断言：由于验证， $F. module . dataaddrs [x]$ 存在。
令 $da$ 为数据地址 $F. module . dataaddrs [x]$ .
断言：由于验证， $S. datas [da]$ 存在。
令 $data$ 为数据实例 $S. datas [da]$ .
断言：由于验证，堆栈顶端存在一个值类型为 $i32$ 的值。
从栈顶弹出值 $i32 . const n$ 。
断言：由于验证，堆栈顶端存在一个值类型为 $i32$ 的值。
从栈顶弹出 $i32 . const s$ 值。
断言：由于验证，堆栈顶端存在一个值类型为 $i32$ 的值。
从堆栈中弹出值 $i32 . const d$ .
如果 $s + n$ 大于 $data . data$ 的长度，或者 $d + n$ 大于 $mem . data$ 的长度，则
1. 陷入陷阱。
如果 $n = 0$ ，则
1. 返回。
令 $b$ 为字节 $data . data [s]$ .
将值 $i32 . const d$ 压入堆栈。
将值 $i32 . const b$ 推入堆栈。
执行指令 $i32 . store 8 {offset 0, align 0}$ .
断言：由于之前对内存大小的检查， $d + 1 < 2^{32}$ .
将值 $i32 . const (d + 1)$ 推入堆栈。
断言：由于先前对内存大小的检查， $s + 1 < 2^{32}$ .
将值 $i32 . const (s + 1)$ 推入堆栈。
将值 $i32 . const (n - 1)$ 推入栈。
执行指令 $memory.init x$ .

S; F; (i32 . const d) (i32 . const s) (i32 . const n) (memory.init x) ↪ S; F; trap (if \lor s + n > ∣ S . datas [F . module . dataaddrs [x]] . data ∣ d + n > ∣ S . mems [F . module . memaddrs [0]] . data ∣) 1 e x] 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const 0) (memory.init x) ↪ S; F; ϵ (otherwise) 1 e x] S; F; (i32 . const d) (i32 . const s) (i32 . const n + 1) (memory.init x) ↪ S; F; (i32 . const d) (i32 . const b) (i32 . store 8 {offset 0, align 0}) (i32 . const d + 1) (i32 . const s + 1) (i32 . const n) (memory.init x) (otherwise, if b = S . datas [F . module . dataaddrs [x]] . data [s])

4.4.7.13. $data.drop x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . dataaddrs [x]$ 存在。
令 $a$ 为数据地址 $F. module . dataaddrs [x]$ .
断言：由于验证， $S. datas [a]$ 存在。
将 $S. datas [a]$ 替换为数据实例 ${data ϵ}$ .

S; F; (data.drop x) ↪ S^{'}; F; ϵ (如果 S^{'} = S 用 datas [F . module . dataaddrs [x]] = {data ϵ})

4.4.8. 控制指令

4.4.8.1. $nop$

什么也不做。

nop ↪ ϵ

4.4.8.2. $unreachable$

陷入陷阱。

unreachable ↪ trap

4.4.8.3. $block blocktype instr^{*} end$

令 $F$ 为当前帧。
断言：由于验证， $expand_{F} (blocktype)$ 已定义。
设 $[t_{1}^{m}] \to [t_{2}^{n}]$ 为函数类型 $expand_{F} (blocktype)$ .
设 $L$ 为参数个数为 $n$ 且延续为块结尾的标签。
断言：根据验证，栈顶至少有 $m$ 个值。
从栈顶弹出 $val^{m}$ 个值。
进入块 $val^{m} instr^{*}$ ，标签为 $L$ .

F; val^{m} block bt instr^{*} end ↪ F; label_{n} {ϵ} val^{m} instr^{*} end (if expand_{F} (bt) = [t_{1}^{m}] \to [t_{2}^{n}])

4.4.8.4. $loop blocktype instr^{*} end$

令 $F$ 为当前帧。
断言：由于验证， $expand_{F} (blocktype)$ 已定义。
设 $[t_{1}^{m}] \to [t_{2}^{n}]$ 为函数类型 $expand_{F} (blocktype)$ .
设 $L$ 为参数个数为 $m$ 且延续为循环开始的标签。
断言：根据验证，栈顶至少有 $m$ 个值。
从栈顶弹出 $val^{m}$ 个值。
进入块 $val^{m} instr^{*}$ ，标签为 $L$ .

F; val^{m} loop bt instr^{*} end ↪ F; label_{m} {loop bt instr^{*} end} val^{m} instr^{*} end (if expand_{F} (bt) = [t_{1}^{m}] \to [t_{2}^{n}])

4.4.8.5. $if blocktype instr_{1}^{} else instr_{2}^{} end$

断言：由于验证，一个值类型为 $i32$ 的值在栈顶。
从栈中弹出值 $i32 . const c$ 。
如果 $c$ 不为零，那么
1. 执行块指令 $block blocktype instr_{1}^{*} end$ .
否则
1. 执行块指令 $block blocktype instr_{2}^{*} end$ .

(i32 . const c) if bt instr_{1}^{*} else instr_{2}^{*} end (i32 . const c) if bt instr_{1}^{*} else instr_{2}^{*} end ↪ ↪ block bt instr_{1}^{*} end (if c \neq = 0) block bt instr_{2}^{*} end (if c = 0)

4.4.8.6. $br l$

断言：由于验证，栈至少包含 $l + 1$ 个标签。
设 $L$ 为栈中出现的第 $l$ 个标签，从栈顶开始，从零开始计数。
设 $n$ 为 $L$ 的元数。
断言：由于验证，栈顶至少有 $n$ 个值。
从栈顶弹出 $val^{n}$ 个值。
重复 $l + 1$ 次
1. 当栈顶为值时，执行以下操作：
  1. 从栈顶弹出值。
2. 断言：由于验证，栈顶现在是一个标签。
3. 从栈顶弹出标签。
将值 $val^{n}$ 推入栈。
跳转到 $L$ 的延续部分。

label_{n} {instr^{*}} B^{l} [val^{n} (br l)] end ↪ val^{n} instr^{*}

4.4.8.7. $br_if l$

断言：由于验证，栈顶有一个值类型 $i32$ 的值。
从栈中弹出值 $i32 . const c$ 。
如果 $c$ 不为零，那么
1. 执行指令 $br l$ .
否则
1. 什么也不做。

(i32 . const c) (br_if l) (i32 . const c) (br_if l) ↪ ↪ (br l) ϵ (if c \neq = 0) (if c = 0)

4.4.8.8. $br_table l^{*} l_{N}$

断言：由于验证，栈顶有一个值类型 $i32$ 的值。
从栈中弹出值 $i32 . const i$ .
如果 $i$ 小于 $l^{*}$ 的长度，则
1. 令 $l_{i}$ 为标签 $l^{*} [i]$ .
2. 执行指令 $br l_{i}$ .
否则
1. 执行指令 $br l_{N}$ .

(i32 . const i) (br_table l^{*} l_{N}) (i32 . const i) (br_table l^{*} l_{N}) ↪ ↪ (br l_{i}) (br l_{N}) (if l^{*} [i] = l_{i}) (if ∣ l^{*} ∣ \leq i)

4.4.8.9. $return$

令 $F$ 为当前帧。
设 $n$ 为 $F$ 的元数。
断言：由于验证，栈顶至少有 $n$ 个值。
从栈中弹出结果 $val^{n}$ .
断言：由于验证，栈中至少包含一个帧。
当栈顶不是帧时，执行以下操作
1. 从栈中弹出栈顶元素。
断言：栈顶是帧 $F$ .
从栈中弹出帧。
将 $val^{n}$ 推入栈。
跳转到最初推送帧的调用指令后的指令。

frame_{n} {F} B^{k} [val^{n} return] end ↪ val^{n}

4.4.8.10. $call x$

令 $F$ 为当前帧。
断言：由于验证， $F. module . funcaddrs [x]$ 存在。
令 $a$ 为函数地址 $F. module . funcaddrs [x]$ 。
调用地址为 $a$ 的函数实例。

F; (call x) ↪ F; (invoke a) (if F . module . funcaddrs [x] = a)

4.4.8.11. $call_indirect x y$

令 $F$ 为当前帧。
断言：由于验证， $F. module . tableaddrs [x]$ 存在。
令 $ta$ 为表格地址 $F. module . tableaddrs [x]$ .
断言：由于验证， $S. tables [ta]$ 存在。
令 $tab$ 为表格实例 $S. tables [ta]$ .
断言：由于验证， $F. module . types [y]$ 存在。
令 $ft_{expect}$ 为函数类型 $F. module . types [y]$ .
断言：由于验证，栈顶存在一个值类型为 $i32$ 的值。
从栈中弹出值 $i32 . const i$ .
如果 $i$ 不小于 $tab . elem$ 的长度，那么
1. 陷入陷阱。
令 $r$ 为引用 $tab . elem [i]$ .
如果 $r$ 是 $ref . null t$ , 那么
1. 陷入陷阱。
断言：由于表格修改的验证， $r$ 是一个函数引用。
令 $ref a$ 为函数引用 $r$ .
断言：由于表格修改的验证， $S. funcs [a]$ 存在。
令 $f$ 为函数实例 $S. funcs [a]$ .
令 $ft_{actual}$ 为函数类型 $f . type$ .
如果 $ft_{actual}$ 和 $ft_{expect}$ 不同，则
1. 陷入陷阱。
调用地址为 $a$ 的函数实例。

S; F; (i32 . const i) (call_indirect x y) ↪ S; F; (invoke a) (if \land \land S . tables [F . module . tableaddrs [x]] . elem [i] = ref a S . funcs [a] = f F . module . types [y] = f . type) 1 e x] S; F; (i32 . const i) (call_indirect x y) ↪ S; F; trap (otherwise)

4.4.9. 块

以下辅助规则定义了执行形成块的指令序列的语义。

4.4.9.1. 进入带标签 $L$ 的 $instr^{*}$

将 $L$ 推入堆栈。
跳转到指令序列 $instr^{*}$ 的开头。

注意

进入指令序列不需要正式的规约规则，因为标签 $L$ 已嵌入到控制指令直接规约到的管理指令中。

4.4.9.2. 退出带有标签 $L$ 的 $instr^{*}$

当一个块在没有跳转或陷阱中止的情况下结束时，执行以下步骤。

从堆栈顶部弹出所有值 $val^{*}$ .
断言：由于验证，标签 $L$ 现在位于堆栈顶部。
从栈顶弹出标签。
将 $val^{*}$ 推回堆栈。
跳转到与标签 $L$ 相关的结构化控制指令的 $end$ 之后的位置。

label_{n} {instr^{*}} val^{*} end ↪ val^{*}

注意

此语义也适用于包含在 $loop$ 指令中的指令序列。因此，循环的执行会从末尾掉落，除非显式执行反向分支。

4.4.10. 函数调用

以下辅助规则定义了通过一个调用指令调用函数实例并从其中返回的语义。

4.4.10.1. 调用函数地址 $a$

断言：由于验证， $S. funcs [a]$ 存在。
令 $f$ 为函数实例， $S. funcs [a]$ .
令 $[t_{1}^{n}] \to [t_{2}^{m}]$ 为函数类型 $f. type$ .
令 $t^{*}$ 为值类型列表 $f. code . locals$ .
令 $instr^{*} end$ 为表达式 $f. code . body$ .
断言：由于验证，堆栈顶部有 $n$ 个值。
从栈顶弹出 $val^{n}$ 个值。
设 $F$ 为帧 ${模块 f. 模块, 局部变量 val^{n} (默认_{t})^{*}}$ .
将具有元数 $m$ 的 $F$ 的激活压入栈。
设 $L$ 为元数为 $m$ 且继续为函数结尾的标签。
进入具有标签 $L$ 的指令序列 $instr^{*}$ .

S; val^{n} (invoke a) ↪ S; frame_{m} {F} label_{m} {} instr^{*} end end (if \land \land \land S . funcs [a] = f f . type = [t_{1}^{n}] \to [t_{2}^{m}] f . code = {type x, locals t^{k}, body instr^{*} end} F = {module f . module, locals val^{n} (default_{t})^{k}})

4.4.10.2. 从函数返回

当函数执行到末尾时，如果没有发生跳转（例如， $return$ ) 或发生陷阱中断，则执行以下步骤。

令 $F$ 为当前帧。
设 $n$ 为 $F$ 激活的元数。
断言：由于验证，堆栈顶端有 $n$ 个值。
从栈中弹出结果 $val^{n}$ .
断言：由于验证，帧 $F$ 现在位于堆栈顶端。
从栈中弹出帧。
将 $val^{n}$ 推回堆栈。
跳转到原始调用后的指令。

frame_{n} {F} val^{n} end ↪ val^{n}

4.4.10.3. 宿主函数

调用宿主函数具有非确定性行为。它可能以陷阱终止，也可能正常返回。但是，在后一种情况下，它必须根据其函数类型在堆栈上消耗和生成正确数量和类型的 WebAssembly 值。

宿主函数也可以修改存储。然而，所有存储修改必须导致原始存储的扩展，即它们只能修改可变内容，并且不能删除实例。此外，生成的存储必须是有效的，即其中的所有数据和代码都类型正确。

S; val^{n} (invoke a) ↪ S^{'}; result (if \land S . funcs [a] = {type [t_{1}^{n}] \to [t_{2}^{m}

这里， $hf (S; val^{n})$ 表示在当前存储 $S$ 中，使用参数 $val^{n}$ 执行宿主函数 $hf$ 的实现定义方式。它产生一组可能的结果，其中每个元素要么是修改后的存储 $S^{'}$ 和一个结果的对，要么是表示发散的特殊值 $⊥$ 。如果至少有一个参数，其结果集不是单一的，则宿主函数是非确定性的。

为了使 WebAssembly 实现能够在存在宿主函数的情况下保持健全性，每个宿主函数实例都必须是有效的，这意味着它必须遵守适当的前置条件和后置条件：在有效存储 $S$ 下，给定与指定的参数类型 $t_{1}^{n}$ 匹配的参数 $val^{n}$ , 执行宿主函数必须产生一组非空的可能结果，每个结果要么是发散，要么由一个有效存储 $S^{'}$ 组成，该存储是 $S$ 的扩展，以及一个与指定的返回类型 $t_{2}^{m}$ 匹配的结果。所有这些概念在附录中进行了精确定义。

注意

宿主函数可以通过调用从模块中导出的函数来回调到 WebAssembly。但是，任何此类调用的影响都被宿主函数允许的非确定性行为所包含。

4.4.11. 表达式

一个表达式是相对于当前帧进行求值的，该帧指向其包含的模块实例。

跳转到表达式的指令序列 $instr^{*}$ 的开头。
执行指令序列。
断言：由于验证，栈顶包含一个值。
从栈中弹出值 $val$ 。

值 $val$ 是求值的結果。

[S; F; instr^{*} ↪ S^{'}; F^{'}; instr^{' *} (if S; F; instr^{*} end ↪ S^{'}; F^{'}; instr^{' *} end)

注意

求值会迭代此归约规则，直到达到一个值。构成函数主体的表达式在函数调用期间被执行。

4.5. 模块

对于模块，执行语义主要定义了实例化，它会分配模块及其包含的定义的实例，从包含的元素和数据段初始化表格和内存，如果存在则调用启动函数。它还包括对导出函数的调用。

实例化依赖于一些辅助概念来进行类型检查导入和分配实例。

4.5.1. 外部类型

为了将外部值与导入进行比较，这些值由外部类型进行分类。以下辅助类型规则指定了相对于存储 $S$ 的这种类型关系，其中引用了实例。

4.5.1.1. $func a$

存储条目 $S. funcs [a]$ 必须存在。
然后， $func a$ 对外部类型 $func S. funcs [a] . type$ 有效。

S ⊢ func a : func S. funcs [ a ] . type

4.5.1.2. $table a$

存储条目 $S. tables [a]$ 必须存在。
然后， $table a$ 对外部类型 $table S. tables [a] . type$ 有效。

S ⊢ table a : table S. tables [ a ] . type

4.5.1.3. $mem a$

存储条目 $S. mems [a]$ 必须存在。
然后， $mem a$ 对外部类型 $mem S. mems [a] . type$ 有效。

S ⊢ mem a : mem S. mems [ a ] . type

4.5.1.4. $global a$

存储条目 $S. globals [a]$ 必须存在。
然后， $global a$ 对外部类型 $global S. globals [a] . type$ 有效。

S ⊢ global a : global S. globals [ a ] . type

4.5.2. 值类型

为了将参数值与导出的函数的参数类型进行比较，值被分类为值类型。以下辅助类型规则指定了此类型关系，相对于一个可能包含引用地址的存储 S。

4.5.2.1. 数值 $t. const c$

该值在数值类型 $t$ 中有效。

S ⊢ t. const c : t

4.5.2.2. 空引用 $ref . null t$

该值在引用类型 $t$ 中有效。

S ⊢ ref . null t : t

4.5.2.3. 函数引用 $ref a$

外部值 $func a$ 必须有效。
然后，该值在引用类型 $funcref$ 中有效。

\frac{S ⊢ func a : func functype}{S ⊢ ref a : funcref}

4.5.2.4. 外部引用 $ref . extern a$

该值在引用类型 $externref$ 中有效。

S ⊢ ref . extern a : externref

4.5.3. 分配

函数、表格、内存和全局变量的新实例在存储 S 中被分配，如下面辅助函数定义。

4.5.3.1. 函数

设 $func$ 为要分配的函数，而 $moduleinst$ 为其模块实例。
设 $a$ 为 S 中第一个空闲函数地址。
设 $functype$ 为函数类型 $moduleinst . types [func . type]$ .
令 $funcinst$ 为函数实例 ${type functype, module moduleinst, code func}$ .
将 $funcinst$ 附加到 $funcs$ 中的 $S$ .
返回 $a$ .

allocfunc (S, func, moduleinst) funcaddr functype funcinst S^{'} = = = = = S^{'}, funcaddr 1 e x] where: ∣ S . funcs ∣ moduleinst . types [func . type] {type functype, module moduleinst, code func} S \oplus {funcs funcinst}

4.5.3.2. 宿主函数

令 $hostfunc$ 为宿主函数用于分配和 $functype$ 的函数类型.
设 $a$ 为 S 中第一个空闲函数地址。
令 $funcinst$ 为函数实例 ${type functype, hostcode hostfunc}$ .
将 $funcinst$ 附加到 $funcs$ 中的 $S$ .
返回 $a$ .

allochostfunc (S, functype, hostfunc) funcaddr funcinst S^{'} = = = = S^{'}, funcaddr 1 e x] where: ∣ S . funcs ∣ {type functype, hostcode hostfunc} S \oplus {funcs funcinst}

注意

WebAssembly 语义本身永远不会分配宿主函数，但可以由嵌入器分配。

4.5.3.3. 表格

设 $tabletype$ 为要分配的表格类型，而 $ref$ 为初始化值。
设 $({min n, max m^{?}} reftype)$ 为表格类型 $tabletype$ 的结构。
设 $a$ 为 $S$ 中第一个空闲的表格地址。
设 $tableinst$ 为表格实例 ${type tabletype, elem ref^{n}}$ ，其中 $n$ 个元素都设置为 $ref$ .
将 $tableinst$ 追加到 $tables$ 中，并加入到 $S$ 中。
返回 $a$ .

alloctable (S, tabletype, ref) tabletype tableaddr tableinst S^{'} = = = = = S^{'}, tableaddr 1 e x] where: {min n, max m^{?}} reftype ∣ S . tables ∣ {type tabletype, elem ref^{n}} S \oplus {tables tableinst}

4.5.3.4. Memories

令 $memtype$ 为要分配的内存类型。
令 ${min n, max m^{?}}$ 为内存类型 $memtype$ 的结构。
令 $a$ 为 $S$ 中第一个空闲的内存地址。
令 $meminst$ 为内存实例 ${type memtype, data (0x 00)^{n \cdot 64 Ki}}$ ，它包含 $n$ 页已归零的字节。
将 $meminst$ 附加到 $mems$ 的 $S$ 中。
返回 $a$ .

allocmem (S, memtype) memtype memaddr meminst S^{'} = = = = = S^{'}, memaddr 1 e x] where: {min n, max m^{?}} ∣ S . mems ∣ {type memtype, data (0x 00)^{n \cdot 64 Ki}} S \oplus {mems meminst}

4.5.3.5. 全局变量

设 $globaltype$ 为要分配的全局变量类型，并且 $val$ 为用来初始化全局变量的值。
设 $a$ 为 $S$ 中第一个空闲的全局变量地址。
设 $globalinst$ 为全局变量实例 ${type globaltype, value val}$ .
将 $globalinst$ 追加到 $globals$ 的 $S$ 中。
返回 $a$ .

allocglobal (S, globaltype, val) globaladdr globalinst S^{'} = = = = S^{'}, globaladdr 1 e x] where: ∣ S . globals ∣ {type globaltype, value val} S \oplus {globals globalinst}

4.5.3.6. 元素段

令 $reftype$ 为元素类型，并令 $ref^{*}$ 为要分配的引用向量。
令 $a$ 为 $S$ 中的第一个空闲元素地址。
令 $eleminst$ 为元素实例 ${type reftype, elem ref^{*}}$ .
将 $eleminst$ 附加到 $elems$ 的 $S$ 中。
返回 $a$ .

allocelem (S, reftype, ref^{*}) elemaddr eleminst S^{'} = = = = S^{'}, elemaddr 1 e x] 其中： ∣ S . elems ∣ {type reftype, elem ref^{*}} S \oplus {elems eleminst}

4.5.3.7. 数据段

令 $b^{*}$ 为要分配的字节向量。
令 $a$ 为 $S$ 中的第一个空闲数据地址。
令 $datainst$ 为数据实例 ${data b^{*}}$ .
将 $datainst$ 附加到 $datas$ 的 $S$ 中。
返回 $a$ .

allocdata (S, b^{*}) dataaddr datainst S^{'} = = = = S^{'}, dataaddr 1 e x] where: ∣ S . datas ∣ {data b^{*}} S \oplus {datas datainst}

4.5.3.8. 扩展表

假设 $tableinst$ 是要扩展的表实例， $n$ 是要扩展的元素数量， $ref$ 是初始化值。
假设 $len$ 是 $n$ 加上 $tableinst . elem$ 的长度。
如果 $len$ 大于或等于 $2^{32}$ , 则失败。
假设 $limits t$ 是表类型 $tableinst . type$ 的结构。
假设 $limits^{'}$ 是 $limits$ ，其中 $min$ 更新为 $len$ .
如果 $limits^{'}$ 不是有效的，则失败。
将 $ref^{n}$ 附加到 $tableinst . elem$ .
将 $tableinst . type$ 设置为表类型 $limits^{'} t$ .

growtable (tableinst, n, ref) = tableinst with type = limits^{'} t with elem = tableinst . elem ref^{n} (if \land \land \land \land len = n + ∣ tableinst . elem ∣ len < 2^{32} limits t = tableinst . type limits^{'} = limits with min = len ⊢ limits^{'} ok)

4.5.3.9. 增长内存

令 $meminst$ 表示要增长的内存实例， $n$ 表示要增长的大小（以页为单位）。
断言： $meminst . data$ 的长度可以被页大小 $64 Ki$ 整除。
令 $len$ 等于 $n$ 加上 $meminst . data$ 的长度除以页大小 $64 Ki$ .
如果 $len$ 大于 $2^{16}$ , 则失败。
令 $limits$ 表示内存类型 $meminst . type$ 的结构。
假设 $limits^{'}$ 是 $limits$ ，其中 $min$ 更新为 $len$ .
如果 $limits^{'}$ 不是有效的，则失败。
在 $n$ 次循环中，将 $64 Ki$ 个字节，值设置为 $0x 00$ ，追加到 $meminst . data$ .
将 $meminst . type$ 设置为内存类型 $limits^{'}$ .

growmem (meminst, n) = meminst with type = limits^{'} with data = meminst . data (0x 00)^{n \cdot 64 Ki} (if \land \land \land \land len = n + ∣ meminst . data ∣/64 Ki len \leq 2^{16} limits = meminst . type limits^{'} = limits with min = len ⊢ limits^{'} ok)

4.5.3.10. 模块

用于模块的分配函数需要一组合适的外部值，这些外部值被假定为与模块的导入向量匹配；此外，还需要模块的全局变量的初始化值列表，以及模块的元素段的引用向量列表。

令 $module$ 为要分配的模块，而 $externval_{im}^{*}$ 为提供模块导入的外部值向量， $val^{*}$ 为模块的全局变量的初始化值，而 $(ref^{*})^{*}$ 为模块的元素段的引用向量。
对于每个在函数 $func_{i}$ 中的 $module . funcs$ ，执行以下操作：
1. 令 $funcaddr_{i}$ 为函数地址，该地址是通过分配 $func_{i}$ 得到的，对于下面定义的模块实例 $moduleinst$ 。
对于每个在表格 $table_{i}$ 中的 $module . tables$ ，执行以下操作：
1. 令 $limits_{i} t_{i}$ 为表格类型 $table_{i} . type$ .
2. 令 $tableaddr_{i}$ 为表格地址，该地址是通过分配 $table_{i} . type$ 并使用初始值 $ref . null t_{i}$ 得到的。
对于每个在内存 $mem_{i}$ 中的 $module . mems$ ，执行以下操作：
1. 令 $memaddr_{i}$ 为内存地址，该地址是通过分配 $mem_{i} . type$ 得到的。
对于每个在全局变量 $global_{i}$ 中的 $module . globals$ ，执行以下操作：
1. 令 $globaladdr_{i}$ 为全局变量地址，该地址是通过分配 $global_{i} . type$ 并使用初始值 $val^{*} [i]$ 得到的。
对于每个元素段 $elem_{i}$ 在 $module . elems$ 中，执行以下操作：
1. 令 $elemaddr_{i}$ 为分配一个元素实例（类型为引用类型 $elem_{i} . type$ ）得到的元素地址，该实例的内容为 $(ref^{*})^{*} [i]$ .
对于每个数据段 $data_{i}$ 在 $module . datas$ 中，执行以下操作：
1. 令 $dataaddr_{i}$ 为分配一个内容为 $data_{i} . init$ 的数据实例得到的数据地址。
令 $funcaddr^{*}$ 为以索引顺序连接的函数地址 $funcaddr_{i}$ 。
令 $tableaddr^{*}$ 为以索引顺序连接的表格地址 $tableaddr_{i}$ 。
令 $memaddr^{*}$ 为以索引顺序连接的内存地址 $memaddr_{i}$ 。
令 $globaladdr^{*}$ 为以索引顺序连接的全局地址 $globaladdr_{i}$ 。
令 $elemaddr^{*}$ 为以索引顺序连接的元素地址 $elemaddr_{i}$ 。
令 $dataaddr^{*}$ 为数据地址 $dataaddr_{i}$ 按索引顺序连接的结果。
令 $funcaddr_{mod}^{*}$ 为从 $externval_{im}^{*}$ 中提取的函数地址列表，与 $funcaddr^{*}$ 连接。
令 $tableaddr_{mod}^{*}$ 为从 $externval_{im}^{*}$ 中提取的表地址列表，与 $tableaddr^{*}$ 连接。
令 $memaddr_{mod}^{*}$ 为从 $externval_{im}^{*}$ 中提取的内存地址列表，与 $memaddr^{*}$ 连接。
令 $globaladdr_{mod}^{*}$ 为从 $externval_{im}^{*}$ 中提取的全局地址列表，与 $globaladdr^{*}$ 连接。
对于每个导出 $export_{i}$ 在 $module . exports$ 中，执行以下操作
1. 如果 $export_{i}$ 是函数索引 $x$ 的函数导出，则令 $externval_{i}$ 为外部值 $func (funcaddr_{mod}^{*} [x])$ .
2. 否则，如果 $export_{i}$ 是表格索引 $x$ 的表格导出，则令 $externval_{i}$ 为外部值 $table (tableaddr_{mod}^{*} [x])$ .
3. 否则，如果 $export_{i}$ 是内存索引 $x$ 的内存导出，则令 $externval_{i}$ 为外部值 $mem (memaddr_{mod}^{*} [x])$ .
4. 否则，如果 $export_{i}$ 是全局索引 $x$ 的全局导出，则令 $externval_{i}$ 为外部值 $global (globaladdr_{mod}^{*} [x])$ .
5. 令 $exportinst_{i}$ 为导出实例 ${name (export_{i} . name), value externval_{i}}$ .
令 $exportinst^{*}$ 为导出实例 $exportinst_{i}$ 按索引顺序的串联。
令 $moduleinst$ 为模块实例 ${types (module . types),$ $funcaddrs funcaddr_{mod}^{*},$ $tableaddrs tableaddr_{mod}^{*},$ $memaddrs memaddr_{mod}^{*},$ $globaladdrs globaladdr_{mod}^{*},$ $exports exportinst^{*}}$ .
返回 $moduleinst$ .

allocmodule (S, module, externval_{im}^{*}, val^{*}, (ref^{*})^{*}) = S^{'}, moduleinst

其中

table^{*} mem^{*} global^{*} elem^{*} data^{*} export^{*} S_{2}, tableaddr^{*} S_{3}, memaddr^{*} S_{4}, globaladdr^{*} S_{5}, elemaddr^{*} S^{'}, dataaddr^{*} exportinst^{*} tables (externval_{ex}^{*}) mems (externval_{ex}^{*}) globals (externval_{ex}^{*}) = = = = = = = = = = = = = = = module . tables module . mems module . globals module . elems module . datas module . exports 1 e x] moduleinst alloctable^{*} (S_{1}, (table . type)^{*}, (ref . null t)^{*}) (where (table . type)^{*} = (limits t)^{*}) allocmem^{*} (S_{2}, (mem . type)^{*}) allocglobal^{*} (S_{3}, (global . type)^{*}, val^{*}) allocelem^{*} (S_{4}, (elem . type)^{*}, (ref^{*})^{*}) allocdata^{*} (S_{5}, (data . init)^{*}) {name (export . name), value externval_{ex}}^{*} 1 e x] funcs (externval_{ex}^{*}) (moduleinst . tableaddrs [x])^{*} (where x^{*} = tables (export^{*})) (moduleinst . memaddrs [x])^{*} (where x^{*} = mems (export^{*})) (moduleinst . globaladdrs [x])^{*} (where x^{*} = globals (export^{*})) = = {types module . types, funcaddrs funcs (externval_{im}^{*}) funcaddr^{*}, tableaddrs tables (externval_{im}^{*}) tableaddr^{*}, memaddrs mems (externval_{im}^{*}) memaddr^{*}, globaladdrs globals (externval_{im}^{*}) globaladdr^{*}, elemaddrs elemaddr^{*}, dataaddrs dataaddr^{*}, exports exportinst^{*}} 1 e x] S_{1}, funcaddr^{*} (moduleinst . funcaddrs [x])^{*} (where x^{*} = funcs (export^{*})) = allocfunc^{*} (S, module . funcs, moduleinst)

这里，符号 $allocx^{*}$ 是对多个分配对象类型 $X$ 的简写，定义如下

allocx^{*} (S_{0}, X^{n}, \dots) S_{i + 1}, a^{n} [i] = = S_{n}, a^{n} 1 e x] 其中对于所有 i < n: allocx (S_{i}, X^{n} [i], \dots)

此外，如果省略号 $\dots$ 是一个序列 $A^{n}$ （如全局变量或表格），那么该序列的元素将逐点传递给分配函数。

注意

模块分配的定义与其相关函数的分配相互递归，因为生成的模块实例 $moduleinst$ 被作为参数传递给函数分配器，以形成必要的闭包。在实现中，这种递归可以通过在次要步骤中对其中一个进行修改来轻松地解开。

4.5.4. 实例化

给定一个存储 $S$ ，一个模块 $module$ 使用一个外部值列表 $externval^{n}$ 实例化，该列表提供所需的导入，如下所示。

实例化检查模块是否有效以及提供的导入是否匹配声明的类型，否则可能会 *失败* 并出现错误。实例化也可能导致从初始化一个活动段的表格或内存或从执行启动函数中陷阱。如何报告这些条件取决于嵌入器。

如果 $module$ 不是有效的，那么
1. 失败。
断言： $module$ 是有效的，具有外部类型 $externtype_{im}^{m}$ 对其导入进行分类。
如果导入的数量 $m$ 不等于提供的外部值的数量 $n$ ，那么
1. 失败。
对于每个外部值 $externval_{i}$ 在 $externval^{n}$ 和外部类型 $externtype_{i}^{'}$ 在 $externtype_{im}^{n}$ 中，执行以下操作：
1. 如果 $externval_{i}$ 在存储 $S$ 中不有效，对于外部类型 $externtype_{i}$ ，那么
  1. 失败。
2. 如果 $externtype_{i}$ 与 $externtype_{i}^{'}$ 不匹配，那么
  1. 失败。

设 $moduleinst_{init}$ 是一个辅助模块实例 ${globaladdrs globals (externval^{n}), funcaddrs moduleinst . funcaddrs}$ ，它只包含最终模块实例 $moduleinst$ 中的导入全局变量以及导入和分配的函数，定义如下。
设 $F_{init}$ 是一个辅助帧 ${module moduleinst_{init}, locals ϵ}$ .
将帧 $F_{init}$ 推送到栈中。
设 $val^{*}$ 是由 $module$ 和 $externval^{n}$ 确定的全局初始化值的向量。它们可以按如下方式计算。
1. 对于每个在全局变量 $global_{i}$ 中的 $module . globals$ ，执行以下操作：
  1. 设 $val_{i}$ 是评估初始化表达式 $global_{i} . init$ 的结果。
2. 断言：由于验证，帧 $F_{init}$ 现在位于堆栈顶部。
3. 令 $val^{*}$ 为按索引顺序连接的 $val_{i}$ 。
令 $(ref^{*})^{*}$ 为由 $module$ 中的元素段确定的引用向量列表。它们可以按如下方式计算。
1. 对于 $module . elems$ 中的每个元素段 $elem_{i}$ ，以及对于 $elem_{i} . init$ 中的每个元素表达式 $expr_{ij}$ ，执行以下操作：
  1. 令 $ref_{ij}$ 为求值初始化表达式 $expr_{ij}$ 的结果。
2. 令 $ref_{i}^{*}$ 为按索引 $j$ 顺序连接的函数元素 $ref_{ij}$ 。
3. 令 $(ref^{*})^{*}$ 为按索引 $i$ 顺序连接的函数元素向量 $ref_{i}^{*}$ 。
从堆栈中弹出帧 $F_{init}$ 。
令 $moduleinst$ 为一个新的模块实例，它从 $module$ 在存储 $S$ 中分配，导入为 $externval^{n}$ , 全局初始化值为 $val^{*}$ , 元素段内容为 $(ref^{*})^{*}$ , 令 $S^{'}$ 为模块分配产生的扩展存储。
令 $F$ 为辅助帧 ${module moduleinst, locals ϵ}$ .
将帧 $F$ 推入堆栈。
对于 $module . elems$ 中每个元素段 $elem_{i}$ ，其模式为 $active {table tableidx_{i}, offset einstr_{i}^{*} end}$ ，执行以下操作：
1. 令 $n$ 为向量 $elem_{i} . init$ 的长度。
2. 执行指令序列 $einstr_{i}^{*}$ .
3. 执行指令 $i32 . const 0$ .
4. 执行指令 $i32 . const n$ .
5. 执行指令 $table.init tableidx_{i} i$ .
6. 执行指令 $elem.drop i$ .
对于 $module . elems$ 中每个元素段 $elem_{i}$ ，其模式为 $declarative$ ，执行以下操作：
1. 执行指令 $elem.drop i$ .
对于每个数据段 $data_{i}$ 在 $module . datas$ 中，其模式形式为 $active {memory memidx_{i}, offset dinstr_{i}^{*} end}$ ，执行以下操作：
1. 断言： $memidx_{i}$ 为 $0$ .
2. 令 $n$ 为向量 $data_{i} . init$ 的长度。
3. 执行指令序列 $dinstr_{i}^{*}$ .
4. 执行指令 $i32 . const 0$ .
5. 执行指令 $i32 . const n$ .
6. 执行指令 $memory.init i$ .
7. 执行指令 $data.drop i$ .
如果开始函数 $module . start$ 不为空，则：
1. 令 $start$ 为开始函数 $module . start$ .
2. 执行指令 $call start . func$ .
断言：由于验证，帧 $F$ 现在位于堆栈顶部。
从堆栈中弹出帧 $F$ 。

instantiate (S, module, externval^{k}) = (if \land \land \land \land \land \land \land \land \land S^{'}; F; runelem_{0} (elem^{n} [0]) \dots runelem_{n - 1} (elem^{n} [n - 1]) rundata_{0} (data^{m} [0]) \dots rundata_{m - 1} (data^{m} [m - 1]) (call start . func)^{?} ⊢ module : externtype_{im}^{k} \to externtype_{ex}^{*} (S ⊢ externval : externtype)^{k} (⊢ externtype \leq externtype_{im})^{k} 1 e x] module . elems = elem^{n} module . datas = data^{m} module . start = start^{?} (expr_{g} = global . init)^{*} (expr_{e}^{*} = elem . init)^{n} 1 e x] F = {module moduleinst, locals ϵ} 1 e x] ((S^{'}; F; expr_{e} ↪^{*} S^{'}; F; ref end)^{*})^{n}) \land \land \land module . globals = global^{*} S^{'}, moduleinst = allocmodule (S, module, externval^{k}, val^{*}, (ref^{*})^{n}) (S^{'}; F; expr_{g} ↪^{*} S^{'}; F; val end)^{*}

其中

runelem_{i} ({type et, init expr^{n}, mode passive}) = ϵ runelem_{i} ({type et, init expr^{n}, mode active {table x, offset instr^{*} end}}) = instr^{*} (i32 . const 0) (i32 . const n) (table.init x i) (elem.drop i) runelem_{i} ({type et, init expr^{n},

4.5.5. 调用

一旦一个模块已经实例化，任何导出的函数都可以通过其函数地址 $funcaddr$ 在存储 $S$ 中以及一个适当的列表 $val^{*}$ 的值参数从外部 *调用*。

如果参数不符合函数类型，则调用可能 *失败* 并返回错误。调用也可能导致陷阱。由嵌入器定义如何报告这些情况。

注意

如果嵌入器 API 在执行调用之前本身执行类型检查，无论是静态的还是动态的，那么除了陷阱之外，不会发生其他错误。

执行以下步骤

断言： $S. funcs [funcaddr]$ 存在。
令 $funcinst$ 为函数实例 $S. funcs [funcaddr]$ .
令 $[t_{1}^{n}] \to [t_{2}^{m}]$ 为函数类型 $funcinst . type$ .
如果提供的参数值的长度 $∣ val^{*} ∣$ 与预期参数的数量 $n$ 不同，则
1. 失败。
对于值类型 $t_{i}$ 在 $t_{1}^{n}$ 以及相应的值 $va l_{i}$ 在 $val^{*}$ , 执行
1. 如果 $val_{i}$ 不是有效的值类型 $t_{i}$ , 那么
  1. 失败。
令 $F$ 为虚拟的帧 ${module {}, locals ϵ}$ .
将帧 $F$ 推入堆栈。
将值 $val^{*}$ 推入堆栈。
在地址 $funcaddr$ 调用函数实例。

函数返回后，执行以下步骤。

断言：由于验证，堆栈顶部有 $m$ 个值。
从堆栈中弹出 $val_{res}^{m}$ 。
断言：由于验证，帧 $F$ 现在位于堆栈顶部。
从堆栈中弹出帧 $F$ 。

值 $val_{res}^{m}$ 作为调用的结果返回。

invoke (S, funcaddr, val^{n}) = (if \land \land S; F; val^{n} (invoke funcaddr) S . funcs [funcaddr] . type = [t_{1}^{n}] \to [t_{2}^{m}] (S ⊢ val : t_{1})^{n} F = {module {}, locals ϵ})

5. 二进制格式

5.1. 约定

WebAssembly 模块的二进制格式是对其抽象语法的密集线性 *编码*。[1]

该格式由一个 *属性语法* 定义，其唯一的终结符是字节。字节序列是模块的格式良好的编码，当且仅当它由该语法生成。

该语法中的每个产生式都正好有一个综合属性：相应的字节序列编码的抽象语法。因此，属性语法隐式地定义了一个 *解码* 函数（即，二进制格式的解析函数）。

除了少数例外，二进制语法与抽象语法的语法非常相似。

注意

抽象语法中的某些短语在二进制格式中有多种可能的编码。例如，数字可以像具有可选前导零一样进行编码。解码器实现必须支持所有可能的替代方案；编码器实现可以选择任何允许的编码。

包含 WebAssembly 模块的二进制格式文件的推荐扩展名为“ $.wasm$ ”，推荐的媒体类型为“ $application/wasm$ ”。

5.1.1. 语法

在定义二进制格式的语法规则时，采用以下约定。它们反映了用于抽象语法的约定。为了区分二进制语法的符号和抽象语法的符号，采用 $typewriter$ 字体来表示前者。

终结符是字节，用十六进制表示法表示： $0x 0F$ .
非终结符以打字机字体书写： $valtype, instr$ .
$B^{n}$ 是 $n \geq 0$ 次 $B$ 的迭代序列。
$B^{*}$ 是一个可能是空的 $B$ 的迭代序列。（这是一种简写方式，用于 $B^{n}$ ，其中 $n$ 不相关。）
$B^{?}$ 是 $B$ 的可选出现。（这是一种简写方式，用于 $B^{n}$ ，其中 $n \leq 1$ 。）
$x : B$ 表示与非终结符 $B$ 相同的语言，但同时也为变量 $x$ 绑定了为 $B$ 合成的属性。模式也可以用作变量，例如 $7 : B$ .
产生式以 $sym ::= B_{1} \Rightarrow A_{1} ∣ \dots ∣ B_{n} \Rightarrow A_{n}$ , 其中每个 $A_{i}$ 是在给定情况下为 $sym$ 合成的属性，通常从 $B_{i}$ 中绑定的属性变量中合成。
一些产生式通过括号中的边际条件进行补充，这些条件限制了产生式的适用性。它们为将产生式组合扩展为许多独立情况提供了一种简写方式。
如果相同的元变量或非终结符符号在一个产生式中多次出现（在语法或属性中），那么所有这些出现必须具有相同的实例。（这是一种简写方式，用于需要多个不同变量相等的边际条件。）

注意

例如，用于二进制语法的数字类型如下所示

numtype ::= ∣ ∣ ∣ 0x 7F 0x 7E 0x 7D 0x 7C \Rightarrow \Rightarrow \Rightarrow \Rightarrow i32 i64 f32 f64

因此，字节 $0x 7F$ 编码类型 $i32$ ， $0x 7E$ 编码类型 $i64$ ，以此类推。其他字节值不允许作为数字类型的编码。

有关二进制语法的限制定义如下

limits ::= ∣ 0x 00 n : u 32 0x 01 n : u 32 m : u 32 \Rightarrow \Rightarrow {min n, max ϵ} {min n, max m}

也就是说，限制对编码为字节 $0x 00$ 后跟 $u32$ 值的编码，或者字节 $0x 01$ 后跟两个这样的编码。变量 $n$ 和 $m$ 指定了各自 $u 32$ 非终结符的属性，在本例中，它们是实际的无符号整数，它们将解码为。然后，完整产生的属性是限制的抽象语法，以之前的值的术语表示。

5.1.2. 辅助符号

在处理二进制编码时，还使用以下符号

$ϵ$ 表示空字节序列。
$∣∣B∣∣$ 是从推导中生成产生式 $B$ 的字节序列的长度。

5.1.3. 向量

向量使用其 $u 32$ 长度以及其元素序列的编码进行编码。

vec (B) ::= n : u 32 (x : B)^{n} \Rightarrow x^{n}

5.2. 值

5.2.1. 字节

字节自己进行编码。

byte ::= ∣ ∣ 0x 00 0x FF \Rightarrow \dots \Rightarrow 0x 00 0x FF

5.2.2. 整数

所有整数使用 LEB128 可变长度整数编码进行编码，可以是无符号或有符号变体。

无符号整数使用无符号 LEB128 格式进行编码。作为附加约束，对类型为 $u N$ 的值的总字节数不能超过 $ceil (N/7)$ 字节。

u N ::= ∣ n : byte n : byte m : u (N - 7) \Rightarrow \Rightarrow n 2^{7} \cdot m + (n - 2^{7}) (if n < 2^{7} \land n < 2^{N}) (if n \geq 2^{7} \land N > 7)

带符号整数使用有符号 LEB128 格式编码，该格式使用二进制补码表示。作为额外的约束，编码类型为 $s N$ 的值的字节总数不能超过 $ceil (N/7)$ 个字节。

s N ::= ∣ ∣ n : byte n : byte n : byte m : s (N - 7) \Rightarrow \Rightarrow \Rightarrow n n - 2^{7} 2^{7} \cdot m + (n - 2^{7}) (if n < 2^{6} \land n < 2^{N - 1}) (if 2^{6} \leq n < 2^{7} \land n \geq 2^{7} - 2^{N - 1}) (if n \geq 2^{7} \land N > 7)

未解释整数编码为有符号整数。

i N ::= n : s N \Rightarrow i (if n = signed_{N} (i))

注意

非终结字节的生成式中的边条件 $N > 7$ 限制了编码的长度。但是，在这些界限内仍然允许“尾部零”。例如， $0x 03$ 和 $0x 83 0x 00$ 都是值 $3$ 作为 $u8$ 编码的有效编码。类似地， $0x 7e$ ， $0x FE 0x 7F$ 和 $0x FE 0x FF 0x 7F$ 都是值 $- 2$ 作为 $s16$ 编码的有效编码。

对终结字节的值 $n$ 的边条件进一步强制执行，对于正值，这些字节中任何未使用的位必须为 $0$ ，而对于负值，必须为 $1$ 。例如， $0x 83 0x 10$ 作为 $u8$ 编码是格式错误的。类似地， $0x 83 0x 3E$ 和 $0x FF 0x 7B$ 作为 $s8$ 编码是格式错误的。

5.2.3. 浮点数

浮点数值直接由其 [IEEE-754-2019]（第 3.4 节）中的位模式在小端字节顺序中进行编码

f N ::= b^{*} : byte^{N /8} \Rightarrow bytes_{f N}^{- 1} (b^{*})

5.2.4. 名称

名称被编码为一个包含名称字符序列的 [UNICODE]（第 3.9 节）UTF-8 编码的向量字节。

name ::= b^{*} : vec (byte) \Rightarrow name (if utf8 (name) = b^{*})

辅助 $utf8$ 函数表示此编码，定义如下

utf8 (c^{*}) utf8 (c) utf8 (c) utf8 (c) = = = = (utf8 (c))^{*} 1 e x] utf8 (c) b_{1} b_{2} b_{1} b_{2} b_{3} b_{1} b_{2} b_{3} b_{4} = (if \land U + 80 \leq c < U + 800 c = 2^{6} (b_{1} - 0x C0) + (b_{2} - 0x 80)) (if \land U + 800 \leq c < U + D800 \lor U + E000 \leq c < U + 10000 c = 2^{12} (b_{1} - 0x E0) + 2^{6} (b_{2} - 0x 80) + (b_{3} - 0x 80)) (if \land U + 10000 \leq c < U + 110000 c = 2^{18} (b_{1} - 0x F0) + 2^{12} (b_{2} - 0x 80) + 2^{6} (b_{3} - 0x 80) + (b_{4} - 0x 80)) b (if \land c < U + 80 c = b) where b_{2}, b_{3}, b_{4} < 0x C0

注意

与其他一些格式不同，名称字符串不以 0 结尾。

5.3. 类型

注意

在某些情况下，可能的类型包括类型构造函数或由类型索引表示的类型。因此，类型构造函数的二进制格式对应于小负数的编码 $s N$ 值，因此它们可以明确地出现在与（正）类型索引相同的位置。

5.3.1. 数字类型

数字类型由单个字节编码。

numtype ::= ∣ ∣ ∣ 0x 7F 0x 7E 0x 7D 0x 7C \Rightarrow \Rightarrow \Rightarrow \Rightarrow i32 i64 f32 f64

5.3.2. 向量类型

向量类型也由单个字节编码。

vectype ::= 0x 7B \Rightarrow v128

5.3.3. 引用类型

引用类型也由单个字节编码。

reftype ::= ∣ 0x 70 0x 6F \Rightarrow \Rightarrow funcref externref

5.3.4. 值类型

值类型使用其各自的编码作为数字类型、向量类型或引用类型进行编码。

valtype ::= ∣ ∣ t : numtype t : vectype t : reftype \Rightarrow \Rightarrow \Rightarrow t t t

注意

值类型可以出现在允许使用类型索引的上下文中，例如在块类型的情况下。因此，类型的二进制格式对应于小负数的带符号 LEB128 编码，以便它们将来可以与（正）类型索引共存。

5.3.5. 结果类型

结果类型通过各自的值类型向量进行编码。

resulttype ::= t^{*} : vec (valtype) \Rightarrow [t^{*}]

5.3.6. 函数类型

函数类型通过字节 0x60 后面跟着的各自的参数类型和结果类型向量进行编码。

functype ::= 0x 60 rt_{1} : resulttype rt_{2} : resulttype \Rightarrow rt_{1} \to rt_{2}

5.3.7. 限制

限制通过一个前导标志进行编码，该标志指示是否存在最大值。

limits ::= ∣ 0x 00 n : u 32 0x 01 n : u 32 m : u 32 \Rightarrow \Rightarrow {min n, max ϵ} {min n, max m}

5.3.8. 内存类型

内存类型使用它们的限制进行编码。

memtype ::= lim : limits \Rightarrow lim

5.3.9. 表类型

表类型使用它们的限制以及它们元素的引用类型编码。

tabletype ::= et : reftype lim : limits \Rightarrow lim et

5.3.10. 全局类型

全局类型通过它们的值类型和一个表示它们可变性的标志进行编码。

globaltype mut ::= ::= ∣ t : valtype m : mut 0x 00 0x 01 \Rightarrow \Rightarrow \Rightarrow m t const var

5.4. 指令

指令由操作码进行编码。每个操作码由一个字节表示，后面跟着指令的立即数参数（如果有）。唯一的例外是结构化控制指令，它由多个操作码组成，用来括起它们的嵌套指令序列。

注意

用于编码指令的字节码范围内的间隙保留供将来扩展。

5.4.1. 控制指令

控制指令具有不同的编码。对于结构化指令，构成嵌套块的指令序列以 $end$ 和 $else$ 的显式操作码结尾。

块类型使用特殊的压缩形式进行编码，可以是字节 $0x 40$ （表示空类型），单个值类型，或者作为以正有符号整数编码的类型索引。

blocktype instr ::= ∣ ∣ ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ 0x 40 t : valtype x : s 33 0x 00 0x 01 0x 02 bt : blocktype (in : instr)^{*} 0x 0B 0x 03 bt : blocktype (in : instr)^{*} 0x 0B 0x 04 bt : blocktype (in : instr)^{*} 0x 0B 0x 04 bt : blocktype (in_{1} : instr)^{*} 0x 05 (in_{2} : instr)^{*} 0x 0B 0x 0C l : labelidx 0x 0D l : labelidx 0x 0E l^{*} : vec (labelidx) l_{N} : labelidx 0x 0F 0x 10 x : funcidx 0x 11 y : typeidx x : tableidx \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow ϵ t x unreachable nop block bt in^{*} end loop bt in^{*} end if bt in^{*} else ϵ end if bt in_{1}^{*} else in_{2}^{*} end br l br_if l br_table l^{*} l_{N} return call x call_indirect x y (if x \geq 0)

注意

在 $else$ 指令的编码中， $0x 05$ 的操作码可以省略，如果接下来的指令序列为空。

与任何其他出现不同，类型索引在块类型中被编码为正的有符号整数，这样它的有符号 LEB128 位模式就不会与值类型或特殊代码 $0x 40$ 的编码冲突，这些编码对应于负整数的 LEB128 编码。为了避免在允许的索引范围内有任何损失，它被视为一个 33 位有符号整数。

5.4.2. 引用指令

引用指令由单个字节码表示。

instr ::= ∣ ∣ ∣ \dots 0x D0 t : reftype 0x D1 0x D2 x : funcidx \Rightarrow \Rightarrow \Rightarrow ref . null t ref . is_null ref . func x

5.4.3. 参数化指令

参数化指令由单个字节码表示，可能后跟类型注释。

instr ::= ∣ ∣ ∣ \dots 0x 1A 0x 1B 0x 1C t^{*} : vec (valtype) \Rightarrow \Rightarrow \Rightarrow drop select select t^{*}

5.4.4. 变量指令

变量指令由字节码表示，后跟相应索引的编码。

instr ::= ∣ ∣ ∣ ∣ ∣ \dots 0x 20 x : localidx 0x 21 x : localidx 0x 22 x : localidx 0x 23 x : globalidx 0x 24 x : globalidx \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow local.get x local.set x local.tee x global.get x global.set x

5.4.5. 表格指令

表格指令用单个字节或一个字节前缀后跟一个可变长度的无符号整数表示。

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 25 x : tableidx 0x 26 x : tableidx 0x FC 12 : u 32 y : elemidx x : tableidx 0x FC 13 : u 32 x : elemidx 0x FC 14 : u 32 x : tableidx y : tableidx 0x FC 15 : u 32 x : tableidx 0x FC 16 : u 32 x : tableidx 0x FC 17 : u 32 x : tableidx \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow table.get x table.set x table.init x y elem.drop x table.copy x y table.grow x table.size x table.fill x

5.4.6. 内存指令

每个内存指令变体都使用不同的字节码进行编码。加载和存储指令后面跟着其 $memarg$ 立即数的编码。

memarg instr ::= ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a : u 32 o : u 32 \dots 0x 28 m : memarg 0x 29 m : memarg 0x 2A m : memarg 0x 2B m : memarg 0x 2C m : memarg 0x 2D m : memarg 0x 2E m : memarg 0x 2F m : memarg 0x 30 m : memarg 0x 31 m : memarg 0x 32 m : memarg 0x 33 m : memarg 0x 34 m : memarg 0x 35 m : memarg 0x 36 m : memarg 0x 37 m : memarg 0x 38 m : memarg 0x 39 m : memarg 0x 3A m : memarg 0x 3B m : memarg 0x 3C m : memarg 0x 3D m : memarg 0x 3E m : memarg 0x 3F 0x 00 0x 40 0x 00 0x FC 8 : u 32 x : dataidx 0x 00 0x FC 9 : u 32 x : dataidx 0x FC 10 : u 32 0x 00 0x 00 0x FC 11 : u 32 0x 00 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow {align a, offset o} i32 . load m i64 . load m f32 . load m f64 . load m i32 . load 8_s m i32 . load 8_u m i32 . load 16_s m i32 . load 16_u m i64 . load 8_s m i64 . load 8_u m i64 . load 16_s m i64 . load 16_u m i64 . load 32_s m i64 . load 32_u m i32 . store m i64 . store m f32 . store m f64 . store m i32 . store 8 m i32 . store 16 m i64 . store 8 m i64 . store 16 m i64 . store 32 m memory.size memory.grow memory.init x data.drop x memory.copy memory.fill

注意

在未来的 WebAssembly 版本中， $memory.size$ 、 $memory.grow$ 、 $memory.copy$ 和 $memory.fill$ 指令编码中出现的额外零字节可用于索引其他内存。

5.4.7. 数值指令

所有数值指令变体都由不同的字节码表示。

$const$ 指令后面跟着相应的字面量。

instr ::= ∣ ∣ ∣ ∣ \dots 0x 41 n : i 32 0x 42 n : i 64 0x 43 z : f 32 0x 44 z : f 64 \Rightarrow \Rightarrow \Rightarrow \Rightarrow i32 . const n i64 . const n f32 . const z f64 . const z

所有其他数字指令都是没有立即数的普通操作码。

指令 ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 45 0x 46 0x 47 0x 48 0x 49 0x 4A 0x 4B 0x 4C 0x instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 50 0x 51 0x 52 0x 53 0x 54 0x 55 0x 56 0x <

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 5B 0x 5C 0x 5D 0x 5E 0x 5F 0x 60 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h f32 . eq f32 . ne f32 . lt f32 . gt f32 . le f32 . ge

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 61 0x 62 0x 63 0x 64 0x 65 0x 66 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h f64 . eq f64 . ne f64 . lt f64 . gt f64 . le f64 . ge

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 67 0x 68 0x 69 0x 6A 0x 6B 0x 6C 0x 6D 0x 6E 0x 6F 0x 70 0x 71 0x 72 0x 73 0x 74 0x 75 0x 76 0x 77 0x 78 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i32 . clz i32 . ctz i32 . popcnt i32 . add i32 . sub i32 . mul i32 . div_s i32 . div_u i32 . rem_s i32 . rem_u i32 . and i32 . or i32 . xor i32 . shl i32 . shr_s i32 . shr_u i32 . rotl i32 . rotr

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 79 0x 7A 0x 7B 0x 7C 0x 7D 0x 7E 0x 7F 0x 80 0x 81 0x 82 0x 83 0x 84 0x 85 0x 86 0x 87 0x 88 0x 89 0x 8A \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i64 . clz i64 . ctz i64 . popcnt i64 . add i64 . sub i64 . mul i64 . div_s i64 . div_u i64 . rem_s i64 . rem_u i64 . and i64 . or i64 . xor i64 . shl i64 . shr_s i64 . shr_u i64 . rotl i64 . rotr

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 8B 0x 8C 0x 8D 0x 8E 0x 8F 0x 90 0x 91 0x 92 0x 93 0x 94 0x 95 0x 96 0x 97 0x 98 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h f32 . abs f32 . neg f32 . ceil f32 . floor f32 . trunc f32 . nearest f32 . sqrt f32 . add f32 . sub f32 . mul f32 . div f32 . min f32 . max f32 . copysign

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x 99 0x 9A 0x 9B 0x 9C 0x 9D 0x 9E 0x 9F 0x A0 0x A1 0x A2 0x A3 0x A4 0x A5 0x A6 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h f64 . abs f64 . neg f64 . ceil f64 . floor f64 . trunc f64 . nearest f64 . sqrt f64 . add f64 . sub f64 . mul f64 . div f64 . min f64 . max f64 . copysign

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x A7 0x A8 0x A9 0x AA 0x AB 0x AC 0x AD 0x AE 0x AF 0x B0 0x B1 0x B2 0x B3 0x B4 0x B5 0x B6 0x B7 0x B8 0x B9 0x BA 0x BB 0x BC 0x BD 0x BE 0x BF \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i32 . wrap_i64 i32 . trunc_f32_s i32 . trunc_f32_u i32 . trunc_f64_s i32 . trunc_f64_u i64 . extend_i32_s i64 . extend_i32_u i64 . trunc_f32_s i64 . trunc_f32_u i64 . trunc_f64_s i64 . trunc_f64_u f32 . convert_i32_s f32 . convert_i32_u f32 . convert_i64_s f32 . convert_i64_u f32 . demote_f64 f64 . convert_i32_s f64 . convert_i32_u f64 . convert_i64_s f64 . convert_i64_u f64 . promote_f32 i32 . reinterpret_f32 i64 . reinterpret_f64 f32 . reinterpret_i32 f64 . reinterpret_i64

instr ::= ∣ ∣ ∣ ∣ ∣ \dots 0x C0 0x C1 0x C2 0x C3 0x C4 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i32 . extend 8_s i32 . extend 16_s i64 . extend 8_s i64 . extend 16_s i64 . extend 32_s

所有饱和截断指令都有一个字节的前缀，而实际的操作码则由一个可变长度的无符号整数编码。

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FC 0 : u 32 0x FC 1 : u 32 0x FC 2 : u 32 0x FC 3 : u 32 0x FC 4 : u 32 0x FC 5 : u 32 0x FC 6 : u 32 0x FC 7 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i32 . trunc_sat_f32_s i32 . trunc_sat_f32_u i32 . trunc_sat_f64_s i32 . trunc_sat_f64_u i64 . trunc_sat_f32_s i64 . trunc_sat_f32_u i64 . trunc_sat_f64_s i64 . trunc_sat_f64_u

5.4.8. 向量指令

向量指令的所有变体都由独立的字节码表示。它们都有一个字节前缀，而实际的操作码由一个可变长度的无符号整数编码。

向量加载和存储后是其 $memarg$ 介质的编码。

laneidx instr ::= ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ l : byte \dots 0x FD 0 : u 32 m : memarg 0x FD 1 : u 32 m : memarg 0x FD 2 : u 32 m : memarg 0x FD 3 : u 32 m : memarg 0x FD 4 : u 32 m : memarg 0x FD 5 : u 32 m : memarg 0x FD 6 : u 32 m : memarg 0x FD 7 : u 32 m : memarg 0x FD 8 : u 32 m : memarg 0x FD 9 : u 32 m : memarg 0x FD 10 : u 32 m : memarg 0x FD 92 : u 32 m : memarg 0x FD 93 : u 32 m : memarg 0x FD 11 : u 32 m : memarg 0x FD 84 : u 32 m : memarg l : laneidx 0x FD 85 : u 32 m : memarg l : laneidx 0x FD 86 : u 32 m : memarg l : laneidx 0x FD 87 : u 32 m : memarg l : laneidx 0x FD 88 : u 32 m : memarg l : laneidx 0x FD 89 : u 32 m : memarg l : laneidx 0x FD 90 : u 32 m : memarg l : laneidx 0x FD 91 : u 32 m : memarg l : laneidx \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow l v128 . load m v128 . load 8x8_s m v128 . load 8x8_u m v128 . load 16x4_s m v128 . load 16x4_u m v128 . load 32x2_s m v128 . load 32x2_u m v128 . load 8_splat m v128 . load 16_splat m v128 . load 32_splat m v128 . load 64_splat m v128 . load 32_zero m v128 . load 64_zero m v128 . store m v128 . load 8_lane m l v128 . load 16_lane m l v128 . load 32_lane m l v128 . load 64_lane m l v128 . store 8_lane m l v128 . store 16_lane m l v128 . store 32_lane m l v128 . store 64_lane m l

$const$ 指令后紧跟 16 个立即字节，这些字节将被转换为 $i128$ ，字节序为 $littleendian$ 。

instr ::= ∣ \dots 0x FD 12 : u 32 (b : byte)^{16} \Rightarrow v128 . const bytes_{i128}^{- 1} (b_{0} \dots b_{15})

$shuffle$ 指令后紧跟 16 个 $laneidx$ 立即数的编码。

instr ::= ∣ \dots 0x FD 13 : u 32 (l : laneidx)^{16} \Rightarrow i8x16 . shuffle l^{16}

$extract_lane$ 和 $replace_lane$ 指令后紧跟一个 $laneidx$ 立即数的编码。

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 21 : u 32 l : laneidx 0x FD 22 : u 32 l : laneidx 0x FD 23 : u 32 l : laneidx 0x FD 24 : u 32 l : laneidx 0x FD 25 : u 32 l : laneidx 0x FD 26 : u 32 l : laneidx 0x FD 27 : u 32 l : laneidx 0x FD 28 : u 32 l : laneidx 0x FD 29 : u 32 l : laneidx 0x FD 30 : u 32 l : laneidx 0x FD 31 : u 32 l : laneidx 0x FD 32 : u 32 l : laneidx 0x FD 33 : u 32 l : laneidx 0x FD 34 : u 32 l : laneidx \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow i8x16 . extract_lane_s l i8x16 . extract_lane_u l i8x16 . replace_lane l i16x8 . extract_lane_s l i16x8 . extract_lane_u l i16x8 . replace_lane l i32x4 . extract_lane l i32x4 . replace_lane l i64x2 . extract_lane l i64x2 . replace_lane l f32x4 . extract_lane l f32x4 . replace_lane l f64x2 . extract_lane l f64x2 . replace_lane l

所有其他向量指令都是没有立即数的纯操作码。

指令 ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 14 : u 32 0x FD 15 : u 32 0x FD 16 : u 32 0x FD 17 : u 32 0x FD 18 : u 32 0x FD 19 : u 32 0x FD 20 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i8x16 . swizzle i8x16 . splat i16x8 . splat i32x4 . splat i64x2 . splat f32x4 . splat f64x2 . splat

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 35 : u 32 0x FD 36 : u 32 0x FD 37 : u 32 0x FD 38 : u 32 0x FD 39 : u 32 0x FD 40 : u 32 0x FD 41 : u 32 0x FD 42 : u 32 0x FD 43 : u 32 0x FD 44 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i8x16 . eq i8x16 . ne i8x16 . lt_s i8x16 . lt_u i8x16 . gt_s i8x16 . gt_u i8x16 . le_s i8x16 . le_u i8x16 . ge_s i8x16 . ge_u

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 45 : u 32 0x FD 46 : u 32 0x FD 47 : u 32 0x FD 48 : u 32 0x FD 49 : u 32 0x FD 50 : u 32 0x FD 51 : u 32 0x FD 52 : u 32 0x FD 53 : u 32 0x FD 54 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i16x8 . eq i16x8 . ne i16x8 . lt_s i16x8 . lt_u i16x8 . gt_s i16x8 . gt_u i16x8 . le_s i16x8 . le_u i16x8 . ge_s i16x8 . ge_u

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 55 : u 32 0x FD 56 : u 32 0x FD 57 : u 32 0x FD 58 : u 32 0x FD 59 : u 32 0x FD 60 : u 32 0x FD 61 : u 32 0x FD 62 : u 32 0x FD 63 : u 32 0x FD 64 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i32x4 . eq i32x4 . ne i32x4 . lt_s i32x4 . lt_u i32x4 . gt_s i32x4 . gt_u i32x4 . le_s i32x4 . le_u i32x4 . ge_s i32x4 . ge_u

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 214 : u 32 0x FD 215 : u 32 0x FD 216 : u 32 0x FD 217 : u 32 0x FD 218 : u 32 0x FD 219 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i64x2 . eq <

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 65 : u 32 0x FD 66 : u 32 0x FD 67 : u 32 0x FD 68 : u 32 0x FD 69 : u 32 0x FD 70 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es f32x4 . eq f32x4 . ne instr ::= ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 71 : u 32 0x FD 72 : u 32 0x FD 73 : u 32 0x FD 74 : u 32 0x FD 75 : u 32 0x FD 76 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es f64x2 . eq f64x2 . ne

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 77 : u 32 0x FD 78 : u 32 0x FD 79 : u 32 0x FD 80 : u 32 0x FD 81 : u 32 0x FD 82 : u 32 0x FD 83 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es v128 . not v128 . and v128 . andnot v128 . or v128 . xor v128 . bitselect v128 . any_true

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 96 : u 32 0x FD 97 : u 32 0x FD 98 : u 32 0x FD 99 : u 32 0x FD 100 : u 32 0x FD 101 : u 32 0x FD 102 : u 32 0x FD 107 : u 32 0x FD 108 : u 32 0x FD 109 : u 32 0x FD 110 : u 32 0x FD 111 : u 32 0x FD 112 : u 32 0x FD 113 : u 32 0x FD 114 : u 32 0x FD 115 : u 32 0x FD 118 : u 32 0x FD 119 : u 32 0x FD 120 : u 32 0x FD 121 : u 32 0x FD 123 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i8x16 . abs i8x16 . neg i8x16 . popcnt i8x16 . all_true i8x16 . bitmask i8x16 . narrow_i16x8_s i8x16 . narrow_i16x8_u i8x16 . shl i8x16 . shr_s i8x16 . shr_u i8x16 . add i8x16 . add_sat_s i8x16 . add_sat_u i8x16 . sub i8x16 . sub_sat_s i8x16 . sub_sat_u i8x16 . min_s i8x16 . min_u i8x16 . max_s i8x16 . max_u i8x16 . avgr_u

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 124 : u 32 0x FD 125 : u 32 0x FD 128 : u 32 0x FD 129 : u 32 0x FD 130 : u 32 0x FD 131 : u 32 0x FD 132 : u 32 0x FD 133 : u 32 0x FD 134 : u 32 0x FD 135 : u 32 0x FD 136 : u 32 0x FD 137 : u 32 0x FD 138 : u 32 0x FD 139 : u 32 0x FD 140 : u 32 0x FD 141 : u 32 0x FD 142 : u 32 0x FD 143 : u 32 0x FD 144 : u 32 0x FD 145 : u 32 0x FD 146 : u 32 0x FD 147 : u 32 0x FD 149 : u 32 0x FD 150 : u 32 0x FD 151 : u 32 0x FD 152 : u 32 0x FD 153 : u 32 0x FD 155 : u 32 0x FD 156 : u 32 0x FD 157 : u 32 0x FD 158 : u 32 0x FD 159 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i16x8 . extadd_pairwise_i8x16_s i16x8 . extadd_pairwise_i8x16_u i16x8 . abs i16x8 . neg i16x8 . q15mulr_sat_s i16x8 . all_true i16x8 . bitmask i16x8 . narrow_i32x4_s i16x8 . narrow_i32x4_u i16x8 . extend_low_i8x16_s i16x8 . extend_high_i8x16_s i16x8 . extend_low_i8x16_u i16x8 . extend_high_i8x16_u i16x8 . shl i16x8 . shr_s i16x8 . shr_u i16x8 . add i16x8 . add_sat_s i16x8 . add_sat_u i16x8 . sub i16x8 . sub_sat_s i16x8 . sub_sat_u i16x8 . mul i16x8 . min_s i16x8 . min_u i16x8 . max_s i16x8 . max_u i16x8 . avgr_u i16x8 . extmul_low_i8x16_s i16x8 . extmul_high_i8x16_s i16x8 . extmul_low_i8x16_u i16x8 . extmul_high_i8x16_u

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 126 : u 32 0x FD 127 : u 32 0x FD 160 : u 32 0x FD 161 : u 32 0x FD 163 : u 32 0x FD 164 : u 32 0x FD 167 : u 32 0x FD 168 : u 32 0x FD 169 : u 32 0x FD 170 : u 32 0x FD 171 : u 32 0x FD 172 : u 32 0x FD 173 : u 32 0x FD 174 : u 32 0x FD 177 : u 32 0x FD 181 : u 32 0x FD 182 : u 32 0x FD 183 : u 32 0x FD 184 : u 32 0x FD 185 : u 32 0x FD 186 : u 32 0x FD 188 : u 32 0x FD 189 : u 32 0x FD 190 : u 32 0x FD 191 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i32x4 . extadd_pairwise_i16x8_s i32x4 . extadd_pairwise_i16x8_u i32x4 . abs i32x4 . neg i32x4 . all_true i32x4 . bitmask i32x4 . extend_low_i16x8_s i32x4 . extend_high_i16x8_s i32x4 . extend_low_i16x8_u i32x4 . extend_high_i16x8_u i32x4 . shl i32x4 . shr_s i32x4 . shr_u i32x4 . add i32x4 . sub i32x4 . mul i32x4 . min_s i32x4 . min_u i32x4 . max_s i32x4 . max_u i32x4 . dot_i16x8_s i32x4 . extmul_low_i16x8_s i32x4 . extmul_high_i16x8_s i32x4 . extmul_low_i16x8_u i32x4 . extmul_high_i16x8_u

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 192 : u 32 0x FD 193 : u 32 0x FD 195 : u 32 0x FD 196 : u 32 0x FD 199 : u 32 0x FD 200 : u 32 0x FD 201 : u 32 0x FD 202 : u 32 0x FD 203 : u 32 0x FD 204 : u 32 0x FD 205 : u 32 0x FD 206 : u 32 0x FD 209 : u 32 0x FD 213 : u 32 0x FD 220 : u 32 0x FD 221 : u 32 0x FD 222 : u 32 0x FD 223 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i64x2 . abs i64x2 . neg i64x2 . all_true i64x2 . bitmask i64x2 . extend_low_i32x4_s i64x2 . extend_high_i32x4_s i64x2 . extend_low_i32x4_u i64x2 . extend_high_i32x4_u i64x2 . shl i64x2 . shr_s i64x2 . shr_u i64x2 . add i64x2 . sub i64x2 . mul i64x2 . extmul_low_i32x4_s i64x2 . extmul_high_i32x4_s i64x2 . extmul_low_i32x4_u i64x2 . extmul_high_i32x4_u

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 103 : u 32 0x FD 104 : u 32 0x FD 105 : u 32 0x FD 106 : u 32 0x FD 224 : u 32 0x FD 225 : u 32 0x FD 227 : u 32 0x FD 228 : u 32 0x FD 229 : u 32 0x FD 230 : u 32 0x FD 231 : u 32 0x FD 232 : u 32 0x FD 233 : u 32 0x FD 234 : u 32 0x FD 235 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es f32x4 . ceil f32x4 . floor f32x4 . trunc f32x4 . nearest f32x4 . abs f32x4 . neg f32x4 . sqrt f32x4 . add f32x4 . sub f32x4 . mul f32x4 . div f32x4 . min f32x4 . max f32x4 . pmin f32x4 . pmax

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 116 : u 32 0x FD 117 : u 32 0x FD 122 : u 32 0x FD 148 : u 32 0x FD 236 : u 32 0x FD 237 : u 32 0x FD 239 : u 32 0x FD 240 : u 32 0x FD 241 : u 32 0x FD 242 : u 32 0x FD 243 : u 32 0x FD 244 : u 32 0x FD 245 : u 32 0x FD 246 : u 32 0x FD 247 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es f64x2 . ceil f64x2 . floor f64x2 . trunc f64x2 . nearest f64x2 . abs f64x2 . neg f64x2 . sqrt f64x2 . add f64x2 . sub f64x2 . mul f64x2 . div f64x2 . min f64x2 . max f64x2 . pmin f64x2 . pmax

instr ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots 0x FD 248 : u 32 0x FD 249 : u 32 0x FD 250 : u 32 0x FD 251 : u 32 0x FD 252 : u 32 0x FD 253 : u 32 0x FD 254 : u 32 0x FD 255 : u 32 0x FD 94 : u 32 0x FD 95 : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha s l o n g er in s t r u c t i o nnam es i32x4 . trunc_sat_f32x4_s i32x4 . trunc_sat_f32x4_u f32x4 . convert_i32x4_s f32x4 . convert_i32x4_u i32x4 . trunc_sat_f64x2_s_zero i32x4 . trunc_sat_f64x2_u_zero f64x2 . convert_low_i32x4_s f64x2 . convert_low_i32x4_u f32x4 . demote_f64x2_zero f64x2 . promote_low_f32x4

5.4.9. 表达式

表达式由其指令序列编码，并以一个明确的 $0x 0B$ 操作码来终止，表示 $end$ .

expr ::= (in : instr)^{*} 0x 0B \Rightarrow in^{*} end

5.5. 模块

模块的二进制编码被组织成节。大多数节对应于一个模块记录的组件，除了函数定义被分成两个节，将它们的类型声明在函数节中与它们在代码节中的主体分离。

注意

这种分离使模块中函数的并行和流式编译成为可能。

5.5.1. 索引

所有索引都使用它们的值进行编码。

typeidx funcidx tableidx memidx globalidx elemidx dataidx localidx labelidx ::= ::= ::= ::= ::= ::= ::= ::= ::= x : u 32 x : u 32 x : u 32 x : u 32 x : u 32 x : u 32 x : u 32 x : u 32 l : u 32 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow x x x x x x x x l

5.5.2. 节

每个节包含：

一个字节的节标识符，
以字节为单位的内容的 $u32$ 大小，
实际的内容，其结构取决于节标识符。

每个节都是可选的；省略的节等同于存在且内容为空的节。

以下带参数的语法规则定义了具有标识符 $N$ 的节的通用结构，其内容由语法 $B$ 描述。

section_{N} (B) ::= ∣ N : byte size : u 32 cont : B ϵ \Rightarrow \Rightarrow cont ϵ (if size = ∣∣ B ∣∣)

对于大多数部分，内容 $B$ 编码一个向量。在这些情况下，空结果 $ϵ$ 被解释为空向量。

注意

除了未知的自定义部分， $size$ 对于解码不是必需的，但可以在浏览二进制文件时用于跳过部分。如果大小与二进制内容 $B$ 的长度不匹配，则模块格式错误。

使用以下部分 ID

ID	部分
0	自定义部分
1	类型部分
2	导入部分
3	函数部分
4	表部分
5	内存部分
6	全局部分
7	导出部分
8	开始部分
9	元素部分
10	代码部分
11	数据部分
12	数据计数部分

注意

部分 ID 不总是对应于模块编码中的部分顺序。

5.5.3. 自定义部分

自定义部分 的 ID 为 0。它们旨在用于调试信息或第三方扩展，并且被 WebAssembly 语义忽略。它们的内容包括一个名称，以进一步标识自定义部分，后面跟着一个用于自定义用途的未解释字节序列。

customsec custom ::= ::= section_{0} (custom) name byte^{*}

注意

如果实现解释了自定义部分的数据，则该数据中的错误或部分的放置位置不得使模块失效。

5.5.4. 类型部分

类型部分 的 ID 为 1。它解码为一个函数类型向量，表示模块的 $types$ 组件。

typesec ::= ft^{*} : section_{1} (vec (functype)) \Rightarrow ft^{*}

5.5.5. 导入部分

导入部分 的 id 为 2。它解码为一个导入的向量，表示 $导入$ 是一个模块的组件。

importsec import importdesc ::= ::= ::= ∣ ∣ ∣ im^{*} : section_{2} (vec (import)) mod : name nm : name d : importdesc 0x 00 x : typeidx 0x 01 tt : tabletype 0x 02 mt : memtype 0x 03 gt : globaltype \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow im^{*} {模块 mod, 名称 nm, 描述 d} 函数 x 表格 tt 内存 mt 全局 gt

5.5.6. 函数部分

函数节的 ID 为 3。它解码成一个类型索引的向量，表示函数中的 $type$ 字段，这些函数位于模块的 $funcs$ 组件中。相应函数的 $locals$ 和 $body$ 字段在代码节中单独编码。

funcsec ::= x^{*} : section_{3} (vec (typeidx)) \Rightarrow x^{*}

5.5.7. 表格节

表格节的 ID 为 4。它解码成一个表格的向量，表示模块的 $tables$ 组件。

tablesec table ::= ::= tab^{*} : section_{4} (vec (table)) tt : tabletype \Rightarrow \Rightarrow tab^{*} {type tt}

5.5.8. 内存节

内存节的 ID 为 5。它解码成一个内存的向量，表示模块的 $mems$ 组件。

memsec mem ::= ::= mem^{*} : section_{5} (vec (mem)) mt : memtype \Rightarrow \Rightarrow mem^{*} {type mt}

5.5.9. 全局段

全局段的 ID 为 6。它解码为一个全局变量的向量，表示模块的 $全局变量$ 部分。

globalsec global ::= ::= glob^{*} : section_{6} (vec (global)) gt : globaltype e : expr \Rightarrow \Rightarrow glob^{*} {type gt, init e}

5.5.10. 导出段

导出段的 ID 为 7。它解码为一个导出的向量，表示模块的 $导出$ 部分。

exportsec export exportdesc ::= ::= ::= ∣ ∣ ∣ ex^{*} : section_{7} (vec (export)) nm : name d : exportdesc 0x 00 x : funcidx 0x 01 x : tableidx 0x 02 x : memidx 0x 03 x : globalidx \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow ex^{*} {name nm, desc d} func x table x mem x global x

5.5.11. 开始部分

开始部分 具有 ID 8。它解码为一个可选的启动函数，它表示 $start$ 模块的组成部分。

startsec start ::= ::= st^{?} : section_{8} (start) x : funcidx \Rightarrow \Rightarrow st^{?} {func x}

5.5.12. 元素部分

元素段 的 id 为 9。它解码为一个元素段的向量，这些段表示 $elems$ 组件的一个模块。

elemsec elem elemkind ::= ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ::= seg^{*} : section_{9} (vec (elem)) 0 : u 32 e : expr y^{*} : vec (funcidx) {type funcref, init ((ref . func y) end)^{*}, mode active {table 0, offset e}} 1 : u 32 et : elemkind y^{*} : vec (funcidx) {type et, init ((ref . func y) end)^{*}, mode passive} 2 : u 32 x : tableidx e : expr et : elemkind y^{*} : vec (funcidx) {type et, init ((ref . func y) end)^{*}, mode active {table x, offset e}} 3 : u 32 et : elemkind y^{*} : vec (funcidx) {type et, init ((ref . func y) end)^{*}, mode declarative} 4 : u 32 e : expr el^{*} : vec (expr) {type funcref, init el^{*}, mode active {table 0, offset e}} 5 : u 32 et : reftype el^{*} : vec (expr) {type e t, init el^{*}, mode passive} 6 : u 32 x : tableidx e : expr et : reftype el^{*} : vec (expr) {type e t, init el^{*}, mode active {table x, offset e}} 7 : u 32 et : reftype el^{*} : vec (expr) {type e t, init el^{*}, mode declarative} 0x 00 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow seg^{*} funcref

注意

初始整数可以解释为一个位域。位 0 区分被动段或声明段和主动段，位 1 表示主动段存在显式表格索引，否则区分被动段和声明段，位 2 表示使用元素类型和元素表达式而不是元素种类和元素索引。

将来版本的 WebAssembly 中可能会添加其他元素种类。

5.5.13. 代码段

代码段 的 id 为 10。它解码为一个代码条目向量，这些条目是值类型向量和表达式的对。它们表示 $locals$ 和 $body$ 字段的一个函数在 $funcs$ 组件的一个模块。相应的函数的 $type$ 字段在函数段中单独编码。

每个代码条目的编码包括

函数代码的 $u32$ 大小（以字节为单位），
实际的 函数代码，它依次包含
- 局部变量 的声明，
- 作为表达式的函数主体。

局部变量声明被压缩成一个向量，其条目包含

一个 $u32$ 计数，
一个值类型，

表示相同值类型的计数个局部变量。

codesec code func locals ::= ::= ::= ::= code^{*} : section_{10} (vec (code)) size : u 32 code : func (t^{*})^{*} : vec (locals) e : expr n : u 32 t : valtype \Rightarrow \Rightarrow \Rightarrow \Rightarrow code^{*} code concat ((t^{*})^{*}), e t

在此， $code$ 遍历对 $(valtype^{*}, expr)$ 。元函数 $concat ((t^{*})^{*})$ 连接所有序列 $t_{i}^{*}$ 在 $(t^{*})^{*}$ . 任何导致结果序列长度超出 vector 最大尺寸的代码格式错误。

注意

与 sections 类似，代码 $size$ 在解码时不需要，但可以用于在二进制文件中导航时跳过函数。如果尺寸与相应函数代码的长度不匹配，则模块格式错误。

5.5.14. 数据段

数据段 的 ID 为 11。它解码为一个数据段向量，代表模块的 $datas$ 组件。

datasec data ::= ::= ∣ ∣ seg^{*} : section_{11} (vec (data)) 0 : u 32 e : expr b^{*} : vec (byte) 1 : u 32 b^{*} : vec (byte) 2 : u 32 x : memidx e : expr b^{*} : vec (byte) \Rightarrow \Rightarrow \Rightarrow \Rightarrow seg^{*} {init b^{*}, mode active {memory 0, offset e}} {init b^{*}, mode passive} {init b^{*}, mode active {memory x, offset e}}

注意

初始整数可以解释为位域。位 0 表示被动段，位 1 表示活动段是否存在显式内存索引。

在当前版本的 WebAssembly 中，单个模块最多可以定义或导入一个内存，因此所有有效的 active 数据段的 $memory$ 值为 $0$ .

5.5.15. 数据计数段

数据计数段 的 ID 为 12。它解码为一个可选的 u32，表示数据段在数据段中的数量。如果此计数与数据段向量长度不匹配，则模块格式错误。

datacountsec ::= n^{?} : section_{12} (u 32) \Rightarrow n^{?}

注意

数据计数区用于简化单遍验证。由于数据区出现在代码区之后， $memory.init$ 和 $data.drop$ 指令在读取数据区之前无法检查数据段索引是否有效。数据计数区出现在代码区之前，因此单遍验证器可以使用此计数，而不是延迟验证。

5.5.16. 模块

一个模块的编码以一个包含 4 字节魔数（字符串 $‘ \0asm ’$ ) 和一个版本字段的序言开始。WebAssembly 二进制格式的当前版本为 1。

序言之后是一系列区段。自定义区段可以插入此序列中的任何位置，而其他区段最多只能出现一次，并且必须按照规定的顺序排列。所有区段都可以为空。

由（可能为空的）函数和代码区段产生的向量的长度必须匹配。

同样，可选的数据计数必须与数据段向量长度匹配。此外，如果代码区段中出现任何数据索引，则数据计数必须存在。

magic version module ::= ::= ::= 0x 00 0x 61 0x 73 0x 6D 0x 01 0x 00 0x 00 0x 00 magic version customsec^{*} functype^{*} : typesec customsec^{*} import^{*} : importsec customsec^{*} typeidx^{n} : funcsec customsec^{*} table^{*} : tablesec customsec^{*} mem^{*} : memsec customsec^{*} global^{*} : globalsec customsec^{*} export^{*} : exportsec customsec^{*} start^{?} : startsec customsec^{*} elem^{*} : elemsec customsec^{*} m^{?} : datacountsec customsec^{*} code^{n} : codesec customsec^{*} data^{m} : datasec customsec^{*} \Rightarrow {types functype^{*}, funcs func^{n}, tables table^{*}, mems mem^{*}, globals global^{*}, elems elem^{*}, datas data^{m}, start start^{?}, imports import^{*}, exports export^{*}} (if m^{?} \neq = ϵ \lor dataidx (code^{n}) = \emptyset)

其中，对于每个 $t_{i}^{*}, e_{i}$ 在 $code^{n}$ ,

func^{n} [i] = {type typeidx^{n} [i], locals t_{i}^{*}, body e_{i}}

注意

WebAssembly 二进制格式的版本将来可能会增加，如果需要对格式进行向后不兼容的更改。但是，此类更改预计很少发生，即使有也只会在极少数情况下发生。二进制格式旨在向前兼容，以便将来可以进行扩展而无需增加其版本。

6. 文本格式

6.1. 约定

WebAssembly 模块的文本格式是其抽象语法转换为 S 表达式的渲染。

与二进制格式一样，文本格式由一个属性语法定义。文本字符串是模块的格式良好的描述，当且仅当它是根据语法生成的。此语法的每个产生式最多有一个综合属性：相应的字符序列表达的抽象语法。因此，属性语法隐式地定义了一个解析函数。一些产生式还将上下文作为继承属性，该属性记录绑定标识符。

除了少数例外，文本语法的核心与抽象语法的语法密切相关。但是，它还定义了许多缩写，这些缩写是对核心语法的“语法糖”。

包含文本格式 WebAssembly 模块的文件的推荐扩展名为“ $.wat$ ”。具有此扩展名的文件被假定为使用 UTF-8 编码，如 [UNICODE]（第 2.5 节）所述。

6.1.1. 语法

在定义文本格式的语法规则时采用以下约定。它们反映了用于抽象语法和二进制格式的约定。为了将文本语法的符号与抽象语法的符号区分开来，采用 $打字机$ 字体来表示前者。

终结符可以是引号括起来的文字字符串，也可以用 [UNICODE] 标量值表示： $‘ module ’$ , $U + 0A$ .（所有直接写出的字符都明确地来自 Unicode 的 7 位 ASCII 子集。）
非终结符以打字机字体书写： $valtype, instr$ .
$T^{n}$ 是 $n \geq 0$ 次 $T$ 的迭代序列。
$T^{*}$ 是可能为空的 $T$ 迭代序列。（这是 $T^{n}$ 的简写形式，在 $n$ 不相关的情况下使用。）
$T^{+}$ 是一个或多个 $T$ 迭代的序列。（这是 $T^{n}$ 的简写形式，在 $n \geq 1$ 的情况下使用。）
$T^{?}$ 是 $T$ 的可选出现。（这是 $T^{n}$ 的简写形式，在 $n \leq 1$ 的情况下使用。）
$x : T$ 表示与非终结符 $T$ 相同的语言，但它也将变量 $x$ 绑定到为 $T$ 合成的属性。模式也可以用作变量，例如 $(x, y) : T$ .
产生式写成 $sym ::= T_{1} \Rightarrow A_{1} ∣ \dots ∣ T_{n} \Rightarrow A_{n}$ , 其中每个 $A_{i}$ 是在给定情况下为 $sym$ 合成的属性，通常来自在 $T_{i}$ 中绑定的属性变量。
一些产生式通过括号中的边际条件进行补充，这些条件限制了产生式的适用性。它们为将产生式组合扩展为许多独立情况提供了一种简写方式。
如果同一个元变量或非终结符在产生式中多次出现（在语法或属性中），那么所有这些出现都必须具有相同的实例化。

区分词法产生式和语法产生式。对于后者，在语法包含空格的任何地方都允许任意空格。定义词法语法和值语法的产生式被认为是词法产生式，其他所有产生式都是语法产生式。

注意

例如，文本语法为数字类型给出如下：

numtype ::= ∣ ∣ ∣ ‘ i32 ’ ‘ i64 ’ ‘ f32 ’ ‘ f64 ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow i32 i64 f32 f64

对于文本语法，限制定义如下

limits ::= ∣ n : u 32 n : u 32 m : u 32 \Rightarrow \Rightarrow {min n, max ϵ} {min n, max m}

变量 $n$ 和 $m$ 分别命名了各自 $u 32$ 非终结符的属性，在本例中，它们是实际解析的无符号整数。完整产生的属性是限制的抽象语法，用前述值表示。

6.1.2. 缩写

除了与抽象语法紧密对应的核心语法之外，文本语法还定义了一些缩写，这些缩写可用于方便性和可读性。

缩写由重写规则定义，这些规则指定了它们扩展到核心语法的形式

abbreviation syntax \equiv expanded syntax

在将核心语法规则应用于构造抽象语法之前，假定这些扩展是递归地按出现顺序应用的。

6.1.3. 上下文

文本格式允许使用符号标识符来代替索引。为了将这些标识符解析为具体的索引，一些语法产生式由标识符上下文 $I$ 索引，它作为合成属性，记录了每个索引空间中声明的标识符。此外，上下文记录了模块中定义的类型，以便可以为函数计算参数索引。

将标识符上下文定义为记录 $I$ 非常方便，其抽象语法如下

I ::= {types funcs tables mems globals elem data locals labels typedefs (id^{?})^{*}, (id^{?})^{*}, (id^{?})^{*}, (id^{?})^{*}, (id^{?})^{*}, (id^{?})^{*}, (id^{?})^{*}, (id^{?})^{*}, (id^{?})^{*}, functype^{*}}

对于每个索引空间，这样的上下文包含分配给已定义索引的标识符列表。未命名的索引与这些列表中的空条目 ( $ϵ$ ) 相关联。

如果在没有索引空间包含重复标识符的情况下，则标识符上下文为格式正确。

6.1.3.1. 约定

为了避免不必要的混乱，在写出标识符上下文时会省略空组件。例如，记录 ${}$ 是一个标识符上下文的简写形式，其组件全部为空。

6.1.4. 向量

向量写成普通的序列，但对这些序列的长度有限制。

vec (A) ::= (x : A)^{n} \Rightarrow x^{n} (if n < 2^{32})

6.2. 词法格式

6.2.1. 字符

文本格式为源文本分配含义，源文本由字符序列组成。假设字符表示为有效的[UNICODE]（第 2.4 节）标量值。

source char ::= ::= char^{*} U + 00 ∣ \dots ∣ U + D7FF ∣ U + E000 ∣ \dots ∣ U + 10FFFF

注意

虽然源文本可能在注释或字符串文字中包含任何 Unicode 字符，但语法其余部分仅由 7 位ASCII Unicode 子集支持的字符组成。

6.2.2. 标记

源文本中的字符流从左到右被划分为标记序列，如下面的语法定义所示。

token keyword reserved ::= ::= ::= keyword ∣ u N ∣ s N ∣ f N ∣ string ∣ id ∣ ‘ (’ ∣ ‘) ’ ∣ reserved (‘ a ’ ∣ \dots ∣ ‘ z ’) idchar^{*} (if occurring as a literal terminal in the grammar) (idchar ∣ string)^{+}

令牌根据 *最长匹配* 规则从输入字符流中形成。也就是说，下一个令牌总是由上述词法语法识别的最长可能的字符序列组成。令牌可以用空格分隔，但除了字符串外，它们本身不能包含空格。

*关键字* 令牌是通过在本章的词法生产中以字面形式出现的终结符隐式定义的，例如 $‘ keyword ’$ , 或在本章中出现的显式定义。

任何不属于其他类别的令牌都被认为是 *保留的*，并且不能出现在源代码中。

注意

定义保留令牌集的效果是，所有令牌必须用括号、空格或注释分隔。例如， $‘ 0$x ’$ 是一个保留令牌， $‘ "a""b" ’$ 也是一个保留令牌。因此，它们不会被识别为两个独立的令牌 $‘ 0 ’$ 和 $‘ $x ’$ ，或

6.2.3. White Space

White space is any sequence of literal space characters, formatting characters, or comments. The allowed formatting characters correspond to a subset of the ASCII format effectors, namely, horizontal tabulation ( $U + 09$ ), line feed ( $U + 0A$ ), and carriage return ( $U + 0D$ ).

space format newline ::= ::= ::= (‘ ’ ∣ format ∣ comment)^{*} newline ∣ U + 09 U + 0A ∣ U + 0D ∣ U + 0D U + 0A

空白字符只用于分隔tokens，除此之外将被忽略。

6.2.4. 注释

一个注释可以是行注释，以双分号 $‘;; ’$ 开始并延伸到行尾，也可以是块注释，用分隔符 $‘ (; ’ \dots ‘;) ’$ 包裹起来。块注释可以嵌套。

comment linecomment linechar blockcomment blockchar ::= ::= ::= ::= ::= ∣ ∣ ∣ linecomment ∣ blockcomment ‘;; ’ linechar^{*} (newline ∣ eof) c : char ‘ (; ’ blockchar^{*} ‘;) ’ c : char ‘; ’ ‘ (’ blockcomment (if c \neq = U + 0A \land c \neq = U + 0D) (if c \neq = ‘; ’ \land c \neq = ‘ (’) (if the next character is not ‘) ’) (if the next character is not ‘; ’)

这里，伪标记 $eof$ 表示输入的结束。针对 $blockchar$ 产生的规则中的 _前瞻_ 限制，消除了语法歧义，使得只有正确的方括号形式的块注释分隔符才被允许。

注意

任何格式化和控制字符都可以在注释中使用。

6.3. 值

本节中的语法产生式定义了 _词法语法_，因此不允许使用任何空白。

6.3.1. 整数

所有整数可以用十进制或十六进制表示。在两种情况下，数字都可以选择性地用下划线分隔。

sign digit hexdigit hexnum ::= ::= ::= ∣ ∣ ∣ ::= ∣ ϵ \Rightarrow + ∣ ‘ + ’ \Rightarrow + ∣ ‘ - ’ \Rightarrow - ‘ 0 ’ \Rightarrow 0 ∣ \dots ∣ ‘ 9 ’ \Rightarrow 9 d : digit \Rightarrow d ‘ A ’ \Rightarrow 10 ∣ \dots ∣ ‘ F ’ \Rightarrow 15 ‘ a ’ \Rightarrow 10 ∣ \dots ∣ ‘ f ’ \Rightarrow 151 e x] n : num ‘_’^{?} d : digit h : hexdigit n : hexnum ‘_’^{?} h : hexdigit num \Rightarrow \Rightarrow \Rightarrow ::= 10 \cdot n + d h 16 \cdot n + h d : digit \Rightarrow d

整数字面量的允许语法取决于大小和符号。此外，它们的数值必须在相应的类型范围内。

u N s N ::= ∣ ::= ∣ n : num ‘ 0x ’ n : hexnum \pm : sign n : num \pm : sign ‘ 0x ’ n : hexnum \Rightarrow \Rightarrow \Rightarrow \Rightarrow n n \pm n \pm n (if n < 2^{N}) (if n < 2^{N}) (if - 2^{N - 1} \leq \pm n < 2^{N - 1}) (if - 2^{N - 1} \leq \pm n < 2^{N - 1})

未解释整数可以写成有符号或无符号形式，并在抽象语法中归一化为无符号形式。

i N ::= ∣ n : u N i : s N \Rightarrow \Rightarrow n n (if i = signed (n))

6.3.2. 浮点数

浮点数值可以用十进制或十六进制表示。

frac hexfrac float hexfloat ::= ∣ ::= ∣ ::= ∣ ∣ ∣ ::= ∣ ∣ ∣ d : digit d : digit ‘_’^{?} p : frac h : hexdigit h : hexdigit ‘_’^{?} p : hexfrac p : num ‘ . ’^{?} p : num ‘ . ’ q : frac p : num ‘ . ’^{?} (‘ E ’ ∣ ‘ e ’) \pm : sign e : num p : num ‘ . ’ q : frac (‘ E ’ ∣ ‘ e ’) \pm : sign e : num ‘ 0x ’ p : hexnum ‘ . ’^{?} ‘ 0x ’ p : hexnum ‘ . ’ q : hexfrac ‘ 0x ’ p : hexnum ‘ . ’^{?} (‘ P ’ ∣ ‘ p ’) \pm : sign e : num ‘ 0x ’ p : hexnum ‘ . ’ q : hexfrac (‘ P ’ ∣ ‘ p ’) \pm : sign e : num \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow d /10 (d + p /10) /10 h /16 (h + p /16) /16 p p + q p \cdot 1 0^{\pm e} (p + q) \cdot 1 0^{\pm e} p p + q p \cdot 2^{\pm e} (p + q) \cdot 2^{\pm e}

字面量的值不能超出对应 [IEEE-754-2019] 类型的可表示范围（即，数值不能溢出到 $\pm infinity$ ），但它可能会被舍入到最接近的可表示值。

注意

可以通过使用十六进制表示法来防止舍入，该表示法不超过所需类型支持的有效位数。

浮点数也可以写成无穷大或规范 NaN（非数字）的常量。此外，通过提供显式有效载荷值可以表示任意 NaN 值。

f N f N mag ::= ::= ∣ ∣ ∣ ∣ \pm : sign z : f N mag z : float z : hexfloat ‘ inf ’ ‘ nan ’ ‘ nan : 0x ’ n : hexnum \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \pm z float_{N} (z) float_{N} (z) \infty nan (canon_{N}) nan (n) (if float_{N} (z) \neq = \pm \infty) (if float_{N} (z) \neq = \pm \infty) (if 1 \leq n < 2^{signif (N)})

6.3.3. 字符串

字符串表示字节序列，可以用来表示文本和二进制数据。它们用引号括起来，可以包含除 ASCII 控制字符、引号 ( $‘ " ’$ ) 或反斜杠 ( $‘ \ ’$ ) 之外的任何字符，除非用转义序列表示。

字符串 字符串元素 ::= ::= ∣ ‘ " ’ (b^{*} : 字符串元素)^{*} ‘ " ’ c : 字符串字符 ‘ \ ’ n : 十六进制数字 m : 十六进制数字 \Rightarrow \Rightarrow \Rightarrow 连接 ((b^{*})^{*}) utf8 (c) 16 \cdot n + m (如果 ∣ 连接 ((b^{*})^{*}) ∣ < 2^{32})

字符串字面量中的每个字符都表示其 UTF-8 [UNICODE] (第 2.5 节) 编码对应的字节序列，除了十六进制转义序列 $‘ \hh ’$ ，它们表示相应值的原始字节。

stringchar ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ c : char ‘ \t ’ ‘ \n ’ ‘ \r ’ ‘ \ " ’ ‘ \^{'} ’ ‘ \\ ’ ‘ \u {n : hexnum ‘} ’ ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow c U + 09 U + 0A U + 0D U + 22 U + 27 U + 5C U + (n) (if c \geq U + 20 \land c \neq = U + 7F \land c \neq = ‘ " ’ \land c \neq = ‘ \ ’) (if n < 0x D800 \lor 0x E000 \leq n < 0x 110000)

6.3.4. 名称

名称是表示字面字符序列的字符串。名称字符串必须形成有效的 UTF-8 编码，如 [UNICODE]（第 2.5 节）所定义，并被解释为 Unicode 标量值的字符串。

name ::= b^{*} : string \Rightarrow c^{*} (if b^{*} = utf8 (c^{*}))

注意

假设源文本本身编码正确，不包含任何十六进制字节转义的字符串始终是有效的名称。

6.3.5. 标识符

索引可以以数字和符号形式给出。代替索引的符号 *标识符* 以 $‘ $ ’$ 开头，后面跟着任何不包含空格、引号、逗号、分号或括号的可打印 ASCII 字符序列。

id idchar ::= ::= ∣ ∣ ∣ ∣ ‘ $ ’ idchar^{+} ‘ 0 ’ ∣ \dots ∣ ‘ 9 ’ ‘ A ’ ∣ \dots ∣ ‘ Z ’ ‘ a ’ ∣ \dots ∣ ‘ z ’ ‘! ’ ∣ ‘ # ’ ∣ ‘ $ ’ ∣ ‘ % ’ ∣ ‘ & ’ ∣ ‘^{'} ’ ∣ ‘ * ’ ∣ ‘ + ’ ∣ ‘ - ’ ∣ ‘ . ’ ∣ ‘ / ’ ‘ : ’ ∣ ‘ < ’ ∣ ‘ = ’ ∣ ‘ > ’ ∣ ‘ ? ’ ∣ ‘ @ ’ ∣ ‘ \ ’ ∣ ‘^’ ∣ ‘_’ ∣ ‘ ˋ ’ ∣ ‘ ∣ ’ ∣ ‘ ~ ’

6.3.5.1. 约定

一些缩写的扩展规则需要插入一个 *新的* 标识符。这可以是任何语法有效的标识符，只要它在给定的源文本中没有出现过。

6.4. 类型

6.4.1. 数字类型

numtype ::= ∣ ∣ ∣ ‘ i32 ’ ‘ i64 ’ ‘ f32 ’ ‘ f64 ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow i32 i64 f32 f64

6.4.2. 向量类型

vectype ::= ‘ v128 ’ \Rightarrow v128

6.4.3. 引用类型

reftype heaptype ::= ∣ ::= ∣ ‘ funcref ’ ‘ externref ’ ‘ func ’ ‘ extern ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow funcref externref funcref externref

6.4.4. 值类型

valtype ::= ∣ ∣ t : numtype t : vectype t : reftype \Rightarrow \Rightarrow \Rightarrow t t t

6.4.5. 函数类型

functype param result ::= ::= ::= ‘ (’ ‘ func ’ t_{1}^{*} : vec (param) t_{2}^{*} : vec (result) ‘) ’ ‘ (’ ‘ param ’ id^{?} t : valtype ‘) ’ ‘ (’ ‘ result ’ t : valtype ‘) ’ \Rightarrow \Rightarrow \Rightarrow [t_{1}^{*}] \to [t_{2}^{*}] t t

注意

函数类型中参数的可选标识符名称仅用于文档目的。它们不能在任何地方被引用。

6.4.5.1. 缩写

多个匿名参数或结果可以合并到单个声明中

‘ (’ ‘ param ’ valtype^{*} ‘) ’ ‘ (’ ‘ result ’ valtype^{*} ‘) ’ \equiv \equiv (‘ (’ ‘ param ’ valtype ‘) ’)^{*} (‘ (’ ‘ result ’ valtype ‘) ’)^{*}

6.4.6. 限制

limits ::= ∣ n : u 32 n : u 32 m : u 32 \Rightarrow \Rightarrow {min n, max ϵ} {min n, max m}

6.4.7. 内存类型

memtype ::= lim : limits \Rightarrow lim

6.4.8. 表类型

tabletype ::= lim : limits et : reftype \Rightarrow lim et

6.4.9. 全局类型

globaltype ::= ∣ t : valtype ‘ (’ ‘ mut ’ t : valtype ‘) ’ \Rightarrow \Rightarrow const t var t

6.5. 指令

指令在语法上分为简单指令和结构化指令。

instr_{I} ::= ∣ in : plaininstr_{I} in : blockinstr_{I} \Rightarrow \Rightarrow in in

此外，作为语法上的简写，指令可以用折叠形式的 S 表达式来编写，以便在视觉上进行分组。

6.5.1. 标签

结构化控制指令可以用符号化的标签标识符进行注释。它们是唯一可以在指令序列中局部绑定的符号标识符。以下语法通过组合上下文和额外的标签条目来处理对标识符上下文的相应更新。

label_{I} ::= ∣ ∣ v : id v : id ϵ \Rightarrow \Rightarrow \Rightarrow {labels v} \oplus I {labels v} \oplus (I with labels [i] = ϵ) {labels (ϵ)} \oplus I (if v \in / I . labels) (if I . labels [i] = v)

注意

在标识符上下文中，新的标签条目被插入标签列表的开头。这实际上将所有现有标签向上移动一位，反映了控制指令是相对索引而不是绝对索引的事实。

如果已经存在具有相同名称的标签，则它会被遮蔽，并且先前标签将无法访问。

6.5.2. 控制指令

结构化控制指令可以绑定一个可选的符号标签标识符。相同的标签标识符可以在相应的 $end$ 和 $else$ 伪指令后重复，以指示匹配的分隔符。

它们的块类型被指定为类型使用，类似于函数的类型。但是，语法为空或仅包含单个结果的类型使用情况不被视为缩写用于内联函数类型，而是直接解析为可选的值类型。

blocktype_{I} blockinstr_{I} ::= ∣ ::= ∣ ∣ (t : result)^{?} x, I^{'} : typeuse_{I} \Rightarrow \Rightarrow t^{?} x (if I^{'} = {locals (ϵ)^{*}}) ‘ block ’ I^{'} : label_{I} bt : blocktype_{I} (in : instr_{I^{'}})^{*} ‘ end ’ id^{?} \Rightarrow block bt in^{*} end (if id^{?} = ϵ \lor id^{?} = label) ‘ loop ’ I^{'} : label_{I} bt : blocktype_{I} (in : instr_{I^{'}})^{*} ‘ end ’ id^{?} \Rightarrow loop bt in^{*} end (if id^{?} = ϵ \lor id^{?} = label) ‘ if ’ I^{'} : label_{I} bt : blocktype_{I} (in_{1} : instr_{I^{'}})^{*} ‘ else ’ id_{1}^{?} (in_{2} : instr_{I^{'}})^{*} ‘ end ’ id_{2}^{?} \Rightarrow if bt in_{1}^{*} else in_{2}^{*} end (if id_{1}^{?} = ϵ \lor id_{1}^{?} = label, id_{2}^{?} = ϵ \lor id_{2}^{?} = label)

注意

对于 $typeuse$ 块类型的规则中，边条件说明标识符上下文 $I^{'}$ 必须仅包含未命名的条目，这强制了在任何 $param$ 块类型的声明中都不能绑定标识符。

所有其他控制指令都按原样表示。

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ‘ unreachable ’ ‘ nop ’ ‘ br ’ l : labelidx_{I} ‘ br_if ’ l : labelidx_{I} ‘ br_table ’ l^{*} : vec (labelidx_{I}) l_{N} : labelidx_{I} ‘ return ’ ‘ call ’ x : funcidx_{I} ‘ call_indirect ’ x : tableidx y, I^{'} : typeuse_{I} \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow unreachable nop br l br_if l br_table l^{*} l_{N} return call x call_indirect x y (if I^{'} = {locals (ϵ)^{*}})

注意

对于 $call_indirect$ 的规则中，边条件说明标识符上下文 $I^{'}$ 必须仅包含未命名的条目，这强制了在类型注释中出现的任何 $param$ 声明中都不能绑定标识符。

6.5.2.1. 缩写

$‘ else ’$ $‘ if ’$ 指令的关键字可以省略，如果后面的指令序列为空。

‘ if ’ label blocktype instr^{*} ‘ end ’ \equiv ‘ if ’ label blocktype instr^{*} ‘ else ’ ‘ end ’

此外，为了向后兼容性，可以省略到 $‘ call_indirect ’$ 的表格索引，默认为 $0$ .

‘ call_indirect ’ typeuse \equiv ‘ call_indirect ’ 0 typeuse

6.5.3. 引用指令

plaininstr_{I} ::= ∣ ∣ ∣ \dots ‘ ref.null ’ t : heaptype ‘ ref.is_null ’ ‘ ref.func ’ x : funcidx \Rightarrow \Rightarrow \Rightarrow ref . null t ref . is_null ref . func x

6.5.4. 参数化指令

plaininstr_{I} ::= ∣ ∣ \dots ‘ drop ’ ‘ select ’ ((t : result)^{*})^{?} \Rightarrow \Rightarrow drop select (t^{*})^{?}

6.5.5. 变量指令

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ \dots ‘ local.get ’ x : localidx_{I} ‘ local.set ’ x : localidx_{I} ‘ local.tee ’ x : localidx_{I} ‘ global.get ’ x : globalidx_{I} ‘ global.set ’ x : globalidx_{I} \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow local.get x local.set x local.tee x global.get x global.set x

6.5.6. 表指令

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ \dots ‘ table.get ’ x : tableidx_{I} ‘ table.set ’ x : tableidx_{I} ‘ table.size ’ x : tableidx_{I} ‘ table.grow ’ x : tableidx_{I} ‘ table.fill ’ x : tableidx_{I} ‘ table.copy ’ x : tableidx_{I} y : tableidx_{I} ‘ table.init ’ x : tableidx_{I} y : elemidx_{I} ‘ elem.drop ’ x : elemidx_{I} \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow table.get x table.set x table.size x table.grow x table.fill x table.copy x y table.init x y elem.drop x

6.5.6.1. 缩写

为了向后兼容，所有表索引都可以从表指令中省略，默认值是 $0$ .

‘ table.get ’ ‘ table.set ’ ‘ table.size ’ ‘ table.grow ’ ‘ table.fill ’ ‘ table.copy ’ ‘ table.init ’ x : elemidx_{I} \equiv \equiv \equiv \equiv \equiv \equiv \equiv ‘ table.get ’ ‘ 0 ’ ‘ table.set ’ ‘ 0 ’ ‘ table.size ’ ‘ 0 ’ ‘ table.grow ’ ‘ 0 ’ ‘ table.fill ’ ‘ 0 ’ ‘ table.copy ’ ‘ 0 ’ ‘ 0 ’ ‘ table.init ’ ‘ 0 ’ x : elemidx_{I}

6.5.7. 内存指令

内存指令的偏移量和对齐立即数是可选的。偏移量默认为 $0$ ，对齐为相应内存访问的存储大小，即其自然对齐。从语法上讲，一个 $offset$ 或 $align$ 短语被认为是一个单独的关键字标记，因此不允许在 $‘ = ’$ 周围使用空白。

6.5.8. 数值指令

plaininstr_{I} ::= ∣ ∣ ∣ ∣ \dots ‘ i32.const ’ n : i 32 ‘ i64.const ’ n : i 64 ‘ f32.const ’ z : f 32 ‘ f64.const ’ z : f 64 \Rightarrow \Rightarrow \Rightarrow \Rightarrow i32 . const n i64 . const n f32 . const z f64 . const z

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ i32.clz ’ ‘ i32.ctz ’ ‘ i32.popcnt ’ ‘ i32.add ’ ‘ i32.sub ’ ‘ i32.mul ’ ‘ i32.div_s ’ ‘ i32.div_u ’ ‘ i32.rem_s ’ ‘ i32.rem_u ’ ‘ i32.and ’ ‘ i32.or ’ ‘ i32.xor ’ ‘ i32.shl ’ ‘ i32.shr_s ’ ‘ i32.shr_u ’ ‘ i32.rotl ’ ‘ i32.rotr ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i32 . clz i32 . ctz i32 . popcnt i32 . add i32 . sub i32 . mul i32 . div_s i32 . div_u i32 . rem_s i32 . rem_u i32 . and i32 . or i32 . xor i32 . shl i32 . shr_s i32 . shr_u i32 . rotl i32 . rotr

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ i64.clz ’ ‘ i64.ctz ’ ‘ i64.popcnt ’ ‘ i64.add ’ ‘ i64.sub ’ ‘ i64.mul ’ ‘ i64.div_s ’ ‘ i64.div_u ’ ‘ i64.rem_s ’ ‘ i64.rem_u ’ ‘ i64.and ’ ‘ i64.or ’ ‘ i64.xor ’ ‘ i64.shl ’ ‘ i64.shr_s ’ ‘ i64.shr_u ’ ‘ i64.rotl ’ ‘ i64.rotr ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i64 . clz i64 . ctz i64 . popcnt i64 . add i64 . sub i64 . mul i64 . div_s i64 . div_u i64 . rem_s i64 . rem_u i64 . and i64 . or i64 . xor i64 . shl i64 . shr_s i64 . shr_u i64 . rotl i64 . rotr

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ f32.abs ’ ‘ f32.neg ’ ‘ f32.ceil ’ ‘ f32.floor ’ ‘ f32.trunc ’ ‘ f32.nearest ’ ‘ f32.sqrt ’ ‘ f32.add ’ ‘ f32.sub ’ ‘ f32.mul ’ ‘ f32.div ’ ‘ f32.min ’ ‘ f32.max ’ ‘ f32.copysign ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h f32 . abs f32 . neg f32 . ceil f32 . floor f32 . trunc f32 . nearest f32 . sqrt f32 . add f32 . sub f32 . mul f32 . div f32 . min f32 . max f32 . copysign

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ f64.abs ’ ‘ f64.neg ’ ‘ f64.ceil ’ ‘ f64.floor ’ ‘ f64.trunc ’ ‘ f64.nearest ’ ‘ f64.sqrt ’ ‘ f64.add ’ ‘ f64.sub ’ ‘ f64.mul ’ ‘ f64.div ’ ‘ f64.min ’ ‘ f64.max ’ ‘ f64.copysign ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h f64 . abs f64 . neg f64 . ceil f64 . floor f64 . trunc f64 . nearest f64 . sqrt f64 . add f64 . sub f64 . mul f64 . div f64 . min f64 . max f64 . copysign

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ i32.eqz ’ ‘ i32.eq ’ ‘ i32.ne ’ ‘ i32.lt_s ’ ‘ i32.lt_u ’ ‘ i32.gt_s ’ ‘ i32.gt_u ’ ‘ i32.le_s ’ ‘ i32.le_u ’ ‘ i32.ge_s ’ ‘ i32.ge_u ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i32 . eqz i32 . eq i32 . ne i32 . lt_s i32 . lt_u i32 . gt_s i32 . gt_u i32 . le_s i32 . le_u i32 . ge_s i32 . ge_u

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ i64.eqz ’ ‘ i64.eq ’ ‘ i64.ne ’ ‘ i64.lt_s ’ ‘ i64.lt_u ’ ‘ i64.gt_s ’ ‘ i64.gt_u ’ ‘ i64.le_s ’ ‘ i64.le_u ’ ‘ i64.ge_s ’ ‘ i64.ge_u ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i64 . eqz i64 . eq i64 . ne i64 . lt_s i64 . lt_u i64 . gt_s i64 . gt_u i64 . le_s i64 . le_u i64 . ge_s i64 . ge_u

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ f32.eq ’ ‘ f32.ne ’ ‘ f32.lt ’ ‘ f32.gt ’ ‘ f32.le ’ ‘ f32.ge ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h f32 . eq f32 . ne f32 . lt f32 . gt f32 . le f32 . ge

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ f64.eq ’ ‘ f64.ne ’ ‘ f64.lt ’ ‘ f64.gt ’ ‘ f64.le ’ ‘ f64.ge ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h f64 . eq f64 . ne f64 . lt f64 . gt f64 . le f64 . ge

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ t hi s i se n o ug h ‘ i32.extend8_s ’ ‘ i32.extend16_s ’ ‘ i64.extend8_s ’ ‘ i64.extend16_s ’ ‘ i64.extend32_s ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow t hi ss h o u l d b ee n o ug h i32 . extend 8_s i32 . extend 16_s i64 . extend 8_s i64 . extend 16_s i64 . extend 32_s

6.5.9. 向量指令

向量内存指令具有可选的偏移量和对齐方式立即数，类似于内存指令。

向量常量指令具有必需的形状描述符，用于确定如何解析后续的值。

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ v128.const ’ ‘ i8x16 ’ (n : i 8)^{16} ‘ v128.const ’ ‘ i16x8 ’ (n : i 16)^{8} ‘ v128.const ’ ‘ i32x4 ’ (n : i 32)^{4} ‘ v128.const ’ ‘ i64x2 ’ (n : i 64)^{2} ‘ v128.const ’ ‘ f32x4 ’ (z : f 32)^{4} ‘ v128.const ’ ‘ f64x2 ’ (z : f 64)^{2} \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es v128 . const bytes_{i 128}^{- 1} (bytes_{i 8} (n)^{16}) v128 . const bytes_{i 128}^{- 1} (bytes_{i 16} (n)^{8}) v128 . const bytes_{i 128}^{- 1} (bytes_{i 32} (n)^{4}) v128 . const bytes_{i 128}^{- 1} (bytes_{i 64} (n)^{2}) v128 . const bytes_{i 128}^{- 1} (bytes_{f 32} (z)^{4}) v128 . const bytes_{i 128}^{- 1} (bytes_{f 64} (z)^{2})

plaininstr_{I} ::= ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i8x16.shuffle ’ (l an e i d x : u 8)^{16} ‘ i8x16.swizzle ’ \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i8x16 . shuffle l an e i d x^{16} i8x16 . swizzle

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i8x16.splat ’ ‘ i16x8.splat ’ ‘ i32x4.splat ’ ‘ i64x2.splat ’ ‘ f32x4.splat ’ ‘ f64x2.splat ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i8x16.extract_lane_s ’ l an e i d x : u 8 ‘ i8x16.extract_lane_u ’ l an e i d x : u 8 ‘ i8x16.replace_lane ’ l an e i d x : u 8 ‘ i16x8.extract_lane_s ’ l an e i d x : u 8 ‘ i16x8.extract_lane_u ’ l an e i d x : u 8 ‘ i16x8.replace_lane ’ l an e i d x : u 8 ‘ i32x4.extract_lane ’ l an e i d x : u 8 ‘ i32x4.replace_lane ’ l an e i d x : u 8 ‘ i64x2.extract_lane ’ l an e i d x : u 8 ‘ i64x2.replace_lane ’ l an e i d x : u 8 ‘ f32x4.extract_lane ’ l an e i d x : u 8 ‘ f32x4.replace_lane ’ l an e i d x : u 8 ‘ f64x2.extract_lane ’ l an e i d x : u 8 ‘ f64x2.replace_lane ’ l an e i d x : u 8 \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i8x16 . extract_lane_s l an e i d x i8x16 . extract_lane_u l an e i d x i8x16 . replace_lane l an e i d x i16x8 . extract_lane_s l an e i d x i16x8 . extract_lane_u l an e i d x i16x8 . replace_lane l an e i d x i32x4 . extract_lane l an e i d x i32x4 . replace_lane l an e i d x i64x2 . extract_lane l an e i d x i64x2 . replace_lane l an e i d x f32x4 . extract_lane l an e i d x f32x4 . replace_lane l an e i d x f64x2 . extract_lane l an e i d x f64x2 . replace_lane l an e i d x

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i8x16.eq ’ ‘ i8x16.ne ’ ‘ i8x16.lt_s ’ ‘ i8x16.lt_u ’ ‘ i8x16.gt_s ’ ‘ i8x16.gt_u ’ ‘ i8x16.le_s ’ ‘ i8x16.le_u ’ ‘ i8x16.ge_s ’ ‘ i8x16.ge_u ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i8x16 . eq i8x16 . ne i8x16 . lt_s i8x16 . lt_u i8x16 . gt_s i8x16 . gt_u i8x16 . le_s i8x16 . le_u i8x16 . ge_s i8x16 . ge_u

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i16x8.eq ’ ‘ i16x8.ne ’ ‘ i16x8.lt_s ’ ‘ i16x8.lt_u ’ ‘ i16x8.gt_s ’ ‘ i16x8.gt_u ’ ‘ i16x8.le_s ’ ‘ i16x8.le_u ’ ‘ i16x8.ge_s ’ ‘ i16x8.ge_u ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i16x8 . eq i16x8 . ne i16x8 . lt_s i16x8 . lt_u i16x8 . gt_s i16x8 . gt_u i16x8 . le_s i16x8 . le_u i16x8 . ge_s i16x8 . ge_u

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i32x4.eq ’ ‘ i32x4.ne ’ ‘ i32x4.lt_s ’ ‘ i32x4.lt_u ’ ‘ i32x4.gt_s ’ ‘ i32x4.gt_u ’ ‘ i32x4.le_s ’ ‘ i32x4.le_u ’ ‘ i32x4.ge_s ’ ‘ i32x4.ge_u ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i32x4 . eq i32x4 . ne i32x4 . lt_s i32x4 . lt_u i32x4 . gt_s i32x4 . gt_u i32x4 . le_s i32x4 . le_u i32x4 . ge_s i32x4 . ge_u

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i64x2.eq ’ ‘ i64x2.ne ’ ‘ i64x2.lt_s ’ ‘ i64x2.gt_s ’ ‘ i64x2.le_s ’ ‘ i64x2.ge_s ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ f32x4.eq ’ ‘ f32x4.ne ’ ‘ f32x4.lt ’ ‘ f32x4.gt ’ ‘ f32x4.le ’ ‘ f32x4.ge ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ f64x2.eq ’ ‘ f64x2.ne ’ ‘ f64x2.lt ’ ‘ f64x2.gt ’ ‘ f64x2.le ’ ‘ f64x2.ge ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i8x16.abs ’ ‘ i8x16.neg ’ ‘ i8x16.all_true ’ ‘ i8x16.bitmask ’ ‘ i8x16.narrow_i16x8_s ’ ‘ i8x16.narrow_i16x8_u ’ ‘ i8x16.shl ’ ‘ i8x16.shr_s ’ ‘ i8x16.shr_u ’ ‘ i8x16.add ’ ‘ i8x16.add_sat_s ’ ‘ i8x16.add_sat_u ’ ‘ i8x16.sub ’ ‘ i8x16.sub_sat_s ’ ‘ i8x16.sub_sat_u ’ ‘ i8x16.min_s ’ ‘ i8x16.min_u ’ ‘ i8x16.max_s ’ ‘ i8x16.max_u ’ ‘ i8x16.avgr_u ’ ‘ i8x16.popcnt ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i8x16 . abs i8x16 . neg i8x16 . all_true i8x16 . bitmask i8x16 . narrow_i16x8_s i8x16 . narrow_i16x8_u i8x16 . shl i8x16 . shr_s i8x16 . shr_u i8x16 . add i8x16 . add_sat_s i8x16 . add_sat_u i8x16 . sub i8x16 . sub_sat_s i8x16 . sub_sat_u i8x16 . min_s i8x16 . min_u i8x16 . max_s i8x16 . max_u i8x16 . avgr_u i8x16 . popcnt

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i32x4.abs ’ ‘ i32x4.neg ’ ‘ i32x4.all_true ’ ‘ i32x4.bitmask ’ ‘ i32x4.extadd_pairwise_i16x8_s ’ ‘ i32x4.extend_low_i16x8_s ’ ‘ i32x4.extend_high_i16x8_s ’ ‘ i32x4.extend_low_i16x8_u ’ ‘ i32x4.extend_high_i16x8_u ’ ‘ i32x4.shl ’ ‘ i32x4.shr_s ’ ‘ i32x4.shr_u ’ ‘ i32x4.add ’ ‘ i32x4.sub ’ ‘ i32x4.mul ’ ‘ i32x4.min_s ’ ‘ i32x4.min_u ’ ‘ i32x4.max_s ’ ‘ i32x4.max_u ’ ‘ i32x4.dot_i16x8_s ’ ‘ i32x4.extmul_low_i16x8_s ’ ‘ i32x4.extmul_high_i16x8_s ’ ‘ i32x4.extmul_low_i16x8_u ’ ‘ i32x4.extmul_high_i16x8_u ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i32x4 . abs i32x4 . neg i32x4 . all_true i32x4 . bitmask i32x4 . extadd_pairwise_i16x8_s i32x4 . extend_low_i16x8_s i32x4 . extend_high_i16x8_s i32x4 . extend_low_i16x8_u i32x4 . extend_high_i16x8_u i32x4 . shl i32x4 . shr_s i32x4 . shr_u i32x4 . add i32x4 . sub i32x4 . mul i32x4 . min_s i32x4 . min_u i32x4 . max_s i32x4 . max_u i32x4 . dot_i16x8_s i32x4 . extmul_low_i16x8_s i32x4 . extmul_high_i16x8_s i32x4 . extmul_low_i16x8_u i32x4 . extmul_high_i16x8_u

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i64x2.abs ’ ‘ i64x2.neg ’ ‘ i64x2.all_true ’ ‘ i64x2.bitmask ’ ‘ i64x2.extend_low_i32x4_s ’ ‘ i64x2.extend_high_i32x4_s ’ ‘ i64x2.extend_low_i32x4_u ’ ‘ i64x2.extend_high_i32x4_u ’ ‘ i64x2.shl ’ ‘ i64x2.shr_s ’ ‘ i64x2.shr_u ’ ‘ i64x2.add ’ ‘ i64x2.sub ’ ‘ i64x2.mul ’ ‘ i64x2.extmul_low_i32x4_s ’ ‘ i64x2.extmul_high_i32x4_s ’ ‘ i64x2.extmul_low_i32x4_u ’ ‘ i64x2.extmul_high_i32x4_u ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i64x2 . abs i64x2 . neg i64x2 . all_true i64x2 . bitmask i64x2 . extend_low_i32x4_s i64x2 . extend_high_i32x4_s i64x2 . extend_low_i32x4_u i64x2 . extend_high_i32x4_u i64x2 . shl i64x2 . shr_s i64x2 . shr_u i64x2 . add i64x2 . sub i64x2 . mul i64x2 . extmul_low_i32x4_s i64x2 . extmul_high_i32x4_s i64x2 . extmul_low_i32x4_u i64x2 . extmul_high_i32x4_u

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ f32x4.abs ’ ‘ f32x4.neg ’ ‘ f32x4.sqrt ’ ‘ f32x4.ceil ’ ‘ f32x4.floor ’ ‘ f32x4.trunc ’ ‘ f32x4.nearest ’ ‘ f32x4.add ’ ‘ f32x4.sub ’ ‘ f32x4.mul ’ ‘ f32x4.div ’ ‘ f32x4.min ’ ‘ f32x4.max ’ ‘ f32x4.pmin ’ ‘ f32x4.pmax ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es f32x4 . abs f32x4 . neg f32x4 . sqrt f32x4 . ceil f32x4 . floor f32x4 . trunc f32x4 . nearest f32x4 . add f32x4 . sub f32x4 . mul f32x4 . div f32x4 . min f32x4 . max f32x4 . pmin f32x4 . pmax

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ f64x2.abs ’ ‘ f64x2.neg ’ ‘ f64x2.sqrt ’ ‘ f64x2.ceil ’ ‘ f64x2.floor ’ ‘ f64x2.trunc ’ ‘ f64x2.nearest ’ ‘ f64x2.add ’ ‘ f64x2.sub ’ ‘ f64x2.mul ’ ‘ f64x2.div ’ ‘ f64x2.min ’ ‘ f64x2.max ’ ‘ f64x2.pmin ’ ‘ f64x2.pmax ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es f64x2 . abs f64x2 . neg f64x2 . sqrt f64x2 . ceil f64x2 . floor f64x2 . trunc f64x2 . nearest f64x2 . add f64x2 . sub f64x2 . mul f64x2 . div f64x2 . min f64x2 . max f64x2 . pmin f64x2 . pmax

plaininstr_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ a v ery l o n g in s t r u c t i o nnam e f or v ec t e x t ‘ i32x4.trunc_sat_f32x4_s ’ ‘ i32x4.trunc_sat_f32x4_u ’ ‘ i32x4.trunc_sat_f64x2_s_zero ’ ‘ i32x4.trunc_sat_f64x2_u_zero ’ ‘ f32x4.convert_i32x4_s ’ ‘ f32x4.convert_i32x4_u ’ ‘ f64x2.convert_low_i32x4_s ’ ‘ f64x2.convert_low_i32x4_u ’ ‘ f32x4.demote_f64x2_zero ’ ‘ f64x2.promote_low_f32x4 ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow v ec ha sre a ll y l o n g in s t r u c t i o nnam es i32x4 . trunc_sat_f32x4_s i32x4 . trunc_sat_f32x4_u i32x4 . trunc_sat_f64x2_s_zero i32x4 . trunc_sat_f64x2_u_zero f32x4 . convert_i32x4_s f32x4 . convert_i32x4_u f64x2 . convert_low_i32x4_s f64x2 . convert_low_i32x4_u f32x4 . demote_f64x2_zero f64x2 . promote_low_f32x4

6.5.10. 折叠指令

指令可以写成 S-表达式，通过将它们分组为“折叠”形式。在这个表示法中，指令用圆括号括起来，并可以包含嵌套的折叠指令来表示其操作数。

在块指令的情况下，折叠形式省略了 $‘ end ’$ 分隔符。对于 $if$ 指令，两个分支都必须用嵌套的 S-表达式括起来，并以关键字 $‘ then ’$ 和 $‘ else ’$ 开头。

由以下缩写递归定义的所有短语集合构成了辅助句法类 $foldedinstr$ 。这种折叠指令可以出现在任何常规指令可以出现的地方。

‘ (’ plaininstr foldedinstr^{*} ‘) ’ ‘ (’ ‘ block ’ label blocktype instr^{*} ‘) ’ ‘ (’ ‘ loop ’ label blocktype instr^{*} ‘) ’ ‘ (’ ‘ if ’ label blocktype foldedinstr^{*} foldedinstr^{*} ‘ if ’ label blocktype \equiv foldedinstr^{*} plaininstr \equiv ‘ block ’ label blocktype instr^{*} ‘ end ’ \equiv ‘ loop ’ label blocktype instr^{*} ‘ end ’ ‘ (’ ‘ then ’ instr_{1}^{*} ‘) ’ (‘ (’ ‘ else ’ instr_{2}^{*} ‘) ’)^{?} ‘) ’ \equiv instr_{1}^{*} ‘ else ’ (instr_{2}^{*})^{?} ‘ end ’

注意

例如，指令序列

(local.get $x) (i32.const 2) i32.add (i32.const 3) i32.mul

可以折叠成

(i32.mul (i32.add (local.get $x) (i32.const 2)) (i32.const 3))

折叠指令仅仅是语法糖，不暗示额外的语法或基于类型的检查。

6.5.11. 表达式

表达式以指令序列的形式编写。没有显式包含 $‘ end ’$ 关键字，因为它们只出现在方括号的位置。

expr_{I} ::= (in : instr_{I})^{*} \Rightarrow in^{*} end

6.6. 模块

6.6.1. 索引

索引可以以原始数字形式或作为符号标识符给出，当被相应构造绑定时。这些标识符会在合适的标识符上下文 $I$ 空间中查找。

typeidx_{I} funcidx_{I} tableidx_{I} memidx_{I} globalidx_{I} elemidx_{I} dataidx_{I} localidx_{I} labelidx_{I} ::= ∣ ::= ∣ ::= ∣ ::= ∣ ::= ∣ ::= ∣ ::= ∣ ::= ∣ ::= ∣ x : u 32 v : id x : u 32 v : id x : u 32 v : id x : u 32 v : id x : u 32 v : id x : u 32 v : id x : u 32 v : id x : u 32 v : id l : u 32 v : id \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow x x x x x x x x x x x x x x x x l l (if I . types [x] = v) (if I . funcs [x] = v) (if I . tables [x] = v) (if I . mems [x] = v) (if I . globals [x] = v) (if I . elem [x] = v) (if I . data [x] = v) (if I . locals [x] = v) (if I . labels [l] = v)

6.6.2. 类型

类型定义可以绑定符号类型标识符。

type ::= ‘ (’ ‘ type ’ id^{?} ft : functype ‘) ’ \Rightarrow ft

6.6.3. 类型使用

类型使用是对类型定义的引用。它可以选择性地通过内联的参数和结果声明进行增强。这允许绑定符号标识符来命名参数的局部索引。如果给出内联声明，则它们的类型必须与引用的函数类型匹配。

typeuse_{I} ::= ‘ (’ ‘ type ’ x : typeidx_{I} ‘) ’ \Rightarrow x, I^{'} (if I . typedefs [x] = [t_{1}^{n}] \to [t_{2}^{*}] \land I^{'} = {locals (ϵ)^{n}}) 1 e x] (if I . typedefs [x] = [t_{1}^{*}] \to [t_{2}^{*}] \land I^{'} = {locals id (param)^{*}} well-formed) ∣ ‘ (’ ‘ type ’ x : typeidx_{I} ‘) ’ (t_{1} : param)^{*} (t_{2} : result)^{*} \Rightarrow x, I^{'}

$typeuse$ 的合成属性是一个对，它包含使用的类型索引和包含可能的参数标识符的局部标识符上下文。以下辅助函数从参数中提取可选标识符

id (‘ (’ ‘ param ’ id^{?} \dots ‘) ’) = id^{?}

注意

两种生成方式在函数类型为 $[] \to []$ 时重叠。但是，在这种情况下，它们也会产生相同的结果，因此选择无关紧要。

关于 $I^{'}$ 的良好格式条件确保参数不包含重复的标识符。

6.6.3.1. 缩写

一个 $typeuse$ 也可以完全由内联的参数和结果声明替换。在这种情况下，会自动插入一个类型索引

(t_{1} : param)^{*} (t_{2} : result)^{*} \equiv ‘ (’ ‘ type ’ x ‘) ’ param^{*} result^{*}

其中 $x$ 是当前模块中定义的最小现存类型索引，其定义为函数类型 $[t_{1}^{*}] \to [t_{2}^{*}]$ 。如果不存在此类索引，则会插入一个新的类型定义，其形式为

‘ (’ ‘ type ’ ‘ (’ ‘ func ’ param^{*} result^{*} ‘) ’ ‘) ’

插入到模块的末尾。

缩写按其出现的顺序扩展，因此先前插入的类型定义会被连续的扩展所重用。

6.6.4. 导入

导入中的描述符可以绑定符号函数、表格、内存或全局标识符。

import_{I} ::= ∣ ∣ ∣ ‘ (’ ‘ import ’ mod : name nm : name d : importdesc_{I} ‘) ’ \Rightarrow {module mod, name nm, desc d} 1 e x] ‘ (’ ‘ table ’ id^{?} tt : tabletype ‘) ’ ‘ (’ ‘ memory ’ id^{?} mt : memtype ‘) ’ ‘ (’ ‘ global ’ id^{?} gt : globaltype ‘) ’ importdesc_{I} \Rightarrow \Rightarrow \Rightarrow ::= table tt mem mt global gt ‘ (’ ‘ func ’ id^{?} x, I^{'} : typeuse_{I} ‘) ’ \Rightarrow func x

6.6.4.1. 缩写

作为缩写，导入也可以与函数、表格、内存或全局定义内联指定；请参见相应的章节。

6.6.5. 函数

函数定义可以绑定一个符号化的函数标识符，以及局部标识符，分别用于其参数和局部变量。

func_{I} ::= ‘ (’ ‘ func ’ id^{?} x, I^{'} : typeuse_{I} (t : local)^{*} (in : instr_{I^{''}})^{*} ‘) ’ \Rightarrow {type x, locals t^{*}, body in^{*} end} (if I^{''} = I \oplus I^{'} \oplus {locals id (local)^{*}} well-formed) 1 e x] local ::= ‘ (’ ‘ local ’ id^{?} t : valtype ‘) ’ \Rightarrow t

局部标识符上下文 $I^{''}$ 的定义使用以下辅助函数来从局部变量中提取可选标识符

id (‘ (’ ‘ local ’ id^{?} \dots ‘) ’) = id^{?}

注意

关于 $I^{''}$ 的良构性条件确保参数和局部变量不包含重复的标识符。

6.6.5.1. 缩写

多个匿名局部变量可以合并成单个声明。

‘ (’ ‘ local ’ valtype^{*} ‘) ’ \equiv (‘ (’ ‘ local ’ valtype ‘) ’)^{*}

函数可以定义为导入或导出内联。

‘ (’ ‘ func ’ id^{?} ‘ (’ ‘ import ’ name_{1} name_{2} ‘) ’ typeuse ‘) ’ \equiv ‘ (’ ‘ import ’ name_{1} name_{2} ‘ (’ ‘ func ’ id^{?} typeuse ‘) ’ ‘) ’ 1 e x] ‘ (’ ‘ export ’ name ‘ (’ ‘ func ’ id^{'} ‘) ’ ‘) ’ ‘ (’ ‘ func ’ id^{'} \dots ‘) ’ (if id^{?} \neq = ϵ \land id^{'} = id^{?} \lor id^{?} = ϵ \land id^{'} fresh) ‘ (’ ‘ func ’ id^{?} ‘ (’ ‘ export ’ name ‘) ’ \dots ‘) ’ \equiv

注意

如果“ $\dots$ ”包含额外的导出子句，则后一种缩写可以重复应用。因此，函数声明可以包含任意数量的导出，可能后面跟着一个导入。

6.6.6. 表格

表格定义可以绑定一个符号表格标识符。

table_{I} ::= ‘ (’ ‘ table ’ id^{?} tt : tabletype ‘) ’ \Rightarrow {type tt}

6.6.6.1. 缩写

一个元素段可以与表格定义一起内联给出，在这种情况下，它的偏移量为 $0$ ，并且限制在表格类型中从给定段的长度推断出来。

‘ (’ ‘ table ’ id^{?} reftype ‘ (’ ‘ elem ’ expr^{n} : vec (elemexpr) ‘) ’ ‘) ’ \equiv ‘ (’ ‘ table ’ id^{'} n n reftype ‘) ’ ‘ (’ ‘ elem ’ ‘ (’ ‘ table ’ id^{'} ‘) ’ ‘ (’ ‘ i32.const ’ ‘ 0 ’ ‘) ’ reftype vec (elemexpr) ‘) ’ (if id^{?} \neq = ϵ \land id^{'} = <

‘ (’ ‘ table ’ id^{?} reftype ‘ (’ ‘ elem ’ x^{n} : vec (funcidx) ‘) ’ ‘) ’ \equiv ‘ (’ ‘ table ’ id^{'} n n reftype ‘) ’ ‘ (’ ‘ elem ’ ‘ (’ ‘ table ’ id^{'} ‘) ’ ‘ (’ ‘ i32.const ’ ‘ 0 ’ ‘) ’ ‘ func ’ vec (funcidx) ‘) ’ (if id^{?} \neq = ϵ \land id^{'} = id^{?} \lor id^{?} = ϵ \land id^{'} fresh)

表格可以定义为导入或导出内联

‘ (’ ‘ table ’ id^{?} ‘ (’ ‘ import ’ name_{1} name_{2} ‘) ’ tabletype ‘) ’ \equiv ‘ (’ ‘ import ’ name_{1} name_{2} ‘ (’ ‘ table ’ id^{?} tabletype ‘) ’ ‘) ’ 1 e x] ‘ (’ ‘ export ’ name ‘ (’ ‘ table ’ id^{'} ‘) ’ ‘) ’ ‘ (’ ‘ table ’ id^{'} \dots ‘) ’ (if id^{?} \neq = ϵ \land id^{'} = id^{?} \lor id^{?} = ϵ \land id^{'} fresh) ‘ (’ ‘ table ’ id^{?} ‘ (’ ‘ export ’ name ‘) ’ \dots ‘) ’ \equiv

注意

如果“ $\dots$ ”包含额外的导出子句，则后一个缩写可以重复使用。因此，表格声明可以包含任意数量的导出，后面可能紧跟着导入。

6.6.7. 内存

内存定义可以绑定符号内存标识符。

mem_{I} ::= ‘ (’ ‘ memory ’ id^{?} mt : memtype ‘) ’ \Rightarrow {type mt}

6.6.7.1. 缩写

一个数据段可以在内存定义中内联给出，在这种情况下，它的偏移量为 $0$ ，并且限制的内存类型从数据的长度推断，向上取整到页面大小

‘ (’ ‘ memory ’ id^{?} ‘ (’ ‘ data ’ b^{n} : datastring ‘) ’ ‘) ’ \equiv ‘ (’ ‘ memory ’ id^{'} m m ‘) ’ ‘ (’ ‘ data ’ ‘ (’ ‘ memory ’ id^{'} ‘) ’ ‘ (’ ‘ i32.const ’ ‘ 0 ’ ‘) ’ datastring ‘) ’ (if id^{?} \neq = ϵ \land id^{'} = id^{?} \lor id^{?} = ϵ \land id^{'} fresh, m = ceil (n /64 Ki))

内存可以被定义为导入或者导出内联

‘ (’ ‘ memory ’ id^{?} ‘ (’ ‘ import ’ name_{1} name_{2} ‘) ’ memtype ‘) ’ \equiv ‘ (’ ‘ import ’ name_{1} name_{2} ‘ (’ ‘ memory ’ id^{?} memtype ‘) ’ ‘) ’ 1 e x] ‘ (’ ‘ export ’ name ‘ (’ ‘ memory ’ id^{'} ‘) ’ ‘) ’ ‘ (’ ‘ memory ’ id^{'} \dots ‘) ’ (if id^{?} \neq = ϵ \land id^{'} = id^{?} \lor id^{?} = ϵ \land id^{'} fresh) ‘ (’ ‘ memory ’ id^{?} ‘ (’ ‘ export ’ name ‘) ’ \dots ‘) ’ \equiv

注意

如果“ $\dots$ ” 包含额外的导出子句，则后一种缩写可以重复使用。因此，内存声明可以包含任意数量的导出，后面可能跟着一个导入。

6.6.8. 全局变量

全局定义可以绑定一个符号化的全局标识符.

global_{I} ::= ‘ (’ ‘ global ’ id^{?} gt : globaltype e : expr_{I} ‘) ’ \Rightarrow {type gt, init e}

6.6.8.1. 缩写

全局变量可以定义为导入或导出内联

‘ (’ ‘ global ’ id^{?} ‘ (’ ‘ import ’ name_{1} name_{2} ‘) ’ globaltype ‘) ’ \equiv ‘ (’ ‘ import ’ name_{1} name_{2} ‘ (’ ‘ global ’ id^{?} globaltype ‘) ’ ‘) ’ 1 e x] ‘ (’ ‘ export ’ name ‘ (’ ‘ global ’ id^{'} ‘) ’ ‘) ’ ‘ (’ ‘ global ’ id^{'} \dots ‘) ’ (if id^{?} \neq = ϵ \land id^{'} = id^{?} \lor id^{?} = ϵ \land id^{'} fresh) ‘ (’ ‘ global ’ id^{?} ‘ (’ ‘ export ’ name ‘) ’ \dots ‘) ’ \equiv

注意

如果“ $\dots$ ”包含额外的导出子句，则后一种缩写可以重复应用。因此，全局声明可以包含任意数量的导出，之后可以跟着一个导入。

6.6.9. 导出

导出的语法直接反映了它们的抽象语法。

export_{I} exportdesc_{I} ::= ::= ∣ ∣ ∣ ‘ (’ ‘ export ’ nm : name d : exportdesc_{I} ‘) ’ ‘ (’ ‘ func ’ x : funcidx_{I} ‘) ’ ‘ (’ ‘ table ’ x : tableidx_{I} ‘) ’ ‘ (’ ‘ memory ’ x : memidx_{I} ‘) ’ ‘ (’ ‘ global ’ x : globalidx_{I} ‘) ’ \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow {name nm, desc d} func x table x mem x global x

6.6.9.1. 缩写

作为缩写，导出也可以与函数、表格、内存或全局定义内联；请参见各自部分。

6.6.10. 开始函数

一个开始函数是根据其索引定义的。

start_{I} ::= ‘ (’ ‘ start ’ x : funcidx_{I} ‘) ’ \Rightarrow {func x}

注意

在模块中最多只能出现一个启动函数，这可以通过在 $module$ 语法上设置适当的辅助条件来确保。

6.6.11. 元素段

元素段允许使用可选的表格索引来标识要初始化的表格。

elem_{I} elemlist_{I} elemexpr_{I} tableuse_{I} ::= ∣ ::= ::= ::= ‘ (’ ‘ elem ’ id^{?} (e t, y^{*}) : elemlist_{I} ‘) ’ \Rightarrow {type e t, init y^{*}, mode passive} ‘ (’ ‘ elem ’ id^{?} x : tableuse_{I} ‘ (’ ‘ offset ’ e : expr_{I} ‘) ’ (e t, y^{*}) : elemlist_{I} ‘) ’ \Rightarrow {type e t, init y^{*}, mode active {table x, offset e}} ‘ (’ ‘ elem ’ id^{?} ‘ declare ’ (e t, y^{*}) : elemlist_{I} ‘) ’ \Rightarrow {type e t, init y^{*}, mode declarative} t : reftype y^{*} : vec (elemexpr_{I}) \Rightarrow (type t, init y^{*}) ‘ (’ ‘ item ’ e : expr_{I} ‘) ’ \Rightarrow e ‘ (’ ‘ table ’ x : tableidx_{I} ‘) ’ \Rightarrow x

6.6.11.1. 缩写

作为缩写，单个指令可以替代活动元素段的偏移量或作为元素表达式。

‘ (’ instr ‘) ’ ‘ (’ instr ‘) ’ \equiv \equiv ‘ (’ ‘ offset ’ instr ‘) ’ ‘ (’ ‘ item ’ instr ‘) ’

此外，元素列表可以写成一系列函数索引。

‘ func ’ vec (funcidx_{I}) \equiv ‘ funcref ’ vec (‘ (’ ‘ ref.func ’ funcidx_{I} ‘) ’)

表格使用可以省略，默认值为 $0$ 。此外，为了向后兼容 WebAssembly 的早期版本，如果省略了表格使用，则 $‘ func ’$ 关键字也可以省略。

ϵ ‘ (’ ‘ elem ’ id^{?} ‘ (’ ‘ offset ’ expr_{I} ‘) ’ vec (funcidx_{I}) ‘) ’ \equiv \equiv ‘ (’ ‘ table ’ ‘ 0 ’ ‘) ’ ‘ (’ ‘ elem ’ id^{?} ‘ (’ ‘ table ’ ‘ 0 ’ ‘) ’ ‘ (’ ‘ offset ’ expr_{I} ‘) ’ ‘ func ’ vec (funcidx_{I}) ‘) ’

作为另一种缩写形式，元素段也可以在表格定义中内联指定；请参阅相关部分。

6.6.12. 数据段

数据段允许使用可选的内存索引来标识要初始化的内存。数据以字符串形式写入，该字符串可以拆分为可能为空的单个字符串字面量的序列。

data_{I} datastring memuse_{I} ::= ∣ ::= ::= ‘ (’ ‘ data ’ id^{?} b^{*} : datastring ‘) ’ \Rightarrow {init b^{*}, mode passive} ‘ (’ ‘ data ’ id^{?} x : memuse_{I} ‘ (’ ‘ offset ’ e : expr_{I} ‘) ’ b^{*} : datastring ‘) ’ \Rightarrow {init b^{*}, mode active {memory x^{'}, offset e}} (b^{*} : string)^{*} \Rightarrow concat ((b^{*})^{*}) ‘ (’ ‘ memory ’ x : memidx_{I} ‘) ’ \Rightarrow x

注意

在当前版本的 WebAssembly 中，唯一有效的内存索引是 0 或解析为相同值的符号内存标识符。

6.6.12.1. 缩写

作为一种缩写，单个指令可以出现在活动数据段的偏移量位置。

‘ (’ instr ‘) ’ \equiv ‘ (’ ‘ offset ’ instr ‘) ’

此外，可以省略内存使用，默认值为 $0$ 。

ϵ \equiv ‘ (’ ‘ memory ’ ‘ 0 ’ ‘) ’

作为另一种缩写，数据段也可以与内存定义一起内联指定；请参阅相应的章节。

6.6.13. 模块

模块由一系列字段组成，这些字段可以按任何顺序出现。所有定义及其相应的绑定标识符作用域涵盖整个模块，包括它们之前的文本。

模块可以选择绑定一个标识符来命名模块。该名称仅起文档作用。

注意

工具可能会在名称段中包含模块名称二进制格式。

module ::= ‘ (’ ‘ module ’ id^{?} (m : modulefield_{I})^{*} ‘) ’ \Rightarrow ⨁ m^{*} (if I = ⨁ idc (modulefield)^{*} well-formed) 1 e x] modulefield_{I} ::= ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ty : type im : import_{I} fn : func_{I} ta : table_{I} me : mem_{I} gl : global_{I} ex : export_{I} st : start_{I} el : elem_{I} da : data_{I} \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow \Rightarrow {types ty} {imports im} {funcs fn} {tables ta} {mems me} {globals gl} {exports ex} {start st} {elems el} {datas da}

对模块的组成施加以下限制： $m_{1} \oplus m_{2}$ 当且仅当以下条件成立时定义：

$m_{1} . start = ϵ \lor m_{2} . start = ϵ$
$m_{1} . funcs = m_{1} . tables = m_{1} . mems = m_{1} . globals = ϵ \lor m_{2} . imports = ϵ$

注意

第一个条件确保最多只有一个启动函数。第二个条件强制所有导入必须出现在任何函数、表格、内存或全局的常规定义之前，从而保持相应索引空间的顺序。

良好格式条件 $I$ 在 $module$ 语法中确保没有命名空间包含重复标识符。

初始标识符上下文 $I$ 的定义使用以下辅助定义，该定义将每个相关定义映射到一个具有一个（可能是空的）标识符的单一上下文

idc (‘ (’ ‘ type ’ id^{?} ft : functype ‘) ’) idc (‘ (’ ‘ func ’ id^{?} \dots ‘) ’) idc (‘ (’ ‘ table ’ id^{?} \dots ‘) ’) idc (‘ (’ ‘ memory ’ id^{?} \dots ‘) ’) idc (‘ (’ ‘ global ’ id^{?} \dots ‘) ’) idc (‘ (’ ‘ elem ’ id^{?} \dots ‘) ’) idc (‘ (’ ‘ data ’ id^{?} \dots ‘) ’) idc (‘ (’ ‘ import ’ \dots ‘ (’ ‘ func ’ id^{?} \dots ‘) ’ ‘) ’) idc (‘ (’ ‘ import ’ \dots ‘ (’ ‘ table ’ id^{?} \dots ‘) ’ ‘) ’) idc (‘ (’ ‘ import ’ \dots ‘ (’ ‘ memory ’ id^{?} \dots ‘) ’ ‘) ’) idc (‘ (’ ‘ import ’ \dots ‘ (’ ‘ global ’ id^{?} \dots ‘) ’ ‘) ’) idc (‘ (’ \dots ‘) ’) = = = = = = = = = = = = {types (id^{?}), typedefs ft} {funcs (id^{?})} {tables (id^{?})} {mems (id^{?})} {globals (id^{?})} {elem (id^{?})} {data (id^{?})} {funcs (id^{?})} {tables (id^{?})} {mems (id^{?})} {globals (id^{?})} {}

6.6.13.1. 缩写

在源文件中，围绕模块主体的顶级 $(module \dots)$ 可以省略。

modulefield^{*} \equiv ‘ (’ ‘ module ’ modulefield^{*} ‘) ’

附录 A

A.1 嵌入

WebAssembly 实现通常会嵌入到宿主环境中。嵌入器实现宿主环境与本规范主体定义的 WebAssembly 语义之间的连接。预计嵌入器将以定义明确的方式与语义交互。

本节以嵌入器可以通过其访问 WebAssembly 语义的入口点的形式定义一个合适的接口。该接口旨在完整，这意味着嵌入器不需要直接引用 WebAssembly 规范的其他功能部分。

注意

另一方面，嵌入器不需要为宿主环境提供访问此接口中定义的所有功能。例如，实现可能不支持解析文本格式。

类型

在嵌入器接口的描述中，来自抽象语法和运行时抽象机的语法类用作变量的名称，这些变量范围涵盖该类中的所有可能对象。因此，这些语法类也可以解释为类型。

对于数字参数，使用类似于 $n : u32$ 的符号来指定符号名称，以及相应的取值范围。

错误

接口操作失败由辅助语法类指示

error ::= error

除了本节中明确指定的错误条件外，当达到特定的实现限制时，实现也可能返回错误。

注意

根据此定义，错误是抽象且不具体的。实现可以将其细化以携带合适的分类和诊断消息。

先决条件和后置条件

某些操作会声明其参数的先决条件或其结果的后置条件。满足先决条件是嵌入器的责任。如果满足，则语义将保证后置条件。

除了每个操作中明确说明的先决条件和后置条件之外，规范还采用了以下约定，用于运行时对象 ( $store$ , $moduleinst$ , $externval$ , 地址)

作为参数传递的每个运行时对象都必须根据隐式先决条件是有效的。
作为结果返回的每个运行时对象都必须根据隐式后置条件是有效的。

注意

只要嵌入器将运行时对象视为抽象，并且仅通过此处定义的接口创建和操作它们，所有隐式先决条件都会自动满足。

存储

$store_init () : store$

返回空存储。

store_init () = {funcs ϵ, mems ϵ, tables ϵ, globals ϵ}

模块

$module_decode (byte^{*}) : module ∣ error$

如果存在一个推导，根据模块的二进制语法，将字节序列 $byte^{*}$ 推导出一个模块 $m$ ，则返回 $m$ 。
否则，返回 $error$ .

module_decode (b^{*}) module_decode (b^{*}) = = m error (if module ⟹ * m : b^{*}) (otherwise)

$module_parse (char^{*}) : module ∣ error$

如果存在一个推导，根据源代码 $char^{*}$ 作为 $module$ ，根据模块的文本语法，推导出一个模块 $m$ ，则返回 $m$ 。
否则，返回 $error$ .

module_parse (c^{*}) module_parse (c^{*}) = = m error (if module ⟹ * m : c^{*}) (otherwise)

$module_validate (module) : error^{?}$

如果 $module$ 是有效的，则返回空值。
否则，返回 $error$ .

module_validate (m) module_validate (m) = = ϵ error (if ⊢ m : externtype^{*} \to externtype^{'}^{*}) (otherwise)

$module_instantiate (store, module, externval^{*}) : (store, moduleinst ∣ error)$

尝试实例化 $module$ 在 $store$ 中，并使用外部值 $externval^{*}$ 作为导入。

如果它成功地生成了一个模块实例 $moduleinst$ ，则将 $result$ 设置为 $moduleinst$ .

否则，将 $result$ 设置为 $error$ .

返回新的 store 和 $result$ 的组合。

module_instantiate (S, m, ev^{*}) module_instantiate (S, m, ev^{*}) = = (S^{'}, F . module) (S^{'}, error) (if instantiate (S, m, ev^{*}) ↪^{*} S^{'}; F; ϵ) (if instantiate (S, m, ev^{*}) ↪^{*} S^{'}; F; trap)

注意

即使在发生错误的情况下，存储也可能会被修改。

$module_imports (module) : (name, name, externtype)^{*}$

先决条件: $module$ 是有效的，其外部导入类型为 $externtype^{*}$ ，外部导出类型为 $externtype^{'}^{*}$ .
令 $import^{*}$ 为导入 $module . imports$ .
断言: $import^{*}$ 的长度等于 $externtype^{*}$ .
对于每个 $import_{i}$ 在 $import^{*}$ 中以及相应的 $externtype_{i}$ 在 $externtype^{*}$ 中，执行以下操作：

令 $result_{i}$ 为三元组 $(import_{i} . module, import_{i} . name, externtype_{i})$ .

返回所有 $result_{i}$ 的连接，按索引顺序。
后置条件：每个 $externtype_{i}$ 是有效的.

module_imports (m) = (im . module, im . name, externtype)^{*} (if im^{*} = m . imports \land ⊢ m : externtype^{*} \to externtype^{'}^{*})

$module_exports (module) : (name, externtype)^{*}$

先决条件: $module$ 是有效的，其外部导入类型为 $externtype^{*}$ ，外部导出类型为 $externtype^{'}^{*}$ .
令 $export^{*}$ 为导出 $module . exports$ .
断言： $export^{*}$ 的长度等于 $externtype^{'}^{*}$ 的长度。
对于 $export_{i}$ 中的每个 $export^{*}$ 以及 $externtype_{i}^{'}$ 中对应的 $externtype^{'}^{*}$ ，进行以下操作：

令 $result_{i}$ 为一对 $(export_{i} . name, externtype_{i}^{'})$ .

返回所有 $result_{i}$ 的连接，按索引顺序。
后置条件：每个 $externtype_{i}^{'}$ 都是有效的。

module_exports (m) = (ex . name, externtype^{'})^{*} (if ex^{*} = m . exports \land ⊢ m : externtype^{*} \to externtype^{'}^{*})

模块实例

$instance_export (moduleinst, name) : externval ∣ error$

断言：由于模块实例 $moduleinst$ 的有效性，所有其导出名称都是不同的。
如果在 $exportinst_{i}$ 中存在一个 $moduleinst . exports$ ，使得 name $exportinst_{i} . name$ 等于 $name$ ，那么
1. 返回外部值 $exportinst_{i} . value$ .
否则，返回 $error$ .

instance_export (m, name) instance_export (m, name) = = m . exports [i] . value error (如果 m . exports [i] . name = name) (否则)

函数

$func_alloc (store, functype, hostfunc) : (store, funcaddr)$

前提条件： $functype$ 是有效的.
令 $funcaddr$ 为在 $store$ 中使用函数类型 $functype$ 和主机函数代码 $hostfunc$ 分配主机函数的结果。
返回与 $funcaddr$ 配对的新存储。

func_alloc (S, ft, code) = (S^{'}, a) (if allochostfunc (S, ft, code) = S^{'}, a)

注意

此操作假设 $hostfunc$ 满足预置和后置条件，这些条件是类型为 $functype$ 的函数实例所需的。

常规（非主机）函数实例只能通过模块实例化间接创建。

$func_type (store, funcaddr) : functype$

返回 $S. funcs [a] . type$ .
后置条件：返回的函数类型是有效的。

func_type (S, a) = S . funcs [a] . type

$func_invoke (store, funcaddr, val^{}) : (store, val^{} ∣ error)$

尝试调用函数 $funcaddr$ 在 $store$ 中，使用值 $val^{*}$ 作为参数。

如果它成功地使用值 $val^{'}^{*}$ 作为结果，则让 $result$ 为 $val^{'}^{*}$ .

否则它已捕获，因此让 $result$ 为 $error$ .

返回新的 store 和 $result$ 的组合。

func_invoke (S, a, v^{*}) func_invoke (S, a, v^{*}) = = (S^{'}, v^{'}^{*}) (S^{'}, error) (if invoke (S, a, v^{*}) ↪^{*} S^{'}; F; v^{'}^{*}) (if invoke (S, a, v^{*}) ↪^{*} S^{'}; F; trap)

注意

即使在发生错误的情况下，存储也可能会被修改。

表

$table_alloc (store, tabletype, ref) : (store, tableaddr)$

前提条件： $tabletype$ 有效。
令 $tableaddr$ 为在 $store$ 中分配一个类型为 $tabletype$ 的表的结果，并初始化值为 $ref$ .
返回与 $tableaddr$ 配对的新存储。

table_alloc (S, tt, r) = (S^{'}, a) (if alloctable (S, tt, r) = S^{'}, a)

$table_type (store, tableaddr) : tabletype$

返回 $S. tables [a] . type$ .
后置条件：返回的表格类型是有效的.

table_type (S, a) = S . tables [a] . type

$table_read (store, tableaddr, i : u32) : ref ∣ error$

令 $ti$ 为表格实例 $store . tables [tableaddr]$ .
如果 $i$ 大于或等于 $ti . elem$ 的长度，则返回 $error$ .
否则，返回引用值 $ti . elem [i]$ .

table_read (S, a, i) table_read (S, a, i) = = r error (if S . tables [a] . elem [i] = r) (otherwise)

$table_write (store, tableaddr, i : u32, ref) : store ∣ error$

令 $ti$ 为表格实例 $store . tables [tableaddr]$ .
如果 $i$ 大于或等于 $ti . elem$ 的长度，则返回 $error$ .
将 $ti . elem [i]$ 替换为引用值 $ref$ .
返回更新后的存储。

table_write (S, a, i, r) table_write (S, a, i, r) = = S^{'} error (if S^{'} = S with tables [a] . elem [i] = r) (otherwise)

$table_size (store, tableaddr) : u32$

返回 $store . tables [tableaddr] . elem$ 的长度。

table_size (S, a) = n (if ∣ S . tables [a] . elem ∣ = n)

$table_grow (store, tableaddr, n : u32, ref) : store ∣ error$

尝试扩展表格实例 $store . tables [tableaddr]$ ，扩展 $n$ 个元素，初始化值为 $ref$
1. 如果成功，返回更新后的存储区。
2. 否则，返回 $error$ .

table_grow (S, a, n, r) table_grow (S, a, n, r) = = S^{'} error (if S^{'} = S with tables [a] = growtable (S . tables [a], n, r)) (otherwise)

内存

$mem_alloc (store, memtype) : (store, memaddr)$

先决条件： $memtype$ 是有效的。
设 $memaddr$ 为在 $store$ 中分配内存的结果，内存类型为 $memtype$ .
返回与 $memaddr$ 配对的新存储。

mem_alloc (S, mt) = (S^{'}, a) (if allocmem (S, mt) = S^{'}, a)

$mem_type (store, memaddr) : memtype$

返回 $S. mems [a] . type$ .
后置条件：返回的内存类型是有效的.

mem_type (S, a) = S . mems [a] . type

$mem_read (store, memaddr, i : u32) : byte ∣ error$

设 $mi$ 为内存实例 $store . mems [memaddr]$ .
如果 $i$ 大于或等于 $mi . data$ 的长度，则返回 $error$ .
否则，返回字节 $mi . data [i]$ .

mem_read (S, a, i) mem_read (S, a, i) = = b error (if S . mems [a] . data [i] = b) (otherwise)

$mem_write (store, memaddr, i : u32, byte) : store ∣ error$

设 $mi$ 为内存实例 $store . mems [memaddr]$ .
如果 $u32$ 大于或等于 $mi . data$ 的长度，则返回 $error$ .
用 $byte$ 替换 $mi . data [i]$ .
返回更新后的存储。

mem_write (S, a, i, b) mem_write (S, a, i, b) = = S^{'} error (if S^{'} = S with mems [a] . data [i] = b) (otherwise)

$mem_size (store, memaddr) : u32$

返回 $store . mems [memaddr] . data$ 的长度除以页大小.

mem_size (S, a) = n (if ∣ S . mems [a] . data ∣ = n \cdot 64 Ki)

$mem_grow (store, memaddr, n : u32) : store ∣ error$

尝试增长内存实例 $store . mems [memaddr]$ $n$ 页
1. 如果成功，返回更新后的存储区。
2. 否则，返回 $error$ .

mem_grow (S, a, n) mem_grow (S, a, n) = = S^{'} error (if S^{'} = S with mems [a] = growmem (S . mems [a], n)) (otherwise)

全局变量

$global_alloc (store, globaltype, val) : (store, globaladdr)$

前提条件: $globaltype$ 是有效的.
令 $globaladdr$ 为在 $store$ 中分配全局变量的结果，使用全局变量类型 $globaltype$ 和初始化值 $val$ .
返回与 $globaladdr$ 配对的新存储。

global_alloc (S, gt, v) = (S^{'}, a) (if allocglobal (S, gt, v) = S^{'}, a)

$global_type (store, globaladdr) : globaltype$

返回 $S. globals [a] . type$ .
后置条件：返回的全局类型是有效的.

global_type (S, a) = S . globals [a] . type

$global_read (store, globaladdr) : val$

令 $gi$ 为全局实例 $store . globals [globaladdr]$ .
返回值 $gi . value$ .

global_read (S, a) = v (if S . globals [a] . value = v)

$global_write (store, globaladdr, val) : store ∣ error$

令 $gi$ 为全局实例 $store . globals [globaladdr]$ .
令 $mut t$ 为全局类型 $gi . type$ 的结构。
如果 $mut$ 不是 $var$ , 则返回 $error$ .
用值 $val$ 替换 $gi . value$ .
返回更新后的存储。

global_write (S, a, v) global_write (S, a, v) = = S^{'} error (if S . globals [a] . type = var t \land S^{'} = S with globals [a] . value = v) (otherwise)

A.2 实现限制

实现通常会对 WebAssembly 模块或执行的多个方面施加额外的限制。这些限制可能源于

物理资源限制，
嵌入器或其环境施加的约束，
所选实现策略的限制。

本节列出了允许的限制。如果限制采用数值限制的形式，则不会给出最小要求，也不会假设限制是具体的、固定的数字。但是，预计所有实现都具有“合理”的较大限制，以使常见应用程序能够正常运行。

注意

符合标准的实现不允许省略单个特性。但是，将来可能会指定 WebAssembly 的指定子集。

语法限制

结构

实现可能会对模块的以下维度施加限制

类型在模块中的数量
函数在模块中的数量，包括导入
表在模块中的数量，包括导入
内存在模块中的数量，包括导入
全局变量在模块中的数量，包括导入
元素段在模块中的数量
数据段在模块中的数量
导入到模块中的数量
导出从模块中的数量
函数类型中的参数数量
函数类型中的结果数量
块类型中的参数数量
块类型中的结果数量
局部变量在函数中的数量
函数体的大小
结构化控制指令的大小
结构化控制指令在函数中的数量
结构化控制指令的嵌套深度
标签索引在 $br_table$ 指令中的数量
元素段的长度
数据段的长度
名称的长度
字符在名称中的范围

如果实现的限制对于给定的模块被超过，则实现可能会拒绝验证、编译或实例化该模块，并返回嵌入器特定的错误。

注意

最后一个项目允许在没有 [UNICODE] 支持的有限环境中运行的嵌入器将导入和导出的名称限制为常见的子集，例如 ASCII。

二进制格式

对于以二进制格式给出的模块，可能会对以下维度施加额外的限制

模块的大小
任何节的大小
单个函数的代码的大小
节的数量

文本格式

对于以文本格式给出的模块，可能会对以下维度施加额外的限制

源文本的大小
任何语法元素的大小
单个标记的大小
折叠指令的嵌套深度
符号标识符的长度
源文本中允许的文字字符的范围

验证

实现可以延迟对单个函数的验证，直到它们第一次被调用。

如果一个函数被发现无效，那么调用以及对同一个函数的每次连续调用都会导致陷阱。

注意

这是为了允许实现对函数使用解释或即时编译。在执行函数体之前，函数必须完全验证。

执行

在执行 WebAssembly 程序时，可能会对以下维度施加限制

已分配的模块实例的数量
已分配的函数实例的数量
已分配的表格实例的数量
已分配的内存实例的数量
已分配的全局实例的数量
表格实例的大小
内存实例的大小
堆栈上的帧的数量
堆栈上的标签的数量
堆栈上的值的数量

如果在执行计算过程中超过了实现的运行时限制，那么它可能会终止该计算，并向调用代码报告嵌入器特定的错误。

以上某些限制可能已在实例化期间得到验证，在这种情况下，实现可能会以与语法限制相同的方式报告超出限制。

注意

具体的限制通常不是固定的，但可能取决于细节，相互依赖，随时间变化，或取决于其他实现或嵌入器特定的情况或事件。

A.3 验证算法

WebAssembly 验证的规范纯粹是声明式的。它描述了模块或指令序列必须满足的约束才能有效。

本节概述了有效验证代码（即指令序列）的算法的框架。（验证的其他方面很容易实现。）

事实上，该算法是在二进制格式中出现的操作码的扁平序列上表达的，并且只对其进行单次遍历。因此，它可以直接集成到解码器中。

该算法是用类型化伪代码表达的，其语义旨在不言自明。

数据结构

类型可以表示为枚举。

type val_type = I32 | I64 | F32 | F64 | V128 | Funcref | Externref
func is_num(t : val_type | Unknown) : bool =
  return t = I32 || t = I64 || t = F32 || t = F64 || t = Unknown

func is_vec(t : val_type | Unknown) : bool =
  return t = V128 || t = Unknown

func is_ref(t : val_type | Unknown) : bool =
  return t = Funcref || t = Externref || t = Unknown

         

该算法使用两个独立的堆栈：值堆栈和控制堆栈。前者跟踪堆栈上操作数值的类型，后者围绕结构化控制指令及其相关的块。

type val_stack = stack(val_type | Unknown)
type ctrl_stack = stack(ctrl_frame)
type ctrl_frame = {
  opcode : opcode
  start_types : list(val_type)
  end_types : list(val_type)
  height : nat
  unreachable : bool
}

         

对于每个值，值堆栈记录其值类型，或者当类型未知时记录 Unknown。

对于每个进入的块，控制堆栈记录一个控制帧，其中包含源操作码、块开始和结束时操作数堆栈顶部的类型（用于检查其结果以及分支）、块开始时操作数堆栈的高度（用于检查操作数是否未达到当前块的底部）、以及记录块的剩余部分是否不可到达的标志（用于处理分支后的堆栈多态类型）。

为了展示算法，操作数堆栈和控制堆栈只是作为全局变量维护的

var vals : val_stackvar ctrls : ctrl_stack

         

但是，这些变量不是由主检查函数直接操作的，而是通过一组辅助函数操作的

func push_val(type : val_type | Unknown) =  vals.push(type)

func pop_val() : val_type | Unknown =
  if (vals.size() = ctrls[0].height && ctrls[0].unreachable) return Unknown
  error_if(vals.size() = ctrls[0].height)
  return vals.pop()

func pop_val(expect : val_type | Unknown) : val_type | Unknown =
  let actual = pop_val()
  error_if(actual =/= expect && actual =/= Unknown && expect =/= Unknown)
  return actual

func push_vals(types : list(val_type)) = foreach (t in types) push_val(t)
func pop_vals(types : list(val_type)) : list(val_type) =
  var popped := []
  foreach (t in reverse(types)) popped.prepend(pop_val(t))
  return popped

         

推送一个操作数值只是将相应的类型推送到值堆栈。

弹出操作数值会检查值堆栈是否未达到当前块的底部，然后删除一个类型。但首先，会处理一个特殊情况，即块不包含任何已知值，但已被标记为不可到达。这可能在无条件分支后发生，当堆栈以多态的方式进行类型化时。在这种情况下，将返回未知类型。

另一个弹出操作数值的函数接受一个预期类型，将实际操作数类型与之进行检查。如果其中一个类型是 Unknown，那么类型可能会不同。该函数返回从堆栈中弹出的实际类型。

最后，还有一些累积函数用于推送或弹出多个操作数类型。

注意

符号 stack[i] 表示从顶部索引堆栈，例如，ctrls[0] 访问最后推送的元素。

控制堆栈也通过辅助函数进行操作

func push_ctrl(opcode : opcode, in : list(val_type), out : list(val_type)) =  let frame = ctrl_frame(opcode, in, out, vals.size(), false)
  ctrls.push(frame)
  push_vals(in)

func pop_ctrl() : ctrl_frame =
  error_if(ctrls.is_empty())
  let frame = ctrls[0]
  pop_vals(frame.end_types)
  error_if(vals.size() =/= frame.height)
  ctrls.pop()
  return frame

func label_types(frame : ctrl_frame) : list(val_types) =
  return (if frame.opcode == loop then frame.start_types else frame.end_types)

func unreachable() =
  vals.resize(ctrls[0].height)
  ctrls[0].unreachable := true

         

推送控制帧会获取标签和结果值的类型。它分配一个新的帧记录来记录它们以及操作数堆栈的当前高度，并标记该块为可到达。

弹出帧首先检查控制堆栈是否为空。然后，它会验证操作数堆栈是否包含在退出块结束时预期的正确类型的值，并将它们从操作数堆栈中弹出。之后，它会检查堆栈是否缩回其初始高度。

与控制帧关联的标签的类型是帧开始或结束时堆栈的类型，由它起源的操作码决定。

最后，可以将当前帧标记为不可到达。在这种情况下，所有现有的操作数类型都会从值堆栈中清除，以便在 pop_val 中的堆栈多态逻辑生效。由于每个函数都有一个隐式最外层标签，对应于一个隐式块帧，因此验证算法的一个不变式是在验证指令时控制堆栈上始终至少存在一个帧，因此，ctrls[0] 始终定义。

注意

即使设置了不可到达标志，连续的操作数仍会被推送到操作数堆栈和从操作数堆栈中弹出。这是为了检测无效的示例，例如 $(unreachable (i32 . const) i64 . add)$ . 但是，多态堆栈不能出现下溢，而是根据需要生成 Unknown 类型。

操作码序列的验证

以下函数展示了对操作堆栈的几个代表性指令的验证。其他指令以类似的方式进行检查。

注意

此处未显示的各种指令还需要验证上下文来检查索引的使用情况。这是一个简单的添加，因此在本次展示中省略了。

func validate(opcode) =switch (opcode)
  case (i32.add)
    pop_val(I32)
    pop_val(I32)
    push_val(I32)

  case (drop)
    pop_val()

  case (select)
    pop_val(I32)
    let t1 = pop_val()
    let t2 = pop_val()
    error_if(not ((is_num(t1) && is_num(t2)) || (is_vec(t1) && is_vec(t2))))
    error_if(t1 =/= t2 && t1 =/= Unknown && t2 =/= Unknown)
    push_val(if (t1 = Unknown) t2 else t1)

  case (select t)
    pop_val(I32)
    pop_val(t)
    pop_val(t)
    push_val(t)

  case (unreachable)
    unreachable()

  case (block t1*->t2*)
    pop_vals([t1*])
    push_ctrl(block, [t1*], [t2*])

  case (loop t1*->t2*)
    pop_vals([t1*])
    push_ctrl(loop, [t1*], [t2*])

  case (if t1*->t2*)
    pop_val(I32)
    pop_vals([t1*])
    push_ctrl(if, [t1*], [t2*])

  case (end)
    let frame = pop_ctrl()
    push_vals(frame.end_types)

  case (else)
    let frame = pop_ctrl()
    error_if(frame.opcode =/= if)
    push_ctrl(else, frame.start_types, frame.end_types)

  case (br n)
    error_if(ctrls.size() < n)
    pop_vals(label_types(ctrls[n]))
    unreachable()

  case (br_if n)
    error_if(ctrls.size() < n)
    pop_val(I32)
    pop_vals(label_types(ctrls[n]))
    push_vals(label_types(ctrls[n]))

  case (br_table n* m)
    pop_val(I32)
    error_if(ctrls.size() < m)
    let arity = label_types(ctrls[m]).size()
    foreach (n in n*)
      error_if(ctrls.size() < n)
      error_if(label_types(ctrls[n]).size() =/= arity)
      push_vals(pop_vals(label_types(ctrls[n])))
    pop_vals(label_types(ctrls[m]))
    unreachable()

         

注意

在当前 WebAssembly 指令集中，Unknown 类型的操作数永远不会在堆栈上被复制。如果该语言扩展了类似 dup 的堆栈指令，这种情况将会改变。在这样的扩展下，上述算法需要通过用适当的 *类型变量* 替换 Unknown 类型来进行细化，以确保所有使用都是一致的。

A.4 自定义节

本附录定义了 WebAssembly 的二进制格式中的专用自定义节。这些节不会影响或改变 WebAssembly 语义，并且像任何自定义节一样，它们可以被实现忽略。但是，它们提供有用的元数据，实现可以使用这些元数据来改善用户体验或获取编译提示。

目前，只定义了一个专用自定义节，即名称节。

名称节

名称节 是一个自定义节，其名称字符串本身为 $‘ name ’$ . 名称节在模块中应该只出现一次，并且应该出现在数据节之后。

本节的目的是将可打印的名称附加到模块中的定义，例如，调试器或模块的某些部分需要以文本形式呈现时可以使用这些名称。

注意

所有名称都以 [UNICODE] 编码为 UTF-8 表示。名称不需要唯一。

子节

名称节的数据由一系列 *子节* 组成。每个子节包含：

一个字节的子节 *标识符*，
以字节为单位的内容的 $u32$ 大小，
实际的 *内容*，其结构取决于子节标识符。

namesec namedata namesubsection_{N} (B) ::= ::= ::= section_{0} (namedata) n : name modulenamesubsec^{?} funcnamesubsec^{?} localnamesubsec^{?} N : byte size : u 32 B (if n = ‘ name ’) (if size = ∣∣ B ∣∣)

使用以下子节标识符：

ID	子节
0	模块名称
1	函数名称
2	本地名称

每个子节最多只能出现一次，并且按标识符递增的顺序排列。

名称映射

名称映射 将名称映射到给定索引空间中的索引。它由一个向量组成，其中包含按索引值递增顺序排列的索引/名称对。每个索引必须是唯一的，但分配的名称不需要唯一。

namemap nameassoc ::= ::= vec (nameassoc) idx name

间接名称映射将名称分配给二维的索引空间，其中次级索引按主索引进行分组。它包含按升序索引值的向量形式的主索引/名称映射对，其中每个名称映射又将次级索引映射到名称。每个主索引必须是唯一的，同样每个次级索引对于单个名称映射也是唯一的。

indirectnamemap indirectnameassoc ::= ::= vec (indirectnameassoc) idx namemap

模块名称

模块名称小节的 ID 为 0。它仅仅包含单个分配给模块本身的名称。

modulenamesubsec ::= namesubsection_{0} (name)

函数名称

函数名称小节的 ID 为 1。它包含将函数名称分配给函数索引的名称映射。

funcnamesubsec ::= namesubsection_{1} (namemap)

局部名称

局部名称小节的 ID 为 2。它包含将局部名称分配给按函数索引分组的局部索引的间接名称映射。

localnamesubsec ::= namesubsection_{2} (indirectnamemap)

A.5 健壮性

WebAssembly 的类型系统是健壮的，这意味着它在 WebAssembly 语义方面既是类型安全的，又是内存安全的。例如

在运行时，验证期间声明和推导的所有类型都将被遵守；例如，每个局部或全局变量将只包含类型正确的取值，每个指令只应用于预期类型的操作数，以及每个函数调用始终计算为正确类型的结果（如果它不会陷入或发散）。
除了由程序明确定义的内存位置外，不会读取或写入任何内存位置，即作为局部变量、全局变量、表格中的元素，或线性内存中的位置。
不存在未定义行为，即执行规则涵盖了有效程序中可能出现的各种情况，且这些规则相互一致。

健全性也有助于确保其他属性，最值得注意的是函数和模块作用域的封装：任何局部变量都无法在其自身函数之外访问，任何模块组件都无法在其自身模块之外访问，除非它们被明确地导出或导入。

定义 WebAssembly 验证的类型规则仅涵盖 WebAssembly 程序的静态组件。为了准确地陈述和证明健全性，类型规则必须扩展到抽象运行时的动态组件，即存储、配置和管理指令。[1]

结果

结果可以通过结果类型进行如下分类。

结果 $val^{*}$

对于每个值 $val_{i}$ 在 $val^{*}$
- 值 $val_{i}$ 是有效的，并具有某些值类型 $t_{i}$ .
设 $t^{*}$ 是所有 $t_{i}$ 的连接。
则结果对于结果类型 $[t^{*}]$ 是有效的。

\frac{( S ⊢ val : t ) ^{*}}{S ⊢ val ^{*} : [ t ^{*} ]}

结果 $trap$

结果对于结果类型 $[t^{*}]$ 是有效的，对于任何值类型序列 $t^{*}$ 而言。

S ⊢ trap : [ t ^{*} ]

存储有效性

以下键入规则指定了运行时存储 $S$ 何时为有效。有效存储必须包含相对于 $S$ 本身有效的函数、表格、内存、全局和模块实例。

为此，每种实例都由相应的函数、表格、内存或全局类型分类。模块实例由模块上下文分类，它们是将常规上下文重新用作模块类型，用于描述模块定义的索引空间。

存储 $S$

每个函数实例 $funcinst_{i}$ 在 $S. funcs$ 中必须与某个函数类型 $functype_{i}$ 有效。
每个表格实例 $tableinst_{i}$ 在 $S. tables$ 中必须与某个表格类型 $tabletype_{i}$ 有效。
每个内存实例 $meminst_{i}$ 在 $S. mems$ 中必须与某个内存类型 $memtype_{i}$ 有效。
每个全局实例 $globalinst_{i}$ 在 $S. globals$ 中必须与某个全局类型 $globaltype_{i}$ 有效。
每个元素实例 $eleminst_{i}$ 在 $S. elems$ 中必须与某个引用类型 $reftype_{i}$ 有效。
每个数据实例 $datainst_{i}$ 在 $S. datas$ 中必须有效。
那么该存储就是有效的。

\frac{( S ⊢ funcinst : functype ) ^{*} ( S ⊢ tableinst : tabletype ) ^{*} ( S ⊢ meminst : memtype ) ^{*} ( S ⊢ globalinst : globaltype ) ^{*} ( S ⊢ eleminst : reftype ) ^{*} ( S ⊢ datainst ok ) ^{*} S = { funcs funcinst ^{*} , tables tableinst ^{*} , mems meminst ^{*} , globals globalinst ^{*} , elems eleminst ^{*} , datas datainst ^{*} }}{⊢ S ok}

函数实例 ${type functype, module moduleinst, code func}$

该函数类型 $functype$ 必须是有效的。
该模块实例 $moduleinst$ 必须在某些上下文 $C$ 下是有效的。
在上下文 $C$ 下，该函数 $func$ 必须是有效的，并具有函数类型 $functype$ .
那么函数实例是有效的，具有函数类型 $functype$ .

\frac{⊢ functype ok S ⊢ moduleinst : C C ⊢ func : functype}{S ⊢ { type functype , module moduleinst , code func } : functype}

宿主函数实例 ${type functype, hostcode hf}$

该函数类型 $functype$ 必须是有效的。
令 $[t_{1}^{*}] \to [t_{2}^{*}]$ 是函数类型 $functype$ .
对于每个有效存储 $S_{1}$ 扩展 $S$ 和每个类型与 $t_{1}^{*}$ 一致的值序列 $val^{*}$
- 执行 $hf$ 在存储 $S_{1}$ 中，并使用参数 $val^{*}$ ，将产生一个非空的可能结果集。
- 对于这个集合中的每个元素 $R$
  - 要么 $⊥$ （即，发散）。
  - 要么 $R$ 由一个有效存储 $S_{2}$ 扩展 $S_{1}$ 和一个类型与 $[t_{2}^{*}]$ 一致的结果 $result$ 组成。
那么函数实例是有效的，具有函数类型 $functype$ .

\frac{⊢ [ t _{1}^{*} ] \to [ t _{2}^{*} ] ok \forall S _{1} , val ^{*} , ⊢ S _{1} ok \land ⊢ S ⪯ S _{1} \land S _{1} ⊢ val ^{*} : [ t _{1}^{*} ] ⟹ hf ( S _{1} ; val ^{*} ) \supset \emptyset \land \forall R \in hf ( S _{1} ; val ^{*} ) , R = ⊥ \lor \exists S _{2} , result , ⊢ S _{2} ok \land ⊢ S _{1} ⪯ S _{2} \land S _{2} ⊢ result : [ t _{2}^{*} ] \land R = ( S _{2} ; result )}{S ⊢ { type [ t _{1}^{*} ] \to [ t _{2}^{*} ] , hostcode hf } : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}

注意

这条规则表明，如果满足关于存储和参数的适当先决条件，那么执行宿主函数必须满足关于存储和结果的适当后置条件。这些后置条件与在执行规则中调用宿主函数的后置条件相匹配。

任何函数被调用的存储都被假定为当前存储的扩展。这样，函数本身就能够对未来存储做出足够的假设。

表实例 ${type (limits t), elem ref^{*}}$

该表类型 $limits t$ 必须是有效的。
该 $ref^{*}$ 的长度必须等于 $limits . min$ .
对于表元素中的每个引用 $ref_{i}$
- 该引用 $ref_{i}$ 必须是有效的，且其引用类型为 $t$ .
那么该表实例是有效的，且其表类型为 $limits t$ .

\frac{⊢ limits t ok n = limits . min ( S ⊢ ref : t ) ^{n}}{S ⊢ { type ( limits t ) , elem ref ^{n} } : limits t}

内存实例 ${type limits, data b^{*}}$

该内存类型 $limits$ 必须是有效的。
该 $b^{*}$ 的长度必须等于 $limits . min$ 乘以页面大小 $64 Ki$ .
那么该内存实例是有效的，且其内存类型为 $limits$ .

\frac{⊢ limits ok n = limits . min \cdot 64 Ki}{S ⊢ { type limits , data b ^{n} } : limits}

全局实例 ${type (mut t), value val}$

The global type $mut t$ must be valid.
该值 $val$ 必须是有效的，并且其值类型为 $t$ .
然后，该全局实例将成为全局类型 $mut t$ 的有效全局实例。

\frac{⊢ mut t ok S ⊢ val : t}{S ⊢ { type ( mut t ) , value val } : mut t}

元素实例 ${type t, elem ref^{*}}$

对于元素中的每个引用 $ref^{i}$
- 该引用 $ref_{i}$ 必须是有效的，且其引用类型为 $t$ .
然后，该元素实例将成为引用类型 $t$ 的有效元素实例。

\frac{( S ⊢ ref : t ) ^{*}}{S ⊢ { type t , elem ref ^{*} } : t}

数据实例 ${data b^{*}}$

该数据实例是有效的。

S ⊢ { data b ^{*} } ok

导出实例 ${name name, value externval}$

该外部值 $externval$ 必须是有效的，并且其外部类型为 $externtype$ .
然后，该导出实例将成为有效的导出实例。

\frac{S ⊢ externval : externtype}{S ⊢ { name name , value externval } ok}

模块实例 $moduleinst$

每个函数类型 $functype_{i}$ 在 $moduleinst . types$ 中必须是有效的。
对于每个函数地址 $funcaddr_{i}$ 在 $moduleinst . funcaddrs$ , 外部值 $func funcaddr_{i}$ 必须是有效的, 并具有某种外部类型 $func functype_{i}^{'}$ .
对于每个表格地址 $tableaddr_{i}$ 在 $moduleinst . tableaddrs$ , 外部值 $table tableaddr_{i}$ 必须是有效的, 并具有某种外部类型 $table tabletype_{i}$ .
对于每个内存地址 $memaddr_{i}$ 在 $moduleinst . memaddrs$ , 外部值 $mem memaddr_{i}$ 必须是有效的, 并具有某种外部类型 $mem memtype_{i}$ .
对于每个全局地址 $globaladdr_{i}$ in $moduleinst . globaladdrs$ , 外部值 $global globaladdr_{i}$ 必须与某个外部类型 $global globaltype_{i}$ 有效。
对于每个元素地址 $elemaddr_{i}$ in $moduleinst . elemaddrs$ , 元素实例 $S. elems [elemaddr_{i}]$ 必须与某个引用类型 $reftype_{i}$ 有效。
对于每个数据地址 $dataaddr_{i}$ in $moduleinst . dataaddrs$ , 数据实例 $S. datas [dataaddr_{i}]$ 必须有效。
每个导出实例 $exportinst_{i}$ in $moduleinst . exports$ 必须有效。
对于每个导出实例 $exportinst_{i}$ in $moduleinst . exports$ , 名称 $exportinst_{i} . name$ 必须与 $moduleinst . exports$ 中出现的任何其他名称不同。
设 $functype^{'}^{*}$ 为所有 $functype_{i}^{'}$ 的串联，按顺序排列。
令 $tabletype^{*}$ 为所有 $tabletype_{i}$ 按顺序连接的结果。
令 $memtype^{*}$ 为所有 $memtype_{i}$ 按顺序连接的结果。
令 $globaltype^{*}$ 为所有 $globaltype_{i}$ 按顺序连接的结果。
令 $reftype^{*}$ 为所有 $reftype_{i}$ 按顺序连接的结果。
令 $m$ 为 $moduleinst . funcaddrs$ 的长度。
令 $n$ 为 $moduleinst . dataaddrs$ 的长度。
令 $x^{*}$ 为从 $0$ 到 $m - 1$ 的函数索引序列。
那么，模块实例在上下文 ${types functype^{*},$ $funcs functype^{'}^{*},$ $tables tabletype^{*},$ $mems memtype^{*},$ $globals globaltype^{*},$ $elems reftype^{*},$ $datas ok^{n},$ $refs x^{*}}$ 中是有效的。

\frac{( ⊢ functype ok ) ^{*} ( S ⊢ func funcaddr : func functype ^{'} ) ^{*} ( S ⊢ table tableaddr : table tabletype ) ^{*} ( S ⊢ mem memaddr : mem memtype ) ^{*} ( S ⊢ global globaladdr : global globaltype ) ^{*} ( S ⊢ S . elems [ elemaddr ] : reftype ) ^{*} ( S ⊢ S . datas [ dataaddr ] ok ) ^{n} ( S ⊢ exportinst ok ) ^{*} ( exportinst . name ) ^{*} disjoint}{S ⊢ { types funcaddrs tableaddrs memaddrs globaladdrs elemaddrs dataaddrs exports functype ^{*} , funcaddr ^{*} , tableaddr ^{*} , memaddr ^{*} , globaladdr ^{*} , elemaddr ^{*} , dataaddr ^{n} , exportinst ^{*} } : { types funcs tables mems globals elems datas refs functype ^{*} , functype ^{'} ^{*} , tabletype ^{*} , memtype ^{*} , globaltype ^{*} , reftype ^{*} , ok ^{n} , 0 \dots ( ∣ funcaddr ^{*} ∣ - 1 ) }}

配置有效性

为了将 WebAssembly 的类型系统与其执行语义联系起来，必须将指令的类型规则扩展到配置 $S; T$ , 它将存储与执行线程相关联。

配置和线程按其结果类型进行分类。除了存储 $S$ 外，线程还根据返回类型 $resulttype^{?}$ 进行类型化，该类型控制是否以及用哪种类型允许 $return$ 指令。除了管理 $frame$ 指令中的指令序列之外，此类型不存在( $ϵ$ )。

最后，帧通过帧上下文进行分类，帧上下文扩展了帧关联的模块上下文的模块实例，包括帧包含的局部变量。

配置 $S; T$

存储 $S$ 必须有效。
在不允许的返回类型下，线程 $T$ 必须有效，并且具有某些结果类型 $[t^{*}]$ .
那么，该配置使用结果类型 $[t^{*}]$ 是有效的。

\frac{⊢ S ok S ; ϵ ⊢ T : [ t ^{*} ]}{⊢ S ; T : [ t ^{*} ]}

线程 $F; instr^{*}$

设 $resulttype^{?}$ 为当前允许的返回类型。
帧 $F$ 必须有效，并具有上下文 $C$ 。
设 $C^{'}$ 与 $C$ 相同，但将 $return$ 设置为 $resulttype^{?}$ .
在上下文 $C^{'}$ 下，指令序列 $instr^{*}$ 必须有效，并具有某些类型 $[] \to [t^{*}]$ .
那么，该线程使用结果类型 $[t^{*}]$ 是有效的。

\frac{S ⊢ F : C S ; C , return resulttype ^{?} ⊢ instr ^{*} : [ ] \to [ t ^{*} ]}{S ; resulttype ^{?} ⊢ F ; instr ^{*} : [ t ^{*} ]}

Frames ${locals val^{*}, module moduleinst}$

模块实例 $moduleinst$ 必须是有效的，且具有某个模块上下文 $C$ .
每个值 $val_{i}$ 在 $val^{*}$ 中必须是有效的，且具有某个值类型 $t_{i}$ .
令 $t^{*}$ 为所有 $t_{i}$ 的按顺序连接。
令 $C^{'}$ 与 $C$ 为同一个上下文，但其值类型 $t^{*}$ 被预先添加到 $locals$ 向量中。
那么该帧是有效的，且具有帧上下文 $C^{'}$ .

\frac{S ⊢ moduleinst : C ( S ⊢ val : t ) ^{*}}{S ⊢ { locals val ^{*} , module moduleinst } : ( C , locals t ^{*} )}

管理指令

对管理指令的类型规则如下所示。除了上下文 $C$ 之外，这些指令的类型还根据给定的存储 $S$ 定义。为此，所有之前的类型判断 $C ⊢ prop$ 被推广为包含存储，如 $S; C ⊢ prop$ ，通过隐式地将 $S$ 添加到所有规则中 - $S$ 从未被预先存在的规则修改，但它在下面给出的管理指令的额外规则中被访问。

$trap$

该指令的类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ , 对于任何值类型序列 $t_{1}^{*}$ 和 $t_{2}^{*}$ .

S ; C ⊢ trap : [ t _{1}^{*} ] \to [ t _{2}^{*} ]

$ref . extern externaddr$

该指令的类型为 $[] \to [externref]$ .

S ; C ⊢ ref . extern externaddr : [ ] \to [ externref ]

$ref funcaddr$

该外部函数值 $func funcaddr$ 必须为有效的，其类型为外部函数类型 $func functype$ .
然后该指令的类型为 $[] \to [funcref]$ .

\frac{S ⊢ func funcaddr : func functype}{S ; C ⊢ ref funcaddr : [ ] \to [ funcref ]}

$invoke funcaddr$

该外部函数值 $func funcaddr$ 必须为有效的，其类型为外部函数类型 $func ([t_{1}^{*}] \to [t_{2}^{*}])$ .
然后该指令的类型为 $[t_{1}^{*}] \to [t_{2}^{*}]$ .

\frac{S ⊢ func funcaddr : func [ t _{1}^{*} ] \to [ t _{2}^{*} ]}{S ; C ⊢ invoke funcaddr : [ t _{1}^{*} ] \to [ t _{2}^{*} ]}

$label_{n} {instr_{0}^{}} instr^{} end$

指令序列 $instr_{0}^{*}$ 必须是有效的，类型为 $[t_{1}^{n}] \to [t_{2}^{*}]$ .
令 $C^{'}$ 与 $C$ 相同，但上下文的结果类型 $[t_{1}^{n}]$ 被添加到 $labels$ 向量中。
在上下文 $C^{'}$ 下，指令序列 $instr^{*}$ 必须是有效的，类型为 $[] \to [t_{2}^{*}]$ .
然后，复合指令是有效的，类型为 $[] \to [t_{2}^{*}]$ .

\frac{S ; C ⊢ instr _{0}^{*} : [ t _{1}^{n} ] \to [ t _{2}^{*} ] S ; C , labels [ t _{1}^{n} ] ⊢ instr ^{*} : [ ] \to [ t _{2}^{*} ]}{S ; C ⊢ label _{n} { instr _{0}^{*} } instr ^{*} end : [ ] \to [ t _{2}^{*} ]}

$frame_{n} {F} instr^{*} end$

在返回值类型 $[t^{n}]$ 下，线程 $F; instr^{*}$ 必须是有效的，且具有返回值类型 $[t^{n}]$ .
然后该复合指令的类型为 $[] \to [t^{n}]$ 的有效指令。

\frac{S ; [ t ^{n} ] ⊢ F ; instr ^{*} : [ t ^{n} ]}{S ; C ⊢ frame _{n} { F } instr ^{*} end : [ ] \to [ t ^{n} ]}

存储扩展

程序可以修改存储及其包含的实例。任何此类修改必须遵守某些不变性，例如不删除分配的实例或更改不可变定义。尽管这些不变性是 WebAssembly 指令和模块的执行语义所固有的，但宿主函数并不会自动遵守它们。因此，必须将所需的变量声明为对调用宿主函数的显式约束。只有当嵌入器确保这些约束时，健壮性才成立。

必要的约束由存储扩展的概念来编码：当以下规则成立时，存储状态 $S^{'}$ 扩展状态 $S$ , 写作 $S ⪯ S^{'}$ .

注意

扩展并不意味着新存储有效，有效性是单独定义的以上.

存储 $S$

$S. funcs$ 的长度不得缩短。
$S. tables$ 的长度不得缩短。
$S. mems$ 的长度不得缩短。
$S. globals$ 的长度不得缩短。
$S. elems$ 的长度不得缩短。
$S. datas$ 的长度不得缩短。
对于原始 $S. funcs$ 中的每个函数实例 $funcinst_{i}$ , 新的函数实例必须是旧函数实例的扩展。
对于原始 $S. tables$ 中的每个表格实例 $tableinst_{i}$ , 新的表格实例必须是旧表格实例的扩展。
对于原始 $meminst_{i}$ 中的每个内存实例 $S. mems$ , 新的内存实例必须是旧内存实例的扩展。
对于原始 $globalinst_{i}$ 中的每个全局实例 $S. globals$ , 新的全局实例必须是旧全局实例的扩展。
对于原始 $S. elems$ 中的每个元素实例 $eleminst_{i}$ ，新的元素实例必须是旧元素实例的扩展。
对于原始 $S. datas$ 中的每个数据实例 $datainst_{i}$ ，新的数据实例必须是旧数据实例的扩展。

\frac{S _{1} . funcs = funcinst _{1}^{*} S _{1} . tables = tableinst _{1}^{*} S _{1} . mems = meminst _{1}^{*} S _{1} . globals = globalinst _{1}^{*} S _{1} . elems = eleminst _{1}^{*} S _{1} . datas = datainst _{1}^{*} S _{2} . funcs = funcinst _{1}^{'} ^{*} funcinst _{2}^{*} S _{2} . tables = tableinst _{1}^{'} ^{*} tableinst _{2}^{*} S _{2} . mems = meminst _{1}^{'} ^{*} meminst _{2}^{*} S _{2} . globals = globalinst _{1}^{'} ^{*} globalinst _{2}^{*} S _{2} . elems = eleminst _{1}^{'} ^{*} eleminst _{2}^{*} S _{2} . datas = datainst _{1}^{'} ^{*} datainst _{2}^{*} ( ⊢ funcinst _{1} ⪯ funcinst _{1}^{'} ) ^{*} ( ⊢ tableinst _{1} ⪯ tableinst _{1}^{'} ) ^{*} ( ⊢ meminst _{1} ⪯ meminst _{1}^{'} ) ^{*} ( ⊢ globalinst _{1} ⪯ globalinst _{1}^{'} ) ^{*} ( ⊢ eleminst _{1} ⪯ eleminst _{1}^{'} ) ^{*} ( ⊢ datainst _{1} ⪯ datainst _{1}^{'} ) ^{*}}{⊢ S _{1} ⪯ S _{2}}

函数实例 $funcinst$

函数实例必须保持不变。

⊢ funcinst ⪯ funcinst

表实例 $tableinst$

表类型 $tableinst . type$ 必须保持不变。
$tableinst . elem$ 的长度不能缩短。

\frac{n _{1} \leq n _{2}}{⊢ { type tt , elem ( fa _{1}^{?} ) ^{n_{1}} } ⪯ { type tt , elem ( fa _{2}^{?} ) ^{n_{2}} }}

内存实例 $meminst$

内存类型 $meminst . type$ 必须保持不变。
$meminst . data$ 的长度不能缩短。

\frac{n _{1} \leq n _{2}}{⊢ { type mt , data b _{1}^{n_{1}} } ⪯ { type mt , data b _{2}^{n_{2}} }}

全局实例 $globalinst$

的全局类型 $globalinst . type$ 必须保持不变。
设 $mut t$ 为 $globalinst . type$ 的结构。
如果 $const$ 为 $const$ ，那么值 $globalinst . value$ 必须保持不变。

\frac{mut = var \lor val _{1} = val _{2}}{⊢ { type ( mut t ) , value val _{1} } ⪯ { type ( mut t ) , value val _{2} }}

元素实例 $eleminst$

向量 $eleminst . elem$ 必须保持不变或缩短到长度 $0$ 。

\frac{fa _{1}^{*} = fa _{2}^{*} \lor fa _{2}^{*} = ϵ}{⊢ { elem fa _{1}^{*} } ⪯ { elem fa _{2}^{*} }}

数据实例 $datainst$

向量 $datainst . data$ 必须保持不变或缩短至长度 $0$ .

\frac{b _{1}^{*} = b _{2}^{*} \lor b _{2}^{*} = ϵ}{⊢ { data b _{1}^{*} } ⪯ { data b _{2}^{*} }}

定理

根据有效配置的定义，标准的健全性定理成立。 [2] [3]

定理（保持性）。 如果一个配置 $S; T$ 是有效的，其结果类型为 $[t^{*}]$ （即， $⊢ S; T : [t^{*}]$ ），并且经过一系列步骤变为 $S^{'}; T^{'}$ （即， $S; T ↪ S^{'}; T^{'}$ ），那么 $S^{'}; T^{'}$ 也是一个有效的配置，并且具有相同的结果类型（即， $⊢ S^{'}; T^{'} : [t^{*}]$ ）。此外， $S^{'}$ 是 $S$ 的扩展（即， $⊢ S ⪯ S^{'}$ ）。

一个终止的 线程是其指令序列为一个结果的线程。一个终止配置是其线程终止的配置。

定理（进展性）。 如果一个配置 $S; T$ 是有效的（即， $⊢ S; T : [t^{*}]$ 对于一些结果类型 $[t^{*}]$ ），那么它要么是终止的，要么可以经过一步变为某个配置 $S^{'}; T^{'}$ （即， $S; T ↪ S^{'}; T^{'}$ ）。

从保持性和进展性可以直接得出 WebAssembly 类型系统的健全性。

推论（健全性）。如果一个配置 $S; T$ 是有效的（即， $⊢ S; T : [t^{*}]$ 对于某个结果类型 $[t^{*}]$ ），那么它要么会发散，要么会在有限步内到达一个终端配置 $S^{'}; T^{'}$ （即， $S; T ↪^{*} S^{'}; T^{'}$ ）是有效的，并具有相同的结果类型（即， $⊢ S^{'}; T^{'} : [t^{*}]$ ），并且 $S^{'}$ 是 $S$ 的扩展（即， $⊢ S ⪯ S^{'}$ ）。

换句话说，有效配置中的每个线程要么永远运行，要么陷入陷阱，要么以预期类型的结果终止。因此，给定一个有效存储，由实例化或调用有效模块定义的计算不会“崩溃”，也不会以本规范中未涵盖的方式出现其他（错误）行为。

变更历史记录

自从 WebAssembly 规范最初发布 1.0 版以来，已经整合了许多扩展建议。以下部分概述了发生了哪些变化。

版本 2.0

符号扩展指令

添加了用于在整数表示中执行符号扩展的新数值指令 [1]。

新的数值指令： $i nn . extend N_s$

非陷阱浮点数到整数转换

添加了新的转换指令，这些指令在将浮点数转换为整数时避免陷阱 [2]。

新的数值指令： $i nn . trunc_sat_f mm_sx$

多值

将块和函数的结果类型推广以允许使用多值；此外，引入了具有块参数的能力 [3]。

函数类型允许多个结果
块类型可以是任意函数类型

引用类型

添加了 $funcref$ 和 $externref$ 作为新的值类型以及相应的指令 [4]。

新的值类型：引用类型 $funcref$ 和 $externref$
新增引用指令： $ref . null$ ， $ref . func$ ， $ref . is_null$
增强参数化指令： $select$ 可选择性地添加类型立即数
新增声明式元素段形式

表格指令

新增直接访问和修改表格的指令 [4].

表格类型允许任何引用类型作为元素类型
新增表格指令： $table.get$ ， $table.set$ ， $table.size$ ， $table.grow$

多个表格

新增了每个模块使用多个表格的功能 [4].

模块可以定义、导入和导出多个表格
表格指令使用表格索引立即数： $table.get$ ， $table.set$ ， $table.size$ ， $table.grow$ ， $call_indirect$
元素段使用表格索引

批量内存和表格指令

新增修改内存或表格条目范围的指令 [4] [5]

新增内存指令： $memory.fill$ ， $memory.init$ ， $memory.copy$ ， $data.drop$
新增表格指令： $table.fill$ ， $table.init$ ， $table.copy$ ， $elem.drop$
新增被动数据段形式
新增被动元素段形式
新增二进制格式中的数据计数段
活动数据段和元素段边界不再在编译时检查，而是可能导致陷阱

向量指令

新增向量类型和指令，可并行处理多个数值（也称为 _SIMD_，单指令多数据） [6]

新增值类型： $v128$
新增内存指令： $v128. load$ ， $v128. load N x M_sx$ ， $v128. load N_zero$ ， $v128. load N_splat$ ， $v128. load N_lane$ ， $v128. store$ ， $v128. store N_lane$
新增常量向量指令: $v128. const$
新增一元向量指令: $v128.not$ , $i N x M .abs$ , $i N x M .neg$ , $i8x16.popcnt$ , $f N x M .abs$ , $f N x M .neg$ , $f N x M .sqrt$ , $f N x M .ceil$ , $f N x M .floor$ , $f N x M .trunc$ , $f N x M .nearest$
New binary vector instructions: $v128.and$ , $v128.andnot$ , $v128.or$ , $v128.xor$ , $i N x M .add$ , $i N x M .sub$ , $i N x M .mul$ , $i N x M .add_sat_sx$ , $i N x M .sub_sat_sx$ , $i N x M .min_sx$ , $i N x M .max_sx$ , $i N x M .shl$ , $i N x M .shr_sx$ , $f N x M .add$ , $i N x M .extmul_half_i N^{'} x M^{'}_sx$ , $i16x8.q15mulr_sat_s$ , $i32x4.dot_i16x8_s$ , $i16x8.extadd_pairwise_i8x16_sx$ , $i32x4.extadd_pairwise_i16x8_sx$ , $i8x16.avgr_u$ , $i16x8.avgr_u$ , $f N x M .sub$ , $f N x M .mul$ , $f N x M .div$ , $f N x M .min$ , $f N x M .max$ , $f N x M .pmin$ , $f N x M .pmax$
新增三元向量指令: $v128.bitselect$
新增测试向量指令: $v128.any_true$ , $i N x M .all_true$
新的关系型向量指令： $i N x M .eq$ , $i N x M .ne$ , $i N x M .lt_sx$ , $i N x M .gt_sx$ , $i N x M .le_sx$ , $i N x M .ge_sx$ , $f N x M .eq$ , $f N x M .ne$ , $f N x M .lt$ , $f N x M .gt$ , $f N x M .le$ , $f N x M .ge$
新的转换向量指令： $i32x4.trunc_sat_f32x4_sx$ , $i32x4.trunc_sat_f64x2_sx_zero$ , $f32x4.convert_i32x4_sx$ , $f32x4.demote_f64x2_zero$ , $f64x2.convert_low_i32x4_sx$ , $f64x2.promote_low_f32x4$
新的通道访问向量指令： $i N x M .extract_lane_sx^{?}$ , $i N x M .replace_lane$ , $f N x M .extract_lane$ , $f N x M .replace_lane$
新的通道分割/合并向量指令： $i N x M .extend_half_i N^{'} x M^{'}_sx$ , $i8x16.narrow_i16x8_sx$ , $i16x8.narrow_i32x4_sx$
新的字节重排序向量指令: $i8x16.shuffle$ , $i8x16.swizzle$
新的注入/投影向量指令: $i N x M .splat$ , $f N x M .splat$ , $i N x M .bitmask$

A.6 类型索引

类别	构造函数	二进制操作码
类型索引	$x$	(正数，作为 $s 32$ 或 $u 32$ )
数值类型	$i32$	$0x 7F$ (-1，作为 $s 7$ )
数值类型	$i64$	$0x 7E$ (-2，作为 $s 7$ )
数值类型	$f32$	$0x 7D$ (-3，作为 $s 7$ )
数值类型	$f64$	$0x 7C$ (-4，作为 $s 7$ )
向量类型	$v128$	$0x 7B$ (-5，作为 $s 7$ )
(保留)		$0x 7A$ .. $0x 71$
引用类型	$funcref$	$0x 70$ (-16，作为 $s 7$ )
引用类型	$externref$	$0x 6F$ (-17，作为 $s 7$ )
(保留)		$0x 6E$ .. $0x 61$
函数类型	$[valtype^{}] \to [valtype^{}]$	$0x 60$ (-32，作为 $s 7$ )
(保留)		$0x 5F$ .. $0x 41$
结果类型	$[ϵ]$	$0x 40$ (-64，作为 $s 7$ )
表格类型	$limits reftype$	(无)
内存类型	$limits$	(无)
全局类型	$mut valtype$	(无)

A.7 指令索引

指令	二进制操作码	类型	验证	执行
$unreachable$	$0x 00$	$[t_{1}^{}] \to [t_{2}^{}]$	验证	执行
$nop$	$0x 01$	$[] \to []$	验证	执行
$block bt$	$0x 02$	$[t_{1}^{}] \to [t_{2}^{}]$	验证	执行
$loop bt$	$0x 03$	$[t_{1}^{}] \to [t_{2}^{}]$	验证	执行
$if bt$	$0x 04$	$[t_{1}^{} i32] \to [t_{2}^{}]$	验证	执行
$else$	$0x 05$
(保留)	$0x 06$
(保留)	$0x 07$
(保留)	$0x 08$
(保留)	$0x 09$
(保留)	$0x 0A$
$end$	$0x 0B$
$br l$	$0x 0C$	$[t_{1}^{} t^{}] \to [t_{2}^{*}]$	验证	执行
$br_if l$	$0x 0D$	$[t^{} i32] \to [t^{}]$	验证	执行
$br_table l^{*} l$	$0x 0E$	$[t_{1}^{} t^{} i32] \to [t_{2}^{*}]$	验证	执行
$return$	$0x 0F$	$[t_{1}^{} t^{}] \to [t_{2}^{*}]$	验证	执行
$call x$	$0x 10$	$[t_{1}^{}] \to [t_{2}^{}]$	验证	执行
$call_indirect x y$	$0x 11$	$[t_{1}^{} i32] \to [t_{2}^{}]$	验证	执行
(保留)	$0x 12$
(保留)	$0x 13$
(保留)	$0x 14$
(保留)	$0x 15$
(保留)	$0x 16$
(保留)	$0x 17$
(保留)	$0x 18$
(保留)	$0x 19$
$drop$	$0x 1A$	$[t] \to []$	验证	执行
$select$	$0x 1B$	$[t t i32] \to [t]$	验证	执行
$select t$	$0x 1C$	$[t t i32] \to [t]$	验证	执行
(保留)	$0x 1D$
(保留)	$0x 1E$
(保留)	$0x 1F$
$local.get x$	$0x 20$	$[] \to [t]$	验证	执行
$local.set x$	$0x 21$	$[t] \to []$	验证	执行
$local.tee x$	$0x 22$	$[t] \to [t]$	验证	执行
$global.get x$	$0x 23$	$[] \to [t]$	验证	执行
$global.set x$	$0x 24$	$[t] \to []$	验证	执行
$table.get x$	$0x 25$	$[i32] \to [t]$	验证	执行
$table.set x$	$0x 26$	$[i32 t] \to []$	验证	执行
(保留)	$0x 27$
$i32 . load memarg$	$0x 28$	$[i32] \to [i32]$	验证	执行
$i64 . load memarg$	$0x 29$	$[i32] \to [i64]$	验证	执行
$f32 . load memarg$	$0x 2A$	$[i32] \to [f32]$	验证	执行
$f64 . load memarg$	$0x 2B$	$[i32] \to [f64]$	验证	执行
$i32 . load 8_s memarg$	$0x 2C$	$[i32] \to [i32]$	验证	执行
$i32 . load 8_u memarg$	$0x 2D$	$[i32] \to [i32]$	验证	执行
$i32 . load 16_s memarg$	$0x 2E$	$[i32] \to [i32]$	验证	执行
$i32 . load 16_u memarg$	$0x 2F$	$[i32] \to [i32]$	验证	执行
$i64 . load 8_s memarg$	$0x 30$	$[i32] \to [i64]$	验证	执行
$i64 . load 8_u memarg$	$0x 31$	$[i32] \to [i64]$	验证	执行
$i64 . load 16_s memarg$	$0x 32$	$[i32] \to [i64]$	验证	执行
$i64 . load 16_u memarg$	$0x 33$	$[i32] \to [i64]$	验证	执行
$i64 . load 32_s memarg$	$0x 34$	$[i32] \to [i64]$	验证	执行
$i64 . load 32_u memarg$	$0x 35$	$[i32] \to [i64]$	验证	执行
$i32 . store memarg$	$0x 36$	$[i32 i32] \to []$	验证	执行
$i64 . store memarg$	$0x 37$	$[i32 i64] \to []$	验证	执行
$f32 . <$	$0x 38$	$[i32 f32] \to []$	验证	执行
$f64 . store memarg$	$0x 39$	$[i32 f64] \to []$	验证	执行
$i32 . store 8 memarg$	$0x 3A$	$[i32 i32] \to []$	验证	执行
$i32 . store 16 memarg$	$0x 3B$	$[i32 i32] \to []$	验证	执行
$i64 . store 8 memarg$	$0x 3C$	$[i32 i64] \to []$	验证	执行
$i64 . store 16 memarg$	$0x 3D$	$[i32 i64] \to []$	验证	执行
$i64 . store 32 memarg$	$0x 3E$	$[i32 i64] \to []$	验证	执行
$memory.size$	$0x 3F$	$[] \to [i32]$	验证	执行
$memory.grow$	$0x 40$	$[i32] \to [i32]$	验证	执行
$i32 . const i32$	$0x 41$	$[] \to [i32]$	验证	执行
$i64 . const i64$	$0x 42$	$[] \to [i64]$	验证	执行
$f32 . const f32$	$0x 43$	$[] \to [f32]$	验证	执行
$f64 . const f64$	$0x 44$	$[] \to [f64]$	验证	执行
$i32 . eqz$	$0x 45$	$[i32] \to [i32]$	验证	执行 (运算符)
$i32 . eq$	$0x 46$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . ne$	$0x 47$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . lt_s$	$0x 48$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . lt_u$	$0x 49$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . gt_s$	$0x 4A$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . gt_u$	$0x 4B$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . le_s$	$0x 4C$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . le_u$	$0x 4D$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . ge_s$	$0x 4E$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . ge_u$	$0x 4F$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i64 . eqz$	$0x 50$	$[i64] \to [i32]$	验证	执行 (运算符)
$i64 . eq$	$0x 51$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . ne$	$0x 52$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . lt_s$	$0x 53$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . lt_u$	$0x 54$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . gt_s$	$0x 55$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . gt_u$	$0x 56$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . le_s$	$0x 57$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . le_u$	$0x 58$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . ge_s$	$0x 59$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$i64 . ge_u$	$0x 5A$	$[i64 i64] \to [i32]$	验证	执行 (运算符)
$f32 . eq$	$0x 5B$	$[f32 f32] \to [i32]$	验证	执行 (运算符)
$f32 . ne$	$0x 5C$	$[f32 f32] \to [i32]$	验证	执行 (运算符)
$f32 . lt$	$0x 5D$	$[f32 f32] \to [i32]$	验证	执行 (运算符)
$f32 . gt$	$0x 5E$	$[f32 f32] \to [i32]$	验证	执行 (运算符)
$f32 . le$	$0x 5F$	$[f32 f32] \to [i32]$	验证	执行 (运算符)
$f32 . ge$	$0x 60$	$[f32 f32] \to [i32]$	验证	执行 (运算符)
$f64 . eq$	$0x 61$	$[f64 f64] \to [i32]$	验证	执行 (运算符)
$f64 . ne$	$0x 62$	$[f64 f64] \to [i32]$	验证	执行 (运算符)
$f64 . lt$	$0x 63$	$[f64 f64] \to [i32]$	验证	执行 (运算符)
$f64 . gt$	$0x 64$	$[f64 f64] \to [i32]$	验证	执行 (运算符)
$f64 . le$	$0x 65$	$[f64 f64] \to [i32]$	验证	执行 (运算符)
$f64 . ge$	$0x 66$	$[f64 f64] \to [i32]$	验证	执行 (运算符)
$i32 . clz$	$0x 67$	$[i32] \to [i32]$	验证	执行 (运算符)
$i32 . ctz$	$0x 68$	$[i32] \to [i32]$	验证	执行 (运算符)
$i32 . popcnt$	$0x 69$	$[i32] \to [i32]$	验证	执行 (运算符)
$i32 . add$	$0x 6A$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . sub$	$0x 6B$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . mul$	$0x 6C$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . div_s$	$0x 6D$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . div_u$	$0x 6E$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . rem_s$	$0x 6F$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . rem_u$	$0x 70$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . and$	$0x 71$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . or$	$0x 72$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . xor$	$0x 73$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . shl$	$0x 74$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . shr_s$	$0x 75$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . shr_u$	$0x 76$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . rotl$	$0x 77$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i32 . rotr$	$0x 78$	$[i32 i32] \to [i32]$	验证	执行 (运算符)
$i64 . clz$	$0x 79$	$[i64] \to [i64]$	验证	执行 (运算符)
$i64 . ctz$	$0x 7A$	$[i64] \to [i64]$	验证	执行 (运算符)
$i64 . popcnt$	$0x 7B$	$[i64] \to [i64]$	验证	执行 (运算符)
$i64 . add$	$0x 7C$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . sub$	$0x 7D$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . mul$	$0x 7E$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . div_s$	$0x 7F$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . div_u$	$0x 80$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . rem_s$	$0x 81$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . rem_u$	$0x 82$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . and$	$0x 83$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . or$	$0x 84$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . xor$	$0x 85$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . shl$	$0x 86$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . shr_s$	$0x 87$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . shr_u$	$0x 88$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . rotl$	$0x 89$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$i64 . rotr$	$0x 8A$	$[i64 i64] \to [i64]$	验证	执行 (运算符)
$f32 . abs$	$0x 8B$	$[f32] \to [f32]$	验证	执行 (运算符)
$f32 . neg$	$0x 8C$	$[f32] \to [f32]$	验证	执行 (运算符)
$f32 . ceil$	$0x 8D$	$[f32] \to [f32]$	验证	执行 (运算符)
$f32 . floor$	$0x 8E$	$[f32] \to [f32]$	验证	执行 (操作符)
$f32 . trunc$	$0x 8F$	$[f32] \to [f32]$	验证	执行 (操作符)
$f32 . nearest$	$0x 90$	$[f32] \to [f32]$	验证	执行 (操作符)
$f32 . sqrt$	$0x 91$	$[f32] \to [f32]$	验证	执行 (操作符)
$f32 . add$	$0x 92$	$[f32 f32] \to [f32]$	验证	执行 (操作符)
$f32 . sub$	$0x 93$	$[f32 f32] \to [f32]$	验证	执行 (操作符)
$f32 . mul$	$0x 94$	$[f32 f32] \to [f32]$	验证	执行 (操作符)
$f32 . div$	$0x 95$	$[f32 f32] \to [f32]$	验证	执行 (操作符)
$f32 . min$	$0x 96$	$[f32 f32] \to [f32]$	验证	执行 (操作符)
$f32 . max$	$0x 97$	$[f32 f32] \to [f32]$	验证	执行 (操作符)
$f32 . copysign$	$0x 98$	$[f32 f32] \to [f32]$	验证	执行 (操作符)
$f64 . abs$	$0x 99$	$[f64] \to [f64]$	验证	执行 (运算符)
$f64 . neg$	$0x 9A$	$[f64] \to [f64]$	验证	执行 (运算符)
$f64 . ceil$	$0x 9B$	$[f64] \to [f64]$	验证	执行 (运算符)
$f64 . floor$	$0x 9C$	$[f64] \to [f64]$	验证	执行 (操作符)
$f64 . trunc$	$0x 9D$	$[f64] \to [f64]$	验证	执行 (操作符)
$f64 . nearest$	$0x 9E$	$[f64] \to [f64]$	验证	执行 (操作符)
$f64 . sqrt$	$0x 9F$	$[f64] \to [f64]$	验证	执行 (操作符)
$f64 . add$	$0x A0$	$[f64 f64] \to [f64]$	验证	执行 (操作符)
$f64 . sub$	$0x A1$	$[f64 f64] \to [f64]$	验证	执行 (操作符)
$f64 . mul$	$0x A2$	$[f64 f64] \to [f64]$	验证	执行 (操作符)
$f64 . div$	$0x A3$	$[f64 f64] \to [f64]$	验证	执行 (操作符)
$f64 . min$	$0x A4$	$[f64 f64] \to [f64]$	验证	执行 (操作符)
$f64 . max$	$0x A5$	$[f64 f64] \to [f64]$	验证	执行 (操作符)
$f64 . copysign$	$0x A6$	$[f64 f64] \to [f64]$	验证	执行 (操作符)
$i32 . wrap_i64$	$0x A7$	$[i64] \to [i32]$	验证	执行 (运算符)
$i32 . trunc_f32_s$	$0x A8$	$[f32] \to [i32]$	验证	执行 (运算符)
$i32 . trunc_f32_u$	$0x A9$	$[f32] \to [i32]$	验证	执行 (运算符)
$i32 . trunc_f64_s$	$0x AA$	$[f64] \to [i32]$	验证	执行 (运算符)
$i32 . trunc_f64_u$	$0x AB$	$[f64] \to [i32]$	验证	执行 (运算符)
$i64 . extend_i32_s$	$0x AC$	$[i32] \to [i64]$	验证	执行 (运算符)
$i64 . extend_i32_u$	$0x AD$	$[i32] \to [i64]$	验证	执行 (运算符)
$i64 . trunc_f32_s$	$0x AE$	$[f32] \to [i64]$	验证	执行 (运算符)
$i64 . trunc_f32_u$	$0x AF$	$[f32] \to [i64]$	验证	执行 (运算符)
$i64 . trunc_f64_s$	$0x B0$	$[f64] \to [i64]$	验证	执行 (运算符)
$i64 . trunc_f64_u$	$0x B1$	$[f64] \to [i64]$	验证	执行 (运算符)
$f32 . convert_i32_s$	$0x B2$	$[i32] \to [f32]$	验证	执行 (运算符)
$f32 . convert_i32_u$	$0x B3$	$[i32] \to [f32]$	验证	执行 (运算符)
$f32 . convert_i64_s$	$0x B4$	$[i64] \to [f32]$	验证	执行 (运算符)
$f32 . convert_i64_u$	$0x B5$	$[i64] \to [f32]$	验证	执行 (运算符)
$f32 . demote_f64$	$0x B6$	$[f64] \to [f32]$	验证	执行 (运算符)
$f64 . convert_i32_s$	$0x B7$	$[i32] \to [f64]$	验证	执行 (运算符)
$f64 . convert_i32_u$	$0x B8$	$[i32] \to [f64]$	验证	执行 (运算符)
$f64 . convert_i64_s$	$0x B9$	$[i64] \to [f64]$	验证	执行 (运算符)
$f64 . convert_i64_u$	$0x BA$	$[i64] \to [f64]$	验证	执行 (运算符)
$f64 . promote_f32$	$0x BB$	$[f32] \to [f64]$	验证	执行 (运算符)
$i32 . reinterpret_f32$	$0x BC$	$[f32] \to [i32]$	验证	执行 (运算符)
$i64 . reinterpret_f64$	$0x BD$	$[f64] \to [i64]$	验证	执行 (运算符)
$f32 . reinterpret_i32$	$0x BE$	$[i32] \to [f32]$	验证	执行 (运算符)
$f64 . reinterpret_i64$	$0x BF$	$[i64] \to [f64]$	验证	执行 (运算符)
$i32 . extend 8_s$	$0x C0$	$[i32] \to [i32]$	验证	执行 (运算符)
$i32 . extend 16_s$	$0x C1$	$[i32] \to [i32]$	验证	执行 (运算符)
$i64 . extend 8_s$	$0x C2$	$[i64] \to [i64]$	验证	执行 (运算符)
$i64 . extend 16_s$	$0x C3$	$[i64] \to [i64]$	验证	执行 (运算符)
$i64 . extend 32_s$	$0x C4$	$[i64] \to [i64]$	验证	执行 (运算符)
(保留)	$0x C5$
(保留)	$0x C6$
(保留)	$0x C7$
(保留)	$0x C8$
(保留)	$0x C9$
(保留)	$0x CA$
(保留)	$0x CB$
(保留)	$0x CC$
(保留)	$0x CD$
(保留)	$0x CE$
(保留)	$0x CF$
$ref . null t$	$0x D0$	$[] \to [t]$	验证	执行
$ref . is_null$	$0x D1$	$[t] \to [i32]$	验证	执行
$ref . func x$	$0x D2$	$[] \to [funcref]$	验证	执行
(保留)	$0x D3$
(保留)	$0x D4$
(保留)	$0x D5$
(保留)	$0x D6$
(保留)	$0x D7$
(保留)	$0x D8$
(保留)	$0x D9$
(保留)	$0x DA$
(保留)	$0x DB$
(保留)	$0x DC$
(保留)	$0x DD$
(保留)	$0x DE$
(保留)	$0x DF$
(保留)	$0x E0$
(保留)	$0x E1$
(保留)	$0x E2$
(保留)	$0x E3$
(保留)	$0x E4$
(保留)	$0x E5$
(保留)	$0x E6$
(保留)	$0x E7$
(保留)	$0x E8$
(保留)	$0x E9$
(保留)	$0x EA$
(保留)	$0x EB$
(保留)	$0x EC$
(保留)	$0x ED$
(保留)	$0x EE$
(保留)	$0x EF$
(保留)	$0x F0$
(保留)	$0x F1$
(保留)	$0x F2$
(保留)	$0x F3$
(保留)	$0x F4$
(保留)
(保留)	$0x F6$
(保留)	$0x F7$
(保留)	$0x F8$
(保留)	$0x F9$
(保留)	$0x FA$
(保留)	$0x FB$
$i32 . trunc_sat_f32_s$	$0x FC 0x 00$	$[f32] \to [i32]$	验证	执行 (运算符)
$i32 . trunc_sat_f32_u$	$0x FC 0x 01$	$[f32] \to [i32]$	验证	执行 (运算符)
$i32 . trunc_sat_f64_s$	$0x FC 0x 02$	$[f64] \to [i32]$	验证	执行 (运算符)
$i32 . trunc_sat_f64_u$	$0x FC 0x 03$	$[f64] \to [i32]$	验证	执行 (运算符)
$i64 . trunc_sat_f32_s$	$0x FC 0x 04$	$[f32] \to [i64]$	验证	执行 (运算符)
$i64 . trunc_sat_f32_u$	$0x FC 0x 05$	$[f32] \to [i64]$	验证	执行 (运算符)
$i64 . trunc_sat_f64_s$	$0x FC 0x 06$	$[f64] \to [i64]$	验证	执行 (运算符)
$i64 . trunc_sat_f64_u$	$0x FC 0x 07$	$[f64] \to [i64]$	验证	执行 (运算符)
$memory.init x$	$0x FC 0x 08$	$[i32 i32 i32] \to []$	验证	执行
$data.drop x$	$0x FC 0x 09$	$[] \to []$	验证	执行
$memory.copy$	$0x FC 0x 0A$	$[i32 i32 i32] \to []$	验证	执行
$memory.fill$	$0x FC 0x 0B$	$[i32 i32 i32] \to []$	验证	执行
$table.init x y$	$0x FC 0x 0C$	$[i32 i32 i32] \to []$	验证	执行
$elem.drop x$	$0x FC 0x 0D$	$[] \to []$	验证	执行
$table.copy x y$	$0x FC 0x 0E$	$[i32 i32 i32] \to []$	验证	执行
$table.grow x$	$0x FC 0x 0F$	$[t i32] \to [i32]$	验证	执行
$table.size x$	$0x FC 0x 10$	$[] \to [i32]$	验证	执行
$table.fill x$	$0x FC 0x [i32 t i32] \to []$	验证	执行
$v128 . load memarg$	$0x FD 0x 00$	$[i32] \to [v128]$	验证	执行
$v128 . load 8x8_s memarg$	$0x FD 0x 01$	$[i32] \to [v128]$	验证	执行
$v128 . load 8x8_u memarg$	$0x FD 0x 02$	$[i32] \to [v128]$	验证	执行
$v128 . load 16x4_s memarg$	$0x FD 0x 03$	$[i32] \to [v128]$	验证	执行
$v128 . load 16x4_u memarg$	$0x FD 0x 04$	$[i32] \to [v128]$	验证	执行
$v128 . load 32x2_s memarg$	$0x FD 0x 05$	$[i32] \to [v128]$	验证	执行
$v128 . load 32x2_u memarg$	$0x FD 0x 06$	$[i32] \to [v128]$	验证	执行
$v128 . load 8_splat memarg$	$0x FD 0x 07$	$[i32] \to [v128]$	验证	执行
$v128 . load 16_splat memarg$	$0x FD 0x 08$	$[i32] \to [v128]$	验证	执行
$v128 . load 32_splat memarg$	$0x FD 0x 09$	$[i32] \to [v128]$	验证	执行
$v128 . load 64_splat memarg$	$0x FD 0x 0A$	$[i32] \to [v128]$	验证	执行
$v128 . store memarg$	$0x FD 0x 0B$	$[i32 v128] \to []$	验证	执行
$v128 . const i128$	$0x FD 0x 0C$	$[] \to [v128]$	验证	执行
$i8x16 . shuffle laneidx^{16}$	$0x FD 0x 0D$	$[v128 v128] \to [v128]$	验证	执行
$i8x16 . swizzle$	$0x FD 0x 0E$	$[v128 v128] \to [v128]$	验证	执行
$i8x16 . splat$	$0x FD 0x 0F$	$[i32] \to [v128]$	验证	执行
$i16x8 . splat$	$0x FD 0x 10$	$[i32] \to [v128]$	验证	执行
$i32x4 . splat$	$0x FD 0x 11$	$[i32] \to [v128]$	验证	执行
$i64x2 . splat$	$0x FD 0x 12$	$[i64] \to [v128]$	验证	执行
$f32x4 . splat$	$0x FD 0x 13$	$[f32] \to [v128]$	验证	执行
$f64x2 . splat$	$0x FD 0x 14$	$[f64] \to [v128]$	验证	执行
$i8x16 . extract_lane_s laneidx$	$0x FD 0x 15$	$[v128] \to [i32]$	验证	执行
$i8x16 . extract_lane_u laneidx$	$0x FD 0x 16$	$[v128] \to [i32]$	验证	执行
$i8x16 . replace_lane laneidx$	$0x FD 0x 17$	$[v128 i32] \to [v128]$	验证	执行
$i16x8 . extract_lane_s laneidx$	$0x FD 0x 18$	$[v128] \to [i32]$	验证	执行
$i16x8 . extract_lane_u laneidx$	$0x FD 0x 19$	$[v128] \to [i32]$	验证	执行
$i16x8 . replace_lane laneidx$	$0x FD 0x 1A$	$[v128 i32] \to [v128]$	验证	执行
$i32x4 . extract_lane laneidx$	$0x FD 0x 1B$	$[v128] \to [i32]$	验证	执行
$i32x4 . replace_lane laneidx$	$0x FD 0x 1C$	$[v128 i32] \to [v128]$	验证	执行
$i64x2 . extract_lane laneidx$	$0x FD 0x 1D$	$[v128] \to [i64]$	验证	执行
$i64x2 . replace_lane laneidx$	$0x FD 0x 1E$	$[v128 i64] \to [v128]$	验证	执行
$f32x4 . extract_lane laneidx$	$0x FD 0x 1F$	$[v128] \to [f32]$	验证	执行
$f32x4 . replace_lane laneidx$	$0x FD 0x 20$	$[v128 f32] \to [v128]$	验证	执行
$f64x2 . extract_lane laneidx$	$0x FD 0x 21$	$[v128] \to [f64]$	验证	执行
$f64x2 . replace_lane laneidx$	$0x FD 0x 22$	$[v128 f64] \to [v128]$	验证	执行
$i8x16 . eq$	$0x FD 0x 23$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . ne$	$0x FD 0x 24$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . lt_s$	$0x FD 0x 25$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . lt_u$	$0x FD 0x 26$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . gt_s$	$0x FD 0x 27$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . gt_u$	$0x FD 0x 28$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . le_s$	$0x FD 0x 29$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . le_u$	$0x FD 0x 2A$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . ge_s$	$0x FD 0x 2B$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . ge_u$	$0x FD 0x 2C$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . eq$	$0x FD 0x 2D$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . ne$	$0x FD 0x 2E$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . lt_s$	$0x FD 0x 2F$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . lt_u$	$0x FD 0x 30$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . gt_s$	$0x FD 0x 31$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . gt_u$	$0x FD 0x 32$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . le_s$	$0x FD 0x 33$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . le_u$	$0x FD 0x 34$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . ge_s$	$0x FD 0x 35$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . ge_u$	$0x FD 0x 36$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . eq$	$0x FD 0x 37$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . ne$	$0x FD 0x 38$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . lt_s$	$0x FD 0x 39$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . lt_u$	$0x FD 0x 3A$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . gt_s$	$0x FD 0x 3B$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . gt_u$	$0x FD 0x 3C$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . le_s$	$0x FD 0x 3D$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . le_u$	$0x FD 0x 3E$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . ge_s$	$0x FD 0x 3F$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . ge_u$	$0x FD 0x 40$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . eq$	$0x FD 0x 41$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . ne$	$0x FD 0x 42$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . lt$	$0x FD 0x 43$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . gt$	$0x FD 0x 44$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . le$	$0x FD 0x 45$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . ge$	$0x FD 0x 46$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . eq$	$0x FD 0x 47$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . ne$	$0x FD 0x 48$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . lt$	$0x FD 0x 49$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . gt$	$0x FD 0x 4A$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . le$	$0x FD 0x 4B$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . ge$	$0x FD 0x 4C$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$v128 . not$	$0x FD 0x 4D$	$[v128] \to [v128]$	验证	执行 (运算符)
$v128 . and$	$0x FD 0x 4E$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$v128 . andnot$	$0x FD 0x 4F$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$v128 . or$	$0x FD 0x 50$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$v128 . xor$	$0x FD 0x 51$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$v128 . bitselect$	$0x FD 0x 52$	$[v128 v128 v128] \to [v128]$	验证	执行 (操作符)
$v128 . any_true$	$0x FD 0x 53$	$[v128] \to [i32]$	验证	执行
$v128 . load 8_lane memarg laneidx$	$0x FD 0x 54$	$[i32 v128] \to [v128]$	验证	执行
$v128 . load 16_lane memarg laneidx$	$0x FD 0x 55$	$[i32 v128] \to [v128]$	验证	执行
$v128 . load 32_lane memarg laneidx$	$0x FD 0x 56$	$[i32 v128] \to [v128]$	验证	执行
$v128 . load 64_lane memarg laneidx$	$0x FD 0x 57$	$[i32 v128] \to [v128]$	验证	执行
$v128 . store 8_lane memarg laneidx$	$0x FD 0x 58$	$[i32 v128] \to []$	验证	执行
$v128 . store 16_lane memarg laneidx$	$0x FD 0x 59$	$[i32 v128] \to []$	验证	执行
$v128 . store 32_lane memarg laneidx$	$0x FD 0x 5A$	$[i32 v128] \to []$	验证	执行
$v128 . store 64_lane memarg laneidx$	$0x FD 0x 5B$	$[i32 v128] \to []$	验证	执行
$v128 . load 32_zero memarg$	$0x FD 0x 5C$	$[i32] \to [v128]$	验证	执行
$v128 . load 64_zero memarg$	$0x FD 0x 5D$	$[i32] \to [v128]$	验证	执行
$f32x4 . demote_f64x2_zero$	$0x FD 0x 5E$	$[v128] \to [v128]$	验证	执行 (操作符)
$f64x2 . promote_low_f32x4$	$0x FD 0x 5F$	$[v128] \to [v128]$	验证	执行 (操作符)
$i8x16 . abs$	$0x FD 0x 60$	$[v128] \to [v128]$	验证	执行 (操作符)
$i8x16 . neg$	$0x FD 0x 61$	$[v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . popcnt$	$0x FD 0x 62$	$[v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . all_true$	$0x FD 0x 63$	$[v128] \to [i32]$	验证	执行
$i8x16 . bitmask$	$0x FD 0x 64$	$[v128] \to [i32]$	验证	执行
$i8x16 . narrow_i16x8_s$	$0x FD 0x 65$	$[v128 v128] \to [v128]$	验证	执行
$i8x16 . narrow_i16x8_u$	$0x FD 0x 66$	$[v128 v128] \to [v128]$	验证	执行
$f32x4 . ceil$	$0x FD 0x 67$	$[v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . floor$	$0x FD 0x 68$	$[v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . trunc$	$0x FD 0x 69$	$[v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . nearest$	$0x FD 0x 6A$	$[v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . shl$	$0x FD 0x 6B$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i8x16 . shr_s$	$0x FD 0x 6C$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i8x16 . shr_u$	$0x FD 0x 6D$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i8x16 . add$	$0x FD 0x 6E$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . add_sat_s$	$0x FD 0x 6F$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . add_sat_u$	$0x FD 0x 70$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . sub$	$0x FD 0x 71$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . sub_sat_s$	$0x FD 0x 72$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . sub_sat_u$	$0x FD 0x 73$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . ceil$	$0x FD 0x 74$	$[v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . floor$	$0x FD 0x 75$	$[v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . min_s$	$0x FD 0x 76$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . min_u$	$0x FD 0x 77$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . max_s$	$0x FD 0x 78$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . max_u$	$0x FD 0x 79$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . trunc$	$0x FD 0x 7A$	$[v128] \to [v128]$	验证	执行 (运算符)
$i8x16 . avgr_u$	$0x FD 0x 7B$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . extadd_pairwise_i8x16_s$	$0x FD 0x 7C$	$[v128] \to [v128]$	验证	执行
$i16x8 . extadd_pairwise_i8x16_u$	$0x FD 0x 7D$	$[v128] \to [v128]$	验证	执行
$i32x4 . extadd_pairwise_i16x8_s$	$0x FD 0x 7E$	$[v128] \to [v128]$	验证	执行
$i32x4 . extadd_pairwise_i16x8_u$	$0x FD 0x 7F$	$[v128] \to [v128]$	验证	执行
$i16x8 . abs$	$0x FD 0x 80 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$i16x8 . neg$	$0x FD 0x 81 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . q15mulr_sat_s$	$0x FD 0x 82 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . all_true$	$0x FD 0x 83 0x 01$	$[v128] \to [i32]$	验证	执行
$i16x8 . bitmask$	$0x FD 0x 84 0x 01$	$[v128] \to [i32]$	验证	执行
$i16x8 . narrow_i32x4_s$	$0x FD 0x 85 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i16x8 . narrow_i32x4_u$	$0x FD 0x 86 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i16x8 . extend_low_i8x16_s$	$0x FD 0x 87 0x 01$	$[v128] \to [v128]$	验证	执行
$i16x8 . extend_high_i8x16_s$	$0x FD 0x 88 0x 01$	$[v128] \to [v128]$	验证	执行
$i16x8 . extend_low_i8x16_u$	$0x FD 0x 89 0x 01$	$[v128] \to [v128]$	验证	执行
$i16x8 . extend_high_i8x16_u$	$0x FD 0x 8A 0x 01$	$[v128] \to [v128]$	验证	执行
$i16x8 . shl$	$0x FD 0x 8B 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i16x8 . shr_s$	$0x FD 0x 8C 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i16x8 . shr_u$	$0x FD 0x 8D 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i16x8 . add$	$0x FD 0x 8E 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . add_sat_s$	$0x FD 0x 8F 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . add_sat_u$	$0x FD 0x 90 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . sub$	$0x FD 0x 91 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . sub_sat_s$	$0x FD 0x 92 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . sub_sat_u$	$0x FD 0x 93 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . nearest$	$0x FD 0x 94 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . mul$	$0x FD 0x 95 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$i16x8 . min_s$	$0x FD 0x 96 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . min_u$	$0x FD 0x 97 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . max_s$	$0x FD 0x 98 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . max_u$	$0x FD 0x 99 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . avgr_u$	$0x FD 0x 9B 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i16x8 . extmul_low_i8x16_s$	$0x FD 0x 9C 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i16x8 . extmul_high_i8x16_s$	$0x FD 0x 9D 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i16x8 . extmul_low_i8x16_u$	$0x FD 0x 9E 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i16x8 . extmul_high_i8x16_u$	$0x FD 0x 9F 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i32x4 . abs$	$0x FD 0x A0 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$i32x4 . neg$	$0x FD 0x A1 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . all_true$	$0x FD 0x A3 0x 01$	$[v128] \to [i32]$	验证	执行
$i32x4 . bitmask$	$0x FD 0x A4 0x 01$	$[v128] \to [i32]$	验证	执行
$i32x4 . extend_low_i16x8_s$	$0x FD 0x A7 0x 01$	$[v128] \to [v128]$	验证	执行
$i32x4 . extend_high_i16x8_s$	$0x FD 0x A8 0x 01$	$[v128] \to [v128]$	验证	执行
$i32x4 . extend_low_i16x8_u$	$0x FD 0x A9 0x 01$	$[v128] \to [v128]$	验证	执行
$i32x4 . extend_high_i16x8_u$	$0x FD 0x AA 0x 01$	$[v128] \to [v128]$	验证	执行
$i32x4 . shl$	$0x FD 0x AB 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i32x4 . shr_s$	$0x FD 0x AC 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i32x4 . shr_u$	$0x FD 0x AD 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i32x4 . add$	$0x FD 0x AE 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . sub$	$0x FD 0x B1 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . mul$	$0x FD 0x B5 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$i32x4 . min_s$	$0x FD 0x B6 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . min_u$	$0x$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . max_s$	$0x FD 0x B8 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . max_u$	$0x FD 0x B9 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . dot_i16x8_s$	$0x FD 0x BA 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i32x4 . extmul_low_i16x8_s$	$0x FD 0x BC 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i32x4 . extmul_high_i16x8_s$	$0x FD 0x BD 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i32x4 . extmul_low_i16x8_u$	$0x FD 0x BE 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i32x4 . extmul_high_i16x8_u$	$0x FD 0x BF 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i64x2 . abs$	$0x FD 0x C0 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$i64x2 . neg$	$0x FD 0x C1 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . all_true$	$0x FD 0x C3 0x 01$	$[v128] \to [i32]$	验证	执行
$i64x2 . bitmask$	$0x FD 0x C4 0x 01$	$[v128] \to [i32]$	验证	执行
$i64x2 . extend_low_i32x4_s$	$0x FD 0x C7 0x 01$	$[v128] \to [v128]$	验证	执行
$i64x2 . extend_high_i32x4_s$	$0x FD 0x C8 0x 01$	$[v128] \to [v128]$	验证	执行
$i64x2 . extend_low_i32x4_u$	$0x FD 0x C9 0x 01$	$[v128] \to [v128]$	验证	执行
$i64x2 . extend_high_i32x4_u$	$0x FD 0x CA 0x 01$	$[v128] \to [v128]$	验证	执行
$i64x2 . shl$	$0x FD 0x CB 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i64x2 . shr_s$	$0x FD 0x CC 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i64x2 . shr_u$	$0x FD 0x CD 0x 01$	$[v128 i32] \to [v128]$	验证	执行 (运算符)
$i64x2 . add$	$0x FD 0x CE 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . sub$	$0x FD 0x D1 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . mul$	$0x FD 0x D5 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$i64x2 . eq$	$0x FD 0x D6 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . ne$	$0x FD 0x D7 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . lt_s$	$0x FD 0x D8 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . gt_s$	$0x FD 0x D9 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . le_s$	$0x FD 0x DA 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . ge_s$	$0x FD 0x DB 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$i64x2 . extmul_low_i32x4_s$	$0x FD 0x DC 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i64x2 . extmul_high_i32x4_s$	$0x FD 0x DD 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i64x2 . extmul_low_i32x4_u$	$0x FD 0x DE 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$i64x2 . extmul_high_i32x4_u$	$0x FD 0x DF 0x 01$	$[v128 v128] \to [v128]$	验证	执行
$f32x4 . abs$	$0x FD 0x E0 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . neg$	$0x FD 0x E1 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . sqrt$	$0x FD 0x E3 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . add$	$0x FD 0x E4 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . sub$	$0x FD 0x E5 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . mul$	$0x FD 0x E6 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . div$	$0x FD 0x E7 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . min$	$0x FD 0x E8 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f32x4 . max$	$0x FD 0x E9 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$f32x4 . pmin$	$0x FD 0x EA 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$f32x4 . pmax$	$0x FD 0x EB 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$f64x2 . abs$	$0x FD 0x EC 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . neg$	$0x FD 0x ED 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . sqrt$	$0x FD 0x EF 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . add$	$0x FD 0x F0 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . sub$	$0x FD 0x F1 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . mul$	$0x FD 0x F2 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . div$	$0x FD 0x F3 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . min$	$0x FD 0x F4 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (运算符)
$f64x2 . max$	$0x FD 0x F5 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$f64x2 . pmin$	$0x FD 0x F6 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$f64x2 . pmax$	$0x FD 0x F7 0x 01$	$[v128 v128] \to [v128]$	验证	执行 (操作符)
$i32x4 . trunc_sat_f32x4_s$	$0x FD 0x F8 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$i32x4 . trunc_sat_f32x4_u$	$0x FD 0x F9 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$f32x4 . convert_i32x4_s$	$0x FD 0x FA 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$f32x4 . convert_i32x4_u$	$0x FD 0x FB 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)
$i32x4 . trunc_sat_f64x2_s_zero$	$0x FD 0x FC 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$i32x4 . trunc_sat_f64x2_u_zero$	$0x FD 0x FD 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$f64x2 . convert_low_i32x4_s$	$0x FD 0x FE 0x 01$	$[v128] \to [v128]$	验证	执行 (操作符)
$f64x2 . convert_low_i32x4_u$	$0x FD 0x FF 0x 01$	$[v128] \to [v128]$	验证	执行 (运算符)

注意

表中给出了多字节操作码的最短编码。但是，第一个字节后面的内容实际上是使用可变长度编码的u32，因此有多种可能的表示形式。

A.8 语义规则索引

静态结构的类型

结构	判断
限制	$⊢ limits : k$
函数类型	$⊢ functype ok$
块类型	$⊢ blocktype ok$
表格类型	$⊢ tabletype ok$
内存类型	$⊢ memtype ok$
全局类型	$⊢ globaltype ok$
外部类型	$⊢ externtype ok$
指令	$S; C ⊢ instr : stacktype$
指令序列	$S; C ⊢ instr^{*} : stacktype$
表达式	$C ⊢ expr : resulttype$
函数	$C ⊢ func : functype$
表	$C ⊢ table : tabletype$
内存	$C ⊢ mem : memtype$
全局	$C ⊢ global : globaltype$
元素段	$C ⊢ elem : reftype$
元素模式	$C ⊢ elemmode : reftype$
数据段	$C ⊢ data ok$
数据模式	$C ⊢ datamode ok$
启动函数	$C ⊢ start ok$
导出	$C ⊢ export : externtype$
导出描述	$C ⊢ exportdesc : externtype$
导入	$C ⊢ import : externtype$
导入描述	$C ⊢ importdesc : externtype$
模块	$⊢ module : externtype^{} \to externtype^{}$

运行时结构类型

结构	判断
值	$S ⊢ val : valtype$
结果	$S ⊢ result : resulttype$
外部值	$S ⊢ externval : externtype$
函数实例	$S ⊢ funcinst : functype$
表格实例	$S ⊢ tableinst : tabletype$
内存实例	$S ⊢ meminst : memtype$
全局实例	$S ⊢ globalinst : globaltype$
元素实例	$S ⊢ eleminst : t$
数据实例	$S ⊢ datainst ok$
导出实例	$S ⊢ exportinst ok$
模块实例	$S ⊢ moduleinst : C$
存储	$⊢ store ok$
配置	$⊢ config ok$
线程	$S; resulttype^{?} ⊢ thread : resulttype$
帧	$S ⊢ frame : C$

常量性

结构	判断
常量表达式	$C ⊢ expr const$
常量指令	$C ⊢ instr const$

匹配

结构	判断
外部类型	$⊢ externtype_{1} \leq externtype_{2}$
限制	$⊢ limits_{1} \leq limits_{2}$

存储扩展

结构	判断
函数实例	$⊢ funcinst_{1} ⪯ funcinst_{2}$
表格实例	$⊢ tableinst_{1} ⪯ tableinst_{2}$
内存实例	$⊢ meminst_{1} ⪯ meminst_{2}$
全局实例	$⊢ globalinst_{1} ⪯ globalinst_{2}$
元素实例	$⊢ eleminst_{1} ⪯ eleminst_{2}$
数据实例	$⊢ datainst_{1} ⪯ datainst_{2}$
存储	$⊢ store_{1} ⪯ store_{2}$

执行

结构	判断
指令	$S; F; instr^{} ↪ S^{'}; F^{'}; instr^{'}^{}$
表达式	$S; F; expr ↪ S^{'}; F^{'}; expr^{'}$

摘要

本文档的状态

1. 简介

1.1. 简介

1.1.1. 设计目标

1.1.2. 范围

1.1.3. 安全注意事项

1.1.4. 依赖项

1.2. 概述

1.2.1. 概念

1.2.2. 语义阶段

2. 结构

2.1. 约定

2.1.1. 语法表示法

2.1.2. 辅助符号

2.1.3. 向量

2.2. 值

2.2.1. 字节

2.2.1.1. 约定

2.2.2. 整数

2.2.2.1. 约定

2.2.3. 浮点数

2.2.3.1. 约定

2.2.4. 向量

2.2.5. 名称

2.2.5.1. 约定

2.3. 类型

2.3.1. 数值类型

2.3.1.1. 约定

2.3.2. 向量类型

2.3.2.1. 约定

2.3.3. 引用类型

2.3.4. 值类型

2.3.4.1. 约定

2.3.5. 结果类型

2.3.6. 函数类型

2.3.7. 限制

2.3.8. 内存类型

2.3.9. 表格类型

2.3.10. 全局类型

2.3.11. 外部类型

2.3.11.1. 约定

2.4. 指令

2.4.1. 数值指令

2.4.1.1. 约定

2.4.2. 向量指令

2.4.2.1. 约定

2.4.3. 引用指令

2.4.4. 参数指令

2.4.5. 变量指令

2.4.6. 表指令

2.4.7. 内存指令

2.4.8. 控制指令

2.4.9. 表达式

2.5. 模块

2.5.1. 索引

2.5.1.1. 约定

2.5.2. 类型

2.5.3. 函数

2.5.4. 表

2.5.5. 内存

2.5.6. 全局变量

2.5.7. 元素段

2.5.8. 数据段

2.5.9. 开始函数

2.5.10. 导出

2.5.10.1. 约定

2.5.11. 导入

3. 验证

3.1. 约定

3.1.1. 上下文

3.1.2. 散文符号

3.1.3. 形式符号

3.2. 类型

3.2.1. 限制

3.2.1.1. {min n,max m?}

3.2.2. 块类型

3.2.2.1. typeidx

3.2.2.2. [valtype?]

3.2.1.1. ${min n, max m^{?}}$

3.2.2.1. $typeidx$

3.2.2.2. $[valtype^{?}]$

3.2.3.1. $[t_{1}^{n}] \to [t_{2}^{m}]$

3.2.4.1. $limits reftype$

3.2.5.1. $limits$

3.2.6.1. $mut valtype$

3.2.7.1. $func functype$

3.2.7.2. $table tabletype$

3.2.7.3. $mem memtype$

3.2.7.4. $global globaltype$

3.3.1.1. $t . const c$

3.3.1.2. $t . unop$

3.3.1.3. $t . binop$

3.3.1.4. $t . testop$

3.3.1.5. $t . relop$

3.3.1.6. $t_{2} . cvtop_t_{1}_sx^{?}$

3.3.2.1. $ref . null t$

3.3.2.2. $ref . is_null$

3.3.2.3. $ref . func x$

3.3.3.1. $v128 . const c$

3.3.3.2. $v128 . vvunop$

3.3.3.3. $v128 . vvbinop$

3.3.3.4. $v128 . vvternop$

3.3.3.5. $v128 . vvtestop$

3.3.3.6. $i8x16. swizzle$

3.3.3.7. $i8x16. shuffle laneidx^{16}$

3.3.3.8. $shape . splat$

3.3.3.9. $shape . extract_lane_sx^{?} laneidx$

3.3.3.10. $shape . replace_lane laneidx$

3.3.3.11. $shape . vunop$

3.3.3.12. $shape . vbinop$

3.3.3.13. $shape . vrelop$

3.3.3.14. $ishape . vishiftop$

3.3.3.15. $shape . vtestop$

3.3.3.16. $shape . vcvtop_half^{?}_shape_sx^{?}_zero^{?}$

3.3.3.17. $ishape_{1} . narrow_ishape_{2}_sx$

3.3.3.18. $ishape . bitmask$

3.3.3.19. $ishape_{1} . dot_ishape_{2}_s$

3.3.3.20. $ishape_{1} . extmul_half_ishape_{2}_sx$

3.3.3.21. $ishape_{1} . extadd_pairwise_ishape_{2}_sx$

3.3.4.1. $drop$

3.3.4.2. $select (t^{*})^{?}$

3.3.5.1. $local.get x$

3.3.5.2. $local.set x$

3.3.5.3. $local.tee x$

3.3.5.4. $global.get x$

3.3.5.5. $global.set x$

3.3.6.1. $table.get x$

3.3.6.2. $table.set x$

3.3.6.3. $table.size x$

3.3.6.4. $table.grow x$

3.3.6.5. $table.fill x$

3.3.6.6. $table.copy x y$