[vm] New bytecode for aborting with message

aptos-move/aptos-gas-meter/src/meter.rs

@@ -547,6 +547,12 @@ where
 
         self.algebra.charge_execution(cost)
     }
+
+    fn charge_abort_message(&mut self, bytes: &[u8]) -> PartialVMResult<()> {
+        let num_bytes = NumBytes::new(bytes.len() as u64);
+        let cost = ABORT_MSG_BASE + ABORT_MSG_PER_BYTE * num_bytes;
+        self.algebra.charge_execution(cost)
+    }
 }
 
 impl<A> AptosGasMeter for StandardGasMeter<A>

aptos-move/aptos-gas-profiling/src/profiler.rs

@@ -367,6 +367,9 @@ where
 
         [VEC_SWAP]
         fn charge_vec_swap(&mut self) -> PartialVMResult<()>;
+
+        [ABORT_MSG]
+        fn charge_abort_message(&mut self, bytes: &[u8]) -> PartialVMResult<()>;
     }
 
     fn balance_internal(&self) -> InternalGas {

aptos-move/aptos-gas-schedule/src/gas_schedule/instr.rs

@@ -22,6 +22,8 @@ crate::gas_schedule::macros::define_gas_parameters!(
         // control flow
         [ret: InternalGas, "ret", 220],
         [abort: InternalGas, "abort", 220],
+        [abort_msg_base: InternalGas, "abort_msg.base", 440],
+        [abort_msg_per_byte: InternalGasPerByte, "abort_msg.per_byte", 128],
 
         // Note(Gas): The costs of the branch instructions have been jacked up a bit intentionally
         //            to prevent any single transaction from running for too long.

aptos-move/aptos-memory-usage-tracker/src/lib.rs

@@ -343,6 +343,17 @@ where
             .charge_native_function_before_execution(ty_args, args)
     }
 
+    fn charge_abort_message(&mut self, bytes: &[u8]) -> PartialVMResult<()> {
+        self.release_heap_memory(
+            self.vm_gas_params()
+                .misc
+                .abs_val
+                .abstract_heap_size(bytes, self.feature_version())?,
+        );
+
+        self.base.charge_abort_message(bytes)
+    }
+
     #[inline]
     fn charge_native_function(
         &mut self,

aptos-move/aptos-release-builder/src/components/feature_flags.rs

@@ -157,6 +157,7 @@ pub enum FeatureFlag {
     EnableFrameworkForOption,
     SessionContinuation,
     EnableFunctionReflection,
+    VMBinaryFormatV10,
 }
 
 fn generate_features_blob(writer: &CodeWriter, data: &[u64]) {
@@ -413,6 +414,7 @@ impl From<FeatureFlag> for AptosFeatureFlag {
             FeatureFlag::EnableFrameworkForOption => AptosFeatureFlag::ENABLE_FRAMEWORK_FOR_OPTION,
             FeatureFlag::SessionContinuation => AptosFeatureFlag::SESSION_CONTINUATION,
             FeatureFlag::EnableFunctionReflection => AptosFeatureFlag::ENABLE_FUNCTION_REFLECTION,
+            FeatureFlag::VMBinaryFormatV10 => AptosFeatureFlag::VM_BINARY_FORMAT_V10,
         }
     }
 }
@@ -596,6 +598,7 @@ impl From<AptosFeatureFlag> for FeatureFlag {
             AptosFeatureFlag::ENABLE_FRAMEWORK_FOR_OPTION => FeatureFlag::EnableFrameworkForOption,
             AptosFeatureFlag::SESSION_CONTINUATION => FeatureFlag::SessionContinuation,
             AptosFeatureFlag::ENABLE_FUNCTION_REFLECTION => FeatureFlag::EnableFunctionReflection,
+            AptosFeatureFlag::VM_BINARY_FORMAT_V10 => FeatureFlag::VMBinaryFormatV10,
         }
     }
 }

aptos-move/aptos-transactional-test-harness/tests/aptos_test_harness/diamond_clicker.exp

