OpInterfaces.h.inc

Go to the documentation of this file.

/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* Interface Declarations                                                     *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/
 
namespace llzk {
namespace verif {
class ConditionOpInterface;
namespace detail {
struct ConditionOpInterfaceInterfaceTraits {
  struct Concept {
    ::mlir::TypedValue<::mlir::IntegerType> (*getCondition)(const Concept *impl, ::mlir::Operation *);
    const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
 
    void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
      implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
      assert(implMemoryEffectOpInterface && "`::llzk::verif::ConditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
    }
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::verif::ConditionOpInterface;
    Model() : Concept{getCondition} {}
 
    static inline ::mlir::TypedValue<::mlir::IntegerType> getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteOp>
  class FallbackModel : public Concept {
  public:
    using Interface = ::llzk::verif::ConditionOpInterface;
    FallbackModel() : Concept{getCondition} {}
 
    static inline ::mlir::TypedValue<::mlir::IntegerType> getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val);
  };
  template<typename ConcreteModel, typename ConcreteOp>
  class ExternalModel : public FallbackModel<ConcreteModel> {
  public:
    using ConcreteEntity = ConcreteOp;
  };
};
template <typename ConcreteOp>
struct ConditionOpInterfaceTrait;
 
} // namespace detail
class ConditionOpInterface : public ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::ConditionOpInterfaceTrait<ConcreteOp> {};
  ::mlir::TypedValue<::mlir::IntegerType> getCondition();
  //===----------------------------------------------------------------===//
  // Inherited from ::mlir::MemoryEffectOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::mlir::MemoryEffectOpInterface () const {
    if (!*this) return nullptr;
    return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
  }

  void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
};
namespace detail {
  template <typename ConcreteOp>
  struct ConditionOpInterfaceTrait : public ::mlir::OpInterface<ConditionOpInterface, detail::ConditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
  };
}// namespace detail
} // namespace verif
} // namespace llzk
namespace llzk {
namespace verif {
class PreconditionOpInterface;
namespace detail {
struct PreconditionOpInterfaceInterfaceTraits {
  struct Concept {
    const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
    const ::llzk::verif::ConditionOpInterface::Concept *implConditionOpInterface = nullptr;
 
    void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
      implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
      assert(implMemoryEffectOpInterface && "`::llzk::verif::PreconditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
      implConditionOpInterface = interfaceMap.lookup<::llzk::verif::ConditionOpInterface>();
      assert(implConditionOpInterface && "`::llzk::verif::PreconditionOpInterface` expected its base interface `::llzk::verif::ConditionOpInterface` to be registered");
    }
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::verif::PreconditionOpInterface;
    Model() : Concept{} {}
 
  };
  template<typename ConcreteOp>
  class FallbackModel : public Concept {
  public:
    using Interface = ::llzk::verif::PreconditionOpInterface;
    FallbackModel() : Concept{} {}
 
  };
  template<typename ConcreteModel, typename ConcreteOp>
  class ExternalModel : public FallbackModel<ConcreteModel> {
  public:
    using ConcreteEntity = ConcreteOp;
  };
};
template <typename ConcreteOp>
struct PreconditionOpInterfaceTrait;
 
} // namespace detail
class PreconditionOpInterface : public ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::PreconditionOpInterfaceTrait<ConcreteOp> {};
  //===----------------------------------------------------------------===//
  // Inherited from ::mlir::MemoryEffectOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::mlir::MemoryEffectOpInterface () const {
    if (!*this) return nullptr;
    return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
  }

  void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
  //===----------------------------------------------------------------===//
  // Inherited from ::llzk::verif::ConditionOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::llzk::verif::ConditionOpInterface () const {
    if (!*this) return nullptr;
    return ::llzk::verif::ConditionOpInterface(*this, getImpl()->implConditionOpInterface);
  }

  ::mlir::TypedValue<::mlir::IntegerType> getCondition();
};
namespace detail {
  template <typename ConcreteOp>
  struct PreconditionOpInterfaceTrait : public ::mlir::OpInterface<PreconditionOpInterface, detail::PreconditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
  };
}// namespace detail
} // namespace verif
} // namespace llzk
namespace llzk {
namespace verif {
class PostconditionOpInterface;
namespace detail {
struct PostconditionOpInterfaceInterfaceTraits {
  struct Concept {
    const ::mlir::MemoryEffectOpInterface::Concept *implMemoryEffectOpInterface = nullptr;
    const ::llzk::verif::ConditionOpInterface::Concept *implConditionOpInterface = nullptr;
 
