WebAssembly 核心规范

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. 概念

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.1.1. 语法表示法

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

• 终结符（原子）以无衬线字体或符号形式编写： $$i32,\mathsf{end},\to ,[,]$$.

• 非终结符以斜体形式编写： $$valtype,instr$$.

• $${\mathrm{A}}^{\mathrm{n}}$$ 是 $$\mathrm{n}\ge 0$$ 次 $$\mathrm{A}$$ 的序列。

• $${\mathrm{A}}^{\ast }$$ 是一个可能是空的 $$\mathrm{A}$$ 迭代序列。 (这是 $${\mathrm{A}}^{\mathrm{n}}$$ 的简写，在 $$\mathrm{n}$$ 不相关的情况下使用。)

• $${\mathrm{A}}^{+}$$ 是一个非空的 $$\mathrm{A}$$ 迭代序列。 (这是 $${\mathrm{A}}^{\mathrm{n}}$$ 的简写，其中 $$\mathrm{n}\ge 1$$。)

• $${\mathrm{A}}^{?}$$ 是 $$\mathrm{A}$$ 的可选出现。 (这是 $${\mathrm{A}}^{\mathrm{n}}$$ 的简写，其中 $$\mathrm{n}\le 1$$。)

• 产生式写作 $$sym::={\mathrm{A}}_1|\dots |{\mathrm{A}}_{\mathrm{n}}$$.

• 大型产生式可以拆分为多个定义，用显式省略号 ($$sym::={\mathrm{A}}_1|\dots$$) 结束第一个定义，并用省略号 ($$sym::=\dots |{\mathrm{A}}_2$$) 开始后续定义。

• 有些产生式用圆括号 (“$$(\text{if}condition)$$”) 附加了边条件，用于简化将产生式组合扩展为多个独立情况的写法。

• 如果同一个元变量或非终结符在产生式中多次出现，则所有这些出现必须具有相同的实例化。 (这是对多个不同变量相等的要求的简写。)

2.1.2. 辅助符号

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

• $$ϵ$$ 表示空序列。

• $$|s|$$ 表示序列 $$\mathrm{s}$$ 的长度。

• $$\mathrm{s}[\mathrm{i}]$$ 表示序列 $$\mathrm{s}$$ 的第 $$\mathrm{i}$$ 个元素，从 $$0$$ 开始。

• $$\mathrm{s}[\mathrm{i}:\mathrm{n}]$$ 表示序列 $$\mathrm{s}[\mathrm{i}]\dots \mathrm{s}[\mathrm{i}+\mathrm{n}-1]$$ 的子序列。

• $$\mathrm{s}\text{with}[\mathrm{i}]=\mathrm{A}$$ 表示与 $$\mathrm{s}$$ 相同的序列，但将第 $$\mathrm{i}$$ 个元素替换为 $$\mathrm{A}$$。

• $$\mathrm{s}\text{with}[\mathrm{i}:\mathrm{n}]={\mathrm{A}}^{\mathrm{n}}$$ 表示与 $$\mathrm{s}$$ 相同的序列，除了子序列 $$\mathrm{s}[\mathrm{i}:\mathrm{n}]$$ 被替换为 $${\mathrm{A}}^{\mathrm{n}}$$.

• $$\mathrm{concat}({\mathrm{s}}^{\ast })$$ 表示通过连接所有序列 $${\mathrm{s}}_{\mathrm{i}}$$（在 $${\mathrm{s}}^{\ast }$$ 中）而形成的扁平序列。

此外，采用以下约定。

• 符号 $${\mathrm{x}}^{\mathrm{n}}$$，其中 $$\mathrm{x}$$ 是一个非终结符，被视为一个元变量，它遍历 $$\mathrm{x}$$ 的相应序列（类似于 $${\mathrm{x}}^{\ast }$$，$${\mathrm{x}}^{+}$$，$${\mathrm{x}}^{?}$$）。

• 当给定一个序列 $${\mathrm{x}}^{\mathrm{n}}$$ 时，则假设序列 $$({\mathrm{A}}_1\mathrm{x}{\mathrm{A}}_2{)}^{\mathrm{n}}$$ 中的 $$\mathrm{x}$$ 的出现与 $${\mathrm{x}}^{\mathrm{n}}$$ 呈逐点对应关系（类似于 $${\mathrm{x}}^{\ast }$$，$${\mathrm{x}}^{+}$$，$${\mathrm{x}}^{?}$$）。这隐式地表达了一种在序列上映射语法结构的形式。

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

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

• $$r.\mathsf{field}$$ 表示 $$\mathsf{field}$$ 组件在 $$\mathrm{r}$$ 中的内容。

• $$\mathrm{r}\text{with}\mathsf{field}=\mathrm{A}$$ 表示与 $$\mathrm{r}$$ 相同的记录，只是 $$\mathsf{field}$$ 组件的内容被替换为 $$\mathrm{A}$$.

