sideEffects.h

/*
 * Copyright 2016 VMware, Inc.
 * SPDX-FileCopyrightText: 2016 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_SIDEEFFECTS_H_
#define FRONTENDS_P4_SIDEEFFECTS_H_
 
/* makes explicit side effect ordering */
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/methodInstance.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {

class HasTableApply : public Inspector, public ResolutionContext {
    TypeMap *typeMap;
 
 public:
    const IR::P4Table *table;
    const IR::MethodCallExpression *call;
    explicit HasTableApply(TypeMap *typeMap) : typeMap(typeMap), table(nullptr), call(nullptr) {
        CHECK_NULL(typeMap);
        setName("HasTableApply");
    }
 
    void postorder(const IR::MethodCallExpression *expression) override {
        auto mi = MethodInstance::resolve(expression, this, typeMap);
        if (!mi->isApply()) return;
        auto am = mi->to<P4::ApplyMethod>();
        if (!am->object->is<IR::P4Table>()) return;
        BUG_CHECK(table == nullptr, "%1% and %2%: multiple table applications in one expression",
                  table, am->object);
        table = am->object->to<IR::P4Table>();
        call = expression;
        LOG3("Invoked table is " << dbp(table));
    }
};

class SideEffects : public Inspector, public ResolutionContext {
 private:
    TypeMap *typeMap;
 
 public:
    const IR::Node *nodeWithSideEffect = nullptr;

    unsigned sideEffectCount = 0;
 
    void postorder(const IR::MethodCallExpression *mce) override {
        if (mayHaveSideEffect(mce, this, typeMap)) {
            sideEffectCount++;
            nodeWithSideEffect = mce;
        }
    }
 
    void postorder(const IR::ConstructorCallExpression *cce) override {
        sideEffectCount++;
        nodeWithSideEffect = cce;
    }

    explicit SideEffects(TypeMap *typeMap) : typeMap(typeMap) { setName("SideEffects"); }

    static bool check(const IR::Expression *expression, const Visitor *calledBy,
                      TypeMap *typeMap = nullptr, const Visitor::Context *ctxt = nullptr) {
        SideEffects se(typeMap);
        se.setCalledBy(calledBy);
        if (calledBy && !ctxt) ctxt = calledBy->getChildContext();
        expression->apply(se, ctxt);
        return se.nodeWithSideEffect != nullptr;
    }

    static bool mayHaveSideEffect(const IR::MethodCallExpression *mce, DeclarationLookup *refMap,
                                  TypeMap *typeMap) {
        // mce does not produce a side effect in few cases:
        //  * isValid()
        //  * function, extern function, or extern method with noSideEffects annotation
        auto mi = MethodInstance::resolve(mce, refMap, typeMap, !typeMap);
        if (!mi) return true;
        if (const auto *ec = mi->to<P4::ExternCall>())
            return !ec->method->hasAnnotation(IR::Annotation::noSideEffectsAnnotation);
        if (const auto *ef = mi->to<P4::FunctionCall>())
            return !ef->function->hasAnnotation(IR::Annotation::noSideEffectsAnnotation);
        if (const auto *bim = mi->to<BuiltInMethod>()) return bim->name != IR::Type_Header::isValid;
        return true;
    }
};

class DoSimplifyExpressions : public Transform, P4WriteContext, public ResolutionContext {
    MinimalNameGenerator nameGen;
    TypeMap *typeMap;
    // Expressions holding temporaries that are already added.
    std::set<const IR::Expression *> *added;
 
    IR::IndexedVector<IR::Declaration> toInsert;  // temporaries
    IR::IndexedVector<IR::StatOrDecl> statements;
    std::set<const IR::Expression *> temporaries;
 
    IR::ID createTemporary(Util::SourceInfo srcInfo, const IR::Type *type);
    const IR::Expression *addAssignment(Util::SourceInfo srcInfo, IR::ID varName,
                                        const IR::Expression *expression,
                                        Util::SourceInfo resultSrcInfo = {});
    bool mayAlias(const IR::Expression *left, const IR::Expression *right,
                  const Visitor::Context *ctxt) const;
    bool containsHeaderType(const IR::Type *type);
 
 public:
    DoSimplifyExpressions(TypeMap *typeMap, std::set<const IR::Expression *> *added)
        : typeMap(typeMap), added(added) {
        CHECK_NULL(typeMap);
        setName("DoSimplifyExpressions");
    }
 
    const IR::Node *postorder(IR::Expression *expression) override;
    const IR::Node *preorder(IR::StructExpression *expression) override;
    const IR::Node *preorder(IR::ListExpression *expression) override;
    const IR::Node *preorder(IR::Literal *expression) override;
    const IR::Node *preorder(IR::ArrayIndex *expression) override;
    const IR::Node *preorder(IR::Member *expression) override;
    const IR::Node *preorder(IR::SelectExpression *expression) override;
    const IR::Node *preorder(IR::Operation_Unary *expression) override;
    const IR::Node *preorder(IR::Operation_Binary *expression) override;
    const IR::Node *shortCircuit(IR::Operation_Binary *expression);
    const IR::Node *preorder(IR::Mux *expression) override;
    const IR::Node *preorder(IR::LAnd *expression) override;
    const IR::Node *preorder(IR::LOr *expression) override;
    const IR::Node *preorder(IR::MethodCallExpression *mce) override;
 
    const IR::Node *preorder(IR::ConstructorCallExpression *cce) override {
        prune();
        return cce;
    }
    const IR::Node *preorder(IR::Property *prop) override {
        prune();
        return prop;
    }
    const IR::Node *preorder(IR::Annotation *anno) override {
        prune();
        return anno;
    }
 
    const IR::Node *postorder(IR::P4Parser *parser) override;
    const IR::Node *postorder(IR::Function *function) override;
    const IR::Node *postorder(IR::P4Control *control) override;
    const IR::Node *postorder(IR::P4Action *action) override;
    const IR::Node *postorder(IR::ParserState *state) override;
    const IR::Node *postorder(IR::BaseAssignmentStatement *statement) override;
    const IR::Node *postorder(IR::MethodCallStatement *statement) override;
    const IR::Node *postorder(IR::ReturnStatement *statement) override;
    const IR::Node *preorder(IR::SwitchStatement *statement) override;
    const IR::Node *preorder(IR::IfStatement *statement) override;
    const IR::Node *preorder(IR::ForStatement *statement) override;
    const IR::Node *preorder(IR::ForInStatement *statement) override;
 
    profile_t init_apply(const IR::Node *node) override;
    void end_apply(const IR::Node *) override;
};
 
class TableInsertions {
 public:
    std::vector<const IR::Declaration_Variable *> declarations;
    std::vector<const IR::BaseAssignmentStatement *> statements;
};

class KeySideEffect : public Transform, public ResolutionContext {
 protected:
    MinimalNameGenerator nameGen;
    TypeMap *typeMap;
    std::map<const IR::P4Table *, TableInsertions *> toInsert;
    std::set<const IR::P4Table *> *invokedInKey;
 
 public:
    KeySideEffect(TypeMap *typeMap, std::set<const IR::P4Table *> *invokedInKey)
        : typeMap(typeMap), invokedInKey(invokedInKey) {
        CHECK_NULL(typeMap);
        CHECK_NULL(invokedInKey);
        setName("KeySideEffect");
    }
 
    profile_t init_apply(const IR::Node *node) override;
 
    virtual const IR::Node *doStatement(const IR::Statement *statement,
                                        const IR::Expression *expression,
                                        const Visitor::Context *ctxt);
 
    const IR::Node *preorder(IR::Key *key) override;
 
    // 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, getContext());
    }
    const IR::Node *postorder(IR::IfStatement *statement) override {
        return doStatement(statement, statement->condition, getContext());
    }
    const IR::Node *postorder(IR::SwitchStatement *statement) override {
        return doStatement(statement, statement->expression, getContext());
    }
    const IR::Node *postorder(IR::BaseAssignmentStatement *statement) override {
        return doStatement(statement, statement->right, getContext());
    }
    const IR::Node *postorder(IR::KeyElement *element) override;
    const IR::Node *postorder(IR::P4Table *table) override;
    const IR::Node *preorder(IR::P4Table *table) override;
};

