Exception handling support (bytecodealliance#141)

* Implements exception handling

* fix bench

* rm ExceptionSection -> EventSection

* fix linking checks

* bump wasmparser and wasmprinter versions

* address review

Author: yurydelendik

Cargo.lock

@@ -22,6 +22,7 @@ struct Indices {
     globals: u32,
     tables: u32,
     memories: u32,
+    events: u32,
     modules: u32,
     instances: u32,
     types: u32,
@@ -73,6 +74,10 @@ impl<'a> Dump<'a> {
                             write!(me.state, "[memory {}]", i.memories)?;
                             i.memories += 1;
                         }
+                        ImportSectionEntryType::Event(_) => {
+                            write!(me.state, "[event {}]", i.events)?;
+                            i.events += 1;
+                        }
                         ImportSectionEntryType::Table(_) => {
                             write!(me.state, "[table {}]", i.tables)?;
                             i.tables += 1;
@@ -111,6 +116,11 @@ impl<'a> Dump<'a> {
                     i.memories += 1;
                     me.print(end)
                 })?,
+                Payload::EventSection(s) => self.section(s, "event", |me, end, m| {
+                    write!(me.state, "[event {}] {:?}", i.events, m)?;
+                    i.events += 1;
+                    me.print(end)
+                })?,
                 Payload::ExportSection(s) => self.section(s, "export", |me, end, e| {
                     write!(me.state, "export {:?}", e)?;
                     me.print(end)
@@ -130,6 +140,7 @@ impl<'a> Dump<'a> {
                         ExternalKind::Table => i.tables += 1,
                         ExternalKind::Instance => i.instances += 1,
                         ExternalKind::Memory => i.memories += 1,
+                        ExternalKind::Event => i.events += 1,
                         ExternalKind::Type => i.types += 1,
                     }
                     me.print(end)

crates/dump/src/lib.rs

@@ -1,6 +1,6 @@
 [package]
 name = "wasmparser"
-version = "0.67.0"
+version = "0.68.0"
 authors = ["Yury Delendik <ydelendik@mozilla.com>"]
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasm-tools/tree/main/crates/wasmparser"

crates/wasmparser/Cargo.toml

@@ -124,6 +124,11 @@ fn read_all_wasm(wasm: &[u8]) -> Result<()> {
                     item?;
                 }
             }
+            EventSection(s) => {
+                for item in s {
+                    item?;
+                }
+            }
             GlobalSection(s) => {
                 for item in s {
                     for op in item?.init_expr.get_operators_reader() {
@@ -210,6 +215,7 @@ fn validate_benchmark(c: &mut Criterion) {
             reference_types: true,
             multi_value: true,
             simd: true,
+            exceptions: true,
             module_linking: true,
             bulk_memory: true,
             threads: true,

crates/wasmparser/benches/benchmark.rs

@@ -6,5 +6,5 @@ git checkout main && \
 cargo bench --bench benchmark -- --noplot --save-baseline before
 
 # record current bench results
-git checkout - && \
+git checkout -f - && \
 cargo bench --bench benchmark -- --noplot --baseline before

crates/wasmparser/compare-with-main.sh

@@ -25,7 +25,7 @@ use crate::primitives::{
     ResizableLimits, ResizableLimits64, Result, SIMDLaneIndex, SectionCode, TableType, Type,
     TypeOrFuncType, V128,
 };
-use crate::{ExportType, Import, ImportSectionEntryType, InstanceType, ModuleType};
+use crate::{EventType, ExportType, Import, ImportSectionEntryType, InstanceType, ModuleType};
 
 const MAX_WASM_BR_TABLE_SIZE: usize = MAX_WASM_FUNCTION_SIZE;
 
@@ -186,6 +186,7 @@ impl<'a> BinaryReader<'a> {
             -0x05 => Ok(Type::V128),
             -0x10 => Ok(Type::FuncRef),
             -0x11 => Ok(Type::ExternRef),
+            -0x18 => Ok(Type::ExnRef),
             -0x20 => Ok(Type::Func),
             -0x40 => Ok(Type::EmptyBlockType),
             _ => Err(BinaryReaderError::new(
@@ -202,6 +203,7 @@ impl<'a> BinaryReader<'a> {
             1 => Ok(ExternalKind::Table),
             2 => Ok(ExternalKind::Memory),
             3 => Ok(ExternalKind::Global),
+            4 => Ok(ExternalKind::Event),
             5 => Ok(ExternalKind::Module),
             6 => Ok(ExternalKind::Instance),
             7 => Ok(ExternalKind::Type),
@@ -300,6 +302,7 @@ impl<'a> BinaryReader<'a> {
             ExternalKind::Function => ImportSectionEntryType::Function(self.read_var_u32()?),
             ExternalKind::Table => ImportSectionEntryType::Table(self.read_table_type()?),
             ExternalKind::Memory => ImportSectionEntryType::Memory(self.read_memory_type()?),
+            ExternalKind::Event => ImportSectionEntryType::Event(self.read_event_type()?),
             ExternalKind::Global => ImportSectionEntryType::Global(self.read_global_type()?),
             ExternalKind::Module => ImportSectionEntryType::Module(self.read_var_u32()?),
             ExternalKind::Instance => ImportSectionEntryType::Instance(self.read_var_u32()?),
@@ -368,6 +371,18 @@ impl<'a> BinaryReader<'a> {
         }
     }
 
+    pub(crate) fn read_event_type(&mut self) -> Result<EventType> {
+        let attribute = self.read_var_u32()?;
+        if attribute != 0 {
+            return Err(BinaryReaderError::new(
+                "invalid event attributes",
+                self.original_position() - 1,
+            ));
+        }
+        let type_index = self.read_var_u32()?;
+        Ok(EventType { type_index })
+    }
+
     pub(crate) fn read_global_type(&mut self) -> Result<GlobalType> {
         Ok(GlobalType {
             content_type: self.read_type()?,
@@ -434,6 +449,7 @@ impl<'a> BinaryReader<'a> {
             10 => Ok(SectionCode::Code),
             11 => Ok(SectionCode::Data),
             12 => Ok(SectionCode::DataCount),
+            13 => Ok(SectionCode::Event),
             100 => Ok(SectionCode::Module),
             101 => Ok(SectionCode::Instance),
             102 => Ok(SectionCode::Alias),
@@ -1082,6 +1098,18 @@ impl<'a> BinaryReader<'a> {
                 ty: self.read_blocktype()?,
             },
             0x05 => Operator::Else,
+            0x06 => Operator::Try {
+                ty: self.read_blocktype()?,
+            },
+            0x07 => Operator::Catch,
+            0x08 => Operator::Throw {
+                index: self.read_var_u32()?,
+            },
+            0x09 => Operator::Rethrow,
+            0x0a => Operator::BrOnExn {
+                relative_depth: self.read_var_u32()?,
+                index: self.read_var_u32()?,
+            },
             0x0b => Operator::End,
             0x0c => Operator::Br {
                 relative_depth: self.read_var_u32()?,

crates/wasmparser/src/binary_reader.rs

@@ -35,3 +35,4 @@ pub const MAX_WASM_TABLES: usize = 100;
 pub const MAX_WASM_MEMORIES: usize = 100;
 pub const MAX_WASM_MODULES: usize = 1_000;
 pub const MAX_WASM_INSTANCES: usize = 1_000;
+pub const MAX_WASM_EVENTS: usize = 1_000_000;

crates/wasmparser/src/limits.rs

@@ -110,6 +110,8 @@ enum FrameKind {
     If,
     Else,
     Loop,
+    Try,
+    Catch,
 }
 
 impl OperatorValidator {
@@ -394,6 +396,15 @@ impl OperatorValidator {
         Ok(())
     }
 
+    fn check_exceptions_enabled(&self) -> OperatorValidatorResult<()> {
+        if !self.features.exceptions {
+            return Err(OperatorValidatorError::new(
+                "Exceptions support is not enabled",
+            ));
+        }
+        Ok(())
+    }
+
     fn check_bulk_memory_enabled(&self) -> OperatorValidatorResult<()> {
         if !self.features.bulk_memory {
             return Err(OperatorValidatorError::new(
@@ -561,17 +572,78 @@ impl OperatorValidator {
                 }
                 self.push_ctrl(FrameKind::Else, frame.block_type, resources)?;
             }
+            Operator::Try { ty } => {
+                self.check_exceptions_enabled()?;
+                self.check_block_type(ty, resources)?;
+                for ty in params(ty, resources)?.rev() {
+                    self.pop_operand(Some(ty))?;
+                }
+                self.push_ctrl(FrameKind::Try, ty, resources)?;
+            }
+            Operator::Catch => {
+                self.check_exceptions_enabled()?;
+                let frame = self.pop_ctrl(resources)?;
+                if frame.kind != FrameKind::Try {
+                    bail_op_err!("catch found outside of an `try` block");
+                }
+                // Start a new frame and push `exnref` value.
+                self.control.push(Frame {
+                    kind: FrameKind::Catch,
+                    block_type: frame.block_type,
+                    height: self.operands.len(),
+                    unreachable: false,
+                });
+                self.push_operand(Type::ExnRef)?;
+            }
+            Operator::Throw { index } => {
+                self.check_exceptions_enabled()?;
+                // Check values associated with the exception.
+                let ty = func_type_at(&resources, index)?;
+                for ty in ty.inputs().rev() {
+                    self.pop_operand(Some(ty))?;
+                }
+                if ty.outputs().len() > 0 {
+                    bail_op_err!("result type expected to be empty for exception");
+                }
+                self.unreachable();
+            }
+            Operator::Rethrow => {
+                self.check_exceptions_enabled()?;
+                self.pop_operand(Some(Type::ExnRef))?;
+                self.unreachable();
+            }
+            Operator::BrOnExn {
+                relative_depth,
+                index,
+            } => {
+                self.check_exceptions_enabled()?;
+                let (ty, kind) = self.jump(relative_depth)?;
+                self.pop_operand(Some(Type::ExnRef))?;
+                // Check the exception's argument values with target block's.
+                let exn_args = func_type_at(&resources, index)?;
+                if Iterator::ne(exn_args.inputs(), label_types(ty, resources, kind)?) {
+                    bail_op_err!("target block types do not match");
+                }
+                self.push_operand(Type::ExnRef)?;
+            }
             Operator::End => {
                 let mut frame = self.pop_ctrl(resources)?;
 
                 // Note that this `if` isn't included in the appendix right
                 // now, but it's used to allow for `if` statements that are
                 // missing an `else` block which have the same parameter/return
                 // types on the block (since that's valid).
-                if frame.kind == FrameKind::If {
-                    self.push_ctrl(FrameKind::Else, frame.block_type, resources)?;
-                    frame = self.pop_ctrl(resources)?;
+                match frame.kind {
+                    FrameKind::If => {
+                        self.push_ctrl(FrameKind::Else, frame.block_type, resources)?;
+                        frame = self.pop_ctrl(resources)?;
+                    }
+                    FrameKind::Try => {
+                        bail_op_err!("expected catch block");
+                    }
+                    _ => (),
                 }
+
                 for ty in results(frame.block_type, resources)? {
                     self.push_operand(ty)?;
                 }
@@ -1842,6 +1914,7 @@ fn ty_to_str(ty: Type) -> &'static str {
         Type::V128 => "v128",
         Type::FuncRef => "funcref",
         Type::ExternRef => "externref",
+        Type::ExnRef => "exnref",
         Type::Func => "func",
         Type::EmptyBlockType => "nil",
     }

crates/wasmparser/src/operators_validator.rs

@@ -1,3 +1,4 @@
+use crate::EventSectionReader;
 use crate::{AliasSectionReader, InstanceSectionReader, ModuleSectionReader};
 use crate::{BinaryReader, BinaryReaderError, FunctionBody, Range, Result};
 use crate::{DataSectionReader, ElementSectionReader, ExportSectionReader};
@@ -111,6 +112,9 @@ pub enum Payload<'a> {
     /// A memory section was received, and the provided reader can be used to
     /// parse the contents of the memory section.
     MemorySection(crate::MemorySectionReader<'a>),
+    /// An event section was received, and the provided reader can be used to
+    /// parse the contents of the event section.
+    EventSection(crate::EventSectionReader<'a>),
     /// A global section was received, and the provided reader can be used to
     /// parse the contents of the global section.
     GlobalSection(crate::GlobalSectionReader<'a>),
@@ -342,6 +346,7 @@ impl Parser {
     ///             FunctionSection(_) => { /* ... */ }
     ///             TableSection(_) => { /* ... */ }
     ///             MemorySection(_) => { /* ... */ }
+    ///             EventSection(_) => { /* ... */ }
     ///             GlobalSection(_) => { /* ... */ }
     ///             ExportSection(_) => { /* ... */ }
     ///             StartSection { .. } => { /* ... */ }
@@ -526,6 +531,7 @@ impl Parser {
                         let (count, range) = single_u32(reader, len, "data count")?;
                         Ok(DataCountSection { count, range })
                     }
+                    13 => section(reader, len, EventSectionReader::new, EventSection),
                     100 => section(reader, len, ModuleSectionReader::new, ModuleSection),
                     101 => section(reader, len, InstanceSectionReader::new, InstanceSection),
                     102 => section(reader, len, AliasSectionReader::new, AliasSection),
@@ -906,6 +912,7 @@ impl fmt::Debug for Payload<'_> {
             FunctionSection(_) => f.debug_tuple("FunctionSection").field(&"...").finish(),
             TableSection(_) => f.debug_tuple("TableSection").field(&"...").finish(),
             MemorySection(_) => f.debug_tuple("MemorySection").field(&"...").finish(),
+            EventSection(_) => f.debug_tuple("EventSection").field(&"...").finish(),
             GlobalSection(_) => f.debug_tuple("GlobalSection").field(&"...").finish(),
             ExportSection(_) => f.debug_tuple("ExportSection").field(&"...").finish(),
             ElementSection(_) => f.debug_tuple("ElementSection").field(&"...").finish(),

crates/wasmparser/src/parser.rs

@@ -114,6 +114,7 @@ pub enum SectionCode<'a> {
     Code,       // Function bodies (code)
     Data,       // Data segments
     DataCount,  // Count of passive data segments
+    Event,      // Event declarations
 }
 
 /// Types as defined [here].
@@ -128,6 +129,7 @@ pub enum Type {
     V128,
     FuncRef,
     ExternRef,
+    ExnRef,
     Func,
     EmptyBlockType,
 }
@@ -153,6 +155,7 @@ pub enum ExternalKind {
     Function,
     Table,
     Memory,
+    Event,
     Global,
     Type,
     Module,
@@ -219,6 +222,11 @@ pub enum MemoryType {
     },
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct EventType {
+    pub type_index: u32,
+}
+
 impl MemoryType {
     pub fn index_type(&self) -> Type {
         match self {
@@ -239,6 +247,7 @@ pub enum ImportSectionEntryType {
     Function(u32),
     Table(TableType),
     Memory(MemoryType),
+    Event(EventType),
     Global(GlobalType),
     Module(u32),
     Instance(u32),
@@ -337,6 +346,11 @@ pub enum Operator<'a> {
     Loop { ty: TypeOrFuncType },
     If { ty: TypeOrFuncType },
     Else,
+    Try { ty: TypeOrFuncType },
+    Catch,
+    Throw { index: u32 },
+    Rethrow,
+    BrOnExn { relative_depth: u32, index: u32 },
     End,
     Br { relative_depth: u32 },
     BrIf { relative_depth: u32 },