ebpfType.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_EBPF_EBPFTYPE_H_
#define BACKENDS_EBPF_EBPFTYPE_H_
 
#include "ebpfObject.h"
#include "ir/ir.h"
#include "lib/algorithm.h"
#include "lib/rtti.h"
#include "lib/sourceCodeBuilder.h"
 
namespace P4::EBPF {

class EBPFType : public EBPFObject {
 protected:
    explicit EBPFType(const IR::Type *type) : type(type) {}
 
 public:
    const IR::Type *type;
    virtual void emit(CodeBuilder *builder) = 0;
    virtual void declare(CodeBuilder *builder, cstring id, bool asPointer) = 0;
    virtual void declareInit(CodeBuilder *builder, cstring id, bool asPointer) = 0;
    virtual void emitInitializer(CodeBuilder *builder) = 0;
    virtual void declareArray(CodeBuilder * /*builder*/, cstring /*id*/, unsigned /*size*/) {
        BUG("%1%: unsupported array", type);
    }
 
    DECLARE_TYPEINFO(EBPFType, EBPFObject);
};
 
class IHasWidth : public ICastable {
 public:
    virtual ~IHasWidth() {}
    virtual unsigned widthInBits() const = 0;
    virtual unsigned implementationWidthInBits() const = 0;
 
    DECLARE_TYPEINFO(IHasWidth);
};
 
class EBPFTypeFactory {
 protected:
    const P4::TypeMap *typeMap;
    explicit EBPFTypeFactory(const P4::TypeMap *typeMap) : typeMap(typeMap) { CHECK_NULL(typeMap); }
 
 public:
    static EBPFTypeFactory *instance;
    static bool isTC;
    static void createFactory(const P4::TypeMap *typeMap, bool TC) {
        EBPFTypeFactory::instance = new EBPFTypeFactory(typeMap);
        EBPFTypeFactory::isTC = TC;
    }
    virtual EBPFType *create(const IR::Type *type);
};
 
class EBPFBoolType : public EBPFType, public IHasWidth {
 public:
    EBPFBoolType() : EBPFType(IR::Type_Boolean::get()) {}
    void emit(CodeBuilder *builder) override { builder->append("u8"); }
    void declare(CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(CodeBuilder *builder, cstring id, bool asPointer) override;
    void emitInitializer(CodeBuilder *builder) override { builder->append("0"); }
    unsigned widthInBits() const override { return 1; }
    unsigned implementationWidthInBits() const override { return 8; }
 
    DECLARE_TYPEINFO(EBPFBoolType, EBPFType, IHasWidth);
};
 
class EBPFStackType : public EBPFType, public IHasWidth {
    EBPFType *elementType;
    unsigned size;
 
 public:
    EBPFStackType(const IR::Type_Array *type, EBPFType *elementType)
        : EBPFType(type), elementType(elementType), size(type->getSize()) {
        CHECK_NULL(type);
        CHECK_NULL(elementType);
        BUG_CHECK(elementType->is<IHasWidth>(), "Unexpected element type %1%",
                  typeid(*elementType).name());
    }
    void emit(CodeBuilder *) override {}
    void declare(CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(CodeBuilder *builder, cstring id, bool asPointer) override;
    void emitInitializer(CodeBuilder *builder) override;
    unsigned widthInBits() const override;
    unsigned implementationWidthInBits() const override;
 
    DECLARE_TYPEINFO(EBPFStackType, EBPFType, IHasWidth);
};
 
class EBPFScalarType : public EBPFType, public IHasWidth {
 public:
    const unsigned width;
    const bool isSigned;
    const bool isvariable;
    explicit EBPFScalarType(const IR::Type_Bits *bits)
        : EBPFType(bits), width(bits->size), isSigned(bits->isSigned), isvariable(false) {}
    explicit EBPFScalarType(const IR::Type_Varbits *bits)
        : EBPFType(bits), width(bits->size), isSigned(false), isvariable(true) {}
    unsigned bytesRequired() const { return ROUNDUP(width, 8); }
    unsigned alignment() const;
    void emit(CodeBuilder *builder) override;
    void declare(CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(CodeBuilder *builder, cstring id, bool asPointer) override;
    void emitInitializer(CodeBuilder *builder) override;
    unsigned widthInBits() const override { return width; }
    unsigned implementationWidthInBits() const override { return bytesRequired() * 8; }
    // True if this width is small enough to store in a machine scalar
    static bool generatesScalar(unsigned width) { return width <= 64; }
 
    DECLARE_TYPEINFO(EBPFScalarType, EBPFType, IHasWidth);
};

class EBPFTypeName : public EBPFType, public IHasWidth {
    const IR::Type_Name *type;
    EBPFType *canonical;
 
