ebpfPsaHashAlgorithm.h

/*
 * SPDX-FileCopyrightText: 2022 Open Networking Foundation
 * SPDX-FileCopyrightText: 2022 Orange
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef BACKENDS_EBPF_PSA_EXTERNS_EBPFPSAHASHALGORITHM_H_
#define BACKENDS_EBPF_PSA_EXTERNS_EBPFPSAHASHALGORITHM_H_
 
#include "backends/ebpf/ebpfObject.h"
 
namespace P4::EBPF {
 
class EBPFProgram;
 
class EBPFHashAlgorithmPSA : public EBPFObject {
 public:
    typedef std::vector<const IR::Expression *> ArgumentsList;
 
 protected:
    cstring baseName;
    const EBPFProgram *program;
    Visitor *visitor;
 
    ArgumentsList unpackArguments(const IR::MethodCallExpression *expr, int dataPos);
 
 public:
    enum HashAlgorithm {
        IDENTITY,
        CRC32,
        CRC32_CUSTOM,
        CRC16,
        CRC16_CUSTOM,
        ONES_COMPLEMENT16,  // aka InternetChecksum
        TARGET_DEFAULT
    };
 
    EBPFHashAlgorithmPSA(const EBPFProgram *program, cstring name)
        : baseName(name), program(program), visitor(nullptr) {}
 
    void setVisitor(Visitor *instance) { this->visitor = instance; }
 
    virtual unsigned getOutputWidth() const { return 0; }

    virtual void emitVariables(CodeBuilder *builder, const IR::Declaration_Instance *decl) = 0;
 
    virtual void emitClear(CodeBuilder *builder) = 0;
    virtual void emitAddData(CodeBuilder *builder, int dataPos,
                             const IR::MethodCallExpression *expr);
    virtual void emitAddData(CodeBuilder *builder, const ArgumentsList &arguments) = 0;
    virtual void emitGet(CodeBuilder *builder) = 0;
 
    virtual void emitSubtractData(CodeBuilder *builder, int dataPos,
                                  const IR::MethodCallExpression *expr);
    virtual void emitSubtractData(CodeBuilder *builder, const ArgumentsList &arguments) = 0;
 
    virtual void emitGetInternalState(CodeBuilder *builder) = 0;
    virtual void emitSetInternalState(CodeBuilder *builder,
                                      const IR::MethodCallExpression *expr) = 0;
};
 
class CRCChecksumAlgorithm : public EBPFHashAlgorithmPSA {
 protected:
    cstring registerVar;
    cstring initialValue;
    cstring updateMethod;
    cstring finalizeMethod;
    cstring polynomial;
    const int crcWidth;
 
 public:
    CRCChecksumAlgorithm(const EBPFProgram *program, cstring name, int width)
        : EBPFHashAlgorithmPSA(program, name), crcWidth(width) {}
 
    unsigned getOutputWidth() const override { return crcWidth; }
 
    static void emitUpdateMethod(CodeBuilder *builder, int crcWidth);
 
    void emitVariables(CodeBuilder *builder, const IR::Declaration_Instance *decl) override;
 
    void emitClear(CodeBuilder *builder) override;
    void emitAddData(CodeBuilder *builder, const ArgumentsList &arguments) override;
    void emitGet(CodeBuilder *builder) override;
 
    void emitSubtractData(CodeBuilder *builder, const ArgumentsList &arguments) override;
 
    void emitGetInternalState(CodeBuilder *builder) override;
    void emitSetInternalState(CodeBuilder *builder, const IR::MethodCallExpression *expr) override;
};

class CRC16ChecksumAlgorithm : public CRCChecksumAlgorithm {
 public:
    CRC16ChecksumAlgorithm(const EBPFProgram *program, cstring name)
        : CRCChecksumAlgorithm(program, name, 16) {
        initialValue = "0"_cs;
        // We use a 0x8005 polynomial.
        // 0xA001 comes from 0x8005 value bits reflection.
        polynomial = "0xA001"_cs;
        updateMethod = "crc16_update"_cs;
        finalizeMethod = "crc16_finalize"_cs;
    }
 
    static void emitGlobals(CodeBuilder *builder);
};

class CRC32ChecksumAlgorithm : public CRCChecksumAlgorithm {
 public:
    CRC32ChecksumAlgorithm(const EBPFProgram *program, cstring name)
        : CRCChecksumAlgorithm(program, name, 32) {
        initialValue = "0xffffffff"_cs;
        // We use a 0x04C11DB7 polynomial.
        // 0xEDB88320 comes from 0x04C11DB7 value bits reflection.
        polynomial = "0xEDB88320"_cs;
        updateMethod = "crc32_update"_cs;
        finalizeMethod = "crc32_finalize"_cs;
    }
 
    static void emitGlobals(CodeBuilder *builder);
};
 
class InternetChecksumAlgorithm : public EBPFHashAlgorithmPSA {
 protected:
    cstring stateVar;
 
    void updateChecksum(CodeBuilder *builder, const ArgumentsList &arguments, bool addData);
 
 public:
    InternetChecksumAlgorithm(const EBPFProgram *program, cstring name)
        : EBPFHashAlgorithmPSA(program, name) {}
 
    unsigned getOutputWidth() const override { return 16; }
 
    static void emitGlobals(CodeBuilder *builder);
 
    void emitVariables(CodeBuilder *builder, const IR::Declaration_Instance *decl) override;
 
    void emitClear(CodeBuilder *builder) override;
    void emitAddData(CodeBuilder *builder, const ArgumentsList &arguments) override;
    void emitGet(CodeBuilder *builder) override;
 
    void emitSubtractData(CodeBuilder *builder, const ArgumentsList &arguments) override;
 
    void emitGetInternalState(CodeBuilder *builder) override;
    void emitSetInternalState(CodeBuilder *builder, const IR::MethodCallExpression *expr) override;
};
 
class EBPFHashAlgorithmTypeFactoryPSA {
 public:
    static EBPFHashAlgorithmTypeFactoryPSA *instance() {
        static EBPFHashAlgorithmTypeFactoryPSA factory;
        return &factory;
    }
 
    EBPFHashAlgorithmPSA *create(int type, const EBPFProgram *program, cstring name) {
        if (type == EBPFHashAlgorithmPSA::HashAlgorithm::CRC32)
            return new CRC32ChecksumAlgorithm(program, name);
        else if (type == EBPFHashAlgorithmPSA::HashAlgorithm::CRC16)
            return new CRC16ChecksumAlgorithm(program, name);
        else if (type == EBPFHashAlgorithmPSA::HashAlgorithm::ONES_COMPLEMENT16 ||
                 type == EBPFHashAlgorithmPSA::HashAlgorithm::TARGET_DEFAULT)
            return new InternetChecksumAlgorithm(program, name);
 
        return nullptr;
    }
 
    void emitGlobals(CodeBuilder *builder) {
        CRC16ChecksumAlgorithm::emitGlobals(builder);
        CRC32ChecksumAlgorithm::emitGlobals(builder);
        InternetChecksumAlgorithm::emitGlobals(builder);
    }
};
 
}  // namespace P4::EBPF
 
#endif /* BACKENDS_EBPF_PSA_EXTERNS_EBPFPSAHASHALGORITHM_H_ */