[vm] New bytecode for aborting with message

Author: calintat

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

@@ -132,6 +132,7 @@ where
             Nop => NOP,
 
             Abort => ABORT,
+            AbortMsg => ABORT_MSG,
             Ret => RET,
 
             LdU8 => LD_U8,

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

@@ -22,6 +22,7 @@ crate::gas_schedule::macros::define_gas_parameters!(
         // control flow
         [ret: InternalGas, "ret", 220],
         [abort: InternalGas, "abort", 220],
+        [abort_msg: InternalGas, "abort_ msg", 220],
 
         // 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-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-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,7 +673,7 @@ 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 => {
                 },
             }
         }

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,18 @@ 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 = "ty_stack >> _"]
+    AbortMsg,
 }
 
 impl ::std::fmt::Debug for Bytecode {
@@ -3149,6 +3161,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 +3184,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 +3344,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)?;