add attributes for struct api

rahxephon89 · rahxephon89 · commit b720555508b6 · 2025-11-14T17:03:14.000-08:00
diff --git a/aptos-move/aptos-release-builder/src/components/feature_flags.rs b/aptos-move/aptos-release-builder/src/components/feature_flags.rs
@@ -156,6 +156,7 @@ pub enum FeatureFlag {
     VMBinaryFormatV9,
     EnableFrameworkForOption,
     SessionContinuation,
+    VMBinaryFormatV10,
 }
 
 fn generate_features_blob(writer: &CodeWriter, data: &[u64]) {
@@ -411,6 +412,7 @@ impl From<FeatureFlag> for AptosFeatureFlag {
             FeatureFlag::VMBinaryFormatV9 => AptosFeatureFlag::VM_BINARY_FORMAT_V9,
             FeatureFlag::EnableFrameworkForOption => AptosFeatureFlag::ENABLE_FRAMEWORK_FOR_OPTION,
             FeatureFlag::SessionContinuation => AptosFeatureFlag::SESSION_CONTINUATION,
+            FeatureFlag::VMBinaryFormatV10 => AptosFeatureFlag::VM_BINARY_FORMAT_V10,
         }
     }
 }
@@ -593,6 +595,7 @@ impl From<AptosFeatureFlag> for FeatureFlag {
             AptosFeatureFlag::VM_BINARY_FORMAT_V9 => FeatureFlag::VMBinaryFormatV9,
             AptosFeatureFlag::ENABLE_FRAMEWORK_FOR_OPTION => FeatureFlag::EnableFrameworkForOption,
             AptosFeatureFlag::SESSION_CONTINUATION => FeatureFlag::SessionContinuation,
+            AptosFeatureFlag::VM_BINARY_FORMAT_V10 => FeatureFlag::VMBinaryFormatV10,
         }
     }
 }
diff --git a/third_party/move/move-binary-format/src/deserializer.rs b/third_party/move/move-binary-format/src/deserializer.rs
@@ -938,7 +938,7 @@ fn load_function_handle(
     };
 
     let attributes = if version >= VERSION_8 {
-        load_function_attributes(cursor)?
+        load_function_attributes(cursor, version)?
     } else {
         vec![]
     };
@@ -1061,23 +1061,46 @@ fn load_signature_tokens(cursor: &mut VersionedCursor) -> BinaryLoaderResult<Vec
 
 fn load_function_attributes(
     cursor: &mut VersionedCursor,
+    bytecode_version: u32,
 ) -> BinaryLoaderResult<Vec<FunctionAttribute>> {
     let count = read_uleb_internal(cursor, ATTRIBUTE_COUNT_MAX)?;
     let mut attributes = Vec::with_capacity(count);
     for _ in 0..count {
-        attributes.push(load_attribute(cursor)?);
+        attributes.push(load_attribute(cursor, bytecode_version)?);
     }
     Ok(attributes)
 }
 
-fn load_attribute(cursor: &mut VersionedCursor) -> BinaryLoaderResult<FunctionAttribute> {
+fn load_attribute(
+    cursor: &mut VersionedCursor,
+    bytecode_version: u32,
+) -> BinaryLoaderResult<FunctionAttribute> {
     use SerializedFunctionAttribute::*;
-    Ok(
-        match SerializedFunctionAttribute::from_u8(load_u8(cursor)?)? {
-            PERSISTENT => FunctionAttribute::Persistent,
-            MODULE_LOCK => FunctionAttribute::ModuleLock,
+    match SerializedFunctionAttribute::from_u8(load_u8(cursor)?)? {
+        PERSISTENT => Ok(FunctionAttribute::Persistent),
+        MODULE_LOCK => Ok(FunctionAttribute::ModuleLock),
+        PACK => {
+            if bytecode_version < VERSION_10 {
+                Err(PartialVMError::new(StatusCode::MALFORMED)
+                    .with_message("Unexpected EOF".to_string()))?
+            } else {
+                Ok(FunctionAttribute::Pack(load_struct_def_index(cursor)?))
+            }
         },
-    )
+        PACK_VARIANT => {
+            if bytecode_version < VERSION_10 {
+                Err(PartialVMError::new(StatusCode::MALFORMED)
+                    .with_message("Unexpected EOF".to_string()))?
+            } else {
+                let definition_index = load_struct_def_index(cursor)?;
+                let variant_index = load_bytecode_index(cursor)?;
+                Ok(FunctionAttribute::PackVariant(
+                    definition_index,
+                    variant_index,
+                ))
+            }
+        },
+    }
 }
 
 fn load_access_specifiers(
@@ -2249,8 +2272,10 @@ impl SerializedFunctionAttribute {
         match value {
             0x1 => Ok(PERSISTENT),
             0x2 => Ok(MODULE_LOCK),
+            0x3 => Ok(PACK),
+            0x4 => Ok(PACK_VARIANT),
             _ => Err(PartialVMError::new(StatusCode::MALFORMED)
-                .with_message("malformed attribute".to_owned())),
+                .with_message(format!("malformed attribute: {}", value))),
         }
     }
 }
diff --git a/third_party/move/move-binary-format/src/file_format.rs b/third_party/move/move-binary-format/src/file_format.rs
@@ -368,6 +368,8 @@ pub enum FunctionAttribute {
     Persistent,
     /// During execution of the function, a module reentrancy lock is established.
     ModuleLock,
+    Pack(StructDefinitionIndex),
+    PackVariant(StructDefinitionIndex, VariantIndex),
 }
 
 impl FunctionAttribute {
@@ -389,6 +391,16 @@ impl fmt::Display for FunctionAttribute {
         match self {
             FunctionAttribute::Persistent => write!(f, "persistent"),
             FunctionAttribute::ModuleLock => write!(f, "module_lock"),
+            FunctionAttribute::Pack(struct_definition_index) => {
+                write!(f, "pack({})", struct_definition_index)
+            },
+            FunctionAttribute::PackVariant(struct_definition_index, variant_index) => {
+                write!(
+                    f,
+                    "pack_variant({},{})",
+                    struct_definition_index, variant_index
+                )
+            },
         }
     }
 }
diff --git a/third_party/move/move-binary-format/src/file_format_common.rs b/third_party/move/move-binary-format/src/file_format_common.rs
@@ -222,6 +222,8 @@ pub enum SerializedNativeStructFlag {
 pub enum SerializedFunctionAttribute {
     PERSISTENT   = 0x1,
     MODULE_LOCK  = 0x2,
+    PACK         = 0x3,
+    PACK_VARIANT = 0x4,
 }
 
 /// List of opcodes constants.
@@ -552,8 +554,12 @@ pub const VERSION_8: u32 = 8;
 /// + allow `$` in identifiers
 pub const VERSION_9: u32 = 9;
 
+/// Version 10: changes compared to version 9
+/// + new attributes for structs api
+pub const VERSION_10: u32 = 10;
+
 /// Mark which version is the latest version.
-pub const VERSION_MAX: u32 = VERSION_9;
+pub const VERSION_MAX: u32 = VERSION_10;
 
 /// Mark which version is the default version. This is the version used by default by tools like
 /// the compiler. Notice that this version might be different from the one supported on nodes.
@@ -566,6 +572,9 @@ pub const VERSION_DEFAULT_LANG_V2: u32 = VERSION_8;
 /// Mark which version is the default version if compiling with language version 2.3
 pub const VERSION_DEFAULT_LANG_V2_3: u32 = VERSION_9;
 
+/// Mark which version is the default version if compiling with language version 2.4
+pub const VERSION_DEFAULT_LANG_V2_4: u32 = VERSION_10;
+
 // Mark which oldest version is supported.
 pub const VERSION_MIN: u32 = VERSION_5;
 
diff --git a/third_party/move/move-binary-format/src/serializer.rs b/third_party/move/move-binary-format/src/serializer.rs
@@ -549,7 +549,7 @@ fn serialize_function_handle(
         ));
     }
     if major_version >= VERSION_8 {
-        serialize_function_attributes(binary, &function_handle.attributes)
+        serialize_function_attributes(binary, &function_handle.attributes, major_version)
     } else if !function_handle.attributes.is_empty() {
         Err(anyhow!(
             "Function attributes not supported in bytecode version {}",
@@ -867,22 +867,45 @@ fn serialize_ability_sets(binary: &mut BinaryData, sets: &[AbilitySet]) -> Resul
 fn serialize_function_attributes(
     binary: &mut BinaryData,
     attributes: &[FunctionAttribute],
+    version: u32,
 ) -> Result<()> {
     write_as_uleb128(binary, attributes.len() as u64, ATTRIBUTE_COUNT_MAX)?;
     for attr in attributes {
-        serialize_function_attribute(binary, attr)?;
+        serialize_function_attribute(binary, attr, version)?;
     }
     Ok(())
 }
 
 fn serialize_function_attribute(
     binary: &mut BinaryData,
     attribute: &FunctionAttribute,
+    version: u32,
 ) -> Result<()> {
     use FunctionAttribute::*;
     match attribute {
         Persistent => binary.push(SerializedFunctionAttribute::PERSISTENT as u8),
         ModuleLock => binary.push(SerializedFunctionAttribute::MODULE_LOCK as u8),
+        Pack(struct_definition_index) => {
+            if version < VERSION_10 {
+                return Err(anyhow!(
+                    "Pack attribute not supported in bytecode version {}",
+                    version
+                ));
+            }
+            binary.push(SerializedFunctionAttribute::PACK as u8)?;
+            serialize_struct_def_index(binary, struct_definition_index)
+        },
+        PackVariant(struct_definition_index, variant_index) => {
+            if version < VERSION_10 {
+                return Err(anyhow!(
+                    "PackVariant attribute not supported in bytecode version {}",
+                    version
+                ));
+            }
+            binary.push(SerializedFunctionAttribute::PACK_VARIANT as u8)?;
+            serialize_struct_def_index(binary, struct_definition_index)?;
+            write_as_uleb128(binary, *variant_index, BYTECODE_INDEX_MAX)
+        },
     }
 }
 
diff --git a/third_party/move/move-compiler-v2/src/file_format_generator/module_generator.rs b/third_party/move/move-compiler-v2/src/file_format_generator/module_generator.rs
@@ -681,6 +681,8 @@ impl ModuleGenerator {
 
             let name_sym = struct_env.env().symbol_pool().make(&name);
             let name_idx = self.name_index(ctx, loc, name_sym);
+            // TODO: add function attribute
+            // let function_attribute = FunctionAttribute::Pack(struct_env.get_definition_index());
 
             let handle = FF::FunctionHandle {
                 module,
diff --git a/third_party/move/move-model/src/builder/binary_module_loader.rs b/third_party/move/move-model/src/builder/binary_module_loader.rs
@@ -27,7 +27,7 @@ use move_binary_format::{
         AccessKind as FFAccessKind, AddressSpecifier as FFAddressSpecifier, FunctionAttribute,
         FunctionDefinitionIndex, FunctionHandleIndex, MemberCount,
         ResourceSpecifier as FFResourceSpecifier, SignatureToken, StructDefinitionIndex,
-        StructHandleIndex, TableIndex, VariantIndex, Visibility,
+        StructFieldInformation, StructHandleIndex, TableIndex, VariantIndex, Visibility,
     },
     internals::ModuleIndex,
     views::{
@@ -479,6 +479,64 @@ impl<'a> BinaryModuleLoader<'a> {
                         .make(well_known::MODULE_LOCK_ATTRIBUTE);
                     attributes.push(Attribute::Apply(node_id, sym, vec![]));
                 },
+                FunctionAttribute::Pack(struct_definition_index) => {
+                    let node_id = self.env.new_node(Loc::default(), Type::Tuple(vec![]));
+                    let struct_def = handle_view.module().struct_def_at(*struct_definition_index);
+                    let struct_handle = handle_view
+                        .module()
+                        .struct_handle_at(struct_def.struct_handle);
+                    let struct_name = handle_view.module().identifier_at(struct_handle.name);
+                    let module_handle = handle_view.module().module_handle_at(struct_handle.module);
+                    let module_id = handle_view.module().module_id_for_handle(module_handle);
+                    let module_name = module_id.name().as_str();
+                    let addr = module_id.address;
+                    let sym = self.env.symbol_pool().make(&format!(
+                        "pack{}{}{}{}{}{}",
+                        well_known::PUBLIC_STRUCT_DELIMITER,
+                        addr,
+                        well_known::PUBLIC_STRUCT_DELIMITER,
+                        module_name,
+                        well_known::PUBLIC_STRUCT_DELIMITER,
+                        struct_name.as_str()
+                    ));
+                    attributes.push(Attribute::Apply(node_id, sym, vec![]));
+                },
+                FunctionAttribute::PackVariant(struct_definition_index, variant_index) => {
+                    let node_id = self.env.new_node(Loc::default(), Type::Tuple(vec![]));
+                    let struct_def = handle_view.module().struct_def_at(*struct_definition_index);
+                    if let StructFieldInformation::DeclaredVariants(variants) =
+                        &struct_def.field_information
+                    {
+                        if let Some(variant) = variants.get(*variant_index as usize) {
+                            let struct_handle = handle_view
+                                .module()
+                                .struct_handle_at(struct_def.struct_handle);
+                            let struct_name =
+                                handle_view.module().identifier_at(struct_handle.name);
+                            let module_handle =
+                                handle_view.module().module_handle_at(struct_handle.module);
+                            let module_id =
+                                handle_view.module().module_id_for_handle(module_handle);
+                            let module_name = module_id.name().as_str();
+                            let addr = module_id.address;
+                            let variant_name = variant.name;
+                            let variant_name_str =
+                                handle_view.module().identifier_at(variant_name).as_str();
+                            let sym = self.env.symbol_pool().make(&format!(
+                                "pack{}{}{}{}{}{}{}{}",
+                                well_known::PUBLIC_STRUCT_DELIMITER,
+                                addr,
+                                well_known::PUBLIC_STRUCT_DELIMITER,
+                                module_name,
+                                well_known::PUBLIC_STRUCT_DELIMITER,
+                                struct_name.as_str(),
+                                well_known::PUBLIC_STRUCT_DELIMITER,
+                                variant_name_str
+                            ));
+                            attributes.push(Attribute::Apply(node_id, sym, vec![]));
+                        }
+                    }
+                },
             }
         }
 
diff --git a/third_party/move/move-model/src/metadata.rs b/third_party/move/move-model/src/metadata.rs
@@ -4,7 +4,7 @@
 use anyhow::bail;
 use legacy_move_compiler::shared::LanguageVersion as CompilerLanguageVersion;
 use move_binary_format::file_format_common::{
-    VERSION_DEFAULT, VERSION_DEFAULT_LANG_V2, VERSION_DEFAULT_LANG_V2_3,
+    VERSION_DEFAULT, VERSION_DEFAULT_LANG_V2, VERSION_DEFAULT_LANG_V2_3, VERSION_DEFAULT_LANG_V2_4,
 };
 use move_command_line_common::env;
 use serde::{Deserialize, Serialize};
@@ -315,9 +315,8 @@ impl LanguageVersion {
             LanguageVersion::V2_0 | LanguageVersion::V2_1 | LanguageVersion::V2_2 => {
                 VERSION_DEFAULT_LANG_V2
             },
-            LanguageVersion::V2_3 | LanguageVersion::V2_4 | LanguageVersion::V2_5 => {
-                VERSION_DEFAULT_LANG_V2_3
-            },
+            LanguageVersion::V2_3 => VERSION_DEFAULT_LANG_V2_3,
+            LanguageVersion::V2_4 | LanguageVersion::V2_5 => VERSION_DEFAULT_LANG_V2_4,
         })
     }
 
diff --git a/types/src/on_chain_config/aptos_features.rs b/types/src/on_chain_config/aptos_features.rs
@@ -154,6 +154,8 @@ pub enum FeatureFlag {
     /// If enabled, new single session is used by the VM to avoid squashing write-sets and cache
     /// reads between sessions (e.g., between transaction prologue, user session and epilogue).
     SESSION_CONTINUATION = 104,
+    /// Enables bytecode version v9
+    VM_BINARY_FORMAT_V10 = 105,
 }
 
 impl FeatureFlag {
@@ -259,6 +261,7 @@ impl FeatureFlag {
             FeatureFlag::ENABLE_ENUM_OPTION,
             FeatureFlag::VM_BINARY_FORMAT_V9,
             FeatureFlag::ENABLE_FRAMEWORK_FOR_OPTION,
+            FeatureFlag::VM_BINARY_FORMAT_V10,
         ]
     }
 }
@@ -473,7 +476,9 @@ impl Features {
     }
 
     pub fn get_max_binary_format_version(&self) -> u32 {
-        if self.is_enabled(FeatureFlag::VM_BINARY_FORMAT_V9) {
+        if self.is_enabled(FeatureFlag::VM_BINARY_FORMAT_V10) {
+            file_format_common::VERSION_10
+        } else if self.is_enabled(FeatureFlag::VM_BINARY_FORMAT_V9) {
             file_format_common::VERSION_9
         } else if self.is_enabled(FeatureFlag::VM_BINARY_FORMAT_V8) {
             file_format_common::VERSION_8

Original file line number	Diff line number	Diff line change
`@@ -156,6 +156,7 @@ pub enum FeatureFlag {`
`156`	`156`	`VMBinaryFormatV9,`
`157`	`157`	`EnableFrameworkForOption,`
`158`	`158`	`SessionContinuation,`
	`159`	`+ VMBinaryFormatV10,`
`159`	`160`	`}`
`160`	`161`
`161`	`162`	`fn generate_features_blob(writer: &CodeWriter, data: &[u64]) {`
`@@ -411,6 +412,7 @@ impl From<FeatureFlag> for AptosFeatureFlag {`
`411`	`412`	`FeatureFlag::VMBinaryFormatV9 => AptosFeatureFlag::VM_BINARY_FORMAT_V9,`
`412`	`413`	`FeatureFlag::EnableFrameworkForOption => AptosFeatureFlag::ENABLE_FRAMEWORK_FOR_OPTION,`
`413`	`414`	`FeatureFlag::SessionContinuation => AptosFeatureFlag::SESSION_CONTINUATION,`
	`415`	`+ FeatureFlag::VMBinaryFormatV10 => AptosFeatureFlag::VM_BINARY_FORMAT_V10,`
`414`	`416`	`}`
`415`	`417`	`}`
`416`	`418`	`}`
`@@ -593,6 +595,7 @@ impl From<AptosFeatureFlag> for FeatureFlag {`
`593`	`595`	`AptosFeatureFlag::VM_BINARY_FORMAT_V9 => FeatureFlag::VMBinaryFormatV9,`
`594`	`596`	`AptosFeatureFlag::ENABLE_FRAMEWORK_FOR_OPTION => FeatureFlag::EnableFrameworkForOption,`
`595`	`597`	`AptosFeatureFlag::SESSION_CONTINUATION => FeatureFlag::SessionContinuation,`
	`598`	`+ AptosFeatureFlag::VM_BINARY_FORMAT_V10 => FeatureFlag::VMBinaryFormatV10,`
`596`	`599`	`}`
`597`	`600`	`}`
`598`	`601`	`}`
Original file line number	Diff line number	Diff line change
`@@ -368,6 +368,8 @@ pub enum FunctionAttribute {`
`368`	`368`	`Persistent,`
`369`	`369`	`/// During execution of the function, a module reentrancy lock is established.`
`370`	`370`	`ModuleLock,`
	`371`	`+ Pack(StructDefinitionIndex),`
	`372`	`+ PackVariant(StructDefinitionIndex, VariantIndex),`
`371`	`373`	`}`
`372`	`374`
`373`	`375`	`impl FunctionAttribute {`
`@@ -389,6 +391,16 @@ impl fmt::Display for FunctionAttribute {`
`389`	`391`	`match self {`
`390`	`392`	`FunctionAttribute::Persistent => write!(f, "persistent"),`
`391`	`393`	`FunctionAttribute::ModuleLock => write!(f, "module_lock"),`
	`394`	`+ FunctionAttribute::Pack(struct_definition_index) => {`
	`395`	`+ write!(f, "pack({})", struct_definition_index)`
	`396`	`+ },`
	`397`	`+ FunctionAttribute::PackVariant(struct_definition_index, variant_index) => {`
	`398`	`+ write!(`
	`399`	`+ f,`
	`400`	`+ "pack_variant({},{})",`
	`401`	`+ struct_definition_index, variant_index`
	`402`	`+ )`
	`403`	`+ },`
`392`	`404`	`}`
`393`	`405`	`}`
`394`	`406`	`}`
Original file line number	Diff line number	Diff line change
`@@ -154,6 +154,8 @@ pub enum FeatureFlag {`
`154`	`154`	`/// If enabled, new single session is used by the VM to avoid squashing write-sets and cache`
`155`	`155`	`/// reads between sessions (e.g., between transaction prologue, user session and epilogue).`
`156`	`156`	`SESSION_CONTINUATION = 104,`
	`157`	`+ /// Enables bytecode version v9`
	`158`	`+ VM_BINARY_FORMAT_V10 = 105,`
`157`	`159`	`}`
`158`	`160`
`159`	`161`	`impl FeatureFlag {`
`@@ -259,6 +261,7 @@ impl FeatureFlag {`
`259`	`261`	`FeatureFlag::ENABLE_ENUM_OPTION,`
`260`	`262`	`FeatureFlag::VM_BINARY_FORMAT_V9,`
`261`	`263`	`FeatureFlag::ENABLE_FRAMEWORK_FOR_OPTION,`
	`264`	`+ FeatureFlag::VM_BINARY_FORMAT_V10,`
`262`	`265`	`]`
`263`	`266`	`}`
`264`	`267`	`}`
`@@ -473,7 +476,9 @@ impl Features {`
`473`	`476`	`}`
`474`	`477`
`475`	`478`	`pub fn get_max_binary_format_version(&self) -> u32 {`
`476`		`- if self.is_enabled(FeatureFlag::VM_BINARY_FORMAT_V9) {`
	`479`	`+ if self.is_enabled(FeatureFlag::VM_BINARY_FORMAT_V10) {`
	`480`	`+ file_format_common::VERSION_10`
	`481`	`+ } else if self.is_enabled(FeatureFlag::VM_BINARY_FORMAT_V9) {`
`477`	`482`	`file_format_common::VERSION_9`
`478`	`483`	`} else if self.is_enabled(FeatureFlag::VM_BINARY_FORMAT_V8) {`
`479`	`484`	`file_format_common::VERSION_8`