methodInstance.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_METHODINSTANCE_H_
#define FRONTENDS_P4_METHODINSTANCE_H_
 
#include "frontends/common/resolveReferences/referenceMap.h"
#include "frontends/p4/parameterSubstitution.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
 
namespace P4 {
 
class InstanceBase : public ICastable {
 protected:
    virtual ~InstanceBase() {}
 
 public:
    ParameterSubstitution substitution;
    TypeVariableSubstitution typeSubstitution;
 
    DECLARE_TYPEINFO(InstanceBase);
};

class MethodInstance : public InstanceBase {
 protected:
    MethodInstance(const IR::MethodCallExpression *mce, const IR::IDeclaration *decl,
                   const IR::Type_MethodBase *originalMethodType,
                   const IR::Type_MethodBase *actualMethodType)
        : expr(mce),
          object(decl),
          originalMethodType(originalMethodType),
          actualMethodType(actualMethodType) {
        CHECK_NULL(mce);
        CHECK_NULL(originalMethodType);
        CHECK_NULL(actualMethodType);
    }
 
    void bindParameters() {
        auto params = getActualParameters();
        substitution.populate(params, expr->arguments);
    }
 
 public:
    const IR::MethodCallExpression *expr;
    const IR::IDeclaration *object;
    const IR::Type_MethodBase *originalMethodType;
    const IR::Type_MethodBase *actualMethodType;
    virtual bool isApply() const { return false; }

    static MethodInstance *resolve(const IR::MethodCallExpression *mce,
                                   const DeclarationLookup *refMap, TypeMap *typeMap,
                                   bool useExpressionType = false,
                                   const Visitor::Context *ctxt = nullptr, bool incomplete = false);
    static MethodInstance *resolve(const IR::MethodCallExpression *mce,
                                   const DeclarationLookup *refMap, TypeMap *typeMap,
                                   const Visitor::Context *ctxt, bool incomplete = false) {
        return resolve(mce, refMap, typeMap, false, ctxt, incomplete);
    }
    static MethodInstance *resolve(const IR::MethodCallStatement *mcs,
                                   const DeclarationLookup *refMap, TypeMap *typeMap,
                                   const Visitor::Context *ctxt = nullptr) {
        return resolve(mcs->methodCall, refMap, typeMap, false, ctxt, false);
    }
    static MethodInstance *resolve(const IR::MethodCallExpression *mce,
                                   const DeclarationLookup *refMap,
                                   const Visitor::Context *ctxt = nullptr) {
        return resolve(mce, refMap, nullptr, true, ctxt, false);
    }
    static MethodInstance *resolve(const IR::MethodCallStatement *mcs,
                                   const DeclarationLookup *refMap,
                                   const Visitor::Context *ctxt = nullptr) {
        return resolve(mcs->methodCall, refMap, nullptr, true, ctxt, false);
    }
 
    const IR::ParameterList *getOriginalParameters() const {
        return originalMethodType->parameters;
    }
    const IR::ParameterList *getActualParameters() const { return actualMethodType->parameters; }
 
    DECLARE_TYPEINFO(MethodInstance, InstanceBase);
};

class ApplyMethod final : public MethodInstance {
    ApplyMethod(const IR::MethodCallExpression *expr, const IR::IDeclaration *decl,
                const IR::IApply *applyObject)
        : MethodInstance(expr, decl, applyObject->getApplyMethodType(),
                         applyObject->getApplyMethodType()),
          applyObject(applyObject) {
        CHECK_NULL(applyObject);
        bindParameters();
    }
    friend class MethodInstance;
 
 public:
    const IR::IApply *applyObject;
    bool isApply() const override { return true; }
    bool isTableApply() const { return object->is<IR::P4Table>(); }
 
    DECLARE_TYPEINFO(ApplyMethod, MethodInstance);
};

class ExternCall : public MethodInstance {
 protected:
    ExternCall(const IR::MethodCallExpression *expr, const IR::IDeclaration *decl,
               const IR::Method *method, const IR::Type_Method *originalMethodType,
               const IR::Type_Method *actualMethodType, bool incomplete)
        : MethodInstance(expr, decl, originalMethodType, actualMethodType), method(method) {
        CHECK_NULL(method);
        bindParameters();
        if (!incomplete)
            typeSubstitution.setBindings(expr, method->type->typeParameters, expr->typeArguments);
    }
 