class TablesInKeys : public Inspector {
    TypeMap *typeMap;
    std::set<const IR::P4Table *> *invokedInKey;
 
 public:
    TablesInKeys(TypeMap *typeMap, std::set<const IR::P4Table *> *invokedInKey)
        : typeMap(typeMap), invokedInKey(invokedInKey) {
        CHECK_NULL(invokedInKey);
        setName("TableInKeys");
    }
    Visitor::profile_t init_apply(const IR::Node *node) override {
        invokedInKey->clear();
        return Inspector::init_apply(node);
    }
    void postorder(const IR::MethodCallExpression *mce) override {
        if (!isInContext<IR::Key>()) return;
        HasTableApply hta(typeMap);
        hta.setCalledBy(this);
        (void)mce->apply(hta, getContext());
        if (hta.table != nullptr) {
            LOG2("Table " << hta.table << " invoked in key of another table");
            invokedInKey->emplace(hta.table);
        }
    }
};

class TablesInActions : public Inspector {
    TypeMap *typeMap;
 
 public:
    explicit TablesInActions(TypeMap *typeMap) : typeMap(typeMap) {}
    void postorder(const IR::MethodCallExpression *expression) override {
        if (isInContext<IR::ActionList>()) {
            HasTableApply hta(typeMap);
            hta.setCalledBy(this);
            (void)expression->apply(hta, getContext());
            if (hta.table != nullptr) {
                ::P4::error(ErrorType::ERR_UNSUPPORTED, "%1%: table invocation in action argument",
                            expression);
            }
        }
    }
};
 
class SideEffectOrdering : public PassRepeated {
    // Contains all tables that are invoked within key
    // computations for other tables.  The keys for these
    // inner tables cannot be expanded until the keys of
    // the caller tables have been expanded.
    std::set<const IR::P4Table *> invokedInKey;
    // Temporaries that were added
    std::set<const IR::Expression *> added;
 
 public:
    SideEffectOrdering(TypeMap *typeMap, bool skipSideEffectOrdering,
                       TypeChecking *typeChecking = nullptr) {
        if (!typeChecking) typeChecking = new TypeChecking(nullptr, typeMap);
        if (!skipSideEffectOrdering) {
            passes.push_back(new TypeChecking(nullptr, typeMap));
            passes.push_back(new DoSimplifyExpressions(typeMap, &added));
            passes.push_back(new ClearTypeMap(typeMap));
            passes.push_back(typeChecking);
            passes.push_back(new TablesInActions(typeMap));
            passes.push_back(new TablesInKeys(typeMap, &invokedInKey));
            passes.push_back(new KeySideEffect(typeMap, &invokedInKey));
        }
        setName("SideEffectOrdering");
    }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_SIDEEFFECTS_H_ */