core/program_info.h

/*
 * SPDX-FileCopyrightText: 2022 The P4 Language Consortium
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_PROGRAM_INFO_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_PROGRAM_INFO_H_
 
#include <cstddef>
#include <optional>
 
#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_result.h"
#include "backends/p4tools/modules/testgen/lib/concolic.h"
#include "backends/p4tools/modules/testgen/lib/continuation.h"
 
namespace P4::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 P4::P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_PROGRAM_INFO_H_ */