execution_state.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_EXECUTION_STATE_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_EXECUTION_STATE_H_
 
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <map>
#include <optional>
#include <stack>
#include <utility>
#include <variant>
#include <vector>
 
#include "backends/p4tools/common/compiler/reachability.h"
#include "backends/p4tools/common/core/abstract_execution_state.h"
#include "backends/p4tools/common/lib/namespace_context.h"
#include "backends/p4tools/common/lib/symbolic_env.h"
#include "backends/p4tools/common/lib/trace_event.h"
#include "ir/declaration.h"
#include "ir/ir.h"
#include "ir/node.h"
#include "ir/solver.h"
#include "lib/cstring.h"
#include "lib/exceptions.h"
#include "midend/coverage.h"
 
#include "backends/p4tools/modules/testgen/lib/continuation.h"
#include "backends/p4tools/modules/testgen/lib/test_object.h"
 
namespace P4Tools::P4Testgen {
 
class ExecutionState : public AbstractExecutionState {
    friend class Test::SmallStepTest;
 
 public:
    class StackFrame {
     public:
        using ExceptionHandlers = std::map<Continuation::Exception, Continuation>;
 
     private:
        Continuation normalContinuation;
        ExceptionHandlers exceptionHandlers;
        const NamespaceContext *namespaces = nullptr;
 
     public:
        StackFrame(Continuation normalContinuation, const NamespaceContext *namespaces);
 
        StackFrame(Continuation normalContinuation, ExceptionHandlers exceptionHandlers,
                   const NamespaceContext *namespaces);
 
        StackFrame(const StackFrame &) = default;
        StackFrame(StackFrame &&) noexcept = default;
        StackFrame &operator=(const StackFrame &) = default;
        StackFrame &operator=(StackFrame &&) = default;
        ~StackFrame() = default;
 
        [[nodiscard]] const Continuation &getContinuation() const;
 
        [[nodiscard]] const ExceptionHandlers &getExceptionHandlers() const;
 
        [[nodiscard]] const NamespaceContext *getNameSpaces() const;
    };
 
    ExecutionState(ExecutionState &&) = delete;
    ExecutionState &operator=(ExecutionState &&) = delete;
    ~ExecutionState() override = default;
 
 private:
    std::vector<std::reference_wrapper<const TraceEvent>> trace;
 
    P4::Coverage::CoverageSet visitedNodes;
 
    Continuation::Body body;
 
    // Invariant: if the @body is empty, then so is this, and this state is terminal.
    std::stack<std::reference_wrapper<const StackFrame>> stack;
 
    std::map<cstring, Continuation::PropertyValue> stateProperties;
 
    // Test objects are classes of variables that influence the execution of test frameworks. They
    // are collected during interpreter execution and consumed by the respective test framework. For
    // example, when visiting a table, the interpreter will generate a table test object per table,
    // which defines control plane match action entries. Once the interpreter has solved for the
    // variables used by these test objects and concretized the values, they can be used to generate
    // a test. Test objects are not constant because they may be manipulated by a target back end.
    std::map<cstring, TestObjectMap> testObjects;
 
    std::optional<IR::StateVariable> parserErrorLabel = std::nullopt;
 
    int inputPacketCursor = 0;
 
    std::vector<const IR::Expression *> pathConstraint;
 
    std::vector<uint64_t> selectedBranches;
 
    ReachabilityEngineState *reachabilityEngineState = nullptr;
 
    uint16_t numAllocatedPacketVariables = 0;
 
    [[nodiscard]] const IR::SymbolicVariable *createPacketVariable(const IR::Type *type);
 
    /* =========================================================================================
     *  Accessors
     * ========================================================================================= */
 public:
    [[nodiscard]] bool isTerminal() const;
 
    [[nodiscard]] const std::vector<const IR::Expression *> &getPathConstraint() const;
 
    [[nodiscard]] const std::vector<uint64_t> &getSelectedBranches() const;
 
    void pushPathConstraint(const IR::Expression *e);
 
    void pushBranchDecision(uint64_t);
 
    [[nodiscard]] std::optional<const Continuation::Command> getNextCmd() const;
 
    [[nodiscard]] const IR::Expression *get(const IR::StateVariable &var) const override;
 
    void markVisited(const IR::Node *node);
 
    [[nodiscard]] const P4::Coverage::CoverageSet &getVisited() const;
 
    void set(const IR::StateVariable &var, const IR::Expression *value) override;
 
    [[nodiscard]] const std::vector<std::reference_wrapper<const TraceEvent>> &getTrace() const;
 
    [[nodiscard]] const Continuation::Body &getBody() const;
 
    [[nodiscard]] const std::stack<std::reference_wrapper<const StackFrame>> &getStack() const;
 
    void setProperty(cstring propertyName, Continuation::PropertyValue property);
 
    [[nodiscard]] bool hasProperty(cstring propertyName) const;
 
    template <class T>
    [[nodiscard]] T getProperty(cstring propertyName) const {
        auto iterator = stateProperties.find(propertyName);
        if (iterator != stateProperties.end()) {
            auto val = iterator->second;
            try {
                T resolvedVal = std::get<T>(val);
                return resolvedVal;
            } catch (std::bad_variant_access const &ex) {
                BUG("Expected property value type does not correspond to value type stored in the "
                    "property map.");
            }
        }
        BUG("Property %s not found in configuration map.", propertyName);
    }
 
    void addTestObject(cstring category, cstring objectLabel, const TestObject *object);
 
    [[nodiscard]] const TestObject *getTestObject(cstring category, cstring objectLabel,
                                                  bool checked) const;
 
    void deleteTestObject(cstring category, cstring objectLabel);
 
    void deleteTestObjectCategory(cstring category);
 
    template <class T>
    [[nodiscard]] const T *getTestObject(cstring category, cstring objectLabel) const {
        const auto *testObject = getTestObject(category, objectLabel, true);
        return testObject->checkedTo<T>();
    }
 
    [[nodiscard]] TestObjectMap getTestObjectCategory(cstring category) const;
 
    [[nodiscard]] ReachabilityEngineState *getReachabilityEngineState() const;
 
    void setReachabilityEngineState(ReachabilityEngineState *newEngineState);
 
    /* =========================================================================================
     *  Trace events.
     * ========================================================================================= */
    void add(const TraceEvent &event);
 
    /* =========================================================================================
     *  Body operations
     * ========================================================================================= */
    void replaceTopBody(const Continuation::Command &cmd);
 
    void replaceTopBody(const std::vector<Continuation::Command> *cmds);
 
    void replaceTopBody(std::initializer_list<Continuation::Command> cmds);
 
    //
    // Needs to be implemented here because of limitations with templates.
    template <class N>
    void replaceTopBody(const std::vector<const N *> *nodes) {
        BUG_CHECK(!nodes->empty(), "Replaced top of execution stack with empty list");
        body.pop();
        for (auto it = nodes->rbegin(); it != nodes->rend(); ++it) {
            BUG_CHECK(*it, "Evaluation produced a null node.");
            body.push(*it);
        }
    }
 
    void popBody();
 
    void replaceBody(const Continuation::Body &body);
 
    /* =========================================================================================
     *  Continuation-stack operations
     * ========================================================================================= */
    void pushContinuation(const StackFrame &frame);
 
    void pushCurrentContinuation(StackFrame::ExceptionHandlers handlers);
 
    void pushCurrentContinuation(std::optional<const IR::Type *> parameterType_opt = std::nullopt,
                                 StackFrame::ExceptionHandlers = {});
 
    void popContinuation(std::optional<const IR::Node *> argument_opt = std::nullopt);
 
    void handleException(Continuation::Exception e);
 
    /* =========================================================================================
     *  Packet manipulation
     * ========================================================================================= */
    static const IR::SymbolicVariable *getInputPacketSizeVar();
 
    [[nodiscard]] static int getMaxPacketLength();
 
    [[nodiscard]] const IR::Expression *getInputPacket() const;
 
    [[nodiscard]] int getInputPacketSize() const;
 
    void appendToInputPacket(const IR::Expression *expr);
 
    void prependToInputPacket(const IR::Expression *expr);
 
    [[nodiscard]] int getInputPacketCursor() const;
 
    [[nodiscard]] const IR::Expression *getPacketBuffer() const;
 
    [[nodiscard]] int getPacketBufferSize() const;
 
    const IR::Expression *slicePacketBuffer(int amount);
 
    [[nodiscard]] const IR::Expression *peekPacketBuffer(int amount);
 
    void appendToPacketBuffer(const IR::Expression *expr);
 
    void prependToPacketBuffer(const IR::Expression *expr);
 
    void resetPacketBuffer();
 
    [[nodiscard]] const IR::Expression *getEmitBuffer() const;
 
    void resetEmitBuffer();
 
    void appendToEmitBuffer(const IR::Expression *expr);
 
    void setParserErrorLabel(const IR::StateVariable &parserError);
 
    [[nodiscard]] const IR::StateVariable &getCurrentParserErrorLabel() const;
 
    /* =========================================================================================
     *  Constructors
     * ========================================================================================= */
    [[nodiscard]] ExecutionState &clone() const override;
 
    [[nodiscard]] static ExecutionState &create(const IR::P4Program *program);
 
 private:
    explicit ExecutionState(Continuation::Body body);
 
    // Execution state should always be allocated through explicit operators.
    explicit ExecutionState(const IR::P4Program *program);
    ExecutionState(const ExecutionState &) = default;
 
    ExecutionState &operator=(const ExecutionState &) = default;
};
 
using ExecutionStateReference = std::reference_wrapper<ExecutionState>;
 
}  // namespace P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_EXECUTION_STATE_H_ */