Merge branch 'master' into feat-interface-types-record-instructions

src/decoders/binary.rs

@@ -188,7 +188,7 @@ fn instruction<'input, E: ParseError<&'input [u8]>>(
             (
                 input,
                 Instruction::CallCore {
-                    function_index: argument_0 as usize,
+                    function_index: argument_0 as u32,
                 },
             )
         }

src/decoders/wat.rs

@@ -170,7 +170,7 @@ impl<'a> Parse<'a> for Instruction {
             parser.parse::<keyword::call_core>()?;
 
             Ok(Instruction::CallCore {
-                function_index: parser.parse::<u64>()? as usize,
+                function_index: parser.parse::<u32>()?,
             })
         } else if lookahead.peek::<keyword::s8_from_i32>() {
             parser.parse::<keyword::s8_from_i32>()?;

src/errors.rs

@@ -8,6 +8,7 @@ use crate::{
 use std::{
     error::Error,
     fmt::{self, Display, Formatter},
+    num::TryFromIntError,
     result::Result,
     string::{self, ToString},
 };
@@ -153,6 +154,12 @@ pub enum InstructionErrorKind {
     /// The string contains invalid UTF-8 encoding.
     String(string::FromUtf8Error),
 
+    /// Out of range integral type conversion attempted.
+    NegativeValue {
+        /// The variable name that triggered the error.
+        subject: &'static str,
+    },
+
     /// The type doesn't exist.
     TypeIsMissing {
         /// The type index.
@@ -237,6 +244,12 @@ impl Display for InstructionErrorKind {
 
             Self::String(error) => write!(formatter, "{}", error),
 
+            Self::NegativeValue { subject } => write!(
+                formatter,
+                "attempted to convert `{}` but it appears to be a negative value",
+                subject
+            ),
+
             Self::TypeIsMissing { type_index } => write!(
                 formatter,
                 "the type `{}` doesn't exist",
@@ -251,3 +264,9 @@ impl Display for InstructionErrorKind {
         }
     }
 }
+
+impl From<(TryFromIntError, &'static str)> for InstructionErrorKind {
+    fn from((_, subject): (TryFromIntError, &'static str)) -> Self {
+        InstructionErrorKind::NegativeValue { subject }
+    }
+}

src/interpreter/instructions/argument_get.rs

@@ -8,7 +8,7 @@ executable_instruction!(
         move |runtime| -> _ {
             let invocation_inputs = runtime.invocation_inputs;
 
-            if index >= (invocation_inputs.len() as u32) {
+            if (index as usize) >= invocation_inputs.len() {
                 return Err(InstructionError::new(
                     instruction,
                     InstructionErrorKind::InvocationInputIsMissing { index },

src/interpreter/instructions/call_core.rs

@@ -8,16 +8,16 @@ use crate::{
 };
 
 executable_instruction!(
-    call_core(function_index: usize, instruction: Instruction) -> _ {
+    call_core(function_index: u32, instruction: Instruction) -> _ {
         move |runtime| -> _ {
             let instance = &mut runtime.wasm_instance;
-            let index = FunctionIndex::new(function_index);
+            let index = FunctionIndex::new(function_index as usize);
 
             let local_or_import = instance.local_or_import(index).ok_or_else(|| {
                 InstructionError::new(
                     instruction,
                     InstructionErrorKind::LocalOrImportIsMissing {
-                        function_index: function_index as u32,
+                        function_index: function_index,
                     },
                 )
             })?;
@@ -40,7 +40,7 @@ executable_instruction!(
                 return Err(InstructionError::new(
                     instruction,
                     InstructionErrorKind::LocalOrImportSignatureMismatch {
-                        function_index: function_index as u32,
+                        function_index: function_index,
                         expected: (local_or_import.inputs().to_vec(), vec![]),
                         received: (input_types, vec![]),
                     },
@@ -51,7 +51,7 @@ executable_instruction!(
                 InstructionError::new(
                     instruction,
                     InstructionErrorKind::LocalOrImportCall {
-                        function_index: function_index as u32,
+                        function_index: function_index,
                     },
                 )
             })?;

src/interpreter/instructions/strings.rs

@@ -10,7 +10,7 @@ use crate::{
         Instruction,
     },
 };
-use std::cell::Cell;
+use std::{cell::Cell, convert::TryInto};
 
 executable_instruction!(
     string_lift_memory(instruction: Instruction) -> _ {
@@ -23,7 +23,6 @@ executable_instruction!(
             })?;
 
             let memory_index: u32 = 0;
-
             let memory = runtime
                 .wasm_instance
                 .memory(memory_index as usize)
@@ -34,8 +33,14 @@ executable_instruction!(
                     )
                 })?;
 
-            let pointer = to_native::<i32>(&inputs[0], instruction)? as usize;
-            let length = to_native::<i32>(&inputs[1], instruction)? as usize;
+            let pointer: usize = to_native::<i32>(&inputs[0], instruction)?
+                .try_into()
+                .map_err(|e| (e, "pointer").into())
+                .map_err(|k| InstructionError::new(instruction, k))?;
+            let length: usize = to_native::<i32>(&inputs[1], instruction)?
+                .try_into()
+                .map_err(|e| (e, "length").into())
+                .map_err(|k| InstructionError::new(instruction, k))?;
             let memory_view = memory.view();
 
             if length == 0 {
@@ -102,7 +107,12 @@ executable_instruction!(
 
             let string: String = to_native(&string, instruction)?;
             let string_bytes = string.as_bytes();
-            let string_length = string_bytes.len() as i32;
+            let string_length: i32 = string_bytes.len().try_into().map_err(|_| {
+                InstructionError::new(
+                    instruction,
+                    InstructionErrorKind::NegativeValue { subject: "string_length" },
+                )
+            })?;
 
             let outputs = allocator.call(&[InterfaceValue::I32(string_length)]).map_err(|_| {
                 InstructionError::new(
@@ -110,7 +120,12 @@ executable_instruction!(
                     InstructionErrorKind::LocalOrImportCall { function_index: allocator_index },
                 )
             })?;
-            let string_pointer: i32 = to_native(&outputs[0], instruction)?;
+            let string_pointer: u32 = to_native::<i32>(&outputs[0], instruction)?.try_into().map_err(|_| {
+                InstructionError::new(
+                    instruction,
+                    InstructionErrorKind::NegativeValue { subject: "string_pointer" },
+                )
+            })?;
 
             let memory_index: u32 = 0;
             let memory_view = instance
@@ -127,7 +142,7 @@ executable_instruction!(
                 memory_view[string_pointer as usize + nth].set(*byte);
             }
 
-            runtime.stack.push(InterfaceValue::I32(string_pointer));
+            runtime.stack.push(InterfaceValue::I32(string_pointer as i32));
             runtime.stack.push(InterfaceValue::I32(string_length));
 
             Ok(())
@@ -203,6 +218,42 @@ mod tests {
             stack: [InterfaceValue::String("".into())],
     );
 
+    test_executable_instruction!(
+        test_string_lift_memory__negative_pointer =
+            instructions: [
+                Instruction::ArgumentGet { index: 0 },
+                Instruction::ArgumentGet { index: 1 },
+                Instruction::StringLiftMemory,
+            ],
+            invocation_inputs: [
+                InterfaceValue::I32(-42),
+                InterfaceValue::I32(13),
+            ],
+            instance: Instance {
+                memory: Memory::new("Hello!".as_bytes().iter().map(|u| Cell::new(*u)).collect()),
+                ..Default::default()
+            },
+            error: r#"`string.lift_memory` attempted to convert `pointer` but it appears to be a negative value"#,
+    );
+
+    test_executable_instruction!(
+        test_string_lift_memory__negative_length =
+            instructions: [
+                Instruction::ArgumentGet { index: 0 },
+                Instruction::ArgumentGet { index: 1 },
+                Instruction::StringLiftMemory,
+            ],
+            invocation_inputs: [
+                InterfaceValue::I32(0),
+                InterfaceValue::I32(-1),
+            ],
+            instance: Instance {
+                memory: Memory::new("Hello!".as_bytes().iter().map(|u| Cell::new(*u)).collect()),
+                ..Default::default()
+            },
+            error: r#"`string.lift_memory` attempted to convert `length` but it appears to be a negative value"#,
+    );
+
     test_executable_instruction!(
         test_string_lift_memory__read_out_of_memory =
             instructions: [