[Flang][OpenMP][MLIR] Add declare target attribute set and interface for the OpenMP dialect

[agozillon]

Summary

This attribute represents the OpenMP declare target directive, it marks a function
or global as declare target by being present but also contains information on
the device_type and capture clause (link or to). It being an attribute allows it to
mark existing constructs and be converted trivially on lowering from the OpenMP
dialect to MLIR using amendOperation.

An interface has been made for the declare target attribute, with several helper
methods for managing the attribute, this interface can be applied to MLIR
operations that are allowed to be marked as declare target (as an example, it
is by default applied to func.func, LLVMFunc, fir.GlobalOps and LLVMGlobalOps).

[agozillon]

This is the attribute and interface segment, split off from the larger declare target patch here: https://reviews.llvm.org/D146063 This segment has underwent no additions or changes during the split.

[agozillon]

I believe this patch can go in without the semantic analysis pass patch, as can the lowering that utilises the attribute, so if it would be possible to get a review on this it would be appreciated.

[kiranchandramohan]

Thanks @agozillon for splitting up the patch.

Should specifying a function as a declare target have any impact on whether the function can be inlined or specialized?

[agozillon]

In D150328#4342519, @kiranchandramohan wrote:

Thanks @agozillon for splitting up the patch.

Should specifying a function as a declare target have any impact on whether the function can be inlined or specialized?

No problem at all, I'm sorry I let the original grow so large.

Unfortunately we're not really at the stage of testing this sort of interaction (and it's not something I've invested a lot of thought into just yet), however, I think inlining should be fine to do to declare target functions, as the call locations should be occurring in functions or target regions that are being lowered to the appropriate device, so the inlined function should be getting embedded into the appropriate device function. Using the current declare target function interface it might be possible to inhibit inlining from the inliner pass if it does prove to be a problem though, although, I've not tried something like this yet, so it is speculation with my limited MLIR knowledge. I think function specialisation would also fall under a similar umbrella.

Although, someone more knowledgeable may be able to state otherwise (as I can only claim a very basic understanding of these passes), so if anyone can foresee any problems please do bring them up!

[kiranchandramohan]

In D150328#4342656, @agozillon wrote:

In D150328#4342519, @kiranchandramohan wrote:

Thanks @agozillon for splitting up the patch.

I think inlining should be fine to do to declare target functions, as the call locations should be occurring in functions or target regions that are being lowered to the appropriate device, so the inlined function should be getting embedded into the appropriate device function.

OK

Would you know whether the link clause will be handled in the OpenMPIRBuilder or would it require the frontend to move the link clause info to target map/target data?

flang/include/flang/Optimizer/Dialect/FIRDialect.h

52

registerOpExternalInterfaces?

mlir/include/mlir/Dialect/OpenMP/OpenMPDialect.h

24–27

Is this really required?

mlir/include/mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td

91

104

[agozillon]

In D150328#4351011, @kiranchandramohan wrote:

In D150328#4342656, @agozillon wrote:

In D150328#4342519, @kiranchandramohan wrote:

Thanks @agozillon for splitting up the patch.

I think inlining should be fine to do to declare target functions, as the call locations should be occurring in functions or target regions that are being lowered to the appropriate device, so the inlined function should be getting embedded into the appropriate device function.

OK

Would you know whether the link clause will be handled in the OpenMPIRBuilder or would it require the frontend to move the link clause info to target map/target data?

Some of this will at least be handled by the OpenMPIRBuilder during the lowering of declare target's link, I am unfortunately unfamiliar with map/target data and their interactions with link, although it is something I will likely have to look into soon (perhaps after the semantic analysis component of the declare target work has been updated, or soon after). However, at least some of the link case is handled in another two patches (more actually a lot of the IR builder work i've done is purely to support data related declare target cases) I have created:

https://reviews.llvm.org/D149162
https://reviews.llvm.org/D149368

