ebpfTable.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_EBPF_EBPFTABLE_H_
#define BACKENDS_EBPF_EBPFTABLE_H_
 
#include "ebpfObject.h"
#include "ebpfProgram.h"
#include "frontends/p4/methodInstance.h"
 
namespace P4::EBPF {
 
class ActionTranslationVisitor : public virtual CodeGenInspector {
 protected:
    const EBPFProgram *program;
    const IR::P4Action *action;
    cstring valueName;
 
 public:
    ActionTranslationVisitor(cstring valueName, const EBPFProgram *program)
        : CodeGenInspector(program->refMap, program->typeMap),
          program(program),
          action(nullptr),
          valueName(valueName) {
        CHECK_NULL(program);
    }
 
    bool preorder(const IR::PathExpression *expression);
 
    bool preorder(const IR::P4Action *act);
    virtual cstring getParamInstanceName(const IR::Expression *expression) const;
    bool isActionParameter(const IR::PathExpression *expression) const;
};  // ActionTranslationVisitor

class EBPFTableBase : public EBPFObject {
 public:
    const EBPFProgram *program;
 
    cstring instanceName;
    cstring keyTypeName;
    cstring valueTypeName;
    cstring dataMapName;
    CodeGenInspector *codeGen;
 
 protected:
    EBPFTableBase(const EBPFProgram *program, cstring instanceName, CodeGenInspector *codeGen)
        : program(program), instanceName(instanceName), codeGen(codeGen) {
        CHECK_NULL(codeGen);
        CHECK_NULL(program);
        keyTypeName = instanceName + "_key";
        valueTypeName = instanceName + "_value";
        dataMapName = instanceName;
    }
 
    DECLARE_TYPEINFO(EBPFTableBase, EBPFObject);
};
 
class EBPFTable : public EBPFTableBase {
    const int prefixLenFieldWidth = 32;
 
    void initKey();
 
 public:
    bool isLPMTable() const;
    bool isTernaryTable() const;
 
 protected:
    void emitTernaryInstance(CodeBuilder *builder);
 
    virtual void validateKeys() const;
    virtual ActionTranslationVisitor *createActionTranslationVisitor(
        cstring valueName, const EBPFProgram *program) const {
        return new ActionTranslationVisitor(valueName, program);
    }
 
 public:
    const IR::Key *keyGenerator;
    const IR::ActionList *actionList;
    const IR::TableBlock *table;
    cstring defaultActionMapName;
    std::map<const IR::KeyElement *, cstring> keyFieldNames;
    std::map<const IR::KeyElement *, EBPFType *> keyTypes;
    size_t size = 1024;
    const cstring prefixFieldName = "prefixlen"_cs;
 
    EBPFTable(const EBPFProgram *program, const IR::TableBlock *table, CodeGenInspector *codeGen);
    EBPFTable(const EBPFProgram *program, CodeGenInspector *codeGen, cstring name);
 
    cstring p4ActionToActionIDName(const IR::P4Action *action) const;
    void emitActionArguments(CodeBuilder *builder, const IR::P4Action *action, cstring name);
    void emitKey(CodeBuilder *builder, cstring keyName);
 
    virtual void emitTypes(CodeBuilder *builder);
    virtual void emitInstance(CodeBuilder *builder);
    virtual void emitKeyType(CodeBuilder *builder);
    virtual void emitValueType(CodeBuilder *builder);
    virtual void emitValueActionIDNames(CodeBuilder *builder);
    virtual void emitValueStructStructure(CodeBuilder *builder);
    virtual void emitDirectValueTypes(CodeBuilder *builder) { (void)builder; }
    virtual void emitAction(CodeBuilder *builder, cstring valueName, cstring actionRunVariable);
    virtual void emitInitializer(CodeBuilder *builder);
    virtual void emitLookup(CodeBuilder *builder, cstring key, cstring value);
    virtual void emitLookupDefault(CodeBuilder *builder, cstring key, cstring value,
                                   cstring actionRunVariable) {
        (void)actionRunVariable;
        builder->target->emitTableLookup(builder, defaultActionMapName, key, value);
        builder->endOfStatement(true);
    }
    virtual bool isMatchTypeSupported(const IR::Declaration_ID *matchType) {
        return matchType->name.name == P4::P4CoreLibrary::instance().exactMatch.name ||
               matchType->name.name == P4::P4CoreLibrary::instance().ternaryMatch.name ||
               matchType->name.name == P4::P4CoreLibrary::instance().lpmMatch.name;
    }
    virtual bool dropOnNoMatchingEntryFound() const { return true; }
 
    virtual bool cacheEnabled() { return false; }
    virtual void emitCacheLookup(CodeBuilder *builder, cstring key, cstring value) {
        (void)builder;
        (void)key;
        (void)value;
    }
    virtual void emitCacheUpdate(CodeBuilder *builder, cstring key, cstring value) {
        (void)builder;
        (void)key;
        (void)value;
    }
 
    DECLARE_TYPEINFO(EBPFTable, EBPFTableBase);
};
 
class EBPFCounterTable : public EBPFTableBase {
 protected:
    size_t size;
    bool isHash;
 
 public:
    EBPFCounterTable(const EBPFProgram *program, const IR::ExternBlock *block, cstring name,
                     CodeGenInspector *codeGen);
    EBPFCounterTable(const EBPFProgram *program, cstring name, CodeGenInspector *codeGen,
                     size_t size, bool isHash)
        : EBPFTableBase(program, name, codeGen), size(size), isHash(isHash) {}
    virtual void emitTypes(CodeBuilder *);
    virtual void emitInstance(CodeBuilder *builder);
    virtual void emitCounterIncrement(CodeBuilder *builder,
                                      const IR::MethodCallExpression *expression);
    virtual void emitCounterAdd(CodeBuilder *builder, const IR::MethodCallExpression *expression);
    virtual void emitMethodInvocation(CodeBuilder *builder, const P4::ExternMethod *method);
 
    DECLARE_TYPEINFO(EBPFCounterTable, EBPFTableBase);
};
 
class EBPFValueSet : public EBPFTableBase {
 protected:
    size_t size;
    const IR::P4ValueSet *pvs;
    std::vector<std::pair<cstring, const IR::Type *>> fieldNames;
    cstring keyVarName;
 
 public:
    EBPFValueSet(const EBPFProgram *program, const IR::P4ValueSet *p4vs, cstring instanceName,
                 CodeGenInspector *codeGen);
 
    void emitTypes(CodeBuilder *builder);
    void emitInstance(CodeBuilder *builder);
    void emitKeyInitializer(CodeBuilder *builder, const IR::SelectExpression *expression,
                            cstring varName);
    void emitLookup(CodeBuilder *builder);
 
    DECLARE_TYPEINFO(EBPFValueSet, EBPFTableBase);
};
 
}  // namespace P4::EBPF
 
#endif /* BACKENDS_EBPF_EBPFTABLE_H_ */