parseAnnotations.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_PARSEANNOTATIONS_H_
#define FRONTENDS_P4_PARSEANNOTATIONS_H_
 
#include "frontends/p4/typeChecking/typeChecker.h"
#include "frontends/parsers/parserDriver.h"
#include "ir/ir.h"
 
/*
 * Parses known/predefined annotations used by the compiler.
 */
namespace P4 {
 
// A no-op handler. Useful for avoiding warnings about ignored annotations.
#define PARSE_SKIP(aname) {aname, &P4::ParseAnnotations::parseSkip}
 
// Parses an empty annotation.
#define PARSE_EMPTY(aname) {aname, &P4::ParseAnnotations::parseEmpty}
 
// Parses an annotation with a single-element body.
#define PARSE(aname, tname)                                                                    \
    {aname, [](IR::Annotation *annotation) {                                                   \
         const IR::tname *parsed =                                                             \
             P4::P4ParserDriver::parse##tname(annotation->srcInfo, annotation->getUnparsed()); \
         if (parsed != nullptr) {                                                              \
             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed);           \
         }                                                                                     \
         return parsed != nullptr;                                                             \
     }}
 
// Parses an annotation that is either an integer constant or a string literal.
#define PARSE_CONSTANT_OR_STRING_LITERAL(aname)                                           \
    {aname, [](IR::Annotation *annotation) {                                              \
         const IR::Expression *parsed = P4::P4ParserDriver::parseConstantOrStringLiteral( \
             annotation->srcInfo, annotation->getUnparsed());                             \
         if (parsed != nullptr) {                                                         \
             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed);      \
         }                                                                                \
         return parsed != nullptr;                                                        \
     }}
 
#define PARSE_CONSTANT(aname)                                                                   \
    {aname, [](IR::Annotation *annotation) {                                                    \
         const IR::Expression *parsed =                                                         \
             P4::P4ParserDriver::parseConstant(annotation->srcInfo, annotation->getUnparsed()); \
         if (parsed != nullptr) {                                                               \
             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed);            \
         }                                                                                      \
         return parsed != nullptr;                                                              \
     }}
 
#define PARSE_STRING_LITERAL(aname)                                                  \
    {aname, [](IR::Annotation *annotation) {                                         \
         const IR::Expression *parsed = P4::P4ParserDriver::parseStringLiteral(      \
             annotation->srcInfo, annotation->getUnparsed());                        \
         if (parsed != nullptr) {                                                    \
             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed); \
         }                                                                           \
         return parsed != nullptr;                                                   \
     }}
 
// Parses an annotation whose body is a pair.
#define PARSE_PAIR(aname, tname)                                                            \
    {aname, [](IR::Annotation *annotation) {                                                \
         const IR::Vector<IR::Expression> *parsed = P4::P4ParserDriver::parse##tname##Pair( \
             annotation->srcInfo, annotation->getUnparsed());                               \
         if (parsed != nullptr) {                                                           \
             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(*parsed);       \
         }                                                                                  \
         return parsed != nullptr;                                                          \
     }}
 
// Parses an annotation whose body is a triple.
#define PARSE_TRIPLE(aname, tname)                                                            \
    {aname, [](IR::Annotation *annotation) {                                                  \
         const IR::Vector<IR::Expression> *parsed = P4::P4ParserDriver::parse##tname##Triple( \
             annotation->srcInfo, annotation->getUnparsed());                                 \
         if (parsed != nullptr) {                                                             \
             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(*parsed);         \
         }                                                                                    \
         return parsed != nullptr;                                                            \
     }}
 
// Parses an annotation whose body is a list of expressions.
#define PARSE_EXPRESSION_LIST(aname) {aname, &P4::ParseAnnotations::parseExpressionList}
 
// Parses an annotation whose body is a list of key-value pairs.
#define PARSE_KV_LIST(aname) {aname, &P4::ParseAnnotations::parseKvList}
 
// Parses an annotation whose body is a list of integer constants.
#define PARSE_CONSTANT_LIST(aname) {aname, &P4::ParseAnnotations::parseConstantList}
 
// Parses an annotation whose body is a list, where each element is an integer constant or a string
// literal.
#define PARSE_CONSTANT_OR_STRING_LITERAL_LIST(aname) \
    {aname, &P4::ParseAnnotations::parseConstantOrStringLiteralList}
 
// Parses an annotation whose body is a list of string literals.
#define PARSE_STRING_LITERAL_LIST(aname) {aname, &P4::ParseAnnotations::parseStringLiteralList}
 
// Parses a P4Runtime translation which contains both types or expressions.
#define PARSE_P4RUNTIME_TRANSLATION(aname) \
    {aname, &P4::ParseAnnotations::parseP4rtTranslationAnnotation}
 
class ParseAnnotations : public Modifier {
 public:
    using Modifier::postorder;

    typedef std::function<bool(IR::Annotation *)> Handler;

    typedef std::unordered_map<cstring, Handler> HandlerMap;

    explicit ParseAnnotations(bool warn = false, bool errStruct = false)
        : warnUnknown(warn), errorRequireParse(errStruct), handlers(standardHandlers()) {
        setName("ParseAnnotations");
    }

    ParseAnnotations(const char *targetName, bool includeStandard, HandlerMap handlers,
                     bool warn = false, bool errStruct = false)
        : warnUnknown(warn), errorRequireParse(errStruct) {
        std::string buf = targetName;
        buf += "__ParseAnnotations";
        setName(buf.c_str());
 
        if (includeStandard) {
            this->handlers = standardHandlers();
            this->handlers.insert(handlers.begin(), handlers.end());
        } else {
            this->handlers = handlers;
        }
    }
 
    void postorder(IR::Annotation *annotation) final;
 
    static HandlerMap standardHandlers();
 
    static bool parseSkip(IR::Annotation *annotation);
    static bool parseEmpty(IR::Annotation *annotation);
    static bool parseExpressionList(IR::Annotation *annotation);
    static bool parseKvList(IR::Annotation *annotation);
    static bool parseConstantList(IR::Annotation *annotation);
    static bool parseConstantOrStringLiteralList(IR::Annotation *annotation);
    static bool parseStringLiteralList(IR::Annotation *annotation);
    // Parses a `@p4runtime_translation` annotation.
    static bool parseP4rtTranslationAnnotation(IR::Annotation *annotation);
 
    void addHandler(cstring name, Handler h) { handlers.insert({name, h}); }
 
 private:
    const bool warnUnknown;

    const bool errorRequireParse;

    std::set<cstring> warned;
 
    HandlerMap handlers;
};

class ParseAnnotationBodies final : public PassManager {
 public:
    ParseAnnotationBodies(ParseAnnotations *pa, TypeMap *typeMap) {
        passes.push_back(pa);
        passes.push_back(new ClearTypeMap(typeMap));
        setName("ParseAnnotationBodies");
    }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_PARSEANNOTATIONS_H_ */