 public:
    EBPFTypeName(const IR::Type_Name *type, EBPFType *canonical)
        : EBPFType(type), type(type), canonical(canonical) {}
    void emit(CodeBuilder *builder) override { canonical->emit(builder); }
    void declare(CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(CodeBuilder *builder, cstring id, bool asPointer) override;
    void emitInitializer(CodeBuilder *builder) override;
    unsigned widthInBits() const override;
    unsigned implementationWidthInBits() const override;
    void declareArray(CodeBuilder *builder, cstring id, unsigned size) override;
 
    template <typename T>
    bool canonicalTypeIs() const {
        return this->canonical->is<T>();
    }
 
    DECLARE_TYPEINFO(EBPFTypeName, EBPFType, IHasWidth);
};

class EBPFStructType : public EBPFType, public IHasWidth {
    class EBPFField {
     public:
        cstring comment;
        EBPFType *type;
        const IR::StructField *field;
 
        EBPFField(EBPFType *type, const IR::StructField *field, cstring comment = nullptr)
            : comment(comment), type(type), field(field) {}
    };
 
 public:
    cstring kind;
    cstring name;
    std::vector<EBPFField *> fields;
    unsigned width;
    unsigned implWidth;
    bool packed;
 
    explicit EBPFStructType(const IR::Type_StructLike *strct);
    void declare(CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(CodeBuilder *builder, cstring id, bool asPointer) override;
    void emitInitializer(CodeBuilder *builder) override;
    unsigned widthInBits() const override { return width; }
    unsigned implementationWidthInBits() const override { return implWidth; }
    void emit(CodeBuilder *builder) override;
    void declareArray(CodeBuilder *builder, cstring id, unsigned size) override;
 
    DECLARE_TYPEINFO(EBPFStructType, EBPFType, IHasWidth);
};
 
class EBPFEnumType : public EBPFType, public EBPF::IHasWidth {
 public:
    explicit EBPFEnumType(const IR::Type_Enum *type) : EBPFType(type) {}
    void emit(CodeBuilder *builder) override;
    void declare(CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(CodeBuilder *builder, cstring id, bool asPointer) override;
    void emitInitializer(CodeBuilder *builder) override { builder->append("0"); }
    unsigned widthInBits() const override { return 32; }
    unsigned implementationWidthInBits() const override { return 32; }
    const IR::Type_Enum *getType() const { return type->to<IR::Type_Enum>(); }
 
    DECLARE_TYPEINFO(EBPFEnumType, EBPFType, IHasWidth);
};
 
class EBPFErrorType : public EBPFType, public EBPF::IHasWidth {
 public:
    explicit EBPFErrorType(const IR::Type_Error *type) : EBPFType(type) {}
    void emit(CodeBuilder *builder) override;
    void declare(CodeBuilder *builder, cstring id, bool asPointer) override;
    void declareInit(CodeBuilder *builder, cstring id, bool asPointer) override;
    void emitInitializer(CodeBuilder *builder) override { builder->append("0"); }
    unsigned widthInBits() const override { return 32; }
    unsigned implementationWidthInBits() const override { return 32; }
    const IR::Type_Error *getType() const { return type->to<IR::Type_Error>(); }
 
    DECLARE_TYPEINFO(EBPFErrorType, EBPFType, IHasWidth);
};

class EBPFMethodDeclaration : public EBPFObject {
 private:
    const IR::Method *method_;
 
 public:
    explicit EBPFMethodDeclaration(const IR::Method *method);

    void emit(CodeBuilder *builder);
 
    DECLARE_TYPEINFO(EBPFMethodDeclaration, EBPFObject);
};
 
class EBPFScalarTypePNA : public EBPFScalarType {
    bool isPrimitiveByteAligned = false;
 
 public:
    explicit EBPFScalarTypePNA(const IR::Type_Bits *bits) : EBPFScalarType(bits) {
        isPrimitiveByteAligned = (width <= 8 || width <= 16 || (width > 24 && width <= 32) ||
                                  (width > 56 && width <= 64));
    }
    unsigned alignment() const;
    void declare(CodeBuilder *builder, cstring id, bool asPointer);
    void declareInit(CodeBuilder *builder, cstring id, bool asPointer);
    void emitInitializer(CodeBuilder *builder);
};
 
}  // namespace P4::EBPF
 
#endif /* BACKENDS_EBPF_EBPFTYPE_H_ */