@@ -1,6 +1,6 @@
 processed 4 tasks
 task 1 lines 4-35:  print-bytecode --input=module [module Alice::game {]
-// Bytecode version v9
+// Bytecode version v10
 module 0xf75daa73fc071f93593335eb9033da804777eb94491650dd3f095ce6f778acb6::game
 use 0x1::signer
 use 0x1::debug

aptos-move/aptos-vm/src/verifier/event_validation.rs

@@ -235,6 +235,7 @@ pub(crate) fn validate_emit_calls(
                     | Le
                     | Ge
                     | Abort
+                    | AbortMsg
                     | Nop
                     | ImmBorrowVariantField(_)
                     | ImmBorrowVariantFieldGeneric(_)

third_party/move/move-binary-format/src/check_bounds.rs

@@ -673,8 +673,8 @@ impl<'a> BoundsChecker<'a> {
                 | LdI8(_) | LdI16(_) | LdI32(_) | LdI64(_) | LdI256(_) | LdI128(_) | CastI8
                 | CastI16 | CastI32 | CastI64 | CastI128 | CastI256 | LdTrue | LdFalse
                 | ReadRef | WriteRef | Add | Sub | Mul | Mod | Div | Negate | BitOr | BitAnd
-                | Xor | Shl | Shr | Or | And | Not | Eq | Neq | Lt | Gt | Le | Ge | Abort | Nop => {
-                },
+                | Xor | Shl | Shr | Or | And | Not | Eq | Neq | Lt | Gt | Le | Ge | Abort
+                | AbortMsg | Nop => {},
             }
         }
         Ok(())

third_party/move/move-binary-format/src/check_complexity.rs

@@ -376,6 +376,7 @@ impl BinaryComplexityMeter<'_> {
                 | MoveTo(_)
                 | MoveFrom(_)
                 | Abort
+                | AbortMsg
                 | Nop => (),
             }
         }

third_party/move/move-binary-format/src/deserializer.rs

@@ -1831,6 +1831,14 @@ fn load_code(cursor: &mut VersionedCursor, code: &mut Vec<Bytecode>) -> BinaryLo
                     )),
                 );
             },
+            Opcodes::ABORT_MSG if cursor.version() < VERSION_10 => {
+                return Err(
+                    PartialVMError::new(StatusCode::MALFORMED).with_message(format!(
+                        "aborting with message not available before bytecode version {}",
+                        VERSION_10
+                    )),
+                );
+            },
             _ => {},
         };
 
@@ -1943,6 +1951,7 @@ fn load_code(cursor: &mut VersionedCursor, code: &mut Vec<Bytecode>) -> BinaryLo
             Opcodes::LE => Bytecode::Le,
             Opcodes::GE => Bytecode::Ge,
             Opcodes::ABORT => Bytecode::Abort,
+            Opcodes::ABORT_MSG => Bytecode::AbortMsg,
             Opcodes::NOP => Bytecode::Nop,
             Opcodes::EXISTS => Bytecode::Exists(load_struct_def_index(cursor)?),
             Opcodes::EXISTS_GENERIC => Bytecode::ExistsGeneric(load_struct_def_inst_index(cursor)?),
@@ -2226,6 +2235,8 @@ impl Opcodes {
             0x65 => Ok(Opcodes::CAST_I128),
             0x66 => Ok(Opcodes::CAST_I256),
             0x67 => Ok(Opcodes::NEGATE),
+            // Since bytecode version 10
+            0x68 => Ok(Opcodes::ABORT_MSG),
             _ => Err(PartialVMError::new(StatusCode::UNKNOWN_OPCODE)
                 .with_message(format!("code {:X}", value))),
         }

third_party/move/move-binary-format/src/file_format.rs

