core/small_step/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 <cstdint>
#include <utility>
#include <vector>
 
#include "ir/ir.h"
#include "ir/solver.h"
#include "lib/cstring.h"
 
#include "backends/p4tools/modules/testgen/core/extern_info.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 P4::P4Tools::P4Testgen {
 
class ExprStepper : public AbstractStepper {
    /**************************************************************************************************
    ExternMethodImpls
    **************************************************************************************************/
 public:
    template <typename StepperType>
    class ExternMethodImpls {
     public:
        using MethodImpl = std::function<void(const ExternInfo &externInfo, StepperType &stepper)>;
 
        std::optional<MethodImpl> find(const IR::PathExpression &externObjectRef,
                                       const IR::ID &methodName,
                                       const IR::Vector<IR::Argument> &args) const {
            // We have to check the extern type here. We may receive a specialized canonical type,
            // which we need to unpack.
            const IR::Type_Extern *externType = nullptr;
            if (const auto *type = externObjectRef.type->to<IR::Type_Extern>()) {
                externType = type;
            } else if (const auto *specType =
                           externObjectRef.type->to<IR::Type_SpecializedCanonical>()) {
                CHECK_NULL(specType->substituted);
                externType = specType->substituted->checkedTo<IR::Type_Extern>();
            } else if (externObjectRef.path->name == IR::ID("*method")) {
            } else {
                BUG("Not a valid extern: %1% with member %2%. Type is %3%.", externObjectRef,
                    methodName, externObjectRef.type->node_type_name());
            }
 
            cstring qualifiedMethodName = externType->name + "." + methodName;
            auto submapIt = impls.find(qualifiedMethodName);
            if (submapIt == impls.end()) {
                return std::nullopt;
            }
            if (submapIt->second.count(args.size()) == 0) {
                return std::nullopt;
            }
 
            // Find matching methods: if any arguments are named, then the parameter name must
            // match.
            std::optional<MethodImpl> matchingImpl;
            for (const auto &pair : submapIt->second.at(args.size())) {
                const auto &paramNames = pair.first;
                const auto &methodImpl = pair.second;
 
                if (matches(paramNames, args)) {
                    BUG_CHECK(!matchingImpl, "Ambiguous extern method call: %1%",
                              qualifiedMethodName);
                    matchingImpl = methodImpl;
                }
            }
 
            return matchingImpl;
        }
 
     private:
        std::map<cstring,
                 std::map<size_t, std::vector<std::pair<std::vector<cstring>, MethodImpl>>>>
            impls;
 
        static bool matches(const std::vector<cstring> &paramNames,
                            const IR::Vector<IR::Argument> &args) {
            // Number of parameters should match the number of arguments.
            if (paramNames.size() != args.size()) {
                return false;
            }
            // Any named argument should match the name of the corresponding parameter.
            for (size_t idx = 0; idx < paramNames.size(); idx++) {
                const auto &paramName = paramNames.at(idx);
                const auto &arg = args.at(idx);
 
                if (arg->name.name == nullptr) {
                    continue;
                }
                if (paramName != arg->name.name) {
                    return false;
                }
            }
 
            return true;
        }
 
     public:
        using ImplList = std::list<std::tuple<cstring, std::vector<cstring>, MethodImpl>>;
 
        explicit ExternMethodImpls(const ImplList &implList) {
            for (const auto &implSpec : implList) {
                auto &[name, paramNames, impl] = implSpec;
 
                auto &tmpImplList = impls[name][paramNames.size()];
 
                // Make sure that we have at most one implementation for each set of parameter
                // names. This is a quadratic-time algorithm, but should be fine, since we expect
                // the number of overloads to be small in practice.
                for (auto &pair : tmpImplList) {
                    BUG_CHECK(pair.first != paramNames, "Multiple implementations of %1%(%2%)",
                              name, paramNames);
                }
 
                tmpImplList.emplace_back(paramNames, impl);
            }
        }
    };
 
    static const ExprStepper::ExternMethodImpls<ExprStepper> INTERNAL_EXTERN_METHOD_IMPLS;
 
    static const ExprStepper::ExternMethodImpls<ExprStepper> CORE_EXTERN_METHOD_IMPLS;
 
    /**************************************************************************************************
    ExprStepper
    **************************************************************************************************/
 
 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 ExternInfo &externInfo);
 
    void evalInternalExternMethodCall(const ExternInfo &externInfo);
 
    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 P4::P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_CORE_SMALL_STEP_EXPR_STEPPER_H_ */