wasmi_ir2: generate Op::result_ref getter method (#1663)

* change codegen of Op::result_mut

* add Op::result_ref method

* bump expected filesizes

* simplify result_{mut,ref} code generator

* rename result_mut.rs file into just result.rs

* fix indentation of Op::code method

* mention utility methods in docs of Op type

* add proper newlines for docs

Author: Robbepop

crates/ir2/build/display/mod.rs

@@ -4,7 +4,7 @@ mod encode;
 mod ident;
 mod op;
 mod op_code;
-mod result_mut;
+mod result;
 mod utils;
 
 pub use self::{
@@ -13,7 +13,7 @@ pub use self::{
     encode::DisplayEncode,
     op::DisplayOp,
     op_code::DisplayOpCode,
-    result_mut::DisplayResultMut,
+    result::DisplayResultMut,
     utils::Indent,
 };
 use crate::build::{display::ident::DisplayIdent, op::Op};
@@ -36,6 +36,5 @@ macro_rules! impl_trait_for_op {
 apply_macro_for_ops!(impl_trait_for_op, DisplayOp);
 apply_macro_for_ops!(impl_trait_for_op, DisplayIdent);
 apply_macro_for_ops!(impl_trait_for_op, DisplayConstructor);
-apply_macro_for_ops!(impl_trait_for_op, DisplayResultMut);
 apply_macro_for_ops!(impl_trait_for_op, DisplayEncode);
 apply_macro_for_ops!(impl_trait_for_op, DisplayDecode);

crates/ir2/build/display/op.rs

@@ -81,6 +81,12 @@ impl Display for DisplayOp<&'_ Isa> {
             f,
             "\
             {indent}/// A Wasmi bytecode operator or instruction.\n\
+            {indent}///\n\
+            {indent}/// The [`Op`] type features a small utility API:\n\
+            {indent}///\n\
+            {indent}/// - [`Op::result_ref`]\n\
+            {indent}/// - [`Op::result_mut`]\n\
+            {indent}/// - [`Op::code`]\n\
             {indent}#[allow(non_camel_case_types)]\n\
             {indent}#[derive(Debug)]\n\
             {indent}pub enum Op {{\n\

crates/ir2/build/display/op_code.rs

@@ -65,7 +65,7 @@ impl Display for DisplayOpCode<&'_ Isa> {
             {indent}}}\n\
             \n\
             {indent}impl Op {{\n\
-            {indent}    /// Returns the [`OpCode`] associated to `self`.
+            {indent}    /// Returns the [`OpCode`] associated to `self`.\n\
             {indent}    pub fn code(&self) -> OpCode {{\n\
             {indent}        match self {{\n\
                                 {match_arms_code}\n\

crates/ir2/build/display/result.rs

@@ -0,0 +1,88 @@
+use crate::build::{
+    display::{ident::DisplayIdent, utils::DisplaySequence, Indent},
+    isa::Isa,
+    op::Op,
+};
+use core::fmt::{self, Display};
+
+pub struct DisplayResultMut<T> {
+    pub value: T,
+    pub indent: Indent,
+}
+
+impl<T> DisplayResultMut<T> {
+    pub fn new(value: T, indent: Indent) -> Self {
+        Self { value, indent }
+    }
+}
+
+impl Display for DisplayResultMut<&'_ Isa> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let indent = self.indent;
+        let variants = DisplaySequence::new(
+            "\n",
+            self.value
+                .ops
+                .iter()
+                .filter(|op| op.has_result())
+                .map(|op| DisplayResultMut::new(op, indent.inc_by(3))),
+        );
+        write!(
+            f,
+            "\
+            {indent}impl Op {{\n\
+            {indent}    /// Returns a shared reference to the result [`Slot`] of `self` if any.\n\
+            {indent}    pub fn result_ref(&self) -> Option<&Slot> {{\n\
+            {indent}        let res = match self {{\n\
+                                {variants} => result,\n\
+            {indent}            _ => return None,\n\
+            {indent}        }};\n\
+            {indent}        Some(res)\n\
+            {indent}    }}\n\
+            \n\
+            {indent}    /// Returns an exclusive reference to the result [`Slot`] of `self` if any.\n\
+            {indent}    pub fn result_mut(&mut self) -> Option<&mut Slot> {{\n\
+            {indent}        let res = match self {{\n\
+                                {variants} => result,\n\
+            {indent}            _ => return None,\n\
+            {indent}        }};\n\
+            {indent}        Some(res)\n\
+            {indent}    }}\n\
+            {indent}}}\n\
+        "
+        )
+    }
+}
+
+impl Display for DisplayResultMut<&'_ Op> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let indent = self.indent;
+        let ident = DisplayIdent::camel(self.value);
+        write!(f, "{indent}| Self::{ident} {{ result, .. }}")
+    }
+}
+
+impl Op {
+    /// Returns `true` if `self` has a result field.
+    pub fn has_result(&self) -> bool {
+        match self {
+            Op::Unary(_) => true,
+            Op::Binary(_) => true,
+            Op::Ternary(_) => true,
+            Op::CmpBranch(_) => false,
+            Op::CmpSelect(_) => true,
+            Op::Load(_) => true,
+            Op::Store(_) => false,
+            Op::TableGet(_) => true,
+            Op::TableSet(_) => false,
+            Op::Generic0(op) => op.has_result(),
+            Op::Generic1(op) => op.has_result(),
+            Op::Generic2(op) => op.has_result(),
+            Op::Generic3(op) => op.has_result(),
+            Op::Generic4(op) => op.has_result(),
+            Op::Generic5(op) => op.has_result(),
+            Op::V128ReplaceLane(_) => true,
+            Op::V128LoadLane(_) => true,
+        }
+    }
+}

crates/ir2/build/display/result_mut.rs

@@ -75,8 +75,8 @@ pub fn generate_code(config: &Config) -> Result<(), Error> {
 
 fn generate_op_rs(config: &Config, isa: &Isa, contents: &mut String) -> Result<(), Error> {
     let expected_size = match config.simd {
-        true => 210_000,
-        false => 135_000,
+        true => 235_000,
+        false => 150_000,
     };
     write_to_buffer(contents, expected_size, |buffer| {
         write!(