Paged memory allocation

fuel-asm/Cargo.toml

@@ -14,6 +14,7 @@ description = "Atomic types of the FuelVM."
 arbitrary = { version = "1.1", features = ["derive"], optional = true }
 bitflags = "1.3"
 fuel-types = { workspace = true, default-features = false }
+num_enum = "0.6"
 serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
 strum = { version = "0.24", default-features = false, features = ["derive"] }
 

fuel-asm/src/encoding_tests.rs

@@ -69,41 +69,7 @@ fn opcode() {
 fn panic_reason_description() {
     let imm24 = 0xbfffff;
 
-    let reasons = vec![
-        PanicReason::Revert,
-        PanicReason::OutOfGas,
-        PanicReason::TransactionValidity,
-        PanicReason::MemoryOverflow,
-        PanicReason::ArithmeticOverflow,
-        PanicReason::ContractNotFound,
-        PanicReason::MemoryOwnership,
-        PanicReason::NotEnoughBalance,
-        PanicReason::ExpectedInternalContext,
-        PanicReason::AssetIdNotFound,
-        PanicReason::InputNotFound,
-        PanicReason::OutputNotFound,
-        PanicReason::WitnessNotFound,
-        PanicReason::TransactionMaturity,
-        PanicReason::InvalidMetadataIdentifier,
-        PanicReason::MalformedCallStructure,
-        PanicReason::ReservedRegisterNotWritable,
-        PanicReason::ErrorFlag,
-        PanicReason::InvalidImmediateValue,
-        PanicReason::ExpectedCoinInput,
-        PanicReason::MaxMemoryAccess,
-        PanicReason::MemoryWriteOverlap,
-        PanicReason::ContractNotInInputs,
-        PanicReason::InternalBalanceOverflow,
-        PanicReason::ContractMaxSize,
-        PanicReason::ExpectedUnallocatedStack,
-        PanicReason::MaxStaticContractsReached,
-        PanicReason::TransferAmountCannotBeZero,
-        PanicReason::ExpectedOutputVariable,
-        PanicReason::ExpectedParentInternalContext,
-        PanicReason::IllegalJump,
-        PanicReason::ArithmeticError,
-        PanicReason::ContractInstructionNotAllowed,
-    ];
+    let reasons = PanicReason::iter();
 
     for r in reasons {
         let b = r as u8;

fuel-asm/src/lib.rs

@@ -484,6 +484,16 @@ impl Opcode {
             _ => false,
         }
     }
+
+    /// Checks if the instruction has special control flow, i.e.
+    /// returns `false` if $pc is always incremented by four after this.
+    pub fn has_control_flow(&self) -> bool {
+        use Opcode::*;
+        matches!(
+            self,
+            CALL | RET | JNEI | JNZI | JI | JMP | JNE | JMPF | JMPB | JNZF | JNZB | JNEF | JNEB
+        )
+    }
 }
 
 // Direct conversions

fuel-asm/src/panic_instruction.rs

@@ -1,4 +1,3 @@
-use crate::panic_reason::InvalidPanicReason;
 use crate::{Instruction, PanicReason, RawInstruction, Word};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -39,15 +38,13 @@ impl From<PanicInstruction> for Word {
     }
 }
 
-impl TryFrom<Word> for PanicInstruction {
-    type Error = InvalidPanicReason;
-
-    fn try_from(val: Word) -> Result<Self, Self::Error> {
+impl From<Word> for PanicInstruction {
+    fn from(val: Word) -> Self {
         // Safe to cast as we've shifted the 8 MSB.
         let reason_u8 = (val >> REASON_OFFSET) as u8;
         // Cast to truncate in order to remove the `reason` bits.
         let instruction = (val >> INSTR_OFFSET) as u32;
-        let reason = PanicReason::try_from(reason_u8)?;
-        Ok(Self { reason, instruction })
+        let reason = PanicReason::from(reason_u8);
+        Self { reason, instruction }
     }
 }

fuel-asm/src/panic_reason.rs

@@ -1,89 +1,102 @@
-use core::{convert, fmt};
+use core::fmt;
+use num_enum::{FromPrimitive, IntoPrimitive};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, IntoPrimitive, FromPrimitive)]
+#[cfg_attr(test, derive(strum::EnumIter))]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
 #[repr(u8)]
 #[non_exhaustive]
 /// Panic reason representation for the interpreter.
 pub enum PanicReason {
+    /// The byte can't be mapped to any known `PanicReason`.
+    #[num_enum(default)]
+    UnknownPanicReason,
     /// Found `RVRT` instruction.
-    Revert = 0x01,
+    Revert,
     /// Execution ran out of gas.
-    OutOfGas = 0x02,
+    OutOfGas,
     /// The transaction validity is violated.
-    TransactionValidity = 0x03,
-    /// Attempt to write outside interpreter memory boundaries.
-    MemoryOverflow = 0x04,
+    TransactionValidity,
+    /// Attempting to execute memory that doesn't contain a valid instruction.
+    InvalidInstruction,
+    /// Attempting to read current instruction from unaccessible memory area, i.e.
+    /// either between the stack and the heap, or after the heap.
+    InstructionFetch,
+    /// Attempt to read or write unaccessible memory area, i.e.
+    /// either between the stack and the heap, or after the heap.
+    MemoryAccess,
+    /// Attempt to write accessible memory area that's not owned by the caller.
+    MemoryOwnership,
+    /// The requested memory access size exceeds the limits of the interpreter.
+    MemoryAccessSize,
+    /// Two segments of the interpreter memory should not intersect for write operations.
+    MemoryWriteOverlap,
+    /// Attempting to allocate stack or heap memory so that sp and hp would collide.
+    OutOfMemory,
     /// Overflow while executing arithmetic operation.
     /// These errors are ignored using the WRAPPING flag.
-    ArithmeticOverflow = 0x05,
+    ArithmeticOverflow,
     /// Designed contract was not found in the storage.
-    ContractNotFound = 0x06,
-    /// Memory ownership rules are violated.
-    MemoryOwnership = 0x07,
+    ContractNotFound,
     /// The asset ID balance isn't enough for the instruction.
-    NotEnoughBalance = 0x08,
+    NotEnoughBalance,
     /// The interpreter is expected to be in internal context.
-    ExpectedInternalContext = 0x09,
+    ExpectedInternalContext,
     /// The queried asset ID was not found in the state.
-    AssetIdNotFound = 0x0a,
+    AssetIdNotFound,
     /// The provided input is not found in the transaction.
-    InputNotFound = 0x0b,
+    InputNotFound,
     /// The provided output is not found in the transaction.
-    OutputNotFound = 0x0c,
+    OutputNotFound,
     /// The provided witness is not found in the transaction.
-    WitnessNotFound = 0x0d,
+    WitnessNotFound,
     /// The transaction maturity is not valid for this request.
-    TransactionMaturity = 0x0e,
+    TransactionMaturity,
     /// The metadata identifier is invalid.
-    InvalidMetadataIdentifier = 0x0f,
+    InvalidMetadataIdentifier,
     /// The call structure is not valid.
-    MalformedCallStructure = 0x10,
+    MalformedCallStructure,
     /// The provided register does not allow write operations.
-    ReservedRegisterNotWritable = 0x11,
+    ReservedRegisterNotWritable,
+    /// Invalid value was written to a system register.
+    InvalidValue,
     /// The execution resulted in an erroneous state of the interpreter.
-    ErrorFlag = 0x12,
+    ErrorFlag,
     /// The provided immediate value is not valid for this instruction.
-    InvalidImmediateValue = 0x13,
+    InvalidImmediateValue,
     /// The provided transaction input is not of type `Coin`.
-    ExpectedCoinInput = 0x14,
-    /// The requested memory access exceeds the limits of the interpreter.
-    MaxMemoryAccess = 0x15,
-    /// Two segments of the interpreter memory should not intersect for write operations.
-    MemoryWriteOverlap = 0x16,
+    ExpectedCoinInput,
     /// The requested contract is not listed in the transaction inputs.
-    ContractNotInInputs = 0x17,
+    ContractNotInInputs,
     /// The internal asset ID balance overflowed with the provided instruction.
-    InternalBalanceOverflow = 0x18,
+    InternalBalanceOverflow,
     /// The maximum allowed contract size is violated.
-    ContractMaxSize = 0x19,
+    ContractMaxSize,
     /// This instruction expects the stack area to be unallocated for this call.
-    ExpectedUnallocatedStack = 0x1a,
+    ExpectedUnallocatedStack,
     /// The maximum allowed number of static contracts was reached for this transaction.
-    MaxStaticContractsReached = 0x1b,
+    MaxStaticContractsReached,
     /// The requested transfer amount cannot be zero.
-    TransferAmountCannotBeZero = 0x1c,
+    TransferAmountCannotBeZero,
     /// The provided transaction output should be of type `Variable`.
-    ExpectedOutputVariable = 0x1d,
+    ExpectedOutputVariable,
     /// The expected context of the stack parent is internal.
-    ExpectedParentInternalContext = 0x1e,
+    ExpectedParentInternalContext,
     /// The jump instruction cannot move backwards in predicate verification.
-    IllegalJump = 0x1f,
+    IllegalJump,
     /// The contract ID is already deployed and can't be overwritten.
-    ContractIdAlreadyDeployed = 0x20,
+    ContractIdAlreadyDeployed,
     /// The loaded contract mismatch expectations.
-    ContractMismatch = 0x21,
+    ContractMismatch,
     /// Attempting to send message data longer than `MAX_MESSAGE_DATA_LENGTH`
-    MessageDataTooLong = 0x22,
+    MessageDataTooLong,
     /// Mathimatically invalid arguments where given to an arithmetic instruction.
     /// For instance, division by zero produces this.
     /// These errors are ignored using the UNSAFEMATH flag.
-    ArithmeticError = 0x23,
+    ArithmeticError,
     /// The contract instruction is not allowed in predicates.
-    ContractInstructionNotAllowed = 0x24,
-    /// The byte can't be mapped to any known `PanicReason`.
-    UnknownPanicReason = 0x25,
+    ContractInstructionNotAllowed,
 }
 
 impl fmt::Display for PanicReason {
@@ -99,80 +112,6 @@ impl std::error::Error for PanicReason {
     }
 }
 
-// TODO: Remove this - `Infallible` has nothing to do with `PanicReason`.
-impl From<convert::Infallible> for PanicReason {
-    fn from(_i: convert::Infallible) -> Self {
-        unreachable!()
-    }
-}
-
-/// Failed to parse a `u8` as a valid panic reason.
-#[derive(Debug, Eq, PartialEq)]
-pub struct InvalidPanicReason;
-
-impl TryFrom<u8> for PanicReason {
-    type Error = InvalidPanicReason;
-
-    /// Converts the `u8` into a `PanicReason`.
-    fn try_from(b: u8) -> Result<Self, Self::Error> {
-        if b == 0 {
-            return Err(InvalidPanicReason);
-        }
-
-        use PanicReason::*;
-        let reason = match b {
-            0x01 => Revert,
-            0x02 => OutOfGas,
-            0x03 => TransactionValidity,
-            0x04 => MemoryOverflow,
-            0x05 => ArithmeticOverflow,
-            0x06 => ContractNotFound,
-            0x07 => MemoryOwnership,
-            0x08 => NotEnoughBalance,
-            0x09 => ExpectedInternalContext,
-            0x0a => AssetIdNotFound,
-            0x0b => InputNotFound,
-            0x0c => OutputNotFound,
-            0x0d => WitnessNotFound,
-            0x0e => TransactionMaturity,
-            0x0f => InvalidMetadataIdentifier,
-            0x10 => MalformedCallStructure,
-            0x11 => ReservedRegisterNotWritable,
-            0x12 => ErrorFlag,
-            0x13 => InvalidImmediateValue,
-            0x14 => ExpectedCoinInput,
-            0x15 => MaxMemoryAccess,
-            0x16 => MemoryWriteOverlap,
-            0x17 => ContractNotInInputs,
-            0x18 => InternalBalanceOverflow,
-            0x19 => ContractMaxSize,
-            0x1a => ExpectedUnallocatedStack,
-            0x1b => MaxStaticContractsReached,
-            0x1c => TransferAmountCannotBeZero,
-            0x1d => ExpectedOutputVariable,
-            0x1e => ExpectedParentInternalContext,
-            0x1f => IllegalJump,
-            0x20 => ContractIdAlreadyDeployed,
-            0x21 => ContractMismatch,
-            0x22 => MessageDataTooLong,
-            0x23 => ArithmeticError,
-            0x24 => ContractInstructionNotAllowed,
-            _ => UnknownPanicReason,
-        };
-
-        Ok(reason)
-    }
-}
-
-#[cfg(feature = "std")]
-impl From<InvalidPanicReason> for std::io::Error {
-    fn from(_: InvalidPanicReason) -> Self {
-        use std::io;
-
-        io::Error::new(io::ErrorKind::InvalidInput, "Panic reason can't be zero")
-    }
-}
-
 #[cfg(feature = "std")]
 impl From<PanicReason> for std::io::Error {
     fn from(reason: PanicReason) -> Self {
@@ -181,32 +120,3 @@ impl From<PanicReason> for std::io::Error {
         io::Error::new(io::ErrorKind::Other, reason)
     }
 }
-
-impl From<core::array::TryFromSliceError> for PanicReason {
-    fn from(_: core::array::TryFromSliceError) -> Self {
-        Self::MemoryOverflow
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_u8_panic_reason_round_trip() {
-        const LAST_PANIC_REASON: u8 = PanicReason::UnknownPanicReason as u8;
-        let reason = PanicReason::try_from(0);
-        assert!(reason.is_err());
-
-        for i in 1..LAST_PANIC_REASON {
-            let reason = PanicReason::try_from(i).unwrap();
-            let i2 = reason as u8;
-            assert_eq!(i, i2);
-        }
-        for i in LAST_PANIC_REASON..=255 {
-            let reason = PanicReason::try_from(i).unwrap();
-            let i2 = reason as u8;
-            assert_eq!(PanicReason::UnknownPanicReason as u8, i2);
-        }
-    }
-}

fuel-tx/src/contract.rs

@@ -292,7 +292,7 @@ mod tests {
         let expected_root = {
             let mut tree = BinaryMerkleTree::new();
 
-            let leaves = code.chunks(LEAF_SIZE).into_iter().collect::<Vec<_>>();
+            let leaves = code.chunks(LEAF_SIZE).collect::<Vec<_>>();
             tree.push(leaves[0]);
             tree.push(leaves[1]);
             tree.push(leaves[2]);

fuel-tx/src/receipt/receipt_std.rs

@@ -365,7 +365,7 @@ impl io::Write for Receipt {
 
                 let id = id.into();
 
-                *self = Self::panic(id, PanicInstruction::try_from(reason)?, pc, is);
+                *self = Self::panic(id, PanicInstruction::from(reason), pc, is);
             }
 
             ReceiptRepr::Revert => {

fuel-tx/src/tests/bytes.rs

@@ -229,7 +229,7 @@ fn receipt() {
         Receipt::panic(
             rng.gen(),
             PanicInstruction::error(
-                PanicReason::MemoryOverflow,
+                PanicReason::MemoryAccess,
                 op::ji(rng.gen::<Immediate24>() & 0xffffff).into(),
             ),
             rng.gen(),
@@ -382,7 +382,7 @@ fn receipt() {
         Receipt::panic(
             rng.gen(),
             PanicInstruction::error(
-                PanicReason::MaxMemoryAccess,
+                PanicReason::MemoryAccessSize,
                 op::ji(rng.gen::<Immediate24>() & 0xffffff).into(),
             ),
             rng.gen(),