• $${\mathrm{r}}_1\oplus {\mathrm{r}}_2$$ 表示两个具有相同字段序列的记录的组合，通过逐点追加每个序列来完成。

  $$\{{\mathsf{field}}_1{\mathrm{A}}_1^{\ast },{\mathsf{field}}_2{\mathrm{A}}_2^{\ast },\dots \}\oplus \{{\mathsf{field}}_1{\mathrm{B}}_1^{\ast },{\mathsf{field}}_2{\mathrm{B}}_2^{\ast },\dots \}=\{{\mathsf{field}}_1{\mathrm{A}}_1^{\ast }{\mathrm{B}}_1^{\ast },{\mathsf{field}}_2{\mathrm{A}}_2^{\ast }{\mathrm{B}}_2^{\ast },\dots \}$$

• $$⨁{\mathrm{r}}^{\ast }$$ 表示对一个记录序列进行组合，按顺序进行；如果序列为空，则结果记录的所有字段都为空。

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

• $$\mathrm{s}\text{with}[\mathrm{i}]pth=\mathrm{A}$$ 是 $$\mathrm{s}\text{with}[\mathrm{i}]=(\mathrm{s}[\mathrm{i}]\text{with}pth=\mathrm{A})$$ 的简写形式，

• $$\mathrm{r}\text{with}\mathsf{field}pth=\mathrm{A}$$ 是 $$\mathrm{r}\text{with}\mathsf{field}=(r.\mathsf{field}\text{with}pth=\mathrm{A})$$ 的简写形式，

其中 $$\mathrm{r}\text{with}.\mathsf{field}=\mathrm{A}$$ 简化为 $$\mathrm{r}\text{with}\mathsf{field}=\mathrm{A}$$。

2.1.3. 向量

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

2.2.1. 字节

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

2.2.2. 整数

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

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

2.2.3. 浮点数

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

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

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

其中 $$\mathrm{M}=\mathrm{signif}(\mathrm{N})$$ 且 $$\mathrm{E}=\mathrm{expon}(\mathrm{N})$$，

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

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

2.2.4. 向量

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

2.2.5. 名称

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

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

2.3.1. 数值类型

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

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

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

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

2.3.2. 向量类型

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

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

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

2.3.3. 引用类型

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

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

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

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

2.3.4. 值类型

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

2.3.5. 结果类型

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

2.3.6. 函数类型

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

2.3.7. 限制

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

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

2.3.8. 内存类型

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

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

2.3.9. 表格类型

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

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

2.3.10. 全局类型

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

2.3.11. 外部类型

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

2.4.1. 数值指令

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

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

• 常量：返回一个静态常量。

• 一元运算：消耗一个操作数并生成一个相应类型的结果。

• 二元运算：消耗两个操作数并生成一个相应类型的结果。

• 测试：消耗一个相应类型的操作数并生成一个布尔整型结果。

• 比较：消耗两个相应类型的操作数并生成一个布尔整型结果。

• 转换：消耗一个类型的值并生成另一个类型的结果（转换的源类型是“$$\_$$”之后的那个）。

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

2.4.2. 向量指令

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

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

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

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

• 常量：返回一个静态常量。

• 一元运算：消耗一个 $$v128$$ 操作数并生成一个 $$v128$$ 结果。

• 二元运算：消耗两个 $$v128$$ 操作数并生成一个 $$v128$$ 结果。

• 三元运算：消耗三个 $$v128$$ 操作数并生成一个 $$v128$$ 结果。

• 测试：消耗一个 $$v128$$ 操作数并生成一个布尔整型结果。

• 移位：消耗一个 $$v128$$ 操作数和一个 $$i32$$ 操作数，生成一个 $$v128$$ 结果。

• 扩展：消耗一个数值类型的值并生成一个指定形状的 $$v128$$ 结果。

• 提取通道：消耗一个 $$v128$$ 操作数并返回给定通道中的数值。

• 替换通道：消耗一个 $$v128$$ 操作数和给定通道的数值，并生成一个 $$v128$$ 结果。

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

2.4.3. 引用指令

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

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

2.4.4. 参数指令

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

The $$\mathsf{drop}$$ instruction simply throws away a single operand.

The $$\mathsf{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.

2.4.5. 变量指令

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

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

2.4.6. 表指令

这组指令与表 table 相关。

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

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

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

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

另一个访问表的指令是 控制指令 $$call\_indirect$$。

2.4.7. 内存指令

这组指令涉及线性 内存。

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

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

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

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

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

2.4.8. 控制指令

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

指令 $$\mathsf{nop}$$ 什么也不做。

$$\mathsf{unreachable}$$ 指令会导致无条件的 陷阱。

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

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

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

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

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

2.4.9. 表达式

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

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

2.5.1. 索引

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

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

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

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

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

2.5.2. 类型

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

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

2.5.3. 函数

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

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

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

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

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

2.5.4. 表

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

表是特定 引用类型 的不透明值的向量。 表类型中的 $$\mathsf{min}$$ 大小指定了该表的初始大小，而其 $$\mathsf{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. 内存

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

内存是原始未解释字节的向量。 内存类型中的 $$\mathsf{min}$$ 大小指定了该内存的初始大小，而其 $$\mathsf{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$$.

2.5.6. 全局变量

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

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

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

2.5.7. 元素段

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

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

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

该$$\mathsf{offset}$$由常量表达式给出。

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

2.5.8. 数据段

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

模块的$$\mathsf{datas}$$组件定义数据段向量。

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

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

2.5.9. 开始函数

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

2.5.10. 导出

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

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