 public:
    const IR::Method *method;
 
    DECLARE_TYPEINFO(ExternCall, MethodInstance);
};

class ExternMethod final : public ExternCall {
    ExternMethod(const IR::MethodCallExpression *expr, const IR::IDeclaration *decl,
                 const IR::Method *method, const IR::Type_Extern *originalExternType,
                 const IR::Type_Method *originalMethodType, const IR::Type_Extern *actualExternType,
                 const IR::Type_Method *actualMethodType, bool incomplete)
        : ExternCall(expr, decl, method, originalMethodType, actualMethodType, incomplete),
          originalExternType(originalExternType),
          actualExternType(actualExternType) {
        CHECK_NULL(originalExternType);
        CHECK_NULL(actualExternType);
    }
    friend class MethodInstance;
 
 public:
    const IR::Type_Extern *originalExternType;  // type of object method is applied to
    const IR::Type_Extern *actualExternType;    // with type variables substituted

    // If this method is abstract, will consist of (just) the concrete implementation,
    // otherwise will consist of those methods that are @synchronous with this
    std::vector<const IR::IDeclaration *> mayCall() const;
 
    DECLARE_TYPEINFO(ExternMethod, ExternCall);
};

class ExternFunction final : public ExternCall {
    ExternFunction(const IR::MethodCallExpression *expr, const IR::Method *method,
                   const IR::Type_Method *originalMethodType,
                   const IR::Type_Method *actualMethodType, bool incomplete)
        : ExternCall(expr, nullptr, method, originalMethodType, actualMethodType, incomplete) {}
    friend class MethodInstance;
 
 public:
    DECLARE_TYPEINFO(ExternFunction, ExternCall);
};

class ActionCall final : public MethodInstance {
    ActionCall(const IR::MethodCallExpression *expr, const IR::P4Action *action,
               const IR::Type_Action *actionType)
        :  // Actions are never generic
          MethodInstance(expr, nullptr, actionType, actionType),
          action(action) {
        CHECK_NULL(action);
        bindParameters();
    }
    friend class MethodInstance;
 
 public:
    const IR::P4Action *action;
    const IR::P4Action *specialize(const DeclarationLookup *refMap) const;
 
    DECLARE_TYPEINFO(ActionCall, MethodInstance);
};

class FunctionCall final : public MethodInstance {
    FunctionCall(const IR::MethodCallExpression *expr, const IR::Function *function,
                 const IR::Type_Method *originalMethodType, const IR::Type_Method *actualMethodType,
                 bool incomplete)
        : MethodInstance(expr, nullptr, originalMethodType, actualMethodType), function(function) {
        CHECK_NULL(function);
        bindParameters();
        if (!incomplete)
            typeSubstitution.setBindings(function, function->type->typeParameters,
                                         expr->typeArguments);
    }
    friend class MethodInstance;
 
 public:
    const IR::Function *function;
 
    DECLARE_TYPEINFO(FunctionCall, MethodInstance);
};

class BuiltInMethod final : public MethodInstance {
    friend class MethodInstance;
    BuiltInMethod(const IR::MethodCallExpression *expr, IR::ID name,
                  const IR::Expression *appliedTo, const IR::Type_Method *methodType)
        : MethodInstance(expr, nullptr, methodType, methodType), name(name), appliedTo(appliedTo) {
        CHECK_NULL(appliedTo);
        bindParameters();
    }
 
 public:
    const IR::ID name;
    const IR::Expression *appliedTo;  // object is an expression
 
    DECLARE_TYPEINFO(BuiltInMethod, MethodInstance);
};


class ConstructorCall : public InstanceBase {
 protected:
    virtual ~ConstructorCall() {}
    explicit ConstructorCall(const IR::ConstructorCallExpression *cce) : cce(cce) {
        CHECK_NULL(cce);
    }
 
 public:
    const IR::ConstructorCallExpression *cce = nullptr;
    const IR::Vector<IR::Type> *typeArguments = nullptr;
    const IR::ParameterList *constructorParameters = nullptr;
    static ConstructorCall *resolve(const IR::ConstructorCallExpression *cce,
                                    const DeclarationLookup *refMap, TypeMap *typeMap);
    DECLARE_TYPEINFO(ConstructorCall, InstanceBase);
};

class ExternConstructorCall : public ConstructorCall {
    explicit ExternConstructorCall(const IR::ConstructorCallExpression *cce,
                                   const IR::Type_Extern *type, const IR::Method *constructor)
        : ConstructorCall(cce), type(type), constructor(constructor) {
        CHECK_NULL(type);
        CHECK_NULL(constructor);
    }
    friend class ConstructorCall;
 
