ebpfType.h

/*
Copyright 2013-present Barefoot Networks, 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 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_ */