copyStructures.h

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

class DoCopyStructures : public Transform {
    TypeMap *typeMap;
    bool errorOnMethodCall;

    bool copyHeaders;
    bool copyTuples;
 
 public:
    explicit DoCopyStructures(TypeMap *typeMap, bool errorOnMethodCall, bool copyHeaders = false,
                              bool copyTuples = true)
        : typeMap(typeMap),
          errorOnMethodCall(errorOnMethodCall),
          copyHeaders(copyHeaders),
          copyTuples(copyTuples) {
        CHECK_NULL(typeMap);
        setName("DoCopyStructures");
    }
    // FIXME -- this should be a preorder so we can deal with nested structs directly,
    // but that fails because we depend on the typeMap which will be out of date after
    // expanding outer copies.  So we need to repeat this pass in a loop
    const IR::Node *postorder(IR::AssignmentStatement *statement) override;
};

class RemoveAliases : public Transform {
    MinimalNameGenerator nameGen;
    TypeMap *typeMap;
 
    IR::IndexedVector<IR::Declaration> declarations;
 
 public:
    explicit RemoveAliases(TypeMap *typeMap) : typeMap(typeMap) {
        CHECK_NULL(typeMap);
        setName("RemoveAliases");
    }
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = Transform::init_apply(node);
        node->apply(nameGen);
 
        return rv;
    }
 
    const IR::Node *postorder(IR::AssignmentStatement *statement) override;
    const IR::Node *postorder(IR::P4Parser *parser) override;
    const IR::Node *postorder(IR::P4Control *control) override;
};
 
class CopyStructures : public PassRepeated {
 public:
    explicit CopyStructures(TypeMap *typeMap, bool errorOnMethodCall = true,
                            bool copyHeaders = false, bool copyTuples = false,
                            TypeChecking *typeChecking = nullptr) {
        CHECK_NULL(typeMap);
        setName("CopyStructures");
        if (typeChecking == nullptr) typeChecking = new TypeChecking(nullptr, typeMap);
        addPasses({typeChecking, new RemoveAliases(typeMap), typeChecking,
                   new DoCopyStructures(typeMap, errorOnMethodCall, copyHeaders, copyTuples)});
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_COPYSTRUCTURES_H_ */