core: fix how cf and ch controls execution

src/core/core.rs

@@ -89,14 +89,14 @@ pub struct Core<Id: SiteId, const CALL_STACK_SIZE: usize = { CALL_STACK_SIZE_MAX
 
     // --------------------------------------------------------------------------------------------
     // Control flow registers
-    /// Halt register. If set to `true`, halts program when `ck` is set to `true` for the first
-    /// time.
+    /// Halt register. If set to `true`, halts program when `ck` is set to [`Status::Failed`] for
+    /// the first time.
     ///
     /// # See also
     ///
     /// - [`Core::ck`] register
     /// - [`Core::cf`] register
-    ch: bool,
+    pub(super) ch: bool,
 
     /// Check register, which is set on any failure (accessing register in `None` state, zero
     /// division etc.). Can be reset.
@@ -107,13 +107,13 @@ pub struct Core<Id: SiteId, const CALL_STACK_SIZE: usize = { CALL_STACK_SIZE_MAX
     /// - [`Core::cf`] register
     pub(super) ck: Status,
 
-    /// Failure register, which is set on the first time `ck` is set, and can't be reset.
+    /// Failure register, which counts how many times `ck` was set, and can't be reset.
     ///
     /// # See also
     ///
     /// - [`Core::ch`] register
     /// - [`Core::ck`] register
-    cf: Status,
+    pub(super) cf: u64,
 
     /// Test register, which acts as boolean test result (also a carry flag).
     pub(super) co: bool,
@@ -137,7 +137,7 @@ pub struct Core<Id: SiteId, const CALL_STACK_SIZE: usize = { CALL_STACK_SIZE_MAX
     ///
     /// If this register has a value set, once [`Core::ca`] will reach this value the VM will
     /// stop program execution setting `ck` to `false`.
-    cl: Option<u64>,
+    pub(super) cl: Option<u64>,
 
     /// Call stack.
     ///
@@ -208,7 +208,7 @@ impl<Id: SiteId, const CALL_STACK_SIZE: usize> Core<Id, CALL_STACK_SIZE> {
             //b: Default::default(),
             ch: config.halt,
             ck: Status::Ok,
-            cf: Status::Ok,
+            cf: 0,
             co: false,
             cy: 0,
             ca: 0,
@@ -218,15 +218,6 @@ impl<Id: SiteId, const CALL_STACK_SIZE: usize> Core<Id, CALL_STACK_SIZE> {
     }
 }
 
-/// Microcode for flag registers.
-impl<Id: SiteId, const CALL_STACK_SIZE: usize> Core<Id, CALL_STACK_SIZE> {
-    /// Return whether check register `ck` was set to a failed state for at least once.
-    pub fn had_failed(&self) -> bool { self.cf == Status::Fail }
-
-    /// Return complexity limit value.
-    pub fn cl(&self) -> Option<u64> { self.cl }
-}
-
 impl<Id: SiteId, const CALL_STACK_SIZE: usize> Debug for Core<Id, CALL_STACK_SIZE> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let (sect, reg, val, reset) =

src/core/microcode/base.rs

@@ -202,13 +202,23 @@ impl<Id: SiteId, const CALL_STACK_SIZE: usize> Core<Id, CALL_STACK_SIZE> {
     pub fn co(&self) -> bool { self.co }
 
     /// Set overflow/carry flag to a value.
-    pub fn set_co(&mut self, co: bool) { self.co = co }
+    pub fn set_co(&mut self, co: bool) { self.co = co; }
+
+    /// Return whether check register `ck` was set to a failed state for at least once.
+    pub fn cf(&self) -> u64 { self.cf }
 
     /// Return whether check register `ck` was set to a failed state for at least once.
     pub fn ck(&self) -> Status { self.ck }
 
     /// Set `ck` register to a failed state.
-    pub fn fail_ck(&mut self) { self.ck = Status::Fail }
+    ///
+    /// Returns whether further execution should be stopped (i.e. `ch` register value).
+    #[must_use]
+    pub fn fail_ck(&mut self) -> bool {
+        self.ck = Status::Fail;
+        self.cf += 1;
+        self.ch
+    }
 
     /// Reset `ck` register.
     pub fn reset_ck(&mut self) { self.ck = Status::Ok }
@@ -229,6 +239,9 @@ impl<Id: SiteId, const CALL_STACK_SIZE: usize> Core<Id, CALL_STACK_SIZE> {
     /// Pops a call stack item.
     pub fn pop_cs(&mut self) -> Option<Site<Id>> { self.cs.pop() }
 
+    /// Return complexity limit value.
+    pub fn cl(&self) -> Option<u64> { self.cl }
+
     /// Accumulate complexity value.
     ///
     /// # Returns

src/isa/alu/exec.rs

@@ -129,7 +129,11 @@ impl<Id: SiteId> Instruction<Id> for CtrlInstr<Id> {
                     return ExecStep::Stop;
                 }
             }
-            CtrlInstr::FailCk => core.fail_ck(),
+            CtrlInstr::FailCk => {
+                if core.fail_ck() {
+                    return ExecStep::Stop;
+                }
+            }
             CtrlInstr::RsetCk => {
                 core.set_co(core.ck() == Status::Fail);
                 core.reset_ck()
@@ -209,7 +213,9 @@ impl<Id: SiteId> Instruction<Id> for RegInstr {
                 dst: _,
                 val: MaybeU128::NoData,
             } => {
-                core.fail_ck();
+                if core.fail_ck() {
+                    return ExecStep::Stop;
+                }
             }
             RegInstr::Put {
                 dst,

src/library/exec.rs

@@ -112,7 +112,7 @@ impl Lib {
                     return None;
                 }
                 ExecStep::StopFail => {
-                    registers.fail_ck();
+                    let _ = registers.fail_ck();
                     #[cfg(feature = "log")]
                     eprintln!("halting, {d}ck{z} is set to {r}false{z}");
                     return None;
@@ -123,7 +123,11 @@ impl Lib {
                     continue;
                 }
                 ExecStep::NextFail => {
-                    registers.fail_ck();
+                    if registers.fail_ck() {
+                        #[cfg(feature = "log")]
+                        eprintln!("halting, {d}ck{z} is set to {r}false{z} and {d}ch{z} is {r}true{z}");
+                        return None;
+                    }
                     #[cfg(feature = "log")]
                     eprintln!("failing, {d}ck{z} is set to {r}false{z}");
                     continue;
@@ -132,7 +136,7 @@ impl Lib {
                     #[cfg(feature = "log")]
                     eprintln!("{}", pos);
                     if marshaller.seek(pos).is_err() {
-                        registers.fail_ck();
+                        let _ = registers.fail_ck();
                         #[cfg(feature = "log")]
                         eprintln!("jump to non-existing offset; halting, {d}ck{z} is set to {r}fail{z}");
                         return None;