typeSpecConverter.h

/*
 * SPDX-FileCopyrightText: 2018 Barefoot Networks, Inc.
 * Copyright 2018-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef CONTROL_PLANE_TYPESPECCONVERTER_H_
#define CONTROL_PLANE_TYPESPECCONVERTER_H_
 
#include <map>
#include <string>
 
#include "ir/ir.h"
#include "ir/visitor.h"
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wpedantic"
#include "p4/config/v1/p4info.pb.h"
#pragma GCC diagnostic pop
 
namespace p4 {
 
class P4DataTypeSpec;
class P4TypeInfo;
 
}  // namespace p4
 
namespace P4 {
 
class TypeMap;
class ReferenceMap;
 
namespace ControlPlaneAPI {

class TypeSpecConverter : public Inspector {
 private:
    const P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    ::p4::config::v1::P4TypeInfo *p4RtTypeInfo;
    std::map<const IR::Type *, ::p4::config::v1::P4DataTypeSpec *> map;
 
    TypeSpecConverter(const P4::ReferenceMap *refMap, P4::TypeMap *typeMap,
                      ::p4::config::v1::P4TypeInfo *p4RtTypeInfo);
 
    // fallback for unsupported types, should be unreachable
    bool preorder(const IR::Type *type) override;
 
    // anonymous types
    bool preorder(const IR::Type_Bits *type) override;
    bool preorder(const IR::Type_Varbits *type) override;
    bool preorder(const IR::Type_Boolean *type) override;
    bool preorder(const IR::Type_BaseList *type) override;
    bool preorder(const IR::Type_Array *type) override;
 
    bool preorder(const IR::Type_Name *type) override;
    bool preorder(const IR::Type_Newtype *type) override;
 
    // these methods do not update the "map", but update p4RtTypeInfo if it is
    // not null.
    bool preorder(const IR::Type_Struct *type) override;
    bool preorder(const IR::Type_Header *type) override;
    bool preorder(const IR::Type_HeaderUnion *type) override;
    bool preorder(const IR::Type_Enum *type) override;
    bool preorder(const IR::Type_SerEnum *type) override;
    bool preorder(const IR::Type_Error *type) override;
 
 public:
    static const ::p4::config::v1::P4DataTypeSpec *convert(const P4::ReferenceMap *refMap,
                                                           P4::TypeMap *typeMap,
                                                           const IR::Type *type,
                                                           ::p4::config::v1::P4TypeInfo *typeInfo);
};

struct ControllerType {
    enum Type { kBit, kString };
    Type type;  // Supported controller types are `string` and `bit<W>`.
    int width;  // 0 if type == kString.
};

struct TranslationAnnotation {
    std::string original_type_uri;
    ControllerType controller_type;
};

bool hasTranslationAnnotation(const IR::Type *type, TranslationAnnotation *payload);

cstring getTypeName(const IR::Type *type, TypeMap *typeMap);
 
}  // namespace ControlPlaneAPI
 
}  // namespace P4
 
#endif  // CONTROL_PLANE_TYPESPECCONVERTER_H_