Move suivm to latest (#13814)

## Description 

Move suivm to latest. Suivm is getting in the way of a bunch of work
happening in the execution layer.
This is also showing the issues related to branches that are live for
long. It is at times inevitable but we need to be careful about what
people review and how to go back to latest.
Hopefully the work to make latest the working branch will make this less
of a problem. We'll see

## Test Plan 

Existing tests

---
If your changes are not user-facing and not a breaking change, you can
skip the following section. Otherwise, please indicate what changed, and
then add to the Release Notes section as highlighted during the release
process.

### Type of Change (Check all that apply)

- [ ] protocol change
- [ ] user-visible impact
- [ ] breaking change for a client SDKs
- [ ] breaking change for FNs (FN binary must upgrade)
- [ ] breaking change for validators or node operators (must upgrade
binaries)
- [ ] breaking change for on-chain data layout
- [ ] necessitate either a data wipe or data migration

### Release notes

Author: dariorussi

move-vm/runtime/src/lib.rs

@@ -17,7 +17,7 @@ pub mod logging;
 pub mod move_vm;
 pub mod native_extensions;
 pub mod native_functions;
-mod runtime;
+pub mod runtime;
 pub mod session;
 #[macro_use]
 mod tracing;

move-vm/runtime/src/move_vm.rs

@@ -101,4 +101,8 @@ impl MoveVM {
     pub fn get_module_metadata(&self, module: ModuleId, key: &[u8]) -> Option<Metadata> {
         self.runtime.loader().get_metadata(module, key)
     }
+
+    pub fn get_runtime(&self) -> &VMRuntime {
+        &self.runtime
+    }
 }

move-vm/runtime/src/runtime.rs

@@ -13,14 +13,14 @@ use crate::{
 use move_binary_format::{
     access::ModuleAccess,
     errors::{verification_error, Location, PartialVMError, PartialVMResult, VMResult},
-    file_format::LocalIndex,
+    file_format::{AbilitySet, LocalIndex},
     CompiledModule, IndexKind,
 };
 use move_bytecode_verifier::script_signature;
 use move_core_types::{
     account_address::AccountAddress,
     identifier::{IdentStr, Identifier},
-    language_storage::ModuleId,
+    language_storage::{ModuleId, TypeTag},
     resolver::MoveResolver,
     value::MoveTypeLayout,
     vm_status::StatusCode,
@@ -31,14 +31,14 @@ use move_vm_profiler::GasProfiler;
 use move_vm_types::{
     data_store::DataStore,
     gas::GasMeter,
-    loaded_data::runtime_types::Type,
+    loaded_data::runtime_types::{CachedStructIndex, StructType, Type},
     values::{Locals, Reference, VMValueCast, Value},
 };
 use std::{borrow::Borrow, collections::BTreeSet, sync::Arc};
 use tracing::warn;
 
 /// An instantiation of the MoveVM.
-pub(crate) struct VMRuntime {
+pub struct VMRuntime {
     loader: Loader,
 }
 
@@ -68,7 +68,7 @@ impl VMRuntime {
         }
     }
 
-    pub(crate) fn publish_module_bundle(
+    pub fn publish_module_bundle(
         &self,
         modules: Vec<Vec<u8>>,
         sender: AccountAddress,
@@ -482,4 +482,98 @@ impl VMRuntime {
     pub(crate) fn loader(&self) -> &Loader {
         &self.loader
     }
+
+    pub fn get_type_abilities(&self, ty: &Type) -> VMResult<AbilitySet> {
+        self.loader
+            .abilities(ty)
+            .map_err(|e| e.finish(Location::Undefined))
+    }
+
+    pub fn get_type_tag(&self, ty: &Type) -> VMResult<TypeTag> {
+        self.loader
+            .type_to_type_tag(ty)
+            .map_err(|e| e.finish(Location::Undefined))
+    }
+
+    pub fn get_struct_type(&self, index: CachedStructIndex) -> Option<Arc<StructType>> {
+        self.loader.get_struct_type(index)
+    }
+
+    pub fn type_to_type_layout(&self, ty: &Type) -> VMResult<MoveTypeLayout> {
+        self.loader
+            .type_to_type_layout(ty)
+            .map_err(|e| e.finish(Location::Undefined))
+    }
+
+    pub fn load_struct(
+        &self,
+        module_id: &ModuleId,
+        struct_name: &IdentStr,
+        data_store: &impl DataStore,
+    ) -> VMResult<(CachedStructIndex, Arc<StructType>)> {
+        self.loader
+            .load_struct_by_name(struct_name, module_id, data_store)
+    }
+
+    pub fn execute_function_bypass_visibility(
+        &self,
+        module: &ModuleId,
+        function_name: &IdentStr,
+        ty_args: Vec<Type>,
+        args: Vec<impl Borrow<[u8]>>,
+        data_store: &mut impl DataStore,
+        gas_meter: &mut impl GasMeter,
+        extensions: &mut NativeContextExtensions,
+    ) -> VMResult<SerializedReturnValues> {
+        #[cfg(debug_assertions)]
+        {
+            if gas_meter.get_profiler_mut().is_none() {
+                gas_meter.set_profiler(GasProfiler::init_default_cfg(
+                    function_name.to_string(),
+                    gas_meter.remaining_gas().into(),
+                ));
+            }
+        }
+
+        let bypass_declared_entry_check = true;
+        self.execute_function(
+            module,
+            function_name,
+            ty_args,
+            args,
+            data_store,
+            gas_meter,
+            extensions,
+            bypass_declared_entry_check,
+        )
+    }
+
+    pub fn type_to_fully_annotated_layout(&self, ty: &Type) -> VMResult<MoveTypeLayout> {
+        self.loader
+            .type_to_fully_annotated_layout(ty)
+            .map_err(|e| e.finish(Location::Undefined))
+    }
+
+    pub fn load_function(
+        &self,
+        module_id: &ModuleId,
+        function_name: &IdentStr,
+        type_arguments: &[Type],
+        data_store: &mut impl DataStore,
+    ) -> VMResult<LoadedFunctionInstantiation> {
+        let (_, _, _, instantiation) =
+            self.loader
+                .load_function(module_id, function_name, type_arguments, data_store)?;
+        Ok(instantiation)
+    }
+
+    pub fn load_module(
+        &self,
+        module_id: &ModuleId,
+        data_store: &impl DataStore,
+    ) -> VMResult<Arc<CompiledModule>> {
+        self.loader
+            .load_module(module_id, data_store)
+            .map(|(compiled, _)| compiled)
+    }
 }