This is an attempt to mimic what Clang generates for the link/to clauses when data is passed to them, creating the relevant metadata and global pointers/references for host and device. However, I am aware that the OpenMP specification mentions that map handles some or all of the data management for declare target link, so I think what these patches do is only part of the work required for supporting the link clause (in part why I call the patch initial).

Thank you very much for the review Kiran, I will apply your comments and try to upstream this on Monday after I'm back from a long weekend break.

flang/include/flang/Optimizer/Dialect/FIRDialect.h

52

Definitely a better name! I'll make the alteration before submission.

mlir/include/mlir/Dialect/OpenMP/OpenMPDialect.h

24–27

I can double check before I commit upstream, but as I recall a forward declaration is necessary for these, but it's been a little bit so I can't remember the exact reason why and perhaps moving to the interface method allows me to avoid it (as i was using these when it was dialect functions)! So i'll give removing these a try when I'm back from vacation on Monday

[agozillon]

I've reverted this till I find a fix for some buildbots it's breaking the compilation for, once I find the fix, I'll re-push and confirm it's all in working order here!

[agozillon]

Re-committed now with a fix to the mlir/lib/Dialect/OpenMP/CMakeLists.txt to add MLIRFuncDialect to the link list, to support the usage of adding the declare target interface to the FuncOp. Will keep track of the buildbots to make sure it's fixed!

flang/include/flang/Optimizer/Dialect/FIRDialect.h

static constexpr llvm::StringRef getFirRuntimeAttrName() {
     return "fir.runtime";
   }
 
 private:
   // Register the Attributes of this dialect.
   void registerAttributes();
   // Register the Types of this dialect.
   void registerTypes();
+  // Register external interfaces on operations of
+  // this dialect.
+  void registerOpInterfaces();
 };
 
 /// The FIR codegen dialect is a dialect containing a small set of transient
 /// operations used exclusively during code generation.
 class FIRCodeGenDialect final : public mlir::Dialect {
 public:
   explicit FIRCodeGenDialect(mlir::MLIRContext *ctx);
   virtual ~FIRCodeGenDialect();

flang/lib/Optimizer/Dialect/FIRDialect.cpp

 fir::FIROpsDialect::FIROpsDialect(mlir::MLIRContext *ctx)
     : mlir::Dialect("fir", ctx, mlir::TypeID::get<FIROpsDialect>()) {
   registerTypes();
   registerAttributes();
   addOperations<
 #define GET_OP_LIST
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"
       >();
+  registerOpInterfaces();
   addInterfaces<FIRInlinerInterface>();
 }
 
 // anchor the class vtable to this compilation unit
 fir::FIROpsDialect::~FIROpsDialect() {
   // do nothing
 }
 

flang/lib/Optimizer/Dialect/FIROps.cpp

 //===-- FIROps.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Dialect/FIROps.h"
 #include "flang/Optimizer/Dialect/FIRAttr.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/Utils.h"
 #include "mlir/Dialect/CommonFolders.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/PatternMatch.h"
 #include "llvm/ADT/STLExtras.h"

 }
 
 mlir::LogicalResult fir::DeclareOp::verify() {
   auto fortranVar =
       mlir::cast<fir::FortranVariableOpInterface>(this->getOperation());
   return fortranVar.verifyDeclareLikeOpImpl(getMemref());
 }
 
+//===----------------------------------------------------------------------===//
+// FIROpsDialect
+//===----------------------------------------------------------------------===//
+
+void fir::FIROpsDialect::registerOpInterfaces() {
+  // Attach default declare target interfaces to operations which can be marked
+  // as declare target.
+  fir::GlobalOp::attachInterface<
+      mlir::omp::DeclareTargetDefaultModel<fir::GlobalOp>>(*getContext());
+}
+
 // Tablegen operators
 
 #define GET_OP_CLASSES
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"

flang/test/Fir/omp-declare-target-data.fir

