Optimize error naming

mohanson · mohanson · commit b36ccda01283 · 2025-11-18T16:07:16.000+08:00
diff --git a/definitions/src/asm.rs b/definitions/src/asm.rs
@@ -15,11 +15,11 @@ pub const RET_OUT_OF_BOUND: u8 = 7;
 pub const RET_INVALID_PERMISSION: u8 = 8;
 pub const RET_SLOWPATH: u8 = 9;
 pub const RET_PAUSE: u8 = 10;
-pub const RET_SHADOW_STACK_LPAD_NOT_4BYTE_ALIGNED: u8 = 11;
-pub const RET_SHADOW_STACK_NOT_LPAD: u8 = 12;
-pub const RET_SHADOW_STACK_LABEL_WRONG: u8 = 13;
-pub const RET_SHADOW_STACK_VALUE_WRONG: u8 = 14;
-pub const RET_SHADOW_STACK_STACK_OUT_OF_STACK: u8 = 15;
+pub const RET_CFI_LPAD_NOT_4BYTE_ALIGNED: u8 = 11;
+pub const RET_CFI_LPAD_NOT_FOUND: u8 = 12;
+pub const RET_CFI_LPAD_LABEL_MISMATCH: u8 = 13;
+pub const RET_CFI_SS_VALUE_FAULT: u8 = 14;
+pub const RET_CFI_SS_OUT_OF_STACK: u8 = 15;
 
 #[inline(always)]
 pub fn calculate_slot(addr: u64) -> usize {
diff --git a/definitions/src/generate_asm_constants.rs b/definitions/src/generate_asm_constants.rs
@@ -2,12 +2,11 @@ use ckb_vm_definitions::{
     DEFAULT_SHADOW_STACK_SIZE, MEMORY_FRAME_PAGE_SHIFTS, MEMORY_FRAME_SHIFTS, MEMORY_FRAMESIZE,
     RISCV_PAGE_SHIFTS, RISCV_PAGESIZE,
     asm::{
-        AsmCoreMachine, FixedTrace, InvokeData, RET_CYCLES_OVERFLOW, RET_DECODE_TRACE,
-        RET_DYNAMIC_JUMP, RET_EBREAK, RET_ECALL, RET_INVALID_PERMISSION, RET_MAX_CYCLES_EXCEEDED,
-        RET_OUT_OF_BOUND, RET_PAUSE, RET_SHADOW_STACK_LABEL_WRONG,
-        RET_SHADOW_STACK_LPAD_NOT_4BYTE_ALIGNED, RET_SHADOW_STACK_NOT_LPAD,
-        RET_SHADOW_STACK_STACK_OUT_OF_STACK, RET_SHADOW_STACK_VALUE_WRONG, RET_SLOWPATH,
-        TRACE_ITEM_LENGTH,
+        AsmCoreMachine, FixedTrace, InvokeData, RET_CFI_LPAD_LABEL_MISMATCH,
+        RET_CFI_LPAD_NOT_4BYTE_ALIGNED, RET_CFI_LPAD_NOT_FOUND, RET_CFI_SS_OUT_OF_STACK,
+        RET_CFI_SS_VALUE_FAULT, RET_CYCLES_OVERFLOW, RET_DECODE_TRACE, RET_DYNAMIC_JUMP,
+        RET_EBREAK, RET_ECALL, RET_INVALID_PERMISSION, RET_MAX_CYCLES_EXCEEDED, RET_OUT_OF_BOUND,
+        RET_PAUSE, RET_SLOWPATH, TRACE_ITEM_LENGTH,
     },
     for_each_inst,
     instructions::{MAXIMUM_OPCODE, MINIMAL_OPCODE, instruction_opcode_name},
@@ -74,24 +73,24 @@ fn main() {
     println!("#define CKB_VM_ASM_RET_SLOWPATH {}", RET_SLOWPATH);
     println!("#define CKB_VM_ASM_RET_PAUSE {}", RET_PAUSE);
     println!(
-        "#define CKB_VM_ASM_RET_SHADOW_STACK_LPAD_NOT_4BYTE_ALIGNED {}",
-        RET_SHADOW_STACK_LPAD_NOT_4BYTE_ALIGNED
+        "#define CKB_VM_ASM_RET_CFI_LPAD_NOT_4BYTE_ALIGNED {}",
+        RET_CFI_LPAD_NOT_4BYTE_ALIGNED
     );
     println!(
-        "#define CKB_VM_ASM_RET_SHADOW_STACK_NOT_LPAD {}",
-        RET_SHADOW_STACK_NOT_LPAD
+        "#define CKB_VM_ASM_RET_CFI_LPAD_NOT_FOUND {}",
+        RET_CFI_LPAD_NOT_FOUND
     );
     println!(
-        "#define CKB_VM_ASM_RET_SHADOW_STACK_LABEL_WRONG {}",
-        RET_SHADOW_STACK_LABEL_WRONG
+        "#define CKB_VM_ASM_RET_CFI_LPAD_LABEL_MISMATCH {}",
+        RET_CFI_LPAD_LABEL_MISMATCH
     );
     println!(
-        "#define CKB_VM_ASM_RET_SHADOW_STACK_VALUE_WRONG {}",
-        RET_SHADOW_STACK_VALUE_WRONG
+        "#define CKB_VM_ASM_RET_CFI_SS_VALUE_FAULT {}",
+        RET_CFI_SS_VALUE_FAULT
     );
     println!(
-        "#define CKB_VM_ASM_RET_SHADOW_STACK_STACK_OUT_OF_STACK {}",
-        RET_SHADOW_STACK_STACK_OUT_OF_STACK
+        "#define CKB_VM_ASM_RET_CFI_SS_OUT_OF_STACK {}",
+        RET_CFI_SS_OUT_OF_STACK
     );
     println!();
 
diff --git a/src/decoder.rs b/src/decoder.rs
@@ -124,7 +124,7 @@ impl DefaultDecoder {
             if let Some(instruction) = factory(instruction_bits, self.version, self.cfi) {
                 // Shadow Stack Software Check for LPAD instruction.
                 if extract_opcode(instruction) == insts::OP_LPAD && pc % 4 != 0 {
-                    return Err(Error::ShadowStackLpadNot4ByteAligned);
+                    return Err(Error::CFILpadNot4ByteAligned);
                 }
                 self.instructions_cache[instruction_cache_key] = (pc, instruction);
                 return Ok(instruction);
diff --git a/src/error.rs b/src/error.rs
@@ -52,15 +52,15 @@ pub enum Error {
     #[display("yield")]
     Yield,
     #[display("shadow stack lpad not 4-byte aligned")]
-    ShadowStackLpadNot4ByteAligned,
+    CFILpadNot4ByteAligned,
     #[display("shadow stack not lpad")]
-    ShadowStackNotLpad,
+    CFILpadNotFound,
     #[display("shadow stack label wrong")]
-    ShadowStackLabelWrong,
+    CFILpadLabelMismatched,
     #[display("shadow stack value wrong")]
-    ShadowStackValueWrong,
+    CFIShadowStackValueFault,
     #[display("shadow stack out of stack")]
-    ShadowStackOutOfStack,
+    CFIShadowStackOutOfStack,
 }
 
 #[derive(Debug, PartialEq, Clone, Eq, Display)]
diff --git a/src/instructions/execute.rs b/src/instructions/execute.rs
@@ -1514,13 +1514,13 @@ pub fn handle_lpad<Mac: Machine>(machine: &mut Mac, inst: Instruction) -> Result
     }
     // If PC not 4-byte aligned then software-check exception.
     if machine.pc().to_u64() % 4 != 0 {
-        return Err(Error::ShadowStackLpadNot4ByteAligned);
+        return Err(Error::CFILpadNot4ByteAligned);
     }
     // If landing pad label not matched -> software-check exception
     let lpl = Utype(inst).immediate_u();
     let x7l = machine.registers()[T2].to_u32() & 0xFFFFF000;
     if lpl != x7l && lpl != 0 {
-        return Err(Error::ShadowStackLabelWrong);
+        return Err(Error::CFILpadLabelMismatched);
     }
     machine.set_elp(0);
     Ok(())
@@ -1532,7 +1532,7 @@ pub fn handle_sspush<Mac: Machine>(machine: &mut Mac, inst: Instruction) -> Resu
     let ssp = machine.ssp().clone();
     let ssp = ssp.overflowing_sub(&Mac::REG::from_u8(Mac::REG::BITS / 8));
     if ssp.to_u64() == 0 {
-        return Err(Error::ShadowStackOutOfStack);
+        return Err(Error::CFIShadowStackOutOfStack);
     }
     machine.set_ra(&ssp, &rs2_value)?;
     machine.set_ssp(&ssp);
@@ -1546,7 +1546,7 @@ pub fn handle_sspopchk<Mac: Machine>(machine: &mut Mac, inst: Instruction) -> Re
     let ret = machine.ra(&ssp)?.clone();
     let ssp = ssp.overflowing_add(&Mac::REG::from_u8(Mac::REG::BITS / 8));
     if ret.to_u64() != rs1_value.to_u64() {
-        return Err(Error::ShadowStackValueWrong);
+        return Err(Error::CFIShadowStackValueFault);
     }
     machine.set_ssp(&ssp);
     Ok(())
diff --git a/src/machine/asm/cdefinitions_generated.h b/src/machine/asm/cdefinitions_generated.h
@@ -17,11 +17,11 @@
 #define CKB_VM_ASM_RET_INVALID_PERMISSION 8
 #define CKB_VM_ASM_RET_SLOWPATH 9
 #define CKB_VM_ASM_RET_PAUSE 10
-#define CKB_VM_ASM_RET_SHADOW_STACK_LPAD_NOT_4BYTE_ALIGNED 11
-#define CKB_VM_ASM_RET_SHADOW_STACK_NOT_LPAD 12
-#define CKB_VM_ASM_RET_SHADOW_STACK_LABEL_WRONG 13
-#define CKB_VM_ASM_RET_SHADOW_STACK_VALUE_WRONG 14
-#define CKB_VM_ASM_RET_SHADOW_STACK_STACK_OUT_OF_STACK 15
+#define CKB_VM_ASM_RET_CFI_LPAD_NOT_4BYTE_ALIGNED 11
+#define CKB_VM_ASM_RET_CFI_LPAD_NOT_FOUND 12
+#define CKB_VM_ASM_RET_CFI_LPAD_LABEL_MISMATCH 13
+#define CKB_VM_ASM_RET_CFI_SS_VALUE_FAULT 14
+#define CKB_VM_ASM_RET_CFI_SS_OUT_OF_STACK 15
 
 #define CKB_VM_ASM_REGISTER_RA 1
 #define CKB_VM_ASM_REGISTER_SP 2
diff --git a/src/machine/asm/execute_aarch64.S b/src/machine/asm/execute_aarch64.S
@@ -2005,16 +2005,16 @@ ckb_vm_x64_execute:
   mov x0, CKB_VM_ASM_RET_INVALID_PERMISSION
   b .exit
 .exit_shadow_stack_not_lpad:
-  mov x0, CKB_VM_ASM_RET_SHADOW_STACK_NOT_LPAD
+  mov x0, CKB_VM_ASM_RET_CFI_LPAD_NOT_FOUND
   b .exit
 .exit_shadow_stack_label_wrong:
-  mov x0, CKB_VM_ASM_RET_SHADOW_STACK_LABEL_WRONG
+  mov x0, CKB_VM_ASM_RET_CFI_LPAD_LABEL_MISMATCH
   b .exit
 .exit_shadow_stack_value_wrong:
-  mov x0, CKB_VM_ASM_RET_SHADOW_STACK_VALUE_WRONG
+  mov x0, CKB_VM_ASM_RET_CFI_SS_VALUE_FAULT
   b .exit
 .exit_shadow_stack_stack_out_of_stack:
-  mov x0, CKB_VM_ASM_RET_SHADOW_STACK_STACK_OUT_OF_STACK
+  mov x0, CKB_VM_ASM_RET_CFI_SS_OUT_OF_STACK
   b .exit
 .exit_pause:
   mov x0, CKB_VM_ASM_RET_PAUSE
diff --git a/src/machine/asm/execute_x64.S b/src/machine/asm/execute_x64.S
@@ -2496,19 +2496,19 @@ ckb_vm_x64_execute:
   jmp .exit
 .p2align 3
 .exit_shadow_stack_not_lpad:
-  mov $CKB_VM_ASM_RET_SHADOW_STACK_NOT_LPAD, ARG_RETd
+  mov $CKB_VM_ASM_RET_CFI_LPAD_NOT_FOUND, ARG_RETd
   jmp .exit
 .p2align 3
 .exit_shadow_stack_label_wrong:
-  mov $CKB_VM_ASM_RET_SHADOW_STACK_LABEL_WRONG, ARG_RETd
+  mov $CKB_VM_ASM_RET_CFI_LPAD_LABEL_MISMATCH, ARG_RETd
   jmp .exit
 .p2align 3
 .exit_shadow_stack_value_wrong:
-  mov $CKB_VM_ASM_RET_SHADOW_STACK_VALUE_WRONG, ARG_RETd
+  mov $CKB_VM_ASM_RET_CFI_SS_VALUE_FAULT, ARG_RETd
   jmp .exit
 .p2align 3
 .exit_shadow_stack_stack_out_of_stack:
-  mov $CKB_VM_ASM_RET_SHADOW_STACK_STACK_OUT_OF_STACK, ARG_RETd
+  mov $CKB_VM_ASM_RET_CFI_SS_OUT_OF_STACK, ARG_RETd
   jmp .exit
 /*
  * Some instructions that are difficult to implement will be interpreted and
diff --git a/src/machine/asm/mod.rs b/src/machine/asm/mod.rs
@@ -7,11 +7,10 @@ use ckb_vm_definitions::{
     ISA_MOP, MEMORY_FRAME_PAGE_SHIFTS, MEMORY_FRAMESIZE, RISCV_GENERAL_REGISTER_NUMBER,
     RISCV_PAGE_SHIFTS,
     asm::{
-        FixedTrace, InvokeData, RET_CYCLES_OVERFLOW, RET_DECODE_TRACE, RET_DYNAMIC_JUMP,
-        RET_EBREAK, RET_ECALL, RET_INVALID_PERMISSION, RET_MAX_CYCLES_EXCEEDED, RET_OUT_OF_BOUND,
-        RET_PAUSE, RET_SHADOW_STACK_LABEL_WRONG, RET_SHADOW_STACK_LPAD_NOT_4BYTE_ALIGNED,
-        RET_SHADOW_STACK_NOT_LPAD, RET_SHADOW_STACK_STACK_OUT_OF_STACK,
-        RET_SHADOW_STACK_VALUE_WRONG, RET_SLOWPATH,
+        FixedTrace, InvokeData, RET_CFI_LPAD_LABEL_MISMATCH, RET_CFI_LPAD_NOT_4BYTE_ALIGNED,
+        RET_CFI_LPAD_NOT_FOUND, RET_CFI_SS_OUT_OF_STACK, RET_CFI_SS_VALUE_FAULT,
+        RET_CYCLES_OVERFLOW, RET_DECODE_TRACE, RET_DYNAMIC_JUMP, RET_EBREAK, RET_ECALL,
+        RET_INVALID_PERMISSION, RET_MAX_CYCLES_EXCEEDED, RET_OUT_OF_BOUND, RET_PAUSE, RET_SLOWPATH,
     },
 };
 use rand::{SeedableRng, prelude::RngCore};
@@ -154,7 +153,7 @@ where
         let size = Self::REG::BITS as usize / 8;
         let (end, overflowed) = offset.overflowing_add(size);
         if overflowed || end > DEFAULT_SHADOW_STACK_SIZE {
-            return Err(Error::ShadowStackOutOfStack);
+            return Err(Error::CFIShadowStackOutOfStack);
         }
         let ra = self
             .as_ref()
@@ -172,7 +171,7 @@ where
         let size = Self::REG::BITS as usize / 8;
         let (end, overflowed) = offset.overflowing_add(size);
         if overflowed || end > DEFAULT_SHADOW_STACK_SIZE {
-            return Err(Error::ShadowStackOutOfStack);
+            return Err(Error::CFIShadowStackOutOfStack);
         }
         let bytes = value.to_le_bytes().to_vec();
         self.as_mut().shadow_stack[offset..end].copy_from_slice(&bytes);
@@ -870,21 +869,21 @@ impl<R: AsmCoreMachineRevealer, D: TraceDecoder> DefaultMachineRunner for Abstra
                     self.machine.pause.free();
                     return Err(Error::Pause);
                 }
-                RET_SHADOW_STACK_LPAD_NOT_4BYTE_ALIGNED => {
+                RET_CFI_LPAD_NOT_4BYTE_ALIGNED => {
                     // Should not be caught. The check occurs during the decoder phase.
                     unreachable!();
                 }
-                RET_SHADOW_STACK_NOT_LPAD => {
-                    return Err(Error::ShadowStackNotLpad);
+                RET_CFI_LPAD_NOT_FOUND => {
+                    return Err(Error::CFILpadNotFound);
                 }
-                RET_SHADOW_STACK_LABEL_WRONG => {
-                    return Err(Error::ShadowStackLabelWrong);
+                RET_CFI_LPAD_LABEL_MISMATCH => {
+                    return Err(Error::CFILpadLabelMismatched);
                 }
-                RET_SHADOW_STACK_VALUE_WRONG => {
-                    return Err(Error::ShadowStackValueWrong);
+                RET_CFI_SS_VALUE_FAULT => {
+                    return Err(Error::CFIShadowStackValueFault);
                 }
-                RET_SHADOW_STACK_STACK_OUT_OF_STACK => {
-                    return Err(Error::ShadowStackOutOfStack);
+                RET_CFI_SS_OUT_OF_STACK => {
+                    return Err(Error::CFIShadowStackOutOfStack);
                 }
                 _ => return Err(Error::Asm(result)),
             }
@@ -949,21 +948,21 @@ impl<R: AsmCoreMachineRevealer, D: TraceDecoder> AbstractAsmMachine<R, D> {
                 let instruction = decoder.decode(self.machine.memory_mut(), pc)?;
                 execute_instruction(instruction, &mut self.machine)?;
             }
-            RET_SHADOW_STACK_LPAD_NOT_4BYTE_ALIGNED => {
+            RET_CFI_LPAD_NOT_4BYTE_ALIGNED => {
                 // Should not be caught. The check occurs during the decoder phase.
                 unreachable!();
             }
-            RET_SHADOW_STACK_NOT_LPAD => {
-                return Err(Error::ShadowStackNotLpad);
+            RET_CFI_LPAD_NOT_FOUND => {
+                return Err(Error::CFILpadNotFound);
             }
-            RET_SHADOW_STACK_LABEL_WRONG => {
-                return Err(Error::ShadowStackLabelWrong);
+            RET_CFI_LPAD_LABEL_MISMATCH => {
+                return Err(Error::CFILpadLabelMismatched);
             }
-            RET_SHADOW_STACK_VALUE_WRONG => {
-                return Err(Error::ShadowStackValueWrong);
+            RET_CFI_SS_VALUE_FAULT => {
+                return Err(Error::CFIShadowStackValueFault);
             }
-            RET_SHADOW_STACK_STACK_OUT_OF_STACK => {
-                return Err(Error::ShadowStackOutOfStack);
+            RET_CFI_SS_OUT_OF_STACK => {
+                return Err(Error::CFIShadowStackOutOfStack);
             }
             _ => return Err(Error::Asm(result)),
         }
diff --git a/src/machine/mod.rs b/src/machine/mod.rs
@@ -466,7 +466,7 @@ impl<R: Register, M: Memory<REG = R>> CoreMachine for DefaultCoreMachine<R, M> {
         let size = Self::REG::BITS as usize / 8;
         let (end, overflowed) = offset.overflowing_add(size);
         if overflowed || end > DEFAULT_SHADOW_STACK_SIZE {
-            return Err(Error::ShadowStackOutOfStack);
+            return Err(Error::CFIShadowStackOutOfStack);
         }
         let ra = self
             .shadow_stack
@@ -491,7 +491,7 @@ impl<R: Register, M: Memory<REG = R>> CoreMachine for DefaultCoreMachine<R, M> {
         let size = Self::REG::BITS as usize / 8;
         let (end, overflowed) = offset.overflowing_add(size);
         if overflowed || end > DEFAULT_SHADOW_STACK_SIZE {
-            return Err(Error::ShadowStackOutOfStack);
+            return Err(Error::CFIShadowStackOutOfStack);
         }
         let bytes = match size {
             4 => value.to_u32().to_le_bytes().to_vec(),
@@ -933,7 +933,7 @@ impl<Inner: SupportMachine, Decoder> DefaultMachine<Inner, Decoder> {
             decoder.decode(memory, pc)?
         };
         if self.elp() != 0 && extract_opcode(instruction) != insts::OP_LPAD {
-            return Err(Error::ShadowStackNotLpad);
+            return Err(Error::CFILpadNotFound);
         }
         let cycles = self.instruction_cycle_func()(instruction);
         self.add_cycles(cycles)?;
diff --git a/src/machine/trace.rs b/src/machine/trace.rs
@@ -217,7 +217,7 @@ impl<Inner: SupportMachine, Decoder: InstDecoder> DefaultMachineRunner
             if self.machine.elp() != 0
                 && extract_opcode(self.traces[slot].instructions[0]) != insts::OP_LPAD
             {
-                return Err(Error::ShadowStackNotLpad);
+                return Err(Error::CFILpadNotFound);
             }
             for i in 0..self.traces[slot].instruction_count {
                 let inst = self.traces[slot].instructions[i as usize];
diff --git a/tests/test_cfi.rs b/tests/test_cfi.rs
@@ -40,7 +40,7 @@ pub fn test_cfi_ss_not_active() {
 pub fn test_cfi_ss_stack_downto_zero() {
     let ret = run("tests/programs/cfi_ss_stack_downto_zero");
     assert!(ret.is_err());
-    assert!(matches!(ret, Err(Error::ShadowStackOutOfStack)));
+    assert!(matches!(ret, Err(Error::CFIShadowStackOutOfStack)));
 }
 
 #[test]
@@ -65,7 +65,7 @@ pub fn test_cfi_lpad_not_active() {
 pub fn test_cfi_lpad_unlabeled_failed() {
     let ret = run("tests/programs/cfi_lpad_unlabeled_failed");
     assert!(ret.is_err());
-    assert!(matches!(ret, Err(Error::ShadowStackNotLpad)));
+    assert!(matches!(ret, Err(Error::CFILpadNotFound)));
 }
 
 #[test]
@@ -84,20 +84,20 @@ pub fn test_cfi_lpad_func_sig_zero() {
 pub fn test_cfi_lpad_func_sig_failed() {
     let ret = run("tests/programs/cfi_lpad_func_sig_failed");
     assert!(ret.is_err());
-    assert!(matches!(ret, Err(Error::ShadowStackLabelWrong)));
+    assert!(matches!(ret, Err(Error::CFILpadLabelMismatched)));
 }
 
 #[test]
 pub fn test_cfi_ss_only_pop() {
     let ret = run("tests/programs/cfi_ss_only_pop");
     print!("err {:?}", ret);
     assert!(ret.is_err());
-    assert!(matches!(ret, Err(Error::ShadowStackOutOfStack)));
+    assert!(matches!(ret, Err(Error::CFIShadowStackOutOfStack)));
 }
 
 #[test]
 pub fn test_cfi_ss_popchk_failed() {
     let ret = run("tests/programs/cfi_ss_popchk_failed");
     assert!(ret.is_err());
-    assert!(matches!(ret, Err(Error::ShadowStackValueWrong)));
+    assert!(matches!(ret, Err(Error::CFIShadowStackValueFault)));
 }

Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ impl DefaultDecoder {`
`124`	`124`	`if let Some(instruction) = factory(instruction_bits, self.version, self.cfi) {`
`125`	`125`	`// Shadow Stack Software Check for LPAD instruction.`
`126`	`126`	`if extract_opcode(instruction) == insts::OP_LPAD && pc % 4 != 0 {`
`127`		`- return Err(Error::ShadowStackLpadNot4ByteAligned);`
	`127`	`+ return Err(Error::CFILpadNot4ByteAligned);`
`128`	`128`	`}`
`129`	`129`	`self.instructions_cache[instruction_cache_key] = (pc, instruction);`
`130`	`130`	`return Ok(instruction);`