/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|*                                                                            *|
|* AttrDef Declarations                                                       *|
|*                                                                            *|
|* Automatically generated file, do not edit!                                 *|
|*                                                                            *|
\*===----------------------------------------------------------------------===*/

#ifdef GET_ATTRDEF_CLASSES
#undef GET_ATTRDEF_CLASSES


namespace mlir {
class AsmParser;
class AsmPrinter;
} // namespace mlir
namespace mlir::omp {

/// BindKind Clause
class ClauseBindKindAttr;
/// CancellationConstructType Clause
class ClauseCancellationConstructTypeAttr;
/// GrainsizeType Clause
class ClauseGrainsizeTypeAttr;
/// MemoryOrderKind Clause
class ClauseMemoryOrderKindAttr;
/// NumTasksType Clause
class ClauseNumTasksTypeAttr;
/// NumThreadsType Clause
class ClauseNumThreadsTypeAttr;
/// OrderKind Clause
class ClauseOrderKindAttr;
/// ProcBindKind Clause
class ClauseProcBindKindAttr;
/// ScheduleKind Clause
class ClauseScheduleKindAttr;
/// capture clause
class DeclareTargetCaptureClauseAttr;
/// depend clause
class ClauseDependAttr;
/// requires clauses
class ClauseRequiresAttr;
/// Map types and modifiers tied to data maps
class ClauseMapFlagsAttr;
/// depend clause in a target or task construct
class ClauseTaskDependAttr;
/// Type of a data-sharing clause
class DataSharingClauseTypeAttr;
/// device_type clause
class DeclareTargetDeviceTypeAttr;
/// OpenMP Order Modifier
class OrderModifierAttr;
/// linear modifier
class LinearModifierAttr;
/// reduction modifier
class ReductionModifierAttr;
/// OpenMP Schedule Modifier
class ScheduleModifierAttr;
/// target execution mode, mirroring the `OMPTgtExecModeFlags` LLVM enum
class TargetExecModeAttr;
/// variable capture kind
class VariableCaptureKindAttr;
/// access group modifier
class AccessGroupModifierAttr;
/// fallback modifier
class FallbackModifierAttr;
class AtomicControlAttr;
class DeclareTargetAttr;
class FlagsAttr;
class VersionAttr;
namespace detail {

struct ClauseBindKindAttrStorage;

} // namespace detail
class ClauseBindKindAttr : public ::mlir::Attribute::AttrBase<ClauseBindKindAttr, ::mlir::Attribute, detail::ClauseBindKindAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.bindkind";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseBindKindAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseBindKind value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"bindkind"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseBindKind getValue() const;
};
namespace detail {

struct ClauseCancellationConstructTypeAttrStorage;

} // namespace detail
class ClauseCancellationConstructTypeAttr : public ::mlir::Attribute::AttrBase<ClauseCancellationConstructTypeAttr, ::mlir::Attribute, detail::ClauseCancellationConstructTypeAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.cancellationconstructtype";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseCancellationConstructTypeAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseCancellationConstructType value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"cancellationconstructtype"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseCancellationConstructType getValue() const;
};
namespace detail {

struct ClauseGrainsizeTypeAttrStorage;

} // namespace detail
class ClauseGrainsizeTypeAttr : public ::mlir::Attribute::AttrBase<ClauseGrainsizeTypeAttr, ::mlir::Attribute, detail::ClauseGrainsizeTypeAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.grainsizetype";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseGrainsizeTypeAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseGrainsizeType value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"grainsizetype"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseGrainsizeType getValue() const;
};
namespace detail {

struct ClauseMemoryOrderKindAttrStorage;

} // namespace detail
class ClauseMemoryOrderKindAttr : public ::mlir::Attribute::AttrBase<ClauseMemoryOrderKindAttr, ::mlir::Attribute, detail::ClauseMemoryOrderKindAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.memoryorderkind";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseMemoryOrderKindAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseMemoryOrderKind value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"memoryorderkind"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseMemoryOrderKind getValue() const;
};
namespace detail {

struct ClauseNumTasksTypeAttrStorage;

} // namespace detail
class ClauseNumTasksTypeAttr : public ::mlir::Attribute::AttrBase<ClauseNumTasksTypeAttr, ::mlir::Attribute, detail::ClauseNumTasksTypeAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.numtaskstype";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseNumTasksTypeAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseNumTasksType value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"numtaskstype"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseNumTasksType getValue() const;
};
namespace detail {

struct ClauseNumThreadsTypeAttrStorage;

} // namespace detail
class ClauseNumThreadsTypeAttr : public ::mlir::Attribute::AttrBase<ClauseNumThreadsTypeAttr, ::mlir::Attribute, detail::ClauseNumThreadsTypeAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.numthreadstype";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseNumThreadsTypeAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseNumThreadsType value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"numthreadstype"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseNumThreadsType getValue() const;
};
namespace detail {

struct ClauseOrderKindAttrStorage;

} // namespace detail
class ClauseOrderKindAttr : public ::mlir::Attribute::AttrBase<ClauseOrderKindAttr, ::mlir::Attribute, detail::ClauseOrderKindAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.orderkind";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseOrderKindAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseOrderKind value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"orderkind"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseOrderKind getValue() const;
};
namespace detail {

struct ClauseProcBindKindAttrStorage;

} // namespace detail
class ClauseProcBindKindAttr : public ::mlir::Attribute::AttrBase<ClauseProcBindKindAttr, ::mlir::Attribute, detail::ClauseProcBindKindAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.procbindkind";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseProcBindKindAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseProcBindKind value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"procbindkind"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseProcBindKind getValue() const;
};
namespace detail {

struct ClauseScheduleKindAttrStorage;

} // namespace detail
class ClauseScheduleKindAttr : public ::mlir::Attribute::AttrBase<ClauseScheduleKindAttr, ::mlir::Attribute, detail::ClauseScheduleKindAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.schedulekind";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseScheduleKindAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseScheduleKind value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"schedulekind"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseScheduleKind getValue() const;
};
namespace detail {

struct DeclareTargetCaptureClauseAttrStorage;

} // namespace detail
class DeclareTargetCaptureClauseAttr : public ::mlir::Attribute::AttrBase<DeclareTargetCaptureClauseAttr, ::mlir::Attribute, detail::DeclareTargetCaptureClauseAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.capture_clause";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static DeclareTargetCaptureClauseAttr get(::mlir::MLIRContext *context, ::mlir::omp::DeclareTargetCaptureClause value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"capture_clause"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::DeclareTargetCaptureClause getValue() const;
};
namespace detail {

struct ClauseDependAttrStorage;

} // namespace detail
class ClauseDependAttr : public ::mlir::Attribute::AttrBase<ClauseDependAttr, ::mlir::Attribute, detail::ClauseDependAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.clause_depend";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseDependAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseDepend value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"clause_depend"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseDepend getValue() const;
};
namespace detail {

struct ClauseRequiresAttrStorage;

} // namespace detail
class ClauseRequiresAttr : public ::mlir::Attribute::AttrBase<ClauseRequiresAttr, ::mlir::Attribute, detail::ClauseRequiresAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.clause_requires";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseRequiresAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseRequires value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"clause_requires"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseRequires getValue() const;
};
namespace detail {

struct ClauseMapFlagsAttrStorage;

} // namespace detail
class ClauseMapFlagsAttr : public ::mlir::Attribute::AttrBase<ClauseMapFlagsAttr, ::mlir::Attribute, detail::ClauseMapFlagsAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.clause_map_flags";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseMapFlagsAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseMapFlags value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"clause_map_flags"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseMapFlags getValue() const;
};
namespace detail {

struct ClauseTaskDependAttrStorage;

} // namespace detail
class ClauseTaskDependAttr : public ::mlir::Attribute::AttrBase<ClauseTaskDependAttr, ::mlir::Attribute, detail::ClauseTaskDependAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.clause_task_depend";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ClauseTaskDependAttr get(::mlir::MLIRContext *context, ::mlir::omp::ClauseTaskDepend value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"clause_task_depend"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ClauseTaskDepend getValue() const;
};
namespace detail {

struct DataSharingClauseTypeAttrStorage;

} // namespace detail
class DataSharingClauseTypeAttr : public ::mlir::Attribute::AttrBase<DataSharingClauseTypeAttr, ::mlir::Attribute, detail::DataSharingClauseTypeAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.data_sharing_type";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static DataSharingClauseTypeAttr get(::mlir::MLIRContext *context, ::mlir::omp::DataSharingClauseType value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"data_sharing_type"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::DataSharingClauseType getValue() const;
};
namespace detail {

struct DeclareTargetDeviceTypeAttrStorage;

} // namespace detail
class DeclareTargetDeviceTypeAttr : public ::mlir::Attribute::AttrBase<DeclareTargetDeviceTypeAttr, ::mlir::Attribute, detail::DeclareTargetDeviceTypeAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.device_type";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static DeclareTargetDeviceTypeAttr get(::mlir::MLIRContext *context, ::mlir::omp::DeclareTargetDeviceType value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"device_type"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::DeclareTargetDeviceType getValue() const;
};
namespace detail {

struct OrderModifierAttrStorage;

} // namespace detail
class OrderModifierAttr : public ::mlir::Attribute::AttrBase<OrderModifierAttr, ::mlir::Attribute, detail::OrderModifierAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.order_mod";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static OrderModifierAttr get(::mlir::MLIRContext *context, ::mlir::omp::OrderModifier value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"order_mod"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::OrderModifier getValue() const;
};
namespace detail {

struct LinearModifierAttrStorage;

} // namespace detail
class LinearModifierAttr : public ::mlir::Attribute::AttrBase<LinearModifierAttr, ::mlir::Attribute, detail::LinearModifierAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.linear_modifier";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static LinearModifierAttr get(::mlir::MLIRContext *context, ::mlir::omp::LinearModifier value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"linear_modifier"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::LinearModifier getValue() const;
};
namespace detail {

struct ReductionModifierAttrStorage;

} // namespace detail
class ReductionModifierAttr : public ::mlir::Attribute::AttrBase<ReductionModifierAttr, ::mlir::Attribute, detail::ReductionModifierAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.reduction_modifier";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ReductionModifierAttr get(::mlir::MLIRContext *context, ::mlir::omp::ReductionModifier value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"reduction_modifier"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ReductionModifier getValue() const;
};
namespace detail {

struct ScheduleModifierAttrStorage;

} // namespace detail
class ScheduleModifierAttr : public ::mlir::Attribute::AttrBase<ScheduleModifierAttr, ::mlir::Attribute, detail::ScheduleModifierAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.sched_mod";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static ScheduleModifierAttr get(::mlir::MLIRContext *context, ::mlir::omp::ScheduleModifier value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"sched_mod"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::ScheduleModifier getValue() const;
};
namespace detail {

struct TargetExecModeAttrStorage;

} // namespace detail
class TargetExecModeAttr : public ::mlir::Attribute::AttrBase<TargetExecModeAttr, ::mlir::Attribute, detail::TargetExecModeAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.kernel_type";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static TargetExecModeAttr get(::mlir::MLIRContext *context, ::mlir::omp::TargetExecMode value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"kernel_type"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::TargetExecMode getValue() const;
};
namespace detail {

struct VariableCaptureKindAttrStorage;

} // namespace detail
class VariableCaptureKindAttr : public ::mlir::Attribute::AttrBase<VariableCaptureKindAttr, ::mlir::Attribute, detail::VariableCaptureKindAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.variable_capture_kind";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static VariableCaptureKindAttr get(::mlir::MLIRContext *context, ::mlir::omp::VariableCaptureKind value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"variable_capture_kind"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::VariableCaptureKind getValue() const;
};
namespace detail {

struct AccessGroupModifierAttrStorage;

} // namespace detail
class AccessGroupModifierAttr : public ::mlir::Attribute::AttrBase<AccessGroupModifierAttr, ::mlir::Attribute, detail::AccessGroupModifierAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.access_group_modifier";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static AccessGroupModifierAttr get(::mlir::MLIRContext *context, ::mlir::omp::AccessGroupModifier value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"access_group_modifier"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::AccessGroupModifier getValue() const;
};
namespace detail {

struct FallbackModifierAttrStorage;

} // namespace detail
class FallbackModifierAttr : public ::mlir::Attribute::AttrBase<FallbackModifierAttr, ::mlir::Attribute, detail::FallbackModifierAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.fallback_modifier";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static FallbackModifierAttr get(::mlir::MLIRContext *context, ::mlir::omp::FallbackModifier value);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"fallback_modifier"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  ::mlir::omp::FallbackModifier getValue() const;
};
namespace detail {

struct AtomicControlAttrStorage;

} // namespace detail
class AtomicControlAttr : public ::mlir::Attribute::AttrBase<AtomicControlAttr, ::mlir::Attribute, detail::AtomicControlAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.atomic_control";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static AtomicControlAttr get(::mlir::MLIRContext *context, bool ignore_denormal_mode, bool fine_grained_memory, bool remote_memory);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"atomic_control"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  bool getIgnoreDenormalMode() const;
  bool getFineGrainedMemory() const;
  bool getRemoteMemory() const;
};
namespace detail {

struct DeclareTargetAttrStorage;

} // namespace detail
class DeclareTargetAttr : public ::mlir::Attribute::AttrBase<DeclareTargetAttr, ::mlir::Attribute, detail::DeclareTargetAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.declaretarget";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static DeclareTargetAttr get(::mlir::MLIRContext *context, DeclareTargetDeviceTypeAttr device_type, DeclareTargetCaptureClauseAttr capture_clause, BoolAttr automap);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"declaretarget"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  DeclareTargetDeviceTypeAttr getDeviceType() const;
  DeclareTargetCaptureClauseAttr getCaptureClause() const;
  BoolAttr getAutomap() const;
};
namespace detail {

struct FlagsAttrStorage;

} // namespace detail
class FlagsAttr : public ::mlir::Attribute::AttrBase<FlagsAttr, ::mlir::Attribute, detail::FlagsAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.flags";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static FlagsAttr get(::mlir::MLIRContext *context, uint32_t debug_kind, bool assume_teams_oversubscription, bool assume_threads_oversubscription, bool assume_no_thread_state, bool assume_no_nested_parallelism, bool no_gpu_lib, uint32_t openmp_device_version);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"flags"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  uint32_t getDebugKind() const;
  bool getAssumeTeamsOversubscription() const;
  bool getAssumeThreadsOversubscription() const;
  bool getAssumeNoThreadState() const;
  bool getAssumeNoNestedParallelism() const;
  bool getNoGpuLib() const;
  uint32_t getOpenmpDeviceVersion() const;
};
namespace detail {

struct VersionAttrStorage;

} // namespace detail
class VersionAttr : public ::mlir::Attribute::AttrBase<VersionAttr, ::mlir::Attribute, detail::VersionAttrStorage> {
public:
  using Base::Base;
  static constexpr ::llvm::StringLiteral name = "omp.version";
  static constexpr ::llvm::StringLiteral dialectName = "omp";
  static VersionAttr get(::mlir::MLIRContext *context, uint32_t version);
  static constexpr ::llvm::StringLiteral getMnemonic() {
    return {"version"};
  }

  static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
  void print(::mlir::AsmPrinter &odsPrinter) const;
  uint32_t getVersion() const;
};

} // namespace mlir::omp
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseBindKindAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseCancellationConstructTypeAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseGrainsizeTypeAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseMemoryOrderKindAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseNumTasksTypeAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseNumThreadsTypeAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseOrderKindAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseProcBindKindAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseScheduleKindAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::DeclareTargetCaptureClauseAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseDependAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseRequiresAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseMapFlagsAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ClauseTaskDependAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::DataSharingClauseTypeAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::DeclareTargetDeviceTypeAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::OrderModifierAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::LinearModifierAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ReductionModifierAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::ScheduleModifierAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::TargetExecModeAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::VariableCaptureKindAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::AccessGroupModifierAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::FallbackModifierAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::AtomicControlAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::DeclareTargetAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::FlagsAttr)
MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::omp::VersionAttr)

#endif // GET_ATTRDEF_CLASSES

