program_info.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_PROGRAM_INFO_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_PROGRAM_INFO_H_
 
#include <cstddef>
#include <optional>
#include <vector>
 
#include "backends/p4tools/common/compiler/reachability.h"
#include "backends/p4tools/common/lib/arch_spec.h"
#include "ir/ir.h"
#include "lib/castable.h"
#include "lib/rtti.h"
#include "midend/coverage.h"
 
#include "backends/p4tools/modules/testgen/core/compiler_target.h"
#include "backends/p4tools/modules/testgen/lib/concolic.h"
#include "backends/p4tools/modules/testgen/lib/continuation.h"
 
namespace P4Tools::P4Testgen {
 
class ProgramInfo : public ICastable {
 private:
    std::reference_wrapper<const TestgenCompilerResult> compilerResult;
 
 protected:
    explicit ProgramInfo(const TestgenCompilerResult &compilerResult);
 
    ConcolicMethodImpls concolicMethodImpls;
 
    std::vector<Continuation::Command> pipelineSequence;
 
    std::optional<const IR::Expression *> targetConstraints = std::nullopt;
 
    ordered_map<cstring, cstring> blockMap;
 
 public:
    ProgramInfo(const ProgramInfo &) = default;
 
    ProgramInfo(ProgramInfo &&) = default;
 
    ProgramInfo &operator=(const ProgramInfo &) = default;
 
    ProgramInfo &operator=(ProgramInfo &&) = default;
 
    ~ProgramInfo() override = default;
 
    // The arch map needs to be public to be subclassed.
    [[nodiscard]] virtual const ArchSpec &getArchSpec() const = 0;
 
    [[nodiscard]] const std::vector<Continuation::Command> *getPipelineSequence() const;
 
    [[nodiscard]] std::optional<const IR::Expression *> getTargetConstraints() const;
 
    [[nodiscard]] virtual const IR::StateVariable &getTargetInputPortVar() const = 0;
 
    [[nodiscard]] virtual const IR::StateVariable &getTargetOutputPortVar() const = 0;
 
    [[nodiscard]] virtual const IR::Expression *dropIsActive() const = 0;
 
    virtual const IR::Expression *createTargetUninitialized(const IR::Type *type,
                                                            bool forceTaint) const;
 
    [[nodiscard]] const P4::Coverage::CoverageSet &getCoverableNodes() const;
 
    [[nodiscard]] const ConcolicMethodImpls *getConcolicMethodImpls() const;
 
    // @returns the width of the parser error for this specific target.
    [[nodiscard]] virtual const IR::Type_Bits *getParserErrorType() const = 0;
 
    [[nodiscard]] cstring getCanonicalBlockName(cstring programBlockName) const;
 
    [[nodiscard]] virtual const TestgenCompilerResult &getCompilerResult() const;
 
    [[nodiscard]] const IR::P4Program &getP4Program() const;
 
    [[nodiscard]] const NodesCallGraph &getCallGraph() const;
 
    void produceCopyInOutCall(const IR::Parameter *param, size_t paramIdx,
                              const ArchSpec::ArchMember *archMember,
                              std::vector<Continuation::Command> *copyIns,
                              std::vector<Continuation::Command> *copyOuts) const;
 
    DECLARE_TYPEINFO(ProgramInfo);
};
 
}  // namespace P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_PROGRAM_INFO_H_ */