targets/bmv2/test_spec.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_TARGETS_BMV2_TEST_SPEC_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_TARGETS_BMV2_TEST_SPEC_H_
 
#include <cstddef>
#include <functional>
#include <map>
#include <optional>
#include <utility>
#include <vector>
 
#include "backends/p4tools/common/lib/model.h"
#include "ir/declaration.h"
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/rtti.h"
 
#include "backends/p4tools/modules/testgen/lib/execution_state.h"
#include "backends/p4tools/modules/testgen/lib/test_object.h"
#include "backends/p4tools/modules/testgen/lib/test_spec.h"
#include "backends/p4tools/modules/testgen/targets/bmv2/constants.h"
 
namespace P4::P4Tools::P4Testgen::Bmv2 {
 
/* =========================================================================================
 *  IndexExpression
 * ========================================================================================= */
class IndexExpression : public TestObject {
 private:
    const IR::Expression *index;
 
    const IR::Expression *value;
 
 public:
    explicit IndexExpression(const IR::Expression *index, const IR::Expression *value);
 
    [[nodiscard]] const IR::Constant *getEvaluatedIndex() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedValue() const;
 
    [[nodiscard]] const IR::Expression *getIndex() const;
 
    [[nodiscard]] const IR::Expression *getValue() const;
 
    [[nodiscard]] const IndexExpression *evaluate(const Model &model,
                                                  bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    DECLARE_TYPEINFO(IndexExpression, TestObject);
};
 
/* =========================================================================================
 *  IndexMap
 * ========================================================================================= */
class IndexMap : public TestObject {
 protected:
    const IR::Expression *initialValue;
 
    std::vector<IndexExpression> indexConditions;
 
 public:
    explicit IndexMap(const IR::Expression *initialValue);
 
    void writeToIndex(const IR::Expression *index, const IR::Expression *value);
 
    [[nodiscard]] const IR::Expression *getInitialValue() const;
 
    [[nodiscard]] const IR::Expression *getValueAtIndex(const IR::Expression *index) const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedInitialValue() const;
 
    [[nodiscard]] std::map<big_int, std::pair<int, const IR::Constant *>> unravelMap() const;
 
    DECLARE_TYPEINFO(IndexMap, TestObject);
};
 
/* =========================================================================================
 *  Bmv2V1ModelRegisterValue
 * ========================================================================================= */
class Bmv2V1ModelRegisterValue : public IndexMap {
 public:
    explicit Bmv2V1ModelRegisterValue(const IR::Expression *initialValue);
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const Bmv2V1ModelRegisterValue *evaluate(const Model &model,
                                                           bool doComplete) const override;
 
    DECLARE_TYPEINFO(Bmv2V1ModelRegisterValue, IndexMap);
};
 
/* =========================================================================================
 *  Bmv2V1ModelMeterValue
 * ========================================================================================= */
 
class Bmv2V1ModelMeterValue : public IndexMap {
 private:
    bool isDirect;
 
 public:
    explicit Bmv2V1ModelMeterValue(const IR::Expression *initialValue, bool isDirect);
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const Bmv2V1ModelMeterValue *evaluate(const Model &model,
                                                        bool doComplete) const override;
 
    [[nodiscard]] bool isDirectMeter() const;
 
    DECLARE_TYPEINFO(Bmv2V1ModelMeterValue, IndexMap);
};
 
/* =========================================================================================
 *  Bmv2V1ModelActionProfile
 * ========================================================================================= */
class Bmv2V1ModelActionProfile : public TestObject {
 private:
    std::vector<std::pair<cstring, std::vector<ActionArg>>> actions;
 
    const IR::IDeclaration *profileDecl;
 
 public:
    explicit Bmv2V1ModelActionProfile(const IR::IDeclaration *profileDecl);
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const std::vector<std::pair<cstring, std::vector<ActionArg>>> *getActions() const;
 
    [[nodiscard]] const IR::IDeclaration *getProfileDecl() const;
 
    [[nodiscard]] size_t getActionMapSize() const;
 
    void addToActionMap(cstring actionName, std::vector<ActionArg> actionArgs);
 
    [[nodiscard]] const Bmv2V1ModelActionProfile *evaluate(const Model &model,
                                                           bool doComplete) const override;
 
    DECLARE_TYPEINFO(Bmv2V1ModelActionProfile, TestObject);
};
 
/* =========================================================================================
 *  ActionSelector
 * ========================================================================================= */
class Bmv2V1ModelActionSelector : public TestObject {
 private:
    const IR::IDeclaration *selectorDecl;
 
    const Bmv2V1ModelActionProfile *actionProfile;
 
 public:
    explicit Bmv2V1ModelActionSelector(const IR::IDeclaration *selectorDecl,
                                       const Bmv2V1ModelActionProfile *actionProfile);
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const IR::IDeclaration *getSelectorDecl() const;
 
    [[nodiscard]] const Bmv2V1ModelActionProfile *getActionProfile() const;
 
    [[nodiscard]] const Bmv2V1ModelActionSelector *evaluate(const Model &model,
                                                            bool doComplete) const override;
 
    DECLARE_TYPEINFO(Bmv2V1ModelActionSelector, TestObject);
};
 
/* =========================================================================================
 *  Bmv2V1ModelCloneInfo
 * ========================================================================================= */
class Bmv2V1ModelCloneInfo : public TestObject {
 private:
    const IR::Expression *sessionId;
 
    BMv2Constants::CloneType cloneType;
 
    std::reference_wrapper<const ExecutionState> clonedState;
 
    std::optional<int> preserveIndex;
 
 public:
    explicit Bmv2V1ModelCloneInfo(const IR::Expression *sessionId,
                                  BMv2Constants::CloneType cloneType,
                                  const ExecutionState &clonedState,
                                  std::optional<int> preserveIndex);
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const Bmv2V1ModelCloneInfo *evaluate(const Model &model,
                                                       bool doComplete) const override;
 
    [[nodiscard]] const IR::Expression *getSessionId() const;
 
    [[nodiscard]] BMv2Constants::CloneType getCloneType() const;
 
    [[nodiscard]] std::optional<int> getPreserveIndex() const;
 
    [[nodiscard]] const ExecutionState &getClonedState() const;
 
    DECLARE_TYPEINFO(Bmv2V1ModelCloneInfo, TestObject);
};
 
/* =========================================================================================
 *  Bmv2V1ModelCloneSpec
 * ========================================================================================= */
class Bmv2V1ModelCloneSpec : public TestObject {
 private:
    const IR::Expression *sessionId;
 
    const IR::Expression *clonePort;
 
    bool isClone;
 
 public:
    explicit Bmv2V1ModelCloneSpec(const IR::Expression *sessionId, const IR::Expression *clonePort,
                                  bool isClone);
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const Bmv2V1ModelCloneSpec *evaluate(const Model &model,
                                                       bool doComplete) const override;
 
    [[nodiscard]] const IR::Expression *getSessionId() const;
 
    [[nodiscard]] const IR::Expression *getClonePort() const;
 
    [[nodiscard]] bool isClonedPacket() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedClonePort() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedSessionId() const;
 
    DECLARE_TYPEINFO(Bmv2V1ModelCloneSpec, TestObject);
};
 
/* =========================================================================================
 *  MetadataCollection
 * ========================================================================================= */
class MetadataCollection : public TestObject {
 private:
    std::map<cstring, const IR::Literal *> metadataFields;
 
 public:
    MetadataCollection();
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const MetadataCollection *evaluate(const Model & /*model*/,
                                                     bool doComplete) const override;
 
    [[nodiscard]] const std::map<cstring, const IR::Literal *> &getMetadataFields() const;
 
    void addMetaDataField(cstring name, const IR::Literal *metadataField);
 
    const IR::Literal *getMetadataField(cstring name);
 
    DECLARE_TYPEINFO(MetadataCollection, TestObject);
};
 
/* =========================================================================================
 * Table Key Match Types
 * ========================================================================================= */
 
class Optional : public TableMatch {
 private:
    const IR::Expression *value;
 
    bool addMatch;
 
 public:
    explicit Optional(const IR::KeyElement *key, const IR::Expression *value, bool addMatch);
 
    [[nodiscard]] const Optional *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const IR::Constant *getEvaluatedValue() const;
 
    [[nodiscard]] bool addAsExactMatch() const;
 
    DECLARE_TYPEINFO(Optional, TableMatch);
};
 
class Range : public TableMatch {
 private:
    const IR::Expression *low;
 
    const IR::Expression *high;
 
 public:
    explicit Range(const IR::KeyElement *key, const IR::Expression *low,
                   const IR::Expression *high);
 
    [[nodiscard]] const Range *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const IR::Constant *getEvaluatedLow() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedHigh() const;
 
    DECLARE_TYPEINFO(Range, TableMatch);
};
 
}  // namespace P4::P4Tools::P4Testgen::Bmv2
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_TARGETS_BMV2_TEST_SPEC_H_ */