 public:
    const IR::Type_Extern *type;    // actual extern declaration in program IR
    const IR::Method *constructor;  // that is being invoked
 
    DECLARE_TYPEINFO(ExternConstructorCall, ConstructorCall);
};

class ContainerConstructorCall : public ConstructorCall {
    explicit ContainerConstructorCall(const IR::ConstructorCallExpression *cce,
                                      const IR::IContainer *cont)
        : ConstructorCall(cce), container(cont) {
        CHECK_NULL(cont);
    }
    friend class ConstructorCall;
 
 public:
    const IR::IContainer *container;  // actual container in program IR
 
    DECLARE_TYPEINFO(ContainerConstructorCall, ConstructorCall);
};


class Instantiation : public InstanceBase {
 protected:
    void substitute() {
        substitution.populate(constructorParameters, constructorArguments);
        typeSubstitution.setBindings(instance, typeParameters, typeArguments);
    }
 
 public:
    Instantiation(const IR::Declaration_Instance *instance,
                  const IR::Vector<IR::Type> *typeArguments)
        : instance(instance), typeArguments(typeArguments) {
        CHECK_NULL(instance);
        constructorArguments = instance->arguments;
    }
 
    const IR::Declaration_Instance *instance;
    const IR::Vector<IR::Type> *typeArguments;
    const IR::Vector<IR::Argument> *constructorArguments;
    const IR::ParameterList *constructorParameters = nullptr;
    const IR::TypeParameters *typeParameters = nullptr;
 
    static Instantiation *resolve(const IR::Declaration_Instance *instance,
                                  DeclarationLookup *refMap, TypeMap *typeMap);
 
    DECLARE_TYPEINFO(Instantiation, InstanceBase);
};
 
class ExternInstantiation : public Instantiation {
 public:
    ExternInstantiation(const IR::Declaration_Instance *instance,
                        const IR::Vector<IR::Type> *typeArguments, const IR::Type_Extern *type)
        : Instantiation(instance, typeArguments), type(type) {
        auto constructor = type->lookupConstructor(constructorArguments);
        BUG_CHECK(constructor, "%1%: could not find constructor", type);
        constructorParameters = constructor->type->parameters;
        typeParameters = type->typeParameters;
        substitute();
    }
    const IR::Type_Extern *type;
 
    DECLARE_TYPEINFO(ExternInstantiation, Instantiation);
};
 
class PackageInstantiation : public Instantiation {
 public:
    PackageInstantiation(const IR::Declaration_Instance *instance,
                         const IR::Vector<IR::Type> *typeArguments, const IR::Type_Package *package)
        : Instantiation(instance, typeArguments), package(package) {
        constructorParameters = package->getConstructorParameters();
        typeParameters = package->typeParameters;
        substitute();
    }
    const IR::Type_Package *package;
 
    DECLARE_TYPEINFO(PackageInstantiation, Instantiation);
};
 
class ParserInstantiation : public Instantiation {
 public:
    ParserInstantiation(const IR::Declaration_Instance *instance,
                        const IR::Vector<IR::Type> *typeArguments, const IR::P4Parser *parser)
        : Instantiation(instance, typeArguments), parser(parser) {
        typeParameters = parser->type->typeParameters;
        constructorParameters = parser->getConstructorParameters();
        substitute();
    }
    const IR::P4Parser *parser;
 
    DECLARE_TYPEINFO(ParserInstantiation, Instantiation);
};
 
class ControlInstantiation : public Instantiation {
 public:
    ControlInstantiation(const IR::Declaration_Instance *instance,
                         const IR::Vector<IR::Type> *typeArguments, const IR::P4Control *control)
        : Instantiation(instance, typeArguments), control(control) {
        typeParameters = control->type->typeParameters;
        constructorParameters = control->getConstructorParameters();
        substitute();
    }
    const IR::P4Control *control;
 
    DECLARE_TYPEINFO(ControlInstantiation, Instantiation);
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_METHODINSTANCE_H_ */