flattenUnions.h

/*
Copyright 2022 Intel Corp.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#ifndef MIDEND_FLATTENUNIONS_H_
#define MIDEND_FLATTENUNIONS_H_
 
#include "./frontends/p4/parserControlFlow.h"
#include "./frontends/p4/simplifyDefUse.h"
#include "./frontends/p4/unusedDeclarations.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
namespace P4 {
 
class DoFlattenHeaderUnion : public Transform {
 protected:
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    std::map<cstring, std::map<cstring, cstring>> replacementMap;
    // Replacement map needed to add element-wise header declaration in right context
    std::map<IR::Declaration_Variable *, IR::IndexedVector<IR::Declaration>> replaceDVMap;
 
 public:
    DoFlattenHeaderUnion(P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
        : refMap(refMap), typeMap(typeMap) {}
    const IR::Node *postorder(IR::Type_Struct *sf) override;
    const IR::Node *postorder(IR::Declaration_Variable *dv) override;
    const IR::Node *postorder(IR::Member *m) override;
    const IR::Node *postorder(IR::P4Parser *parser) override;
    const IR::Node *postorder(IR::P4Control *control) override;
    const IR::Node *postorder(IR::P4Action *action) override;
    bool hasHeaderUnionField(IR::Type_Struct *s);
};
 
class DoFlattenHeaderUnionStack : public DoFlattenHeaderUnion {
    std::map<cstring, std::vector<cstring>> stackMap;
 
 public:
    DoFlattenHeaderUnionStack(P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
        : DoFlattenHeaderUnion(refMap, typeMap) {
        setName("DoFlattenHeaderUnionStack");
    }
    const IR::Node *postorder(IR::Type_Struct *sf) override;
    const IR::Node *postorder(IR::ArrayIndex *e) override;
    const IR::Node *postorder(IR::Declaration_Variable *dv) override;
    bool hasHeaderUnionStackField(IR::Type_Struct *s);
};
 
class HandleValidityHeaderUnion : public Transform {
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    IR::IndexedVector<IR::Declaration> toInsert;  // temporaries
 
 public:
    HandleValidityHeaderUnion(P4::ReferenceMap *refMap, P4::TypeMap *typeMap)
        : refMap(refMap), typeMap(typeMap) {
        setName("HandleValidityHeaderUnion");
    }
    const IR::Node *postorder(IR::AssignmentStatement *assn) override;
    const IR::Node *postorder(IR::IfStatement *a) override;
    const IR::Node *postorder(IR::SwitchStatement *a) override;
    const IR::Node *postorder(IR::MethodCallStatement *mcs) override;
    const IR::Node *postorder(IR::P4Parser *parser) override;
    const IR::Node *postorder(IR::P4Control *control) override;
    const IR::Node *postorder(IR::P4Action *action) override;
    const IR::MethodCallStatement *processValidityForStr(const IR::Statement *s,
                                                         const IR::Member *m, cstring headerElement,
                                                         cstring setValid);
    const IR::Node *setInvalidforRest(const IR::Statement *s, const IR::Member *m,
                                      const IR::Type_HeaderUnion *hu, cstring exclude,
                                      bool setValidforCurrMem);
    const IR::Node *expandIsValid(const IR::Statement *a, const IR::MethodCallExpression *mce,
                                  IR::IndexedVector<IR::StatOrDecl> &code_block);
};
 
class RemoveUnusedHUDeclarations : public Transform {
    const UsedDeclSet &used;
 
 public:
    explicit RemoveUnusedHUDeclarations(const UsedDeclSet &used) : used(used) {}
 
    const IR::Node *preorder(IR::Type_HeaderUnion *type) override {
        if (!used.isUsed(getOriginal<IR::IDeclaration>())) return nullptr;
        return type;
    }
};
 
class RemoveAllUnusedHUDDeclarations : public PassManager {
    UsedDeclSet used;
 
 public:
    RemoveAllUnusedHUDDeclarations()
        : PassManager({
              new CollectUsedDeclarations(used),
              new RemoveUnusedHUDeclarations(used),
          }) {
        setName("RemoveAllUnusedHUDDeclarations");
        setStopOnError(true);
    }
};
 
class FlattenHeaderUnion : public PassManager {
 public:
    FlattenHeaderUnion(P4::ReferenceMap *refMap, P4::TypeMap *typeMap, bool loopsUnroll = true) {
        passes.push_back(new P4::TypeChecking(refMap, typeMap));
        passes.push_back(new HandleValidityHeaderUnion(refMap, typeMap));
        // Stack flattening is only applicable if parser loops are unrolled and
        // header union stack elements are accessed using [] notation. This pass does not handle
        // .next .last etc accessors for stack elements.
        if (loopsUnroll) {
            passes.push_back(new DoFlattenHeaderUnionStack(refMap, typeMap));
            passes.push_back(new P4::RemoveAllUnusedDeclarations(RemoveUnusedPolicy()));
        }
        passes.push_back(new P4::ClearTypeMap(typeMap));
        passes.push_back(new P4::TypeInference(typeMap, false));
        passes.push_back(new P4::TypeChecking(refMap, typeMap));
        passes.push_back(new DoFlattenHeaderUnion(refMap, typeMap));
        passes.push_back(new P4::RemoveAllUnusedDeclarations(RemoveUnusedPolicy()));
        passes.push_back(new P4::RemoveAllUnusedHUDDeclarations());
        passes.push_back(new P4::ClearTypeMap(typeMap));
        passes.push_back(new P4::TypeChecking(nullptr, typeMap));
        passes.push_back(new P4::RemoveParserIfs(typeMap));
    }
};
}  // namespace P4
 
#endif /* MIDEND_FLATTENUNIONS_H_ */