introspection.h

/*
 * Copyright (C) 2023 Intel Corporation
 * SPDX-FileCopyrightText: 2023 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_TC_INTROSPECTION_H_
#define BACKENDS_TC_INTROSPECTION_H_
 
#include "frontends/p4/parseAnnotations.h"
#include "frontends/p4/parserCallGraph.h"
#include "ir/ir.h"
#include "lib/json.h"
#include "lib/nullstream.h"
#include "options.h"
#include "tcAnnotations.h"

namespace P4::TC {
 
using namespace P4::literals;
 
struct IntrospectionInfo {
    cstring schemaVersion;
    cstring pipelineName;
    IntrospectionInfo() {
        schemaVersion = nullptr;
        pipelineName = nullptr;
    }
    void initIntrospectionInfo(IR::TCPipeline *tcPipeline) {
        schemaVersion = "1.0.0"_cs;
        pipelineName = tcPipeline->pipelineName;
    }
};
 
struct KeyFieldAttributes {
    unsigned int id;
    cstring name;
    cstring type;
    cstring matchType;
    cstring attribute;
    unsigned int bitwidth;
    KeyFieldAttributes() {
        id = 0;
        name = nullptr;
        type = nullptr;
        matchType = nullptr;
        attribute = nullptr;
        bitwidth = 0;
    }
};
 
struct Annotation {
    cstring name;
    Annotation() { name = nullptr; }
    explicit Annotation(cstring n) { name = n; }
};
 
struct ActionParam {
    unsigned int id;
    cstring name;
    unsigned int dataType;
    unsigned int bitwidth;
    ActionParam() {
        id = 0;
        name = nullptr;
        bitwidth = 0;
    }
};
 
enum ActionScope { TableOnly, DefaultOnly, TableAndDefault };
 
struct ActionAttributes {
    unsigned int id;
    cstring name;
    ActionScope scope;
    bool defaultHit;
    bool defaultMiss;
    safe_vector<struct Annotation *> annotations;
    safe_vector<struct ActionParam *> actionParams;
    ActionAttributes() {
        id = 0;
        name = nullptr;
        scope = TableAndDefault;
        defaultHit = false;
        defaultMiss = false;
    }
};
 
struct TableAttributes {
    cstring name;
    cstring permissions;
    unsigned int id;
    unsigned int tentries;
    unsigned int numMask;
    unsigned int keysize;
    unsigned int keyid;
    safe_vector<struct KeyFieldAttributes *> keyFields;
    safe_vector<struct ActionAttributes *> actions;
    TableAttributes() {
        name = nullptr;
        permissions = nullptr;
        id = 0;
        tentries = 0;
        numMask = 0;
        keysize = 0;
        keyid = 0;
    }
};
 
struct ExternInstancesAttributes {
    unsigned int id;
    cstring name;
    cstring type;
    safe_vector<struct KeyFieldAttributes *> keyFields;
    ExternInstancesAttributes() {
        id = 0;
        name = nullptr;
        type = nullptr;
    }
};
 
struct ExternAttributes {
    cstring name;
    cstring permissions;
    cstring id;
    safe_vector<struct ExternInstancesAttributes *> instances;
    ExternAttributes() {
        name = nullptr;
        permissions = nullptr;
        id = 0;
    }
};

class IntrospectionGenerator : public Inspector {
    IR::TCPipeline *tcPipeline;
    P4::ReferenceMap *refMap;
    P4::TypeMap *typeMap;
    safe_vector<struct ExternAttributes *> externsInfo;
    safe_vector<struct TableAttributes *> tablesInfo;
    ordered_map<cstring, const IR::P4Table *> p4tables;
 
 public:
    IntrospectionGenerator(IR::TCPipeline *tcPipeline, P4::ReferenceMap *refMap,
                           P4::TypeMap *typeMap)
        : tcPipeline(tcPipeline), refMap(refMap), typeMap(typeMap) {}
    void postorder(const IR::P4Table *t);
    const Util::JsonObject *genIntrospectionJson();
    void genExternJson(Util::JsonArray *externJson);
    Util::JsonObject *genExternInfo(struct ExternAttributes *extn);
    void genTableJson(Util::JsonArray *tablesJson);
    Util::JsonObject *genTableInfo(struct TableAttributes *tbl);
    void collectTableInfo();
    void collectExternInfo();
    void collectKeyInfo(const IR::Key *k, struct TableAttributes *tableinfo);
    void collectActionInfo(const IR::ActionList *actionlist, struct TableAttributes *tableinfo,
                           const IR::P4Table *p4table, const IR::TCTable *table);
    Util::JsonObject *genActionInfo(struct ActionAttributes *action);
    Util::JsonObject *genKeyInfo(struct KeyFieldAttributes *keyField);
    bool serializeIntrospectionJson(std::ostream &destination);
    std::optional<cstring> checkValidTcType(const IR::StringLiteral *sl);
    cstring externalName(const IR::IDeclaration *declaration);
};
 
}  // namespace P4::TC
 
#endif /* BACKENDS_TC_INTROSPECTION_H_ */