ubpfType.h

/*
 * Copyright 2019 Orange
 * SPDX-FileCopyrightText: 2019 Orange
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_UBPF_UBPFTYPE_H_
#define BACKENDS_UBPF_UBPFTYPE_H_
 
#include "backends/ebpf/ebpfType.h"
#include "lib/sourceCodeBuilder.h"
 
namespace P4::UBPF {
 
class UBPFTypeFactory : public EBPF::EBPFTypeFactory {
 public:
    explicit UBPFTypeFactory(const P4::TypeMap *typeMap) : EBPF::EBPFTypeFactory(typeMap) {}
 
    static void createFactory(const P4::TypeMap *typeMap) {
        EBPF::EBPFTypeFactory::instance = new UBPFTypeFactory(typeMap);
    }
 
    static EBPFTypeFactory *getInstance() { return EBPF::EBPFTypeFactory::instance; }
 
    EBPF::EBPFType *create(const IR::Type *type) override;
};
 
class UBPFBoolType : public EBPF::EBPFBoolType {
 public:
    UBPFBoolType() : EBPF::EBPFBoolType() {}
 
    void emit(EBPF::CodeBuilder *builder) override { builder->append("uint8_t"); }
 
    DECLARE_TYPEINFO(UBPFBoolType, EBPF::EBPFBoolType);
};
 
class UBPFScalarType : public EBPF::EBPFScalarType {
 public:
    explicit UBPFScalarType(const IR::Type_Bits *bits) : EBPF::EBPFScalarType(bits) {}
 
    void emit(EBPF::CodeBuilder *builder) override;
 
    cstring getAsString();
 
    void declare(EBPF::CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(EBPF::CodeBuilder *builder, cstring id, bool asPointer) override;
 
    DECLARE_TYPEINFO(UBPFScalarType, EBPF::EBPFScalarType);
};
 
class UBPFExternType : public EBPF::EBPFScalarType {
 public:
    explicit UBPFExternType(const IR::Type_Bits *bits) : EBPF::EBPFScalarType(bits) {}
 
    void emit(EBPF::CodeBuilder *builder) override;
 
    cstring getAsString();
 
    void declare(EBPF::CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(EBPF::CodeBuilder *builder, cstring id, bool asPointer) override;
 
    DECLARE_TYPEINFO(UBPFExternType, EBPF::EBPFScalarType);
};
 
class UBPFStructType : public EBPF::EBPFStructType {
 public:
    explicit UBPFStructType(const IR::Type_StructLike *strct) : EBPF::EBPFStructType(strct) {}
    void emit(EBPF::CodeBuilder *builder) override;
    void declare(EBPF::CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(EBPF::CodeBuilder *builder, cstring id, bool asPointer) override;
 
    DECLARE_TYPEINFO(UBPFStructType, EBPF::EBPFStructType);
};
 
class UBPFEnumType : public EBPF::EBPFEnumType {
 public:
    explicit UBPFEnumType(const IR::Type_Enum *strct) : EBPF::EBPFEnumType(strct) {}
 
    void emit(EBPF::CodeBuilder *builder) override;
 
    DECLARE_TYPEINFO(UBPFEnumType, EBPF::EBPFEnumType);
};
 
class UBPFErrorType : public EBPF::EBPFErrorType {
 public:
    explicit UBPFErrorType(const IR::Type_Error *strct) : EBPF::EBPFErrorType(strct) {}
 
    void emit(EBPF::CodeBuilder *builder) override;
 
    DECLARE_TYPEINFO(UBPFErrorType, EBPF::EBPFErrorType);
};
 
class UBPFListType : public EBPF::EBPFType, public EBPF::IHasWidth {
    class UBPFListElement : public ICastable {
     public:
        EBPFType *type;
        const cstring name;
 
        UBPFListElement(EBPFType *type, const cstring name) : type(type), name(name) {}
        virtual ~UBPFListElement() {}  // to make UBPFListElement polymorphic.
 
        DECLARE_TYPEINFO(UBPFListElement);
    };
 
    class Padding : public UBPFListElement {
     public:
        unsigned widthInBytes;
 
        Padding(const cstring name, unsigned widthInBytes)
            : UBPFListElement(nullptr, name), widthInBytes(widthInBytes) {}
 
        DECLARE_TYPEINFO(Padding, UBPFListElement);
    };
 
 public:
    cstring kind;
    cstring name;
    std::vector<UBPFListElement *> elements;
    unsigned width;
    unsigned implWidth;
 
    explicit UBPFListType(const IR::Type_List *lst);
    void emitPadding(EBPF::CodeBuilder *builder, Padding *padding);
    void declare(EBPF::CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(EBPF::CodeBuilder *builder, cstring id, bool asPointer) override;
    void emitInitializer(EBPF::CodeBuilder *builder) override;
    unsigned widthInBits() const override { return width; }
    unsigned implementationWidthInBits() const override { return implWidth; }
    void emit(EBPF::CodeBuilder *builder) override;
 
    DECLARE_TYPEINFO(UBPFListType, EBPF::EBPFType, EBPF::IHasWidth);
};
 
}  // namespace P4::UBPF
 
#endif /* BACKENDS_UBPF_UBPFTYPE_H_ */