From 6e9d5a49d207b1ee64560fa0be2d6e947e11a2e7 Mon Sep 17 00:00:00 2001 From: Jeff Date: Sat, 8 Feb 2025 11:45:03 -0500 Subject: [PATCH] Add tests for multiply instruction --- dust-lang/Cargo.toml | 4 + dust-lang/src/instruction/mod.rs | 7 ++ dust-lang/src/vm/action.rs | 52 +++++++++- dust-lang/tests/math/multiply.rs | 171 +++++++++++++++++++++++++++++++ 4 files changed, 232 insertions(+), 2 deletions(-) create mode 100644 dust-lang/tests/math/multiply.rs diff --git a/dust-lang/Cargo.toml b/dust-lang/Cargo.toml index b286211..67d787a 100644 --- a/dust-lang/Cargo.toml +++ b/dust-lang/Cargo.toml @@ -46,3 +46,7 @@ path = "tests/math/add.rs" [[test]] name = "subtract" path = "tests/math/subtract.rs" + +[[test]] +name = "multiply" +path = "tests/math/multiply.rs" diff --git a/dust-lang/src/instruction/mod.rs b/dust-lang/src/instruction/mod.rs index 0b1d28a..2e2538d 100644 --- a/dust-lang/src/instruction/mod.rs +++ b/dust-lang/src/instruction/mod.rs @@ -346,6 +346,13 @@ impl Instruction { Operand::Register(destination, left.as_type()) } + Operation::MULTIPLY => { + let Multiply { + destination, left, .. + } = Multiply::from(*self); + + Operand::Register(destination, left.as_type()) + } unsupported => todo!("Support {unsupported}"), } } diff --git a/dust-lang/src/vm/action.rs b/dust-lang/src/vm/action.rs index 51af851..c166b09 100644 --- a/dust-lang/src/vm/action.rs +++ b/dust-lang/src/vm/action.rs @@ -675,7 +675,7 @@ pub fn subtract(instruction: InstructionFields, thread: &mut Thread) { thread.set_float_register(destination, register); } - _ => unimplemented!(), + _ => unreachable!(), } } @@ -689,6 +689,54 @@ pub fn multiply(instruction: InstructionFields, thread: &mut Thread) { let right_is_constant = instruction.c_is_constant; match (left_type, right_type) { + (TypeCode::BYTE, TypeCode::BYTE) => { + let left_value = if left_is_constant { + if cfg!(debug_assertions) { + thread.get_constant(left).as_byte().unwrap() + } else { + unsafe { thread.get_constant(left).as_byte().unwrap_unchecked() } + } + } else { + thread.get_byte_register(left) + }; + let right_value = if right_is_constant { + if cfg!(debug_assertions) { + thread.get_constant(right).as_byte().unwrap() + } else { + unsafe { thread.get_constant(right).as_byte().unwrap_unchecked() } + } + } else { + thread.get_byte_register(right) + }; + let result = left_value.saturating_mul(*right_value); + let register = Register::Value(result); + + thread.set_byte_register(destination, register); + } + (TypeCode::FLOAT, TypeCode::FLOAT) => { + let left_value = if left_is_constant { + if cfg!(debug_assertions) { + thread.get_constant(left).as_float().unwrap() + } else { + unsafe { thread.get_constant(left).as_float().unwrap_unchecked() } + } + } else { + thread.get_float_register(left) + }; + let right_value = if right_is_constant { + if cfg!(debug_assertions) { + thread.get_constant(right).as_float().unwrap() + } else { + unsafe { thread.get_constant(right).as_float().unwrap_unchecked() } + } + } else { + thread.get_float_register(right) + }; + let result = left_value * right_value; + let register = Register::Value(result); + + thread.set_float_register(destination, register); + } (TypeCode::INTEGER, TypeCode::INTEGER) => { let left_value = if left_is_constant { if cfg!(debug_assertions) { @@ -708,7 +756,7 @@ pub fn multiply(instruction: InstructionFields, thread: &mut Thread) { } else { thread.get_integer_register(right) }; - let result = left_value * right_value; + let result = left_value.saturating_mul(*right_value); let register = Register::Value(result); thread.set_integer_register(destination as usize, register); diff --git a/dust-lang/tests/math/multiply.rs b/dust-lang/tests/math/multiply.rs new file mode 100644 index 0000000..0cb051a --- /dev/null +++ b/dust-lang/tests/math/multiply.rs @@ -0,0 +1,171 @@ +use dust_lang::{ + Chunk, ConcreteValue, FunctionType, Instruction, Operand, Span, Type, Value, compile, + instruction::TypeCode, run, +}; + +#[test] +fn multiply_bytes() { + let source = "0x0A * 0x02"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Byte), + instructions: vec![ + Instruction::load_encoded(0, 10, TypeCode::BYTE, false), + Instruction::load_encoded(1, 2, TypeCode::BYTE, false), + Instruction::multiply( + 2, + Operand::Register(0, TypeCode::BYTE), + Operand::Register(1, TypeCode::BYTE), + ), + Instruction::r#return(true, 2, TypeCode::BYTE), + ], + positions: vec![Span(0, 4), Span(7, 11), Span(0, 11), Span(11, 11)], + ..Chunk::default() + }; + let return_value = Some(Value::byte(0x14)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn multiply_many_bytes() { + let source = "0x0A * 0x02 * 0x02"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Byte), + instructions: vec![ + Instruction::load_encoded(0, 10, TypeCode::BYTE, false), + Instruction::load_encoded(1, 2, TypeCode::BYTE, false), + Instruction::multiply( + 2, + Operand::Register(0, TypeCode::BYTE), + Operand::Register(1, TypeCode::BYTE), + ), + Instruction::load_encoded(3, 2, TypeCode::BYTE, false), + Instruction::multiply( + 4, + Operand::Register(2, TypeCode::BYTE), + Operand::Register(3, TypeCode::BYTE), + ), + Instruction::r#return(true, 4, TypeCode::BYTE), + ], + positions: vec![ + Span(0, 4), + Span(7, 11), + Span(0, 11), + Span(14, 18), + Span(0, 18), + Span(18, 18), + ], + ..Chunk::default() + }; + let return_value = Some(Value::byte(0x28)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn multiply_floats() { + let source = "0.5 * 2.0"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Float), + instructions: vec![ + Instruction::multiply( + 0, + Operand::Constant(0, TypeCode::FLOAT), + Operand::Constant(1, TypeCode::FLOAT), + ), + Instruction::r#return(true, 0, TypeCode::FLOAT), + ], + positions: vec![Span(0, 9), Span(9, 9)], + constants: vec![ConcreteValue::Float(0.5), ConcreteValue::Float(2.0)], + ..Chunk::default() + }; + let return_value = Some(Value::float(1.0)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn multiply_many_floats() { + let source = "0.5 * 2.0 * 0.5"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Float), + instructions: vec![ + Instruction::multiply( + 0, + Operand::Constant(0, TypeCode::FLOAT), + Operand::Constant(1, TypeCode::FLOAT), + ), + Instruction::multiply( + 1, + Operand::Register(0, TypeCode::FLOAT), + Operand::Constant(0, TypeCode::FLOAT), + ), + Instruction::r#return(true, 1, TypeCode::FLOAT), + ], + positions: vec![Span(0, 9), Span(0, 15), Span(15, 15)], + constants: vec![ConcreteValue::Float(0.5), ConcreteValue::Float(2.0)], + ..Chunk::default() + }; + let return_value = Some(Value::float(0.5)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn multiply_integers() { + let source = "10 * 5"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Integer), + instructions: vec![ + Instruction::multiply( + 0, + Operand::Constant(0, TypeCode::INTEGER), + Operand::Constant(1, TypeCode::INTEGER), + ), + Instruction::r#return(true, 0, TypeCode::INTEGER), + ], + positions: vec![Span(0, 6), Span(6, 6)], + constants: vec![ConcreteValue::Integer(10), ConcreteValue::Integer(5)], + ..Chunk::default() + }; + let return_value = Some(Value::integer(50)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +} + +#[test] +fn multiply_many_integers() { + let source = "10 * 5 * 2"; + let chunk = Chunk { + r#type: FunctionType::new([], [], Type::Integer), + instructions: vec![ + Instruction::multiply( + 0, + Operand::Constant(0, TypeCode::INTEGER), + Operand::Constant(1, TypeCode::INTEGER), + ), + Instruction::multiply( + 1, + Operand::Register(0, TypeCode::INTEGER), + Operand::Constant(2, TypeCode::INTEGER), + ), + Instruction::r#return(true, 1, TypeCode::INTEGER), + ], + positions: vec![Span(0, 6), Span(0, 10), Span(10, 10)], + constants: vec![ + ConcreteValue::Integer(10), + ConcreteValue::Integer(5), + ConcreteValue::Integer(2), + ], + ..Chunk::default() + }; + let return_value = Some(Value::integer(100)); + + assert_eq!(chunk, compile(source).unwrap()); + assert_eq!(return_value, run(source).unwrap()); +}