+// RUN: fir-opt --fir-to-llvm-ir %s | FileCheck %s
+
+module attributes {omp.is_device = #omp.isdevice<is_device = false>} {
+
+  // CHECK: llvm.mlir.global external @_QMtest_0Earray_1d(dense<[1, 2, 3]> : tensor<3xi32>) {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>{{.*}}} : !llvm.array<3 x i32>
+  fir.global @_QMtest_0Earray_1d(dense<[1, 2, 3]> : tensor<3xi32>) {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : !fir.array<3xi32>
+
+  // CHECK: llvm.mlir.global external @_QMtest_0Earray_2d() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>{{.*}}} : !llvm.array<2 x array<2 x i32>>
+  fir.global @_QMtest_0Earray_2d {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : !fir.array<2x2xi32> {
+    %0 = fir.undefined !fir.array<2x2xi32>
+    %c1_i32 = arith.constant 1 : i32
+    %1 = fir.insert_value %0, %c1_i32, [0 : index, 0 : index] : (!fir.array<2x2xi32>, i32) -> !fir.array<2x2xi32>
+    %c2_i32 = arith.constant 2 : i32
+    %2 = fir.insert_value %1, %c2_i32, [1 : index, 0 : index] : (!fir.array<2x2xi32>, i32) -> !fir.array<2x2xi32>
+    %c3_i32 = arith.constant 3 : i32
+    %3 = fir.insert_value %2, %c3_i32, [0 : index, 1 : index] : (!fir.array<2x2xi32>, i32) -> !fir.array<2x2xi32>
+    %c4_i32 = arith.constant 4 : i32
+    %4 = fir.insert_value %3, %c4_i32, [1 : index, 1 : index] : (!fir.array<2x2xi32>, i32) -> !fir.array<2x2xi32>
+    %c2 = arith.constant 2 : index
+    %c2_0 = arith.constant 2 : index
+    fir.has_value %4 : !fir.array<2x2xi32>
+  }
+  
+  // CHECK: llvm.mlir.global external @_QMtest_0Edata_extended_link_1() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>{{.*}}} : f32
+  fir.global @_QMtest_0Edata_extended_link_1 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : f32 {
+    %cst = arith.constant 2.000000e+00 : f32
+    fir.has_value %cst : f32
+  }
+  
+  // CHECK: llvm.mlir.global external @_QMtest_0Edata_extended_link_2() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>{{.*}}} : f32
+  fir.global @_QMtest_0Edata_extended_link_2 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : f32 {
+    %cst = arith.constant 3.000000e+00 : f32
+    fir.has_value %cst : f32
+  }
+  
+  // CHECK: llvm.mlir.global external @_QMtest_0Edata_extended_to_1() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}} : f32
+  fir.global @_QMtest_0Edata_extended_to_1 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : f32 {
+    %cst = arith.constant 2.000000e+00 : f32
+    fir.has_value %cst : f32
+  }
+  
+  // CHECK: llvm.mlir.global external @_QMtest_0Edata_extended_to_2() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}} : f32 {
+  fir.global @_QMtest_0Edata_extended_to_2 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : f32 {
+    %cst = arith.constant 3.000000e+00 : f32
+    fir.has_value %cst : f32
+  }
+  
+  // CHECK: llvm.mlir.global external @_QMtest_0Edata_int() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>{{.*}}} : i32
+  fir.global @_QMtest_0Edata_int {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : i32 {
+    %c10_i32 = arith.constant 10 : i32
+    fir.has_value %c10_i32 : i32
+  }
+  
+  // CHECK: llvm.mlir.global external @_QMtest_0Edata_int_clauseless() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}} : i32
+  fir.global @_QMtest_0Edata_int_clauseless {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : i32 {
+    %c1_i32 = arith.constant 1 : i32
+    fir.has_value %c1_i32 : i32
+  }
+  
+  // CHECK: llvm.mlir.global external @_QMtest_0Edata_int_to() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}} : i32
+  fir.global @_QMtest_0Edata_int_to {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : i32 {
+    %c5_i32 = arith.constant 5 : i32
+    fir.has_value %c5_i32 : i32
+  }
+  
+  // CHECK: llvm.mlir.global external @_QMtest_0Ept1() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>{{.*}}} : !llvm.struct<(ptr<i32>, i64, i32, i8, i8, i8, i8)> {
+  fir.global @_QMtest_0Ept1 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : !fir.box<!fir.ptr<i32>> {
+    %0 = fir.zero_bits !fir.ptr<i32>
+    %1 = fir.embox %0 : (!fir.ptr<i32>) -> !fir.box<!fir.ptr<i32>>
+    fir.has_value %1 : !fir.box<!fir.ptr<i32>>
+  }
+
+  // CHECK: llvm.mlir.global external @_QMtest_0Ept2_tar() {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>{{.*}}} : i32
+  fir.global @_QMtest_0Ept2_tar {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} target : i32 {
+    %c5_i32 = arith.constant 5 : i32
+    fir.has_value %c5_i32 : i32
+  }
+}

mlir/include/mlir/Dialect/OpenMP/OpenMPDialect.h

 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
+namespace mlir::omp {
+enum class DeclareTargetDeviceType : uint32_t;
+enum class DeclareTargetCaptureClause : uint32_t;
+} // namespace mlir::omp
+
 #include "mlir/Dialect/OpenMP/OpenMPOpsDialect.h.inc"
 #include "mlir/Dialect/OpenMP/OpenMPOpsEnums.h.inc"
 #include "mlir/Dialect/OpenMP/OpenMPTypeInterfaces.h.inc"
 
 #define GET_ATTRDEF_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOpsAttributes.h.inc"
 
 #include "mlir/Dialect/OpenMP/OpenMPInterfaces.h"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOps.h.inc"
 
 #endif // MLIR_DIALECT_OPENMP_OPENMPDIALECT_H_

mlir/include/mlir/Dialect/OpenMP/OpenMPInterfaces.h

 
 namespace mlir::omp {
 // You can override defaults here or implement more complex implementations of
 // functions. Or define a completely seperate external model implementation,
 // to override the existing implementation.
 struct OffloadModuleDefaultModel
     : public OffloadModuleInterface::ExternalModel<OffloadModuleDefaultModel,
                                                    mlir::ModuleOp> {};
+
+template <typename T>
+struct DeclareTargetDefaultModel
+    : public DeclareTargetInterface::ExternalModel<DeclareTargetDefaultModel<T>,
+                                                   T> {};
+
 } // namespace mlir::omp
 
 #endif // MLIR_DIALECT_OPENMP_OPENMPINTERFACES_H_

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 include "mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td"
 include "mlir/Dialect/OpenMP/OpenMPTypeInterfaces.td"
 
 def OpenMP_Dialect : Dialect {
   let name = "omp";
   let cppNamespace = "::mlir::omp";
-  let dependentDialects = ["::mlir::LLVM::LLVMDialect"];
+  let dependentDialects = ["::mlir::LLVM::LLVMDialect, ::mlir::func::FuncDialect"];
   let useDefaultAttributePrinterParser = 1;
 }
 
 // OmpCommon requires definition of OpenACC_Dialect.
 include "mlir/Dialect/OpenMP/OmpCommon.td"
 
 //===----------------------------------------------------------------------===//
 //  OpenMP Attributes

 
 // Type which can be constraint accepting standard integers and indices.
 def IntLikeType : AnyTypeOf<[AnyInteger, Index]>;
 
 def OpenMP_PointerLikeType : TypeAlias<OpenMP_PointerLikeTypeInterface,
   "OpenMP-compatible variable type">;
 
 //===----------------------------------------------------------------------===//
+//  2.12.7 Declare Target Directive
+//===----------------------------------------------------------------------===//
+
+def DeviceTypeAny : I32EnumAttrCase<"any", 0>;
+def DeviceTypeHost   : I32EnumAttrCase<"host", 1>;
+def DeviceTypeNoHost   : I32EnumAttrCase<"nohost", 2>;
+
+def DeclareTargetDeviceType : I32EnumAttr<
+    "DeclareTargetDeviceType",
+    "device_type clause",
+    [DeviceTypeAny, DeviceTypeHost, DeviceTypeNoHost]> {
+  let genSpecializedAttr = 0;
+  let cppNamespace = "::mlir::omp";
+}
+
+def DeclareTargetDeviceTypeAttr : EnumAttr<OpenMP_Dialect, DeclareTargetDeviceType, 
+                                    "device_type"> {
+  let assemblyFormat = "`(` $value `)`";
+}
+
+def CaptureClauseLink : I32EnumAttrCase<"to", 0>;
+def CaptureClauseTo   : I32EnumAttrCase<"link", 1>;
+
+def DeclareTargetCaptureClause : I32EnumAttr<
+    "DeclareTargetCaptureClause",
+    "capture clause",
+    [CaptureClauseLink, CaptureClauseTo]> {
+  let genSpecializedAttr = 0;
+  let cppNamespace = "::mlir::omp";
+}
+
+def DeclareTargetCaptureClauseAttr : EnumAttr<OpenMP_Dialect, DeclareTargetCaptureClause, 
+                                    "capture_clause"> {
+  let assemblyFormat = "`(` $value `)`";
+}
+
+def DeclareTargetAttr : OpenMP_Attr<"DeclareTarget", "declaretarget"> {
+  let parameters = (ins 
+    OptionalParameter<"DeclareTargetDeviceTypeAttr">:$device_type,
+    OptionalParameter<"DeclareTargetCaptureClauseAttr">:$capture_clause
+  );
+
+  let assemblyFormat = "`<` struct(params) `>`";
+}
+
+//===----------------------------------------------------------------------===//
 // 2.6 parallel Construct
 //===----------------------------------------------------------------------===//
 
 def ParallelOp : OpenMP_Op<"parallel", [
                  AutomaticAllocationScope, AttrSizedOperandSegments,
                  DeclareOpInterfaceMethods<OutlineableOpenMPOpInterface>,
                  RecursiveMemoryEffects, ReductionClauseInterface]> {
   let summary = "parallel construct";

mlir/include/mlir/Dialect/OpenMP/OpenMPOpsInterfaces.td

let methods = [
     InterfaceMethod<
       "Get reduction vars", "::mlir::SmallVector<::mlir::Value>",
       "getAllReductionVars", (ins), [{}], [{
         return $_op.getReductionVars();
       }]>,
   ];
 }
 
+def DeclareTargetInterface : OpInterface<"DeclareTargetInterface"> {
+  let description = [{
+    OpenMP operations that support declare target have this interface.
+    For example, FuncOp's and llvm.GlobalOp/fir.GlobalOp's. This 
+    interface allows simple manipulation and introspection of the 
+    declare target attribute that can be applied to these operations.
+  }];
+
+  let cppNamespace = "::mlir::omp";
+
+  let methods = [
+    InterfaceMethod<
+      /*description=*/[{
+        Set the declare target attribute on the current operation with the 
+        specified attribute arguments.
+      }],
+      /*retTy=*/"void",
+      /*methodName=*/"setDeclareTarget",
+      (ins "mlir::omp::DeclareTargetDeviceType":$deviceType,
+            "mlir::omp::DeclareTargetCaptureClause":$captureClause), [{}], [{
+        $_op->setAttr("omp.declare_target",
+                  mlir::omp::DeclareTargetAttr::get(
+                      $_op->getContext(),
+                      mlir::omp::DeclareTargetDeviceTypeAttr::get(
+                          $_op->getContext(), deviceType),
+                      mlir::omp::DeclareTargetCaptureClauseAttr::get(
+                          $_op->getContext(), captureClause)));
+      }]>, 
+      InterfaceMethod<
+      /*description=*/[{
+        Checks if the declare target attribute has been applied and exists on the 
+        current operation. Returns true if it exists on it, otherwise returns 
+        false.  
+      }],
+      /*retTy=*/"bool",
+      /*methodName=*/"isDeclareTarget",
+      (ins), [{}], [{
+        return $_op->hasAttr("omp.declare_target");
+      }]>,
+      InterfaceMethod<
+      /*description=*/[{  
+        Returns the DeclareTargetDeviceType segemnt of the DeclareTarget attribute if it
+        exists on the current operation. Otherwise it returns null. 
+      }],
+      /*retTy=*/"mlir::omp::DeclareTargetDeviceType",
+      /*methodName=*/"getDeclareTargetDeviceType",
+      (ins), [{}], [{
+        if (mlir::Attribute dTar = $_op->getAttr("omp.declare_target"))
+          if (auto dAttr = dTar.dyn_cast_or_null<mlir::omp::DeclareTargetAttr>())
+            return dAttr.getDeviceType().getValue();
+        return {};
+      }]>, 
+      InterfaceMethod<
+      /*description=*/[{  
+        Returns the DeclareTargetCaptureClause segemnt of the DeclareTarget attribute if it
+        exists on the current operation. Otherwise it returns null. 
+      }],
+      /*retTy=*/"mlir::omp::DeclareTargetCaptureClause",
+      /*methodName=*/"getDeclareTargetCaptureClause",
+      (ins), [{}], [{
+        if (mlir::Attribute dTar = $_op->getAttr("omp.declare_target"))
+          if (auto dAttr = dTar.dyn_cast_or_null<mlir::omp::DeclareTargetAttr>())
+            return dAttr.getCaptureClause().getValue();
+        return {};
+      }]>
+  ];
+}
+
 def OffloadModuleInterface : OpInterface<"OffloadModuleInterface"> {
   let description = [{
     Operations that represent a module for offloading (host or device) 
     should have this interface.
   }];
 
   let cppNamespace = "::mlir::omp";
 

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

 //===- OpenMPDialect.cpp - MLIR Dialect for OpenMP implementation ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the OpenMP dialect and its operations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMTypes.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/Interfaces/FoldInterfaces.h"
 
 #include "llvm/ADT/BitVector.h"
#include "mlir/Dialect/OpenMP/OpenMPOpsAttributes.cpp.inc"
       >();
 
   addInterface<OpenMPDialectFoldInterface>();
   LLVM::LLVMPointerType::attachInterface<
       PointerLikeModel<LLVM::LLVMPointerType>>(*getContext());
   MemRefType::attachInterface<PointerLikeModel<MemRefType>>(*getContext());
   LLVM::LLVMPointerType::attachInterface<
       PointerLikeModel<LLVM::LLVMPointerType>>(*getContext());
+
+  // Attach default offload module interface to module op to access
+  // offload functionality through
   mlir::ModuleOp::attachInterface<mlir::omp::OffloadModuleDefaultModel>(
       *getContext());
+
+  // Attach default declare target interfaces to operations which can be marked
+  // as declare target (Global Operations and Functions/Subroutines in dialects
+  // that Fortran (or other languages that lower to MLIR) translates too
+  mlir::LLVM::GlobalOp::attachInterface<
+      mlir::omp::DeclareTargetDefaultModel<mlir::LLVM::GlobalOp>>(
+      *getContext());
+  mlir::LLVM::LLVMFuncOp::attachInterface<
+      mlir::omp::DeclareTargetDefaultModel<mlir::LLVM::LLVMFuncOp>>(
+      *getContext());
+  mlir::func::FuncOp::attachInterface<
+      mlir::omp::DeclareTargetDefaultModel<mlir::func::FuncOp>>(*getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // Parser and printer for Allocate Clause
 //===----------------------------------------------------------------------===//
 
 /// Parse an allocate clause with allocators and a list of operands with types.
 ///

mlir/test/Dialect/OpenMP/attr.mlir

 // CHECK: module attributes {omp.flags = #omp.flags<assume_teams_oversubscription = true>} {
 module attributes {omp.flags = #omp.flags<assume_teams_oversubscription = true>} {}
 
 // CHECK: module attributes {omp.flags = #omp.flags<assume_teams_oversubscription = true, assume_no_thread_state = true>} {
 module attributes {omp.flags = #omp.flags<assume_teams_oversubscription = true, assume_no_thread_state = true>} {}
 
 // CHECK: module attributes {omp.flags = #omp.flags<assume_teams_oversubscription = true, assume_no_thread_state = true>} {
 module attributes {omp.flags = #omp.flags<assume_no_thread_state = true, assume_teams_oversubscription = true>} {}
+
+// ----
+
+// CHECK-LABEL: func @omp_decl_tar_host_to
+// CHECK-SAME: {{.*}} attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>} {
+func.func @omp_decl_tar_host_to() -> () attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>} {
+  return
+}
+
+// CHECK-LABEL: func @omp_decl_tar_host_link
+// CHECK-SAME: {{.*}} attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (link)>} {
+func.func @omp_decl_tar_host_link() -> () attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (link)>} {
+  return
+}
+
+// CHECK-LABEL: func @omp_decl_tar_nohost_to
+// CHECK-SAME: {{.*}} attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>} {
+func.func @omp_decl_tar_nohost_to() -> () attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>} {
+  return
+}
+
+// CHECK-LABEL: func @omp_decl_tar_nohost_link
+// CHECK-SAME: {{.*}} attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (link)>} {
+func.func @omp_decl_tar_nohost_link() -> () attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (link)>} {
+  return
+}
+
+// CHECK-LABEL: func @omp_decl_tar_any_to
+// CHECK-SAME: {{.*}} attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} {
+func.func @omp_decl_tar_any_to() -> () attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} {
+  return
+}
+
+// CHECK-LABEL: func @omp_decl_tar_any_link
+// CHECK-SAME: {{.*}} attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} {
+func.func @omp_decl_tar_any_link() -> () attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} {
+  return
+}
+
+// CHECK-LABEL: global external @omp_decl_tar_data_host_to
+// CHECK-SAME: {{.*}} {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>}
+llvm.mlir.global external @omp_decl_tar_data_host_to() {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>} : i32 {
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  llvm.return %0 : i32
+}
+
+// CHECK-LABEL: global external @omp_decl_tar_data_host_link
+// CHECK-SAME: {{.*}} {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (link)>}
+llvm.mlir.global external @omp_decl_tar_data_host_link() {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (link)>} : i32 {
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  llvm.return %0 : i32
+}
+
+// CHECK-LABEL: global external @omp_decl_tar_data_nohost_to
+// CHECK-SAME: {{.*}} {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>}
+llvm.mlir.global external @omp_decl_tar_data_nohost_to() {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>} : i32 {
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  llvm.return %0 : i32
+}
+
+// CHECK-LABEL: global external @omp_decl_tar_data_nohost_link
+// CHECK-SAME: {{.*}} {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (link)>}
+llvm.mlir.global external @omp_decl_tar_data_nohost_link() {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (link)>} : i32 {
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  llvm.return %0 : i32
+}
+
+// CHECK-LABEL: global external @omp_decl_tar_data_any_to
+// CHECK-SAME: {{.*}} {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>}
+llvm.mlir.global external @omp_decl_tar_data_any_to() {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : i32 {
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  llvm.return %0 : i32
+}
+
+// CHECK-LABEL: global external @omp_decl_tar_data_any_link
+// CHECK-SAME: {{.*}} {{{.*}}omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>}
+llvm.mlir.global external @omp_decl_tar_data_any_link() {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : i32 {
+  %0 = llvm.mlir.constant(1 : i32) : i32
+  llvm.return %0 : i32
+}