expr_stepper.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_SMALL_STEP_EXPR_STEPPER_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_SMALL_STEP_EXPR_STEPPER_H_
 
#include <utility>
#include <vector>
 
#include "ir/id.h"
#include "ir/ir.h"
#include "ir/solver.h"
#include "ir/vector.h"
#include "lib/cstring.h"
 
#include "backends/p4tools/modules/testgen/core/program_info.h"
#include "backends/p4tools/modules/testgen/core/small_step/abstract_stepper.h"
#include "backends/p4tools/modules/testgen/lib/execution_state.h"
 
namespace P4Tools::P4Testgen {
 
class ExprStepper : public AbstractStepper {
 private:
    friend class TableStepper;
 
    friend class ExtractUtils;
 
 protected:
    struct PacketCursorAdvanceInfo {
        int advanceSize;
 
        const IR::Expression *advanceCond;
 
        int advanceFailSize;
 
        const IR::Expression *advanceFailCond;
    };
 
    virtual PacketCursorAdvanceInfo calculateSuccessfulParserAdvance(const ExecutionState &state,
                                                                     int advanceSize) const;
    virtual PacketCursorAdvanceInfo calculateAdvanceExpression(
        const ExecutionState &state, const IR::Expression *advanceExpr,
        const IR::Expression *restrictions) const;
 
    static std::vector<std::pair<IR::StateVariable, const IR::Expression *>> setFields(
        ExecutionState &nextState, const std::vector<IR::StateVariable> &flatFields,
        int varBitFieldSize);
    void handleHitMissActionRun(const IR::Member *member);
 
    bool resolveMethodCallArguments(const IR::MethodCallExpression *call);
 
    virtual void evalExternMethodCall(const IR::MethodCallExpression *call,
                                      const IR::Expression *receiver, IR::ID name,
                                      const IR::Vector<IR::Argument> *args, ExecutionState &state);
    virtual void evalInternalExternMethodCall(const IR::MethodCallExpression *call,
                                              const IR::Expression *receiver, IR::ID name,
                                              const IR::Vector<IR::Argument> *args,
                                              const ExecutionState &state);
 
    void evalActionCall(const IR::P4Action *action, const IR::MethodCallExpression *call);
 
    // Otherwise, the target default value is chosen.
    void generateCopyIn(ExecutionState &nextState, const IR::StateVariable &targetPath,
                        const IR::StateVariable &srcPath, cstring dir, bool forceTaint) const;
 
    virtual void stepNoMatch(std::string traceLog, const IR::Expression *condition = nullptr);
 
 public:
    ExprStepper(const ExprStepper &) = default;
 
    ExprStepper(ExprStepper &&) = default;
 
    ExprStepper &operator=(const ExprStepper &) = delete;
 
    ExprStepper &operator=(ExprStepper &&) = delete;
 
    ExprStepper(ExecutionState &state, AbstractSolver &solver, const ProgramInfo &programInfo);
 
    bool preorder(const IR::BoolLiteral *boolLiteral) override;
    bool preorder(const IR::Constant *constant) override;
    bool preorder(const IR::Member *member) override;
    bool preorder(const IR::ArrayIndex *arr) override;
    bool preorder(const IR::MethodCallExpression *call) override;
    bool preorder(const IR::Mux *mux) override;
    bool preorder(const IR::PathExpression *pathExpression) override;
 
    bool preorder(const IR::P4ValueSet *valueSet) override;
    bool preorder(const IR::Operation_Binary *binary) override;
    bool preorder(const IR::Operation_Unary *unary) override;
    bool preorder(const IR::SelectExpression *selectExpression) override;
    bool preorder(const IR::BaseListExpression *listExpression) override;
    bool preorder(const IR::StructExpression *structExpression) override;
    bool preorder(const IR::Slice *slice) override;
    bool preorder(const IR::P4Table *table) override;
};
 
}  // namespace P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_SMALL_STEP_EXPR_STEPPER_H_ */