    void initializeInterfaceConcept(::mlir::detail::InterfaceMap &interfaceMap) {
      implMemoryEffectOpInterface = interfaceMap.lookup<::mlir::MemoryEffectOpInterface>();
      assert(implMemoryEffectOpInterface && "`::llzk::verif::PostconditionOpInterface` expected its base interface `::mlir::MemoryEffectOpInterface` to be registered");
      implConditionOpInterface = interfaceMap.lookup<::llzk::verif::ConditionOpInterface>();
      assert(implConditionOpInterface && "`::llzk::verif::PostconditionOpInterface` expected its base interface `::llzk::verif::ConditionOpInterface` to be registered");
    }
  };
  template<typename ConcreteOp>
  class Model : public Concept {
  public:
    using Interface = ::llzk::verif::PostconditionOpInterface;
    Model() : Concept{} {}
 
  };
  template<typename ConcreteOp>
  class FallbackModel : public Concept {
  public:
    using Interface = ::llzk::verif::PostconditionOpInterface;
    FallbackModel() : Concept{} {}
 
  };
  template<typename ConcreteModel, typename ConcreteOp>
  class ExternalModel : public FallbackModel<ConcreteModel> {
  public:
    using ConcreteEntity = ConcreteOp;
  };
};
template <typename ConcreteOp>
struct PostconditionOpInterfaceTrait;
 
} // namespace detail
class PostconditionOpInterface : public ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits> {
public:
  using ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits>::OpInterface;
  template <typename ConcreteOp>
  struct Trait : public detail::PostconditionOpInterfaceTrait<ConcreteOp> {};
  //===----------------------------------------------------------------===//
  // Inherited from ::mlir::MemoryEffectOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::mlir::MemoryEffectOpInterface () const {
    if (!*this) return nullptr;
    return ::mlir::MemoryEffectOpInterface(*this, getImpl()->implMemoryEffectOpInterface);
  }

  void getEffects(::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<::mlir::MemoryEffects::Effect>> & effects);
  //===----------------------------------------------------------------===//
  // Inherited from ::llzk::verif::ConditionOpInterface
  //===----------------------------------------------------------------===//
 
  operator ::llzk::verif::ConditionOpInterface () const {
    if (!*this) return nullptr;
    return ::llzk::verif::ConditionOpInterface(*this, getImpl()->implConditionOpInterface);
  }

  ::mlir::TypedValue<::mlir::IntegerType> getCondition();
};
namespace detail {
  template <typename ConcreteOp>
  struct PostconditionOpInterfaceTrait : public ::mlir::OpInterface<PostconditionOpInterface, detail::PostconditionOpInterfaceInterfaceTraits>::Trait<ConcreteOp> {
  };
}// namespace detail
} // namespace verif
} // namespace llzk
namespace llzk {
namespace verif {
template<typename ConcreteOp>
::mlir::TypedValue<::mlir::IntegerType> detail::ConditionOpInterfaceInterfaceTraits::Model<ConcreteOp>::getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return (llvm::cast<ConcreteOp>(tablegen_opaque_val)).getCondition();
}
template<typename ConcreteOp>
::mlir::TypedValue<::mlir::IntegerType> detail::ConditionOpInterfaceInterfaceTraits::FallbackModel<ConcreteOp>::getCondition(const Concept *impl, ::mlir::Operation *tablegen_opaque_val) {
  return static_cast<const ConcreteOp *>(impl)->getCondition(tablegen_opaque_val);
}
} // namespace verif
} // namespace llzk
namespace llzk {
namespace verif {
} // namespace verif
} // namespace llzk
namespace llzk {
namespace verif {
} // namespace verif
} // namespace llzk