tcExterns.h

/*
Copyright (C) 2024 Intel Corporation
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_TC_TCEXTERNS_H_
#define BACKENDS_TC_TCEXTERNS_H_
 
#include "backend.h"
 
namespace P4::TC {
 
using namespace P4::literals;
 
class ControlBodyTranslatorPNA;
class ConvertToBackendIR;
 
class EBPFCounterPNA : public EBPF::EBPFCounterPSA {
    const IR::Declaration_Instance *di;
    cstring tblname;
 
 public:
    EBPFCounterPNA(const EBPF::EBPFProgram *program, const IR::Declaration_Instance *di,
                   cstring name, EBPF::CodeGenInspector *codeGen, cstring tblname)
        : EBPF::EBPFCounterPSA(program, di, name, codeGen) {
        this->tblname = tblname;
        this->di = di;
    }
    EBPFCounterPNA(const EBPF::EBPFProgram *program, const IR::Declaration_Instance *di,
                   cstring name, EBPF::CodeGenInspector *codeGen)
        : EBPF::EBPFCounterPSA(program, di, name, codeGen) {
        this->di = di;
    }
 
    void emitDirectMethodInvocation(EBPF::CodeBuilder *builder, const P4::ExternMethod *method,
                                    const ConvertToBackendIR *tcIR);
    void emitMethodInvocation(EBPF::CodeBuilder *builder, const P4::ExternMethod *method,
                              ControlBodyTranslatorPNA *translator);
    virtual void emitCounterUpdate(EBPF::CodeBuilder *builder, const ConvertToBackendIR *tcIR);
    virtual void emitCount(EBPF::CodeBuilder *builder, const P4::ExternMethod *method,
                           ControlBodyTranslatorPNA *translator);
};
 
class EBPFRegisterPNA : public EBPF::EBPFTableBase {
 protected:
    cstring instanceName;
    const IR::Type *keyArg;
    const IR::Type *valueArg;
    EBPF::EBPFType *keyType;
    EBPF::EBPFType *valueType;
 
 public:
    EBPFRegisterPNA(const EBPF::EBPFProgram *program, cstring instanceName,
                    const IR::Declaration_Instance *di, EBPF::CodeGenInspector *codeGen)
        : EBPF::EBPFTableBase(program, instanceName, codeGen) {
        CHECK_NULL(di);
        this->instanceName = di->toString();
        if (!di->type->is<IR::Type_Specialized>()) {
            ::P4::error(ErrorType::ERR_MODEL, "Missing specialization: %1%", di);
            return;
        }
        auto ts = di->type->to<IR::Type_Specialized>();
 
        if (ts->arguments->size() != PARAM_INDEX_2) {
            ::P4::error(ErrorType::ERR_MODEL, "Expected a type specialized with two arguments: %1%",
                        ts);
            return;
        }
 
        this->valueArg = ts->arguments->at(0);
        this->keyArg = ts->arguments->at(1);
 
        this->keyType = EBPF::EBPFTypeFactory::instance->create(keyArg);
        this->valueType = EBPF::EBPFTypeFactory::instance->create(valueArg);
    }
    void emitRegisterRead(EBPF::CodeBuilder *builder, const P4::ExternMethod *method,
                          ControlBodyTranslatorPNA *translator,
                          const IR::Expression *leftExpression);
    void emitRegisterWrite(EBPF::CodeBuilder *builder, const P4::ExternMethod *method,
                           ControlBodyTranslatorPNA *translator);
    void emitInitializer(EBPF::CodeBuilder *builder, const P4::ExternMethod *method,
                         ControlBodyTranslatorPNA *translator);
};
 
class EBPFTablePNADirectCounterPropertyVisitor : public EBPF::EBPFTablePsaPropertyVisitor {
 public:
    explicit EBPFTablePNADirectCounterPropertyVisitor(EBPF::EBPFTablePSA *table)
        : EBPF::EBPFTablePsaPropertyVisitor(table) {}
 
    bool preorder(const IR::PathExpression *pe) override {
        auto decl = table->program->refMap->getDeclaration(pe->path, true);
        auto di = decl->to<IR::Declaration_Instance>();
        CHECK_NULL(di);
        if (EBPF::EBPFObject::getSpecializedTypeName(di) != "DirectCounter") {
            ::P4::error(ErrorType::ERR_UNEXPECTED,
                        "%1%: not a DirectCounter, see declaration of %2%", pe, decl);
            return false;
        }
        auto counterName = EBPF::EBPFObject::externalName(di);
        auto tblname = table->table->container->name.originalName;
        auto ctr = new EBPFCounterPNA(table->program, di, counterName, table->codeGen, tblname);
        table->counters.emplace_back(std::make_pair(counterName, ctr));
        return false;
    }
 
    void visitTableProperty() {
        EBPF::EBPFTablePsaPropertyVisitor::visitTableProperty("pna_direct_counter"_cs);
    }
};
 
class InternetChecksumAlgorithmPNA : public EBPF::EBPFHashAlgorithmPSA {
 protected:
    cstring stateVar;
    cstring csumVar;
 
    void updateChecksum(EBPF::CodeBuilder *builder, const ArgumentsList &arguments, bool addData);
 
 public:
    InternetChecksumAlgorithmPNA(const EBPF::EBPFProgram *program, cstring name)
        : EBPF::EBPFHashAlgorithmPSA(program, name) {}
 
    void emitVariables(EBPF::CodeBuilder *builder, const IR::Declaration_Instance *decl) override;
 
    void emitClear(EBPF::CodeBuilder *builder) override;
    void emitAddData(EBPF::CodeBuilder *builder, const ArgumentsList &arguments) override;
    void emitGet(EBPF::CodeBuilder *builder) override;
 
    void emitSubtractData(EBPF::CodeBuilder *builder, const ArgumentsList &arguments) override;
 
    void emitGetInternalState(EBPF::CodeBuilder *builder) override;
    void emitSetInternalState(EBPF::CodeBuilder *builder,
                              const IR::MethodCallExpression *expr) override;
    cstring getConvertByteOrderFunction(unsigned widthToEmit, cstring byte_order);
};
 
class EBPFChecksumPNA : public EBPF::EBPFChecksumPSA {
 protected:
    cstring csumVar;
    void init(const EBPF::EBPFProgram *program, cstring name, int type);
 
 public:
    EBPFChecksumPNA(const EBPF::EBPFProgram *program, const IR::Declaration_Instance *block,
                    cstring name)
        : EBPF::EBPFChecksumPSA(program, block, name) {
        auto di = block->to<IR::Declaration_Instance>();
        if (di->arguments->size() != 1) {
            ::P4::error(ErrorType::ERR_UNEXPECTED, "Expected exactly 1 argument %1%", block);
            return;
        }
        int type = di->arguments->at(0)->expression->checkedTo<IR::Constant>()->asInt();
        init(program, name, type);
    }
 
    EBPFChecksumPNA(const EBPF::EBPFProgram *program, const IR::Declaration_Instance *block,
                    cstring name, int type)
        : EBPF::EBPFChecksumPSA(program, block, name, type) {
        init(program, name, type);
    }
};
 
class EBPFInternetChecksumPNA : public EBPFChecksumPNA {
 public:
    EBPFInternetChecksumPNA(const EBPF::EBPFProgram *program, const IR::Declaration_Instance *block,
                            cstring name)
        : EBPFChecksumPNA(program, block, name,
                          EBPF::EBPFHashAlgorithmPSA::HashAlgorithm::ONES_COMPLEMENT16) {}
 
    void processMethod(EBPF::CodeBuilder *builder, cstring method,
                       const IR::MethodCallExpression *expr, Visitor *visitor) override;
};
 
class EBPFHashPNA : public EBPF::EBPFChecksumPSA {
 protected:
    void init(const EBPF::EBPFProgram *program, cstring name, int type);
 
 public:
    EBPFHashPNA(const EBPF::EBPFProgram *program, const IR::Declaration_Instance *block,
                cstring name)
        : EBPF::EBPFChecksumPSA(program, block, name) {
        auto di = block->to<IR::Declaration_Instance>();
        if (di->arguments->size() != 1) {
            ::P4::error(ErrorType::ERR_UNEXPECTED, "Expected exactly 1 argument %1%", block);
            return;
        }
        int type = di->arguments->at(0)->expression->checkedTo<IR::Constant>()->asInt();
        init(program, name, type);
    }
    void processMethod(EBPF::CodeBuilder *builder, cstring method,
                       const IR::MethodCallExpression *expr, Visitor *visitor) override;
    void calculateHash(EBPF::CodeBuilder *builder, const IR::MethodCallExpression *expr,
                       Visitor *visitor);
    void emitVariables(EBPF::CodeBuilder *builder);
};
 
class EBPFCRCChecksumPNA : public EBPFChecksumPNA {
 public:
    EBPFCRCChecksumPNA(const EBPF::EBPFProgram *program, const IR::Declaration_Instance *block,
                       cstring name)
        : EBPFChecksumPNA(program, block, name) {}
 
    void processMethod(EBPF::CodeBuilder *builder, cstring method,
                       const IR::MethodCallExpression *expr, Visitor *visitor) override;
    void emitVariables(EBPF::CodeBuilder *builder);
};
 
class CRCChecksumAlgorithmPNA : public EBPF::CRCChecksumAlgorithm {
 protected:
    cstring csumVar;
 
 public:
    CRCChecksumAlgorithmPNA(const EBPF::EBPFProgram *program, cstring name, int width)
        : EBPF::CRCChecksumAlgorithm(program, name, width) {
        BUG_CHECK(width == 16 || width == 32, "Must be 16 bits width or 32 bits width.");
        initialValue = "0"_cs;
    }
    void emitGet(EBPF::CodeBuilder *builder) override;
    void emitAddData(EBPF::CodeBuilder *builder, const ArgumentsList &arguments,
                     const IR::MethodCallExpression *expr);
    void emitAddData(EBPF::CodeBuilder *builder, int dataPos,
                     const IR::MethodCallExpression *expr) override;
    void emitVariables(EBPF::CodeBuilder *builder, const IR::Declaration_Instance *decl) override;
    void emitClear(EBPF::CodeBuilder *builder) override;
};
 
class HashAlgorithmPNA : public EBPF::CRCChecksumAlgorithm {
 public:
    HashAlgorithmPNA(const EBPF::EBPFProgram *program, cstring name, int width)
        : EBPF::CRCChecksumAlgorithm(program, name, width) {
        BUG_CHECK(width == 16 || width == 32, "Must be 16 bits width or 32 bits width.");
        initialValue = "0"_cs;
    }
    void emitGet(EBPF::CodeBuilder *builder) override;
    void emitAddData(EBPF::CodeBuilder *builder, const ArgumentsList &arguments,
                     const IR::MethodCallExpression *expr);
    void emitAddData(EBPF::CodeBuilder *builder, int dataPos,
                     const IR::MethodCallExpression *expr) override;
    void emitVariables(EBPF::CodeBuilder *builder);
};
 
class EBPFDigestPNA : public EBPF::EBPFDigestPSA {
    const ConvertToBackendIR *tcIR;
    cstring externName;
    cstring instanceName;
 
 public:
    EBPFDigestPNA(const EBPF::EBPFProgram *program, const IR::Declaration_Instance *di,
                  cstring externName, const ConvertToBackendIR *tcIR)
        : EBPF::EBPFDigestPSA(program, di) {
        this->tcIR = tcIR;
        this->externName = externName;
        this->instanceName = di->toString();
    }
    void emitInitializer(EBPF::CodeBuilder *builder) const;
    void emitPushElement(EBPF::CodeBuilder *builder, const IR::Expression *elem,
                         Inspector *codegen) const;
    void emitPushElement(EBPF::CodeBuilder *builder, cstring elem) const;
};
 
class EBPFMeterPNA : public EBPF::EBPFMeterPSA {
    cstring tblname;
    cstring instanceName;
 
 public:
    EBPFMeterPNA(const EBPF::EBPFProgram *program, cstring instanceName,
                 const IR::Declaration_Instance *di, EBPF::CodeGenInspector *codeGen)
        : EBPF::EBPFMeterPSA(program, instanceName, di, codeGen) {
        this->instanceName = di->toString();
    }
    EBPFMeterPNA(const EBPF::EBPFProgram *program, cstring instanceName, cstring tblname,
                 const IR::Declaration_Instance *di, EBPF::CodeGenInspector *codeGen)
        : EBPF::EBPFMeterPSA(program, instanceName, di, codeGen) {
        this->tblname = tblname;
        this->instanceName = di->toString();
    }
    void emitExecute(EBPF::CodeBuilder *builder, const P4::ExternMethod *method,
                     ControlBodyTranslatorPNA *translator,
                     const IR::Expression *leftExpression) const;
    void emitDirectMeterExecute(EBPF::CodeBuilder *builder, const P4::ExternMethod *method,
                                ControlBodyTranslatorPNA *translator,
                                const IR::Expression *leftExpression) const;
    void emitInitializer(EBPF::CodeBuilder *builder, const ConvertToBackendIR *tcIR,
                         cstring externName) const;
};
 
class EBPFTablePNADirectMeterPropertyVisitor : public EBPF::EBPFTablePsaPropertyVisitor {
 public:
    explicit EBPFTablePNADirectMeterPropertyVisitor(EBPF::EBPFTablePSA *table)
        : EBPF::EBPFTablePsaPropertyVisitor(table) {}
 
    bool preorder(const IR::PathExpression *pe) override {
        auto decl = table->program->refMap->getDeclaration(pe->path, true);
        auto di = decl->to<IR::Declaration_Instance>();
        CHECK_NULL(di);
        if (EBPF::EBPFObject::getTypeName(di) != "DirectMeter") {
            ::P4::error(ErrorType::ERR_UNEXPECTED, "%1%: not a DirectMeter, see declaration of %2%",
                        pe, decl);
            return false;
        }
 
        auto meterName = EBPF::EBPFObject::externalName(di);
        auto tblname = table->table->container->name.originalName;
        auto met = new EBPFMeterPNA(table->program, meterName, tblname, di, table->codeGen);
        table->meters.emplace_back(std::make_pair(meterName, met));
        return false;
    }
 
    void visitTableProperty() {
        EBPF::EBPFTablePsaPropertyVisitor::visitTableProperty("pna_direct_meter"_cs);
    }
};
 
class EBPFRandomPNA : public EBPF::EBPFRandomPSA {
 public:
    explicit EBPFRandomPNA(const IR::Declaration_Instance *di) : EBPF::EBPFRandomPSA(di) {}
 
    void emitExecute(EBPF::CodeBuilder *builder, ControlBodyTranslatorPNA *translator,
                     const IR::Type *ltype, const IR::Expression *lexpr,
                     const IR::Expression *rexpr) const;
};
}  // namespace P4::TC
 
#endif /* BACKENDS_TC_TCEXTERNS_H_ */