@@ -3050,6 +3050,21 @@ pub enum Bytecode {
         ty_stack << ty
     "#]
     Negate,
+
+    #[group = "control_flow"]
+    #[description = r#"
+        Abort the transaction with an error code and message.
+    "#]
+    #[semantics = r#"
+        stack >> (error_message: vector<u8>)
+        stack >> (error_code: u64)
+        abort transaction with error_code and error_message
+    "#]
+    #[runtime_check_prologue = r#"
+        ty_stack >> _
+        ty_stack >> _
+    "#]
+    AbortMsg,
 }
 
 impl ::std::fmt::Debug for Bytecode {
@@ -3149,6 +3164,7 @@ impl ::std::fmt::Debug for Bytecode {
             Bytecode::Le => write!(f, "Le"),
             Bytecode::Ge => write!(f, "Ge"),
             Bytecode::Abort => write!(f, "Abort"),
+            Bytecode::AbortMsg => write!(f, "AbortMsg"),
             Bytecode::Nop => write!(f, "Nop"),
             Bytecode::Exists(a) => write!(f, "Exists({:?})", a),
             Bytecode::ExistsGeneric(a) => write!(f, "ExistsGeneric({:?})", a),
@@ -3171,7 +3187,10 @@ impl ::std::fmt::Debug for Bytecode {
 impl Bytecode {
     /// Return true if this bytecode instruction always branches
     pub fn is_unconditional_branch(&self) -> bool {
-        matches!(self, Bytecode::Ret | Bytecode::Abort | Bytecode::Branch(_))
+        matches!(
+            self,
+            Bytecode::Ret | Bytecode::Abort | Bytecode::AbortMsg | Bytecode::Branch(_)
+        )
     }
 
     /// Return true if the branching behavior of this bytecode instruction depends on a runtime
@@ -3328,6 +3347,7 @@ impl Bytecode {
             | Le
             | Ge
             | Abort
+            | AbortMsg
             | Nop
             | ImmBorrowVariantField(_)
             | ImmBorrowVariantFieldGeneric(_)

third_party/move/move-binary-format/src/file_format_common.rs

@@ -335,7 +335,9 @@ pub enum Opcodes {
     CAST_I64                    = 0x64,
     CAST_I128                   = 0x65,
     CAST_I256                   = 0x66,
-    NEGATE                      = 0x67
+    NEGATE                      = 0x67,
+    // Since bytecode version 10
+    ABORT_MSG                   = 0x68,
 }
 
 /// Upper limit on the binary size
@@ -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
+/// + abort with message instruction
+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.
@@ -798,6 +804,7 @@ pub fn instruction_key(instruction: &Bytecode) -> u8 {
         Le => Opcodes::LE,
         Ge => Opcodes::GE,
         Abort => Opcodes::ABORT,
+        AbortMsg => Opcodes::ABORT_MSG,
         Nop => Opcodes::NOP,
         Exists(_) => Opcodes::EXISTS,
         ExistsGeneric(_) => Opcodes::EXISTS_GENERIC,

third_party/move/move-binary-format/src/serializer.rs

@@ -1168,6 +1168,7 @@ fn serialize_instruction_inner(
         Bytecode::Le => binary.push(Opcodes::LE as u8),
         Bytecode::Ge => binary.push(Opcodes::GE as u8),
         Bytecode::Abort => binary.push(Opcodes::ABORT as u8),
+        Bytecode::AbortMsg => binary.push(Opcodes::ABORT_MSG as u8),
         Bytecode::Nop => binary.push(Opcodes::NOP as u8),
         Bytecode::Exists(class_idx) => {
             binary.push(Opcodes::EXISTS as u8)?;

third_party/move/move-bytecode-verifier/invalid-mutations/src/bounds/code_unit.rs

@@ -484,7 +484,7 @@ impl<'a> ApplyCodeUnitBoundsContext<'a> {
                     | LdI256(_) | CastI8 | CastI16 | CastI32 | CastI64 | CastI128 | CastI256
                     | LdTrue | LdFalse | ReadRef | WriteRef | Add | Sub | Mul | Mod | Div
                     | Negate | BitOr | BitAnd | Xor | Shl | Shr | Or | And | Not | Eq | Neq
-                    | Lt | Gt | Le | Ge | Abort | Nop => {
+                    | Lt | Gt | Le | Ge | Abort | AbortMsg | Nop => {
                         panic!("Bytecode has no internal index: {:?}", code[bytecode_idx])
                     },
                     PackVariant(_)
@@ -563,7 +563,7 @@ fn is_interesting(bytecode: &Bytecode) -> bool {
         | LdI16(_) | LdI32(_) | LdI64(_) | LdI128(_) | LdI256(_) | CastI8 | CastI16 | CastI32
         | CastI64 | CastI128 | CastI256 | LdTrue | LdFalse | ReadRef | WriteRef | Add | Sub
         | Mul | Mod | Div | Negate | BitOr | BitAnd | Xor | Shl | Shr | Or | And | Not | Eq
-        | Neq | Lt | Gt | Le | Ge | Abort | Nop => false,
+        | Neq | Lt | Gt | Le | Ge | Abort | AbortMsg | Nop => false,
 
         PackClosure(..)
         | PackClosureGeneric(..)

third_party/move/move-bytecode-verifier/src/acquires_list_verifier.rs

@@ -112,6 +112,7 @@ impl<'a> AcquiresVerifier<'a> {
             | Bytecode::BrTrue(_)
             | Bytecode::BrFalse(_)
             | Bytecode::Abort
+            | Bytecode::AbortMsg
             | Bytecode::Branch(_)
             | Bytecode::Nop
             | Bytecode::Ret

third_party/move/move-bytecode-verifier/src/instantiation_loops.rs

@@ -298,6 +298,7 @@ impl<'a> InstantiationLoopChecker<'a> {
                     | Bytecode::Le
                     | Bytecode::Ge
                     | Bytecode::Abort
+                    | Bytecode::AbortMsg
                     | Bytecode::Nop
                     | Bytecode::Exists(_)
                     | Bytecode::ExistsGeneric(_)

third_party/move/move-bytecode-verifier/src/instruction_consistency.rs

@@ -151,9 +151,9 @@ impl<'a> InstructionConsistency<'a> {
                 | Xor | Shl | Shr | Or | And | Not | Eq | Neq | Lt | Gt | Le | Ge | CopyLoc(_)
                 | MoveLoc(_) | StLoc(_) | MutBorrowLoc(_) | ImmBorrowLoc(_) | VecLen(_)
                 | VecImmBorrow(_) | VecMutBorrow(_) | VecPushBack(_) | VecPopBack(_)
-                | VecSwap(_) | Abort | Nop | LdI8(_) | LdI16(_) | LdI32(_) | LdI64(_)
-                | LdI128(_) | LdI256(_) | CastI8 | CastI16 | CastI32 | CastI64 | CastI128
-                | CastI256 => (),
+                | VecSwap(_) | Abort | AbortMsg | Nop | LdI8(_) | LdI16(_) | LdI32(_)
+                | LdI64(_) | LdI128(_) | LdI256(_) | CastI8 | CastI16 | CastI32 | CastI64
+                | CastI128 | CastI256 => (),
             }
         }
         Ok(())

third_party/move/move-bytecode-verifier/src/locals_safety/mod.rs

@@ -93,6 +93,7 @@ fn execute_inner(
         | Bytecode::BrTrue(_)
         | Bytecode::BrFalse(_)
         | Bytecode::Abort
+        | Bytecode::AbortMsg
         | Bytecode::Branch(_)
         | Bytecode::Nop
         | Bytecode::FreezeRef

third_party/move/move-bytecode-verifier/src/reference_safety/mod.rs

@@ -483,6 +483,12 @@ fn execute_inner(
         Bytecode::BrTrue(_) | Bytecode::BrFalse(_) | Bytecode::Abort => {
             safe_assert!(safe_unwrap!(verifier.stack.pop()).is_value());
         },
+        Bytecode::AbortMsg => {
+            // message value
+            safe_assert!(safe_unwrap!(verifier.stack.pop()).is_value());
+            // code value
+            safe_assert!(safe_unwrap!(verifier.stack.pop()).is_value());
+        },
         Bytecode::MoveTo(_) | Bytecode::MoveToGeneric(_) => {
             // resource value
             safe_assert!(safe_unwrap!(verifier.stack.pop()).is_value());

third_party/move/move-bytecode-verifier/src/signature_v2.rs

@@ -1032,6 +1032,7 @@ impl<'a, const N: usize> SignatureChecker<'a, N> {
                 | MoveTo(_)
                 | MoveFrom(_)
                 | Abort
+                | AbortMsg
                 | Nop => (),
             }
         }

third_party/move/move-bytecode-verifier/src/stack_usage_verifier.rs

@@ -211,11 +211,12 @@ impl<'a> StackUsageVerifier<'a> {
             // Vector indexing operations (pop twice and push once)
             Bytecode::VecImmBorrow(_) | Bytecode::VecMutBorrow(_) => (2, 1),
 
-            // MoveTo, WriteRef, and VecPushBack pop twice but do not push
+            // MoveTo, WriteRef, VecPushBack, and AbortMsg pop twice but do not push
             Bytecode::MoveTo(_)
             | Bytecode::MoveToGeneric(_)
             | Bytecode::WriteRef
-            | Bytecode::VecPushBack(_) => (2, 0),
+            | Bytecode::VecPushBack(_)
+            | Bytecode::AbortMsg => (2, 0),
 
             // VecSwap pops three times but does not push
             Bytecode::VecSwap(_) => (3, 0),

third_party/move/move-bytecode-verifier/src/type_safety.rs

@@ -589,7 +589,7 @@ fn borrow_vector_element(
     // check vector and update stack
     // The declared element type must be exactly the same as the element type of the vector
     // operand. (No co-variance.)
-    let element_type = match get_vector_element_type(operand_vec, mut_ref_only) {
+    let element_type = match get_vector_ref_element_type(operand_vec, mut_ref_only) {
         Some(ty) if declared_element_type == &ty => ty,
         _ => return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset)),
     };
@@ -641,6 +641,14 @@ fn verify_instr(
             }
         },
 
+        Bytecode::AbortMsg => {
+            let operand_message = safe_unwrap!(verifier.stack.pop());
+            let operand_code = safe_unwrap!(verifier.stack.pop());
+            if operand_code != ST::U64 || get_vector_element_type(operand_message) != Some(ST::U8) {
+                return Err(verifier.error(StatusCode::ABORT_TYPE_MISMATCH_ERROR, offset));
+            }
+        },
+
         Bytecode::Ret => {
             let return_ = &verifier.function_view.return_().0;
             for return_type in return_.iter().rev() {
@@ -1187,7 +1195,7 @@ fn verify_instr(
         Bytecode::VecLen(idx) => {
             let operand = safe_unwrap!(verifier.stack.pop());
             let declared_element_type = &verifier.resolver.signature_at(*idx).0[0];
-            match get_vector_element_type(operand, false) {
+            match get_vector_ref_element_type(operand, false) {
                 // The derived and declared element types must be equal (no co-variance)
                 Some(derived_element_type) if &derived_element_type == declared_element_type => {
                     verifier.push(meter, ST::U64)?;
@@ -1213,7 +1221,7 @@ fn verify_instr(
             if !declared_element_type.is_assignable_from(&operand_elem) {
                 return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset));
             }
-            match get_vector_element_type(operand_vec, true) {
+            match get_vector_ref_element_type(operand_vec, true) {
                 // Derived and declared element types must be equal.
                 Some(derived_element_type) if &derived_element_type == declared_element_type => {},
                 _ => return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset)),
@@ -1223,7 +1231,7 @@ fn verify_instr(
         Bytecode::VecPopBack(idx) => {
             let operand_vec = safe_unwrap!(verifier.stack.pop());
             let declared_element_type = &verifier.resolver.signature_at(*idx).0[0];
-            match get_vector_element_type(operand_vec, true) {
+            match get_vector_ref_element_type(operand_vec, true) {
                 // Derived and declared element types must be equal.
                 Some(derived_element_type) if &derived_element_type == declared_element_type => {
                     verifier.push(meter, derived_element_type)?;
@@ -1251,7 +1259,7 @@ fn verify_instr(
                 return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset));
             }
             let declared_element_type = &verifier.resolver.signature_at(*idx).0[0];
-            match get_vector_element_type(operand_vec, true) {
+            match get_vector_ref_element_type(operand_vec, true) {
                 // Derived and declared element types must be equal
                 Some(derived_element_type) if &derived_element_type == declared_element_type => {},
                 _ => return Err(verifier.error(StatusCode::TYPE_MISMATCH, offset)),
@@ -1380,7 +1388,15 @@ fn instantiate(token: &SignatureToken, subst: &Signature) -> SignatureToken {
     }
 }
 
-fn get_vector_element_type(
+fn get_vector_element_type(vector_ty: SignatureToken) -> Option<SignatureToken> {
+    if let ST::Vector(element_type) = vector_ty {
+        Some(*element_type)
+    } else {
+        None
+    }
+}
+
+fn get_vector_ref_element_type(
     vector_ref_ty: SignatureToken,
     mut_ref_only: bool,
 ) -> Option<SignatureToken> {