Clean up FpySequencer directives (#4395)

* Remove assert and float floor div

* Rename add/sub/mul

---------

Co-authored-by: M Starch <LeStarch@googlemail.com>

Author: zimri-leisher

Svc/FpySequencer/FpySequencer.hpp

@@ -69,7 +69,6 @@ class FpySequencer : public FpySequencerComponentBase {
         FpySequencer_GetFlagDirective getFlag;
         FpySequencer_GetFieldDirective getField;
         FpySequencer_PeekDirective peek;
-        FpySequencer_AssertDirective assert;
         FpySequencer_StoreDirective store;
 
         DirectiveUnion() {}
@@ -551,9 +550,6 @@ class FpySequencer : public FpySequencerComponentBase {
     //! Internal interface handler for directive_peek
     void directive_peek_internalInterfaceHandler(const Svc::FpySequencer_PeekDirective& directive) override;
 
-    //! Internal interface handler for directive_assert
-    void directive_assert_internalInterfaceHandler(const Svc::FpySequencer_AssertDirective& directive) override;
-
     //! Internal interface handler for directive_store
     void directive_store_internalInterfaceHandler(const Svc::FpySequencer_StoreDirective& directive) override;
 
@@ -790,9 +786,9 @@ class FpySequencer : public FpySequencerComponentBase {
     DirectiveError op_fptosi();
     DirectiveError op_sitofp();
     DirectiveError op_uitofp();
-    DirectiveError op_iadd();
-    DirectiveError op_isub();
-    DirectiveError op_imul();
+    DirectiveError op_add();
+    DirectiveError op_sub();
+    DirectiveError op_mul();
     DirectiveError op_udiv();
     DirectiveError op_sdiv();
     DirectiveError op_umod();
@@ -829,7 +825,6 @@ class FpySequencer : public FpySequencerComponentBase {
     Signal getFlag_directiveHandler(const FpySequencer_GetFlagDirective& directive, DirectiveError& error);
     Signal getField_directiveHandler(const FpySequencer_GetFieldDirective& directive, DirectiveError& error);
     Signal peek_directiveHandler(const FpySequencer_PeekDirective& directive, DirectiveError& error);
-    Signal assert_directiveHandler(const FpySequencer_AssertDirective& directive, DirectiveError& error);
     Signal store_directiveHandler(const FpySequencer_StoreDirective& directive, DirectiveError& error);
 };
 

Svc/FpySequencer/FpySequencerDirectives.cpp

@@ -235,13 +235,6 @@ void FpySequencer::directive_peek_internalInterfaceHandler(const Svc::FpySequenc
     handleDirectiveErrorCode(Fpy::DirectiveId::PEEK, error);
 }
 
-//! Internal interface handler for directive_assert
-void FpySequencer::directive_assert_internalInterfaceHandler(const Svc::FpySequencer_AssertDirective& directive) {
-    DirectiveError error = DirectiveError::NO_ERROR;
-    this->sendSignal(this->assert_directiveHandler(directive, error));
-    handleDirectiveErrorCode(Fpy::DirectiveId::ASSERT, error);
-}
-
 //! Internal interface handler for directive_store
 void FpySequencer::directive_store_internalInterfaceHandler(const Svc::FpySequencer_StoreDirective& directive) {
     DirectiveError error = DirectiveError::NO_ERROR;
@@ -622,7 +615,7 @@ DirectiveError FpySequencer::op_uitofp() {
     this->m_runtime.stack.push(static_cast<F64>(this->m_runtime.stack.pop<U64>()));
     return DirectiveError::NO_ERROR;
 }
-DirectiveError FpySequencer::op_iadd() {
+DirectiveError FpySequencer::op_add() {
     if (this->m_runtime.stack.size < sizeof(I64) * 2) {
         return DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
     }
@@ -642,7 +635,7 @@ DirectiveError FpySequencer::op_iadd() {
     this->m_runtime.stack.push(static_cast<I64>(lhs + rhs));
     return DirectiveError::NO_ERROR;
 }
-DirectiveError FpySequencer::op_isub() {
+DirectiveError FpySequencer::op_sub() {
     if (this->m_runtime.stack.size < sizeof(I64) * 2) {
         return DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
     }
@@ -664,7 +657,7 @@ DirectiveError FpySequencer::op_isub() {
     this->m_runtime.stack.push(static_cast<I64>(lhs - rhs));
     return DirectiveError::NO_ERROR;
 }
-DirectiveError FpySequencer::op_imul() {
+DirectiveError FpySequencer::op_mul() {
     if (this->m_runtime.stack.size < sizeof(I64) * 2) {
         return DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
     }
@@ -789,15 +782,6 @@ DirectiveError FpySequencer::op_fdiv() {
     this->m_runtime.stack.push(static_cast<F64>(lhs / rhs));
     return DirectiveError::NO_ERROR;
 }
-DirectiveError FpySequencer::op_float_floor_div() {
-    if (this->m_runtime.stack.size < sizeof(F64) * 2) {
-        return DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
-    }
-    F64 rhs = this->m_runtime.stack.pop<F64>();
-    F64 lhs = this->m_runtime.stack.pop<F64>();
-    this->m_runtime.stack.push(static_cast<F64>(floor(lhs / rhs)));
-    return DirectiveError::NO_ERROR;
-}
 DirectiveError FpySequencer::op_fpow() {
     if (this->m_runtime.stack.size < sizeof(F64) * 2) {
         return DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
@@ -983,14 +967,14 @@ Signal FpySequencer::stackOp_directiveHandler(const FpySequencer_StackOpDirectiv
         case Fpy::DirectiveId::UITOFP:
             error = this->op_uitofp();
             break;
-        case Fpy::DirectiveId::IADD:
-            error = this->op_iadd();
+        case Fpy::DirectiveId::ADD:
+            error = this->op_add();
             break;
-        case Fpy::DirectiveId::ISUB:
-            error = this->op_isub();
+        case Fpy::DirectiveId::SUB:
+            error = this->op_sub();
             break;
-        case Fpy::DirectiveId::IMUL:
-            error = this->op_imul();
+        case Fpy::DirectiveId::MUL:
+            error = this->op_mul();
             break;
         case Fpy::DirectiveId::UDIV:
             error = this->op_udiv();
@@ -1016,9 +1000,6 @@ Signal FpySequencer::stackOp_directiveHandler(const FpySequencer_StackOpDirectiv
         case Fpy::DirectiveId::FDIV:
             error = this->op_fdiv();
             break;
-        case Fpy::DirectiveId::FLOAT_FLOOR_DIV:
-            error = this->op_float_floor_div();
-            break;
         case Fpy::DirectiveId::FPOW:
             error = this->op_fpow();
             break;
@@ -1321,26 +1302,6 @@ Signal FpySequencer::peek_directiveHandler(const FpySequencer_PeekDirective& dir
     return Signal::stmtResponse_success;
 }
 
-Signal FpySequencer::assert_directiveHandler(const FpySequencer_AssertDirective& directive, DirectiveError& error) {
-    if (this->m_runtime.stack.size < sizeof(U8) * 2) {
-        error = DirectiveError::STACK_ACCESS_OUT_OF_BOUNDS;
-        return Signal::stmtResponse_failure;
-    }
-    U8 errorCode = this->m_runtime.stack.pop<U8>();
-    U8 condition = this->m_runtime.stack.pop<U8>();
-
-    if (condition != 0) {
-        // proceed to next instruction
-        return Signal::stmtResponse_success;
-    }
-
-    // otherwise, kill the sequence here
-    // raise the user defined error code as an event
-    this->log_WARNING_HI_SequenceAsserted(this->m_sequenceFilePath, errorCode);
-    error = DirectiveError::ASSERTION_FAILURE;
-    return Signal::stmtResponse_failure;
-}
-
 Signal FpySequencer::store_directiveHandler(const FpySequencer_StoreDirective& directive, DirectiveError& error) {
     if (this->m_runtime.stack.size < directive.get_size() + sizeof(Fpy::StackSizeType)) {
         // not enough bytes to pop the value and the stack offset

Svc/FpySequencer/FpySequencerDirectives.fppi

@@ -146,13 +146,6 @@ struct PeekDirective {
     _empty: U8
 }
 
-@ asserts that a condition is true, raise an error code if not
-struct AssertDirective {
-    # pops two U8s off the stack
-    # condition and error code
-    _empty: U8
-}
-
 @ stores bytes from the top of the stack into a memory location, determined by the stack
 struct StoreDirective {
     # pops an Fpy.StackSizeType offset off of stack
@@ -206,6 +199,4 @@ internal port directive_getField(directive: GetFieldDirective) priority 6 assert
 
 internal port directive_peek(directive: PeekDirective) priority 6 assert
 
-internal port directive_assert(directive: AssertDirective) priority 6 assert
-
 internal port directive_store(directive: StoreDirective) priority 6 assert

Svc/FpySequencer/FpySequencerEvents.fppi

@@ -103,13 +103,6 @@ event SequenceExitedWithError(
     severity warning high \
     format "Sequence {} exited with error code {}"
 
-event SequenceAsserted(
-    filePath: string
-    errorCode: U8
-) \
-    severity warning high \
-    format "Sequence {} failed an assertion with error code {}"
-
 event UnknownSequencerDirective(
     $opcode: U8
     stmtIdx: U32

Svc/FpySequencer/FpySequencerRunState.cpp

@@ -213,9 +213,9 @@ Fw::Success FpySequencer::deserializeDirective(const Fpy::Statement& stmt, Direc
         case Fpy::DirectiveId::FPTOUI:
         case Fpy::DirectiveId::SITOFP:
         case Fpy::DirectiveId::UITOFP:
-        case Fpy::DirectiveId::IADD:
-        case Fpy::DirectiveId::ISUB:
-        case Fpy::DirectiveId::IMUL:
+        case Fpy::DirectiveId::ADD:
+        case Fpy::DirectiveId::SUB:
+        case Fpy::DirectiveId::MUL:
         case Fpy::DirectiveId::UDIV:
         case Fpy::DirectiveId::SDIV:
         case Fpy::DirectiveId::UMOD:
@@ -224,7 +224,6 @@ Fw::Success FpySequencer::deserializeDirective(const Fpy::Statement& stmt, Direc
         case Fpy::DirectiveId::FSUB:
         case Fpy::DirectiveId::FMUL:
         case Fpy::DirectiveId::FDIV:
-        case Fpy::DirectiveId::FLOAT_FLOOR_DIV:
         case Fpy::DirectiveId::FPOW:
         case Fpy::DirectiveId::FLOG:
         case Fpy::DirectiveId::FMOD:
@@ -399,16 +398,6 @@ Fw::Success FpySequencer::deserializeDirective(const Fpy::Statement& stmt, Direc
             }
             break;
         }
-        case Fpy::DirectiveId::ASSERT: {
-            new (&deserializedDirective.assert) FpySequencer_AssertDirective();
-            if (argBuf.getDeserializeSizeLeft() != 0) {
-                this->log_WARNING_HI_DirectiveDeserializeError(stmt.get_opCode(), this->currentStatementIdx(),
-                                                               Fw::SerializeStatus::FW_DESERIALIZE_SIZE_MISMATCH,
-                                                               argBuf.getDeserializeSizeLeft(), argBuf.getSize());
-                return Fw::Success::FAILURE;
-            }
-            break;
-        }
         case Fpy::DirectiveId::STORE: {
             new (&deserializedDirective.store) FpySequencer_StoreDirective();
             status = argBuf.deserializeTo(deserializedDirective.store);
@@ -499,9 +488,9 @@ void FpySequencer::dispatchDirective(const DirectiveUnion& directive, const Fpy:
         case Fpy::DirectiveId::FPTOUI:
         case Fpy::DirectiveId::SITOFP:
         case Fpy::DirectiveId::UITOFP:
-        case Fpy::DirectiveId::IADD:
-        case Fpy::DirectiveId::ISUB:
-        case Fpy::DirectiveId::IMUL:
+        case Fpy::DirectiveId::ADD:
+        case Fpy::DirectiveId::SUB:
+        case Fpy::DirectiveId::MUL:
         case Fpy::DirectiveId::UDIV:
         case Fpy::DirectiveId::SDIV:
         case Fpy::DirectiveId::UMOD:
@@ -510,7 +499,6 @@ void FpySequencer::dispatchDirective(const DirectiveUnion& directive, const Fpy:
         case Fpy::DirectiveId::FSUB:
         case Fpy::DirectiveId::FMUL:
         case Fpy::DirectiveId::FDIV:
-        case Fpy::DirectiveId::FLOAT_FLOOR_DIV:
         case Fpy::DirectiveId::FPOW:
         case Fpy::DirectiveId::FLOG:
         case Fpy::DirectiveId::FMOD:
@@ -578,10 +566,6 @@ void FpySequencer::dispatchDirective(const DirectiveUnion& directive, const Fpy:
             this->directive_peek_internalInterfaceInvoke(directive.peek);
             return;
         }
-        case Fpy::DirectiveId::ASSERT: {
-            this->directive_assert_internalInterfaceInvoke(directive.assert);
-            return;
-        }
         case Fpy::DirectiveId::STORE: {
             this->directive_store_internalInterfaceInvoke(directive.store);
             return;