convertEnums.h

/*
Copyright 2016 VMware, Inc.
 
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_CONVERTENUMS_H_
#define MIDEND_CONVERTENUMS_H_
 
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {
 
class ChooseEnumRepresentation {
 public:
    virtual ~ChooseEnumRepresentation() {}
    // If true this type has to be converted.
    virtual bool convert(const IR::Type_Enum *type) const = 0;
    // Returns the value to be assigned to the enum Constant.
    // Maps to the index of member in the enum by default.
    virtual unsigned encoding(const IR::Type_Enum *, unsigned n) const { return n; }
    // enumCount is the number of different enum values.
    // The returned value is the width of Type_Bits used
    // to represent the enum.  Obviously, we must have
    // 2^(return) >= enumCount.
    virtual unsigned enumSize(unsigned enumCount) const = 0;
};
 
class EnumRepresentation {
    std::map<cstring, unsigned> repr;
 
 public:
    const IR::Type_Bits *type;
 
    EnumRepresentation(Util::SourceInfo srcInfo, unsigned width) {
        type = IR::Type_Bits::get(srcInfo, width, false);
    }
    void add(cstring decl) { repr.emplace(decl, repr.size()); }
    unsigned get(cstring decl) const { return ::P4::get(repr, decl); }
 
    using iterator = decltype(repr)::iterator;
    using const_iterator = decltype(repr)::const_iterator;
    iterator begin() { return repr.begin(); }
    const_iterator begin() const { return repr.begin(); }
    iterator end() { return repr.end(); }
    const_iterator end() const { return repr.end(); }
};
 
class DoConvertEnums : public Transform {
    friend class ConvertEnums;
 
    ordered_map<const IR::Type_Enum *, EnumRepresentation *> repr;
    ChooseEnumRepresentation *policy;
    TypeMap *typeMap;
 
 public:
    DoConvertEnums(ChooseEnumRepresentation *policy, TypeMap *typeMap)
        : policy(policy), typeMap(typeMap) {
        CHECK_NULL(policy);
        CHECK_NULL(typeMap);
        setName("DoConvertEnums");
    }
    const IR::Node *preorder(IR::Type_Enum *type) override;
    const IR::Node *postorder(IR::Type_Name *type) override;
    const IR::Node *postorder(IR::Member *expression) override;
};
 
class ConvertEnums : public PassManager {
    DoConvertEnums *convertEnums{nullptr};
 
 public:
    using EnumMapping = decltype(DoConvertEnums::repr);
    ConvertEnums(ReferenceMap *refMap, TypeMap *typeMap, ChooseEnumRepresentation *policy,
                 TypeChecking *typeChecking = nullptr)
        : convertEnums(new DoConvertEnums(policy, typeMap)) {
        if (!typeChecking) typeChecking = new TypeChecking(refMap, typeMap);
        passes.push_back(typeChecking);
        passes.push_back(convertEnums);
        passes.push_back(new ClearTypeMap(typeMap));
        setName("ConvertEnums");
    }
 
    EnumMapping getEnumMapping() const { return convertEnums->repr; }
};
 
class EnumOn32Bits : public P4::ChooseEnumRepresentation {
    bool convert(const IR::Type_Enum *type) const override {
        if (type->srcInfo.isValid()) {
            return true;
        }
        return true;
    }
    unsigned enumSize(unsigned) const override { return 32; }
};
 
}  // namespace P4
 
#endif /* MIDEND_CONVERTENUMS_H_ */