implement translate_end_func method

Author: Robbepop

crates/wasmi/src/engine/translator/func2/instrs.rs

@@ -25,7 +25,6 @@ impl InstrEncoder {
     /// Pushes an [`Instruction`] to the [`InstrEncoder`].
     ///
     /// Returns an [`Instr`] that refers to the pushed [`Instruction`].
-    #[must_use]
     pub fn push_instr(&mut self, instruction: Instruction) -> Instr {
         let instr = self.next_instr();
         self.instrs.push(instruction);

crates/wasmi/src/engine/translator/func2/mod.rs

@@ -28,14 +28,14 @@ use self::{
     utils::Reset,
 };
 use crate::{
-    core::{FuelCostsProvider, Typed, TypedVal},
+    core::{FuelCostsProvider, Typed, TypedVal, ValType},
     engine::{
         translator::{utils::FuelInfo, Instr, LabelRef, LabelRegistry, WasmTranslator},
         BlockType,
         CompiledFuncEntity,
         TranslationError,
     },
-    ir::{Const16, Instruction, Reg},
+    ir::{BoundedRegSpan, Const16, Const32, Instruction, Reg, RegSpan},
     module::{FuncIdx, ModuleHeader, WasmiValueType},
     Engine,
     Error,
@@ -250,14 +250,115 @@ impl FuncTranslator {
 
     /// Translates the end of the Wasm function enclosing Wasm `block`.
     fn translate_end_func(&mut self, frame: BlockControlFrame) -> Result<(), Error> {
-        let fuel_info = match (frame.consume_fuel_instr(), &self.fuel_costs) {
-            (Some(consume_fuel), Some(fuel_costs)) => {
+        let fuel_info = match (&self.fuel_costs, frame.consume_fuel_instr()) {
+            (Some(fuel_costs), Some(consume_fuel)) => {
                 FuelInfo::some(fuel_costs.clone(), consume_fuel)
             }
             (None, None) => FuelInfo::None,
             _ => unreachable!(),
         };
-        todo!()
+        let len_results = frame.ty().len_results(&self.engine);
+        if self.reachable && frame.is_branched_to() && len_results > 1 {
+            let height = frame.height();
+            let len_results = usize::from(len_results);
+            for depth in 0..len_results {
+                let result = self
+                    .layout
+                    .temp_to_reg(OperandIdx::from(height + len_results - depth - 1))?;
+                match self.stack.operand_to_temp(depth) {
+                    Some(Operand::Local(operand)) => {
+                        let value = self.layout.local_to_reg(operand.local_index())?;
+                        self.instrs.push_instr(Instruction::copy(result, value));
+                    }
+                    Some(Operand::Immediate(operand)) => {
+                        let val = operand.val();
+                        let instr = match operand.ty() {
+                            ValType::I32 => Instruction::copy_imm32(result, i32::from(val)),
+                            ValType::I64 => {
+                                let val = i64::from(val);
+                                match <Const32<i64>>::try_from(val) {
+                                    Ok(value) => Instruction::copy_i64imm32(result, value),
+                                    Err(_) => {
+                                        let value = self.layout.const_to_reg(val)?;
+                                        Instruction::copy(result, value)
+                                    }
+                                }
+                            }
+                            ValType::F32 => Instruction::copy_imm32(result, f32::from(val)),
+                            ValType::F64 => {
+                                let val = f64::from(val);
+                                match <Const32<f64>>::try_from(val) {
+                                    Ok(value) => Instruction::copy_f64imm32(result, value),
+                                    Err(_) => {
+                                        let value = self.layout.const_to_reg(val)?;
+                                        Instruction::copy(result, value)
+                                    }
+                                }
+                            }
+                            ValType::V128 | ValType::FuncRef | ValType::ExternRef => {
+                                let value = self.layout.const_to_reg(val)?;
+                                Instruction::copy(result, value)
+                            }
+                        };
+                        self.instrs.push_instr(instr);
+                    }
+                    _ => {}
+                }
+            }
+        }
+        self.labels
+            .pin_label(frame.label(), self.instrs.next_instr())
+            .unwrap_or_else(|err| panic!("failed to pin label: {err}"));
+        match len_results {
+            0 => {
+                self.instrs.push_instr(Instruction::Return);
+            }
+            1 => {
+                let instr = match self.stack.peek(0) {
+                    Operand::Local(operand) => {
+                        let value = self.layout.local_to_reg(operand.local_index())?;
+                        Instruction::return_reg(value)
+                    }
+                    Operand::Temp(operand) => {
+                        let value = self.layout.temp_to_reg(operand.operand_index())?;
+                        Instruction::return_reg(value)
+                    }
+                    Operand::Immediate(operand) => {
+                        let val = operand.val();
+                        match operand.ty() {
+                            ValType::I32 => Instruction::return_imm32(i32::from(val)),
+                            ValType::I64 => match <Const32<i64>>::try_from(i64::from(val)) {
+                                Ok(value) => Instruction::return_i64imm32(value),
+                                Err(_) => {
+                                    let value = self.layout.const_to_reg(val)?;
+                                    Instruction::return_reg(value)
+                                }
+                            },
+                            ValType::F32 => Instruction::return_imm32(f32::from(val)),
+                            ValType::F64 => match <Const32<f64>>::try_from(f64::from(val)) {
+                                Ok(value) => Instruction::return_f64imm32(value),
+                                Err(_) => {
+                                    let value = self.layout.const_to_reg(val)?;
+                                    Instruction::return_reg(value)
+                                }
+                            },
+                            ValType::V128 | ValType::FuncRef | ValType::ExternRef => {
+                                let value = self.layout.const_to_reg(val)?;
+                                Instruction::return_reg(value)
+                            }
+                        }
+                    }
+                };
+                self.instrs.push_instr(instr);
+            }
+            n => {
+                let height = frame.height();
+                let result = self.layout.temp_to_reg(OperandIdx::from(height - 1))?;
+                let values = BoundedRegSpan::new(RegSpan::new(result), len_results);
+                self.instrs.push_instr(Instruction::return_span(values));
+            }
+        }
+        Ok(())
     }
 
     /// Translates the end of a Wasm `loop` control frame.