[mono-move] Global storage support

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: georgemitenkov

Cargo.lock

@@ -14,6 +14,7 @@ rust-version = { workspace = true }
 [dependencies]
 anyhow = { workspace = true }
 arc-swap = { workspace = true }
+bytes = { workspace = true }
 mono-move-alloc = { workspace = true }
 mono-move-gas = { workspace = true }
 move-binary-format = { workspace = true }

third_party/move/mono-move/core/Cargo.toml

@@ -6,13 +6,14 @@
 
 use crate::{
     interner::{InternedIdentifier, InternedModuleId},
+    storage::{ResourceProvider, NO_RESOURCE_PROVIDER},
     types::InternedTypeList,
     FunctionPtr,
 };
 use mono_move_gas::{GasMeter, NoOpGasMeter, SimpleGasMeter};
 
 /// Runtime context consulted by the interpreter during execution: gas
-/// charging and cross-module function resolution.
+/// charging, cross-module function or resource resolution.
 pub trait ExecutionContext {
     /// Access the gas meter.
     fn gas_meter(&mut self) -> &mut impl GasMeter;
@@ -26,6 +27,10 @@ pub trait ExecutionContext {
         name: InternedIdentifier,
         ty_args: InternedTypeList,
     ) -> anyhow::Result<FunctionPtr>;
+
+    /// Access the resource provider to fetch resource from storage on read-set
+    /// cache miss.
+    fn resource_provider(&self) -> &dyn ResourceProvider;
 }
 
 /// A [`ExecutionContext`] that supports only local execution within a
@@ -35,20 +40,22 @@ pub trait ExecutionContext {
 /// Intended for tests and benches that don't exercise cross-module dispatch.
 ///
 // TODO: migrate to a real impl and remove this.
-pub struct LocalExecutionContext<G: GasMeter = NoOpGasMeter> {
+pub struct LocalExecutionContext<'r, G: GasMeter = NoOpGasMeter> {
     gas_meter: G,
+    resource_provider: &'r dyn ResourceProvider,
 }
 
-impl LocalExecutionContext<NoOpGasMeter> {
+impl LocalExecutionContext<'static, NoOpGasMeter> {
     /// No gas accounting at all (`charge` is a no-op).
     pub fn unmetered() -> Self {
         Self {
             gas_meter: NoOpGasMeter,
+            resource_provider: &NO_RESOURCE_PROVIDER,
         }
     }
 }
 
-impl LocalExecutionContext<SimpleGasMeter> {
+impl LocalExecutionContext<'static, SimpleGasMeter> {
     /// [`SimpleGasMeter`] with `u64::MAX` budget.
     pub fn with_max_budget() -> Self {
         Self::with_budget(u64::MAX)
@@ -58,11 +65,22 @@ impl LocalExecutionContext<SimpleGasMeter> {
     pub fn with_budget(amount: u64) -> Self {
         Self {
             gas_meter: SimpleGasMeter::new(amount),
+            resource_provider: &NO_RESOURCE_PROVIDER,
+        }
+    }
+}
+
+impl<'r, G: GasMeter> LocalExecutionContext<'r, G> {
+    /// Builds a context with the gas meter and resource provider.
+    pub fn new(gas_meter: G, resource_provider: &'r dyn ResourceProvider) -> Self {
+        Self {
+            gas_meter,
+            resource_provider,
         }
     }
 }
 
-impl<G: GasMeter> ExecutionContext for LocalExecutionContext<G> {
+impl<'r, G: GasMeter> ExecutionContext for LocalExecutionContext<'r, G> {
     fn gas_meter(&mut self) -> &mut impl GasMeter {
         &mut self.gas_meter
     }
@@ -75,4 +93,8 @@ impl<G: GasMeter> ExecutionContext for LocalExecutionContext<G> {
     ) -> anyhow::Result<FunctionPtr> {
         anyhow::bail!("LocalExecutionContext: load_function not supported")
     }
+
+    fn resource_provider(&self) -> &dyn ResourceProvider {
+        self.resource_provider
+    }
 }

third_party/move/mono-move/core/src/execution_context.rs

@@ -92,7 +92,12 @@ impl HasCfgInfo for MicroOp {
             | MicroOp::StoreRandomU64 { .. }
             | MicroOp::ForceGC
             | MicroOp::PackClosure(_)
-            | MicroOp::CallClosure(_) => None,
+            | MicroOp::CallClosure(_)
+            | MicroOp::Exists { .. }
+            | MicroOp::BorrowGlobal { .. }
+            | MicroOp::BorrowGlobalMut { .. }
+            | MicroOp::MoveFrom { .. }
+            | MicroOp::MoveTo { .. } => None,
         }
     }
 }
@@ -203,7 +208,12 @@ impl RemapTargets for MicroOp {
             | MicroOp::StoreRandomU64 { .. }
             | MicroOp::ForceGC
             | MicroOp::PackClosure(_)
-            | MicroOp::CallClosure(_)) => op,
+            | MicroOp::CallClosure(_)
+            | MicroOp::Exists { .. }
+            | MicroOp::BorrowGlobal { .. }
+            | MicroOp::BorrowGlobalMut { .. }
+            | MicroOp::MoveFrom { .. }
+            | MicroOp::MoveTo { .. }) => op,
         }
     }
 }
@@ -305,6 +315,12 @@ impl GasSchedule<MicroOp> for MicroOpGasSchedule {
             // --- Closures ---
             MicroOp::PackClosure(_) => 20,
             MicroOp::CallClosure(_) => 15,
+
+            MicroOp::Exists { .. } => 10,
+            MicroOp::BorrowGlobal { .. } => 10,
+            MicroOp::BorrowGlobalMut { .. } => 20,
+            MicroOp::MoveFrom { .. } => 20,
+            MicroOp::MoveTo { .. } => 20,
         })
     }
 }

third_party/move/mono-move/core/src/instruction/gas.rs

@@ -116,7 +116,7 @@
 use crate::{
     align::MAX_ALIGN,
     interner::{InternedIdentifier, InternedModuleId},
-    types::{display_type_list, InternedTypeList},
+    types::{display_type, display_type_list, InternedType, InternedTypeList},
     FunctionPtr,
 };
 use std::fmt;
@@ -796,6 +796,57 @@ pub enum MicroOp {
     /// Unconditionally trigger a garbage collection cycle.
     /// Useful for testing GC correctness.
     ForceGC,
+
+    /// Stores a boolean value at destination offset if resource of the given
+    /// type exists at the given address.
+    Exists {
+        addr: FrameOffset,
+        ty: InternedType,
+        dst: FrameOffset,
+    },
+    /// Stores a reference to the destination offset pointing to the resource
+    /// of the given type exists at the given address. Aborts if resource does
+    /// not exist.
+    BorrowGlobal {
+        addr: FrameOffset,
+        ty: InternedType,
+        dst: FrameOffset,
+    },
+    /// Stores a reference to the destination offset pointing to the resource
+    /// of the given type exists at the given address. The  reference points to
+    /// the object owned by the current transaction's heap. Aborts if resource
+    /// does not exist.
+    ///
+    /// May trigger GC.
+    BorrowGlobalMut {
+        addr: FrameOffset,
+        ty: InternedType,
+        dst: FrameOffset,
+    },
+    /// Stores a reference to the destination offset pointing to the resource
+    /// of the given type exists at the given address. The resource is then
+    /// treated as "moved" from the global storage. The reference points to
+    /// the object owned by the current transaction's heap. Aborts if resource
+    /// does not exist.
+    ///
+    /// May trigger GC.
+    MoveFrom {
+        addr: FrameOffset,
+        ty: InternedType,
+        dst: FrameOffset,
+    },
+    /// Stores a reference from the source offset to the global storage for the
+    /// resource of the given type at the given address. The resource is then
+    /// treated as "moved" to the global storage. Aborts if resource already
+    /// exists.
+    MoveTo {
+        // TODO(correctness):
+        //   Move requires this to be a signer, using address for simplicity for now.
+        addr: FrameOffset,
+        ty: InternedType,
+        src: FrameOffset,
+    },
+
     //======================================================================
     // Missing instructions
     //======================================================================
@@ -804,7 +855,6 @@ pub enum MicroOp {
     // - **Casting**: truncation and widening between integer types,
     //   including signed casts.
     // - **Boolean**: logical Not, And, Or (distinct from bitwise).
-    // - **Global storage**: MoveTo, MoveFrom, BorrowGlobal, Exists.
     // - **Runtime instrumentation**: tracing, profiling, coverage hooks.
     //======================================================================
 
@@ -1189,6 +1239,35 @@ impl fmt::Display for MicroOp {
                 }
                 write!(f, "]")
             },
+            MicroOp::Exists { addr, ty, dst } => {
+                write!(f, "Exists<")?;
+                display_type(f, *ty)?;
+                write!(f, "> [{}] <- addr=[{}], ty=", dst.0, addr.0)
+            },
+            MicroOp::BorrowGlobal { addr, ty, dst } => {
+                write!(f, "BorrowGlobal<")?;
+                display_type(f, *ty)?;
+                write!(f, "> [{}] <- addr=[{}], ty=", dst.0, addr.0)
+            },
+            MicroOp::BorrowGlobalMut { addr, ty, dst } => {
+                write!(f, "BorrowGlobalMut<")?;
+                display_type(f, *ty)?;
+                write!(f, "> [{}] <- addr=[{}], ty=", dst.0, addr.0)
+            },
+            MicroOp::MoveFrom { addr, ty, dst } => {
+                write!(f, "MoveFrom<")?;
+                display_type(f, *ty)?;
+                write!(f, "> [{}] <- addr=[{}], ty=", dst.0, addr.0)
+            },
+            MicroOp::MoveTo {
+                addr,
+                ty,
+                src,
+            } => {
+                write!(f, "MoveTo<")?;
+                display_type(f, *ty)?;
+                write!(f, "> addr=[{}], src=[{}]", addr.0, src.0)
+            },
         }
     }
 }
@@ -1308,6 +1387,8 @@ impl MicroOp {
             MicroOp::HeapNew { .. }
             | MicroOp::VecPushBack { .. }
             | MicroOp::PackClosure(_)
+            | MicroOp::BorrowGlobalMut { .. }
+            | MicroOp::MoveFrom { .. }
             | MicroOp::ForceGC => true,
 
             // Non-allocating.
@@ -1372,7 +1453,10 @@ impl MicroOp {
             | MicroOp::IntBitXor(_)
             | MicroOp::IntShl(_)
             | MicroOp::IntShr(_)
-            | MicroOp::IntNegate(_) => false,
+            | MicroOp::IntNegate(_)
+            | MicroOp::Exists { .. }
+            | MicroOp::BorrowGlobal { .. }
+            | MicroOp::MoveTo { .. } => false,
         }
     }
 

third_party/move/mono-move/core/src/instruction/mod.rs

@@ -8,6 +8,7 @@ mod function;
 mod instruction;
 pub mod interner;
 mod prepared_module;
+pub mod storage;
 pub mod types;
 
 pub use align::{
@@ -31,4 +32,8 @@ pub use interner::{Interner, ModuleId};
 pub use prepared_module::{
     FieldTypes, FunctionInstantiationSignature, FunctionSignature, PreparedModule,
 };
+pub use storage::{
+    ModuleProvider, NoResourceProvider, ResourceProvider, ResourceProviderError, ResourceRead,
+    NO_RESOURCE_PROVIDER,
+};
 pub use types::{convert_mut_to_immut_ref, strip_ref};

third_party/move/mono-move/core/src/lib.rs

@@ -0,0 +1,12 @@
+// Copyright (c) Aptos Foundation
+// Licensed pursuant to the Innovation-Enabling Source Code License, available at https://github.com/aptos-labs/aptos-core/blob/main/LICENSE
+
+//! Storage abstractions for the VM runtime to provide access to data or code.
+
+pub mod module_provider;
+pub mod resource_provider;
+
+pub use module_provider::ModuleProvider;
+pub use resource_provider::{
+    NoResourceProvider, ResourceProvider, ResourceProviderError, ResourceRead, NO_RESOURCE_PROVIDER,
+};

third_party/move/mono-move/core/src/storage/mod.rs

@@ -0,0 +1,80 @@
+// Copyright (c) Aptos Foundation
+// Licensed pursuant to the Innovation-Enabling Source Code License, available at https://github.com/aptos-labs/aptos-core/blob/main/LICENSE
+
+//! Resource storage access for the runtime.
+
+use crate::types::InternedType;
+use move_core_types::account_address::AccountAddress;
+use std::ptr::NonNull;
+use thiserror::Error;
+
+/// Version of the read value (which can come from storage or from other
+/// transaction write).
+// TODO:
+//   Replace with Block-STM transaction index and incarnation pair.
+pub type Version = u64;
+
+/// Errors a [`ResourceProvider`] can surface. Backends classify their
+/// own failure modes into this enum as they grow.
+#[derive(Debug, Error)]
+pub enum ResourceProviderError {
+    #[error("resource provider invariant violation: {0}")]
+    InvariantViolation(String),
+}
+
+/// Resource read returned to the VM. Every VM execution records reads of any
+/// value coming from global storage.
+#[derive(Clone, Copy, Debug)]
+pub enum ResourceRead {
+    /// Resource does not exist at this key.
+    None,
+    /// Resource is allocated in some other arena or cache. For example, it
+    /// can be a cached DB read or a write from soe transaction at lower
+    /// version.
+    // TODO(safety):
+    //   Figure out how to enforce compile-time guarantees here that owning
+    //   arena is alive.
+    ExternalHeap {
+        /// Just like any other VM value, the pointer points to the start of
+        /// the value allocation. Value's header is at negative offset.
+        // TODO(refactor): have a Value pointer unified API?
+        ptr: NonNull<u8>,
+        /// Version of this read from Block-STM. Used for read-set validation.
+        version: Version,
+    },
+}
+
+/// Returns resource data from storage. Storage backend is not fixed
+/// and can be implemented for different clients:
+///   - tests,
+///   - Block-STM,
+///   - actual DB.
+pub trait ResourceProvider {
+    /// Returns the resource of a particular type at the specified
+    /// address. Returns [`ResourceRead::None`] if the resource does
+    /// not exist. Returns a [`ResourceProviderError`] if the backend
+    /// cannot satisfy the read.
+    fn get_resource(
+        &self,
+        addr: AccountAddress,
+        ty: InternedType,
+    ) -> Result<ResourceRead, ResourceProviderError>;
+}
+
+/// Empty storage with no resources.
+pub struct NoResourceProvider;
+
+impl ResourceProvider for NoResourceProvider {
+    fn get_resource(
+        &self,
+        _addr: AccountAddress,
+        _ty: InternedType,
+    ) -> Result<ResourceRead, ResourceProviderError> {
+        Ok(ResourceRead::None)
+    }
+}
+
+// TODO(test):
+//   This is only needed to make current tests work. Remove once specializer can emit
+//   struct / enum operations or when testing framework is unified.
+pub static NO_RESOURCE_PROVIDER: NoResourceProvider = NoResourceProvider;