simplifyKey.h

/*
 * Copyright 2016 VMware, Inc.
 * SPDX-FileCopyrightText: 2016 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef MIDEND_SIMPLIFYKEY_H_
#define MIDEND_SIMPLIFYKEY_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/sideEffects.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {

class KeyIsSimple {
 public:
    virtual ~KeyIsSimple() {}
    virtual bool isSimple(const IR::Expression *expression, const Visitor::Context *) = 0;
};

class IsLikeLeftValue : public KeyIsSimple, public Inspector {
 protected:
    bool simple = false;
 
 public:
    IsLikeLeftValue() { setName("IsLikeLeftValue"); }
 
    void postorder(const IR::Expression *) override {
        // all other expressions are complicated
        simple = false;
    }
    void postorder(const IR::Member *) override {}
    void postorder(const IR::PathExpression *) override {}
    void postorder(const IR::ArrayIndex *) override {}
    profile_t init_apply(const IR::Node *root) override {
        simple = true;
        return Inspector::init_apply(root);
    }
 
    bool isSimple(const IR::Expression *expression, const Visitor::Context *) override {
        (void)expression->apply(*this);
        return simple;
    }
};

class IsValid : public KeyIsSimple, public Inspector, public ResolutionContext {
    TypeMap *typeMap;
 
 public:
    explicit IsValid(TypeMap *typeMap) : typeMap(typeMap) { CHECK_NULL(typeMap); }
    bool isSimple(const IR::Expression *expression, const Visitor::Context *ctxt);
};

class IsMask : public IsLikeLeftValue {
 public:
    bool isSimple(const IR::Expression *expression, const Visitor::Context *ctxt) {
        if (auto mask = expression->to<IR::BAnd>()) {
            if (mask->right->is<IR::Constant>())
                expression = mask->left;
            else if (mask->left->is<IR::Constant>())
                expression = mask->right;
        }
        return IsLikeLeftValue::isSimple(expression, ctxt);
    }
};

class OrPolicy : public KeyIsSimple {
    KeyIsSimple *left;
    KeyIsSimple *right;
 
 public:
    OrPolicy(KeyIsSimple *left, KeyIsSimple *right) : left(left), right(right) {
        CHECK_NULL(left);
        CHECK_NULL(right);
    }
    bool isSimple(const IR::Expression *expression, const Visitor::Context *ctxt) {
        return left->isSimple(expression, ctxt) || right->isSimple(expression, ctxt);
    }
};

class DoSimplifyKey : public Transform {
    MinimalNameGenerator nameGen;
    TypeMap *typeMap;
    KeyIsSimple *key_policy;
    std::map<const IR::P4Table *, TableInsertions *> toInsert;
 
 public:
    DoSimplifyKey(TypeMap *typeMap, KeyIsSimple *key_policy)
        : typeMap(typeMap), key_policy(key_policy) {
        CHECK_NULL(typeMap);
        CHECK_NULL(key_policy);
        setName("DoSimplifyKey");
    }
 
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = Transform::init_apply(node);
        node->apply(nameGen);
 
        return rv;
    }
 
    const IR::Node *doStatement(const IR::Statement *statement, const IR::Expression *expression);
 
    // These should be all kinds of statements that may contain a table apply
    // after the program has been simplified
    const IR::Node *postorder(IR::MethodCallStatement *statement) override {
        return doStatement(statement, statement->methodCall);
    }
    const IR::Node *postorder(IR::IfStatement *statement) override {
        return doStatement(statement, statement->condition);
    }
    const IR::Node *postorder(IR::SwitchStatement *statement) override {
        return doStatement(statement, statement->expression);
    }
    const IR::Node *postorder(IR::BaseAssignmentStatement *statement) override {
        return doStatement(statement, statement->right);
    }
    const IR::Node *postorder(IR::KeyElement *element) override;
    const IR::Node *postorder(IR::P4Table *table) override;
};

class SimplifyKey : public PassManager {
 public:
    SimplifyKey(TypeMap *typeMap, KeyIsSimple *key_policy, TypeChecking *typeChecking = nullptr) {
        if (!typeChecking) typeChecking = new TypeChecking(nullptr, typeMap);
        passes.push_back(typeChecking);
        passes.push_back(new DoSimplifyKey(typeMap, key_policy));
        setName("SimplifyKey");
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_SIMPLIFYKEY_H_ */