[Flang][OpenMP][MLIR] Add lowering from parse tree to MLIR support for Declare Target for functions, subroutines and global data

[agozillon]

Summary

This adds lowering support to Flang for OpenMP Declare Target
tagged functions, subroutines and global data in the form of
GlobalOps.

This patch adds an attribute which contains data
provided to the device_type clause (any | host | nohost) and
what I've currently called the "capture" clause which is the
To (Enter) and Link clauses. This attribute is then applied
to functions, subroutines and global data (which are
represented as builtin.FuncOp's and fir.GlobalOp's in
MLIR).

An additional semantic analysis pass is added to Flang
which adds functions used within declare target functions
to the original declare target specifier, effectively marking
them as declare target, with the same clauses as their
parent/caller. This is a form of implicit capture, this appears
to occur within Clang (albeit in a different way) and from my
current reading and understanding of the specification is described
there as well.

This also adds several tests testing current global data, functions and
subroutine support.

The idea is that this attribute can be picked up by amendOperation or
similar infrastructure later during lowering of the LLVM Dialect +
OpenMP dialect to LLVM-IR and have specialised lowering based
on the contained attribute data. This can be seen in:
https://reviews.llvm.org/D149368 which lowers GlobalOp's marked
with a declare target attribute to LLVM-IR.

Filtering of functions/global data that is deemed unneccesary for a
module is currently not done in this patch. The approach currently is
to do this later in the pipeline during the lowering to LLVM-IR as shown
for functions here: https://reviews.llvm.org/D147641 Global data can
likely be done similarly.

This patch has the following related patches on-going:

Function filtering: https://reviews.llvm.org/D147641
Initial lowering of declare target to LLVM-IR for global data: https://reviews.llvm.org/D149368
Movement of OMP IR Builder functionality for lowering declare target data: https://reviews.llvm.org/D149162
Loading in of host module data to properly populate device metadata for declare target: https://reviews.llvm.org/D148370

With these four patches and this patch, initial support for declare target will exist for Flang+OpenMP, however,
further testing and extension for all edge cases will be required and something I will continue to work on. Frontend
semantic analysis support also needs a little look into as well, there's a lot of cases where things compile without
error when they shouldn't and vice versa still. But these patches should yield some initial support.

[kiranchandramohan]

The problem with doing this in two stages : i.e during lowering and a pass are that there are two representations for the same thing in the IR. One where the nested functions are not marked, and the other where they are marked.

Would it be better to do this in

1. Semantics + lowering?

or

2. PFT + lowering?

So that there is only one representation in the IR.

[agozillon]

I believe I understand your concerns.

I think I've tried to do number 2 already, if I understand correctly and the PFT + lowering phase comprises the handleDeclareTarget function inside of OpenMP.cpp (and the other lowering steps to the various MLIR dialects from the PFT). I initially tried to do it while processing the initial declare target lowering inside of handleDeclareTarget, however, you run into the issue that the function the declare target is nested inside hasn't been fully lowered yet, so you cannot tell what other functions are invoked by the declare target function from the currently existing MLIR as it's yet to be generated! The only way I can think of circumventing this is by doing some sort of delayed evaluation that occurs once the function is completed, but I'm unsure how ideal that is.

After running into this issue with the original method I also thought about doing it in the semantic check + PFT generation phase as I believe you suggest as option number 1 (but do please correct me if my understanding is wrong), by pushing the functions (to be marked implicitly declare target) invoked within the declare target function onto the originally generated OmpDeclareTargetSpecifier's To or Link list, and then the handleDeclareTarget function would just treat them as normally. I decided to forgo this and go with the MLIR pass as it seemed like the simpler option that was most likely to work and I wasn't sure if there was a precedent for doing this sort of thing at the semantic level.

I am happy to look into either of these if you think they're better than the current solution! Is there one approach you prefer over another?

As a related aside I was considering doing another pass similarly to this, which removes unrequired declare target functions from the module (e.g. remove device only declare target functions if it's a host module), with the intent of removing unnecessary functions as early as possible (as requested in a prior discussion I believe). The main reason for doing this as an end module pass as opposed to removing them directly in the handleDeclareTarget function is that it is going to run into the same problem, as I believe you need to know if other OpenMP offload code exists in the function before you discard it, e.g. if a declare target host function has a device target region within it, it can't be discarded inside of an OpenMP device module early as we'd lose the target region. Perhaps there's some OpenMP specification rules I'm unaware of that prevent a target region inside of a declare target function, although I fear a similar issue may occur with data mapping operations as well in any case. Would a pass like this be more reasonable than the pass in this patch?

[agozillon]

• [Flang][OpenMP][MLIR] Remove optimisation passes
• [Flang][OpenMP] Add Parse Tree Rewrite for Declare Target

[agozillon]

• [Flang Fix left over artifacts from pass removal

[agozillon]

• [Flang] Hidden space re-addition

[agozillon]

First of all, apologies everyone for the spam, had some issues re-aligning some of the previously changed files back to their old form, teaches me to just revert in future!

This is now updated to do the implicit marking during the PFT rewrite phase, this seemed the most "correct" place to alter the parse tree as it's already done here for the ambiguities that arise from parsing certain Fortran syntaxes (from what I understand at least). However, it could be moved into the semantic phase as well I think by simply moving what I've done in the rewrite phase into the semantic phase, but this seems like it would be the first case of the semantic phase altering the parse tree. One side-affect of having it done in the rewrite phase is that the semantic analysis will be executed on the altered declare target specifier, verifying it as if it were exactly as a user wrote.

I would appreciate another review when you have a spare moment @kiranchandramohan I'm aware you're time is likely stretched thin with the current amount of Fortran-Offload related (and other Fortran/OpenMP related) phabricator patches however!

[agozillon]

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

32

I kept these external to the ModuleInterface as I'm unsure if we wish to put FuncOp+fir.GlobalOp related getter and setters into the module interface, have separate interfaces (e.g. an OffloadFuncOp interface for these getters/setters) or leave them as OpenMPDialect static functions. I am open to all of these options.

[kiranchandramohan]

Sorry for the delay here. I had typed a message but failed to post it. I havent gone through the new changes in details. But can you move the parse-tree rewrite to flang/lib/Semantics/canonicalize-omp.cpp?

[agozillon]

In D146063#4243371, @kiranchandramohan wrote:

Sorry for the delay here. I had typed a message but failed to post it. I havent gone through the new changes in details. But can you move the parse-tree rewrite to flang/lib/Semantics/canonicalize-omp.cpp?

That's no problem Kiran, thank you for picking up the review again. I have now looked into this and unfortunately I cannot do this, as this needs to occur after the ResolveNames pass has been executed (and fills in function symbols correctly) otherwise the Parser::Name's aren't complete and it produces semantic errors and the canonocalize-omp pass occurs prior to the ResolveNames pass. I could move the infrastructure into a separate pass within canoncalize-omp.cpp/h (or a different file entirely) and then create a separate access/invocation function for it that can be invoked after the ResolveNames pass has been executed? This would make the pass for canoncalization and implicit declare target gathering seperate passes invoked at different times but allow for names to be properly resolved before the pass has begun execution The alternative would be to teach ResolveNames to go back and update all of the declare target specifiers, but I don't know how simple this would be and it would be adding additional rather unnecessary work for the compiler to do and perhaps bloat the ResolveNames pass needlessly.

Please let me know which of these options seems most reasonable.

[kiranchandramohan]

In D146063#4245843, @agozillon wrote:

In D146063#4243371, @kiranchandramohan wrote:

Sorry for the delay here. I had typed a message but failed to post it. I havent gone through the new changes in details. But can you move the parse-tree rewrite to flang/lib/Semantics/canonicalize-omp.cpp?

That's no problem Kiran, thank you for picking up the review again. I have now looked into this and unfortunately I cannot do this, as this needs to occur after the ResolveNames pass has been executed (and fills in function symbols correctly) otherwise the Parser::Name's aren't complete and it produces semantic errors and the canonocalize-omp pass occurs prior to the ResolveNames pass. I could move the infrastructure into a separate pass within canoncalize-omp.cpp/h (or a different file entirely) and then create a separate access/invocation function for it that can be invoked after the ResolveNames pass has been executed? This would make the pass for canoncalization and implicit declare target gathering seperate passes invoked at different times but allow for names to be properly resolved before the pass has begun execution The alternative would be to teach ResolveNames to go back and update all of the declare target specifiers, but I don't know how simple this would be and it would be adding additional rather unnecessary work for the compiler to do and perhaps bloat the ResolveNames pass needlessly.

Please let me know which of these options seems most reasonable.

There is a resolve-directives.cpp file and it has a pass that resolves the names in OpenMP. But i guess it would be better to go for a separate pass in a separate file. Usually adding a pass is costly. But there are a few cases in my mind where it will be useful.

[agozillon]

• [Flang][Parser] Move to canonicalize-omp
• [Flang][Semantics] Add finalize-omp files, move ImplicitDeclareTargetCapture pass here

[agozillon]

• [Flang][NFC] Try to remove changes to canonicalize-omp.cpp

[agozillon]

• [Flang][NFC] Add missing newline to end of file

[agozillon]

In D146063#4247200, @kiranchandramohan wrote:

In D146063#4245843, @agozillon wrote:

In D146063#4243371, @kiranchandramohan wrote:

Sorry for the delay here. I had typed a message but failed to post it. I havent gone through the new changes in details. But can you move the parse-tree rewrite to flang/lib/Semantics/canonicalize-omp.cpp?

That's no problem Kiran, thank you for picking up the review again. I have now looked into this and unfortunately I cannot do this, as this needs to occur after the ResolveNames pass has been executed (and fills in function symbols correctly) otherwise the Parser::Name's aren't complete and it produces semantic errors and the canonocalize-omp pass occurs prior to the ResolveNames pass. I could move the infrastructure into a separate pass within canoncalize-omp.cpp/h (or a different file entirely) and then create a separate access/invocation function for it that can be invoked after the ResolveNames pass has been executed? This would make the pass for canoncalization and implicit declare target gathering seperate passes invoked at different times but allow for names to be properly resolved before the pass has begun execution The alternative would be to teach ResolveNames to go back and update all of the declare target specifiers, but I don't know how simple this would be and it would be adding additional rather unnecessary work for the compiler to do and perhaps bloat the ResolveNames pass needlessly.

Please let me know which of these options seems most reasonable.

There is a resolve-directives.cpp file and it has a pass that resolves the names in OpenMP. But i guess it would be better to go for a separate pass in a separate file. Usually adding a pass is costly. But there are a few cases in my mind where it will be useful.

I've added a new file set called finalize-omp.h/cpp which now contains the pass, I'm happy to change the names if they seem incorrect to you.

[agozillon]

Just a small ping for reviewer attention please, if at all possible, to push this patch a little further along the pipeline!

[kiranchandramohan]

Can you write a few tests where I can see the modifications made by the finalize-omp pass? You can add the test in flang/test/Semantics/OpenMP.

[agozillon]

• [Flang][OpenMP][MLIR] Remove optimisation passes
• [Flang][OpenMP] Add Parse Tree Rewrite for Declare Target
• [Flang][Parser] Move to canonicalize-omp
• [Flang][Semantics] Add finalize-omp files, move ImplicitDeclareTargetCapture pass here
• [Flang][NFC] Try to remove changes to canonicalize-omp.cpp
• [Flang][NFC] Add missing newline to end of file
• [Flang][OpenMP] Add declare-target-implicit-capture-rewrite.f90 test

[agozillon]

• Fix alterations made from rebasing

[agozillon]

In D146063#4262700, @kiranchandramohan wrote:

Can you write a few tests where I can see the modifications made by the finalize-omp pass? You can add the test in flang/test/Semantics/OpenMP.

I've added the flang/test/Semantics/OpenMP/declare-target-implicit-capture-rewrite.f90 test in the most recent commit, it checks the -fdebug-dump-parse-tree meets the expected modifications. Hopefully it's what you were looking for! Still working my way around the appropriate testing infrastructure for each component I change so I'm sorry for missed tests.

[agozillon]

Just a small ping to keep this patch on peoples radar and to try and get some reviewer attention (I am aware you're all quite busy, so thank you very much for any time you can spare) for more review feedback to push this patch further along the pipeline!

[skatrak]

flang/lib/Lower/OpenMP.cpp

2476

It might be preferable to use llvm::SmallVector<Fortran::semantics::Symbol, 0> here, according to this: https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h.

2550

Could this condition be simplified by something like this?

if (currentDeclTar != deviceType)
  mlir::omp::OpenMPDialect::setDeclareTarget(op, mlir::omp::DeclareTargetDeviceType::any);

2561

Nit: Maybe it's just a matter of personal preference, but I think a switch statement here would be slightly more readable. Feel free to ignore my comment if you don't agree.

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

32

For consistency with the way that module-level OpenMP attributes are accessed, I think it would be a good idea to do the same for these new attributes attached to functions and globals. However, I'd be interested to hear what others think about this. One question that comes up is: would we want a DeclareTargetInterface (maybe with a more descriptive/generic name) for both cases, or an OffloadFunctionInterface plus an OffloadGlobalInterface (both with the same methods at first)?

[agozillon]

• [Flang][OpenMP][MLIR] Remove optimisation passes
• [Flang][OpenMP] Add Parse Tree Rewrite for Declare Target
• [Flang][Parser] Move to canonicalize-omp
• [Flang][Semantics] Add finalize-omp files, move ImplicitDeclareTargetCapture pass here
• [Flang][NFC] Try to remove changes to canonicalize-omp.cpp
• [Flang][NFC] Add missing newline to end of file
• [Flang][OpenMP] Add declare-target-implicit-capture-rewrite.f90 test
• Fix alterations made from rebasing
• Tidy up handleDeclareTarget

[agozillon]

• readd space I removed on rebase.

[agozillon]

• Try to re-align cmakefile after rebase

[agozillon]

Updated based on @skatrak's feedback! sorry for the spam, rebased and had some issue re-adding the exact formatting of the CMakefile

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

32

Yes, perhaps @kiranchandramohan has some preference, I would lean more towards DeclareTargetInterface, if we have no other Offload features currently for Global/Functions!

[agozillon]

• [Flang][OpenMP][MLIR] Update Declare Target for initial GlobalOps support

[agozillon]

Recent update has extended support in this patch from functions and subroutines to global data in the form of fir.GlobalOps. There is likely some other types that need consideration and future extension of this work in the future as well, such as allocatable's which I've yet to look into (but plan too).

flang/test/Lower/OpenMP/omp-declare-target-data.f90

15

These tests will fail the build-bot here, because the dependent patches aren't accepted upstream just yet, but a Flang -> LLVM-IR test is the only way I can think of testing the device portion of this test, however, it can be in another seperate file. I also think the OpenMP support for offloading in Flang could benefit greatly from a test suite that goes directly from Fortran -> LLVM-IR, alongside the already existent tests that filter down in stages.

If this patch is accepted and able to be submitted before the dependent portions, I'll remove this failing segment (then wait on the phabricator buildbot to be happy) to upstream it.

[agozillon]

• [Flang][OpenMP][MLIR] Update Declare Target for initial GlobalOps support
• [Flang][OpenMP][MLIR] Add DeclareTargetInterface in place of Declare Target Dialect functions

[agozillon]

• [Flang][OpenMP][MLIR] Add DeclareTargetInterface in place of Declare Target Dialect functions

[agozillon]

The recent update has moved all of the dialect functions relating to the declare target attribute into a new interface that is applied to LLVM::FuncOp/LLVM::GlobalOp/Fir::GlobalOp/Func::FuncOp. Essentially anything that currently gets marked declare target in the Flang pipeline, although as it's an interface it's easy to apply to other operations as necessary.

[jsjodin]

Can you add a test case with a recursive call?

[agozillon]

• [Flang][OpenMP][MLIR] Update Declare Target for initial GlobalOps support
• [Flang][OpenMP][MLIR] Add DeclareTargetInterface in place of Declare Target Dialect functions
• [Flang][OpenMP][Test] Remove the intentional fails that were for discussion purposes
• [Flang][OpenMP][Test] Add recursive tests to make sure there's no infinity run from the compiler

[agozillon]

Most recent commit adds recursive test cases at the end of omp-declare-target-func-and-subr.f90 and declare-target-implicit-capture-rewrite.f90, the pass handles these appropriately it appears, so no further changes were required. I have also removed the (intentionally) failing test checks to see how the buildbot handles the patch after a rebase.

[agozillon]

• [Flang][OpenMP][Test] Remove illegal link tests (no semantic check for it yet, but there will be eventually)

[jsjodin]

flang/lib/Lower/OpenMP.cpp

2476

It might be preferable to use llvm::SmallVector<Fortran::semantics::Symbol, 0> here, according to this: https://llvm.org/docs/ProgrammersManual.html#llvm-adt-smallvector-h.

Or to not specify any value at all:

In the absence of a well-motivated choice for the number of inlined elements N, it is recommended to use SmallVector<T> (that is, omitting the N). This will choose a default number of inlined elements reasonable for allocation on the stack (for example, trying to keep sizeof(SmallVector<T>) around 64 bytes).

flang/lib/Semantics/finalize-omp.cpp

29

I think it would be helpful to have a short description how this works.

flang/test/Lower/OpenMP/omp-declare-target-func-and-subr.f90

112

Nit: inconjunction -> in conjunction (multiple places)

[agozillon]

• [Flang][OpenMP] Made minor alterations based on reviewer comments

[agozillon]

Made an attempt to address @jsjodin's review comments in the last patch

flang/lib/Lower/OpenMP.cpp

2476

Unfortunately, eliding the size isn't possible with this SmallVector, perhaps because of the change to using a std::pair, it hits a static_assert! So providing 0 appears to be a good middle ground.

[skatrak]

flang/lib/Lower/OpenMP.cpp

2476

I think the problem might not even be the std::pair. I tried this with Symbol and it failed to compile as well, and thought it might be just that it's a large structure so it refuses to provide a default number of elements to place in the stack.

[jsjodin]

LGTM

[kiranchandramohan]

I will have a look at this soon (in a day or two).
Are the declares handled, if inside a module?

[agozillon]

In D146063#4330200, @kiranchandramohan wrote:

I will have a look at this soon (in a day or two).

That's no problem I was going to leave it a few days and leave a ping here in-case you wished to have a look over it before I up-streamed it!

Are the declares handled, if inside a module?

The data tests are all within a module, and work, although they do not need the semantic pass. So I will add another small set of tests with functions and subroutines in a module just in-case as the more tests the better (so if you have any other ideas, please do mention them), however, in this case I am reasonably certain it will work without issue.

flang/lib/Lower/OpenMP.cpp

2476

That's probably the case then, it did seem size related and I'd assumed it was perhaps the coupling of the two in a pair!

[kiranchandramohan]

This patch is rather large and touches both Flang and MLIR. Would you be OK to move the semantics part and its test to a separate patch?

[agozillon]

In D146063#4330975, @kiranchandramohan wrote:

This patch is rather large and touches both Flang and MLIR. Would you be OK to move the semantics part and its test to a separate patch?

I would be happy too, this patch has grown a fair chunk over time! The flang/test/Lower/OpenMP/omp-declare-target-func-and-subr.f90 also depends on the semantic pass as well (some use of implicit capturing, but testing the IR generates okay, rather than the parse tree), so I will move that into the semantic portion of the patch set too if that is okay.

[kiranchandramohan]

In D146063#4330994, @agozillon wrote:

In D146063#4330975, @kiranchandramohan wrote:

This patch is rather large and touches both Flang and MLIR. Would you be OK to move the semantics part and its test to a separate patch?

I would be happy too, this patch has grown a fair chunk over time! The flang/test/Lower/OpenMP/omp-declare-target-func-and-subr.f90 also depends on the semantic pass as well (some use of implicit capturing, but testing the IR generates okay, rather than the parse tree), so I will move that into the semantic portion of the patch set too if that is okay.

If it is only the lowering test without any change in the lowering code then that is fine. Otherwise that can come in a later patch.

[kiranchandramohan]

Also update the relevant section of the document flang/docs/OpenMP-semantics.md.

[agozillon]

I have split this patch into 3 rather than 2, to make it more bite-sized.

The attribute and interface segment: https://reviews.llvm.org/D150328
The semantic pass segment: https://reviews.llvm.org/D150323
The PFT -> MLIR lowering segment: https://reviews.llvm.org/D150329

I will keep this patch open until the other three are closed. This is for record, reference and historical comment purposes (so.. mainly for me, but it might be of use to others as well). But future discussion can go to their representative segment.

[agozillon]

Going to abandon this patch, as 2/3 of the components are upstreamed now and the only patch open is the implicit marking via semantic analysis pass and it's diverged quite a bit from this patch.

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/Lower/OpenMP.cpp

void Fortran::lower::genThreadprivateOp(
   }
 
   fir::ExtendedValue sexv = converter.getSymbolExtendedValue(sym);
   fir::ExtendedValue symThreadprivateExv =
       getExtendedValue(sexv, symThreadprivateValue);
   converter.bindSymbol(sym, symThreadprivateExv);
 }
 
+void handleDeclareTarget(Fortran::lower::AbstractConverter &converter,
+                         Fortran::lower::pft::Evaluation &eval,
+                         const Fortran::parser::OpenMPDeclareTargetConstruct
+                             &declareTargetConstruct) {
+  llvm::SmallVector<std::pair<mlir::omp::DeclareTargetCaptureClause,
+                              Fortran::semantics::Symbol>,
+                    0>
+      symbolAndClause;
+  auto findFuncAndVarSyms = [&](const Fortran::parser::OmpObjectList &objList,
+                                mlir::omp::DeclareTargetCaptureClause clause) {
+    for (const auto &ompObject : objList.v) {
+      Fortran::common::visit(
+          Fortran::common::visitors{
+              [&](const Fortran::parser::Designator &designator) {
+                if (const Fortran::parser::Name *name =
+                        getDesignatorNameIfDataRef(designator)) {
+                  symbolAndClause.push_back(
+                      std::make_pair(clause, *name->symbol));
+                }
+              },
+              [&](const Fortran::parser::Name &name) {
+                symbolAndClause.push_back(std::make_pair(clause, *name.symbol));
+              }},
+          ompObject.u);
+    }
+  };
+
+  const auto &spec{std::get<Fortran::parser::OmpDeclareTargetSpecifier>(
+      declareTargetConstruct.t)};
+  auto mod = converter.getFirOpBuilder().getModule();
+
+  // The default capture type
+  auto deviceType = Fortran::parser::OmpDeviceTypeClause::Type::Any;
+  if (const auto *objectList{
+          Fortran::parser::Unwrap<Fortran::parser::OmpObjectList>(spec.u)}) {
+    // Case: declare target(func, var1, var2)
+    findFuncAndVarSyms(*objectList, mlir::omp::DeclareTargetCaptureClause::to);
+  } else if (const auto *clauseList{
+                 Fortran::parser::Unwrap<Fortran::parser::OmpClauseList>(
+                     spec.u)}) {
+    if (clauseList->v.empty()) {
+      // Case: declare target, implicit capture of function
+      symbolAndClause.push_back(
+          std::make_pair(mlir::omp::DeclareTargetCaptureClause::to,
+                         eval.getOwningProcedure()->getSubprogramSymbol()));
+    }
+
+    for (const auto &clause : clauseList->v) {
+      if (const auto *toClause{
+              std::get_if<Fortran::parser::OmpClause::To>(&clause.u)}) {
+        // Case: declare target to(func, var1, var2)...
+        findFuncAndVarSyms(toClause->v,
+                           mlir::omp::DeclareTargetCaptureClause::to);
+      } else if (const auto *linkClause{
+                     std::get_if<Fortran::parser::OmpClause::Link>(
+                         &clause.u)}) {
+        // Case: declare target link(var1, var2)...
+        findFuncAndVarSyms(linkClause->v,
+                           mlir::omp::DeclareTargetCaptureClause::link);
+      } else if (const auto *deviceClause{
+                     std::get_if<Fortran::parser::OmpClause::DeviceType>(
+                         &clause.u)}) {
+        // Case: declare target ... device_type(any | host | nohost)
+        deviceType = deviceClause->v.v;
+      }
+    }
+  }
+
+  for (auto sym : symbolAndClause) {
+    auto *op = mod.lookupSymbol(converter.mangleName(std::get<1>(sym)));
+
+    auto declareTargetOp = dyn_cast<mlir::omp::DeclareTargetInterface>(op);
+    if (!declareTargetOp)
+      fir::emitFatalError(
+          converter.getCurrentLocation(),
+          "Attempt to apply declare target on unsupproted operation");
+
+    mlir::omp::DeclareTargetDeviceType newDeviceType;
+    switch (deviceType) {
+    case Fortran::parser::OmpDeviceTypeClause::Type::Nohost:
+      newDeviceType = mlir::omp::DeclareTargetDeviceType::nohost;
+      break;
+    case Fortran::parser::OmpDeviceTypeClause::Type::Host:
+      newDeviceType = mlir::omp::DeclareTargetDeviceType::host;
+      break;
+    case Fortran::parser::OmpDeviceTypeClause::Type::Any:
+      newDeviceType = mlir::omp::DeclareTargetDeviceType::any;
+      break;
+    }
+
+    // The function or global already has a declare target applied to it,
+    // very likely through implicit capture (usage in another declare
+    // target function/subroutine). It should be marked as any if it has
+    // been assigned both host and nohost, else we skip, as there is no
+    // change
+    if (declareTargetOp.isDeclareTarget()) {
+      if (declareTargetOp.getDeclareTargetDeviceType() != newDeviceType)
+        declareTargetOp.setDeclareTarget(
+            mlir::omp::DeclareTargetDeviceType::any, std::get<0>(sym));
+      continue;
+    }
+
+    declareTargetOp.setDeclareTarget(newDeviceType, std::get<0>(sym));
+  }
+}
+
 void Fortran::lower::genOpenMPDeclarativeConstruct(
     Fortran::lower::AbstractConverter &converter,
     Fortran::lower::pft::Evaluation &eval,
     const Fortran::parser::OpenMPDeclarativeConstruct &ompDeclConstruct) {
 
   std::visit(
       common::visitors{
           [&](const Fortran::parser::OpenMPDeclarativeAllocate
                   &declarativeAllocate) {
             TODO(converter.getCurrentLocation(), "OpenMPDeclarativeAllocate");
           },
           [&](const Fortran::parser::OpenMPDeclareReductionConstruct
                   &declareReductionConstruct) {
             TODO(converter.getCurrentLocation(),
                  "OpenMPDeclareReductionConstruct");
           },
           [&](const Fortran::parser::OpenMPDeclareSimdConstruct
                   &declareSimdConstruct) {
             TODO(converter.getCurrentLocation(), "OpenMPDeclareSimdConstruct");
           },
           [&](const Fortran::parser::OpenMPDeclareTargetConstruct
                   &declareTargetConstruct) {
-            TODO(converter.getCurrentLocation(),
-                 "OpenMPDeclareTargetConstruct");
+            handleDeclareTarget(converter, eval, declareTargetConstruct);
           },
           [&](const Fortran::parser::OpenMPRequiresConstruct
                   &requiresConstruct) {
             TODO(converter.getCurrentLocation(), "OpenMPRequiresConstruct");
           },
           [&](const Fortran::parser::OpenMPThreadprivate &threadprivate) {
             // The directive is lowered when instantiating the variable to
             // support the case of threadprivate variable declared in module.

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/lib/Semantics/CMakeLists.txt

add_flang_library(FortranSemantics
   check-return.cpp
   check-select-rank.cpp
   check-select-type.cpp
   check-stop.cpp
   compute-offsets.cpp
   data-to-inits.cpp
   definable.cpp
   expression.cpp
+  finalize-omp.cpp
   mod-file.cpp
   pointer-assignment.cpp
   program-tree.cpp
   resolve-labels.cpp
   resolve-directives.cpp
   resolve-names-utils.cpp
   resolve-names.cpp
   rewrite-parse-tree.cpp

flang/lib/Semantics/finalize-omp.h

+//===-- lib/Semantics/finalize-omp.h ------------------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_SEMANTICS_FINALIZE_OMP_H_
+#define FORTRAN_SEMANTICS_FINALIZE_OMP_H_
+
+namespace Fortran::parser {
+struct Program;
+} // namespace Fortran::parser
+
+namespace Fortran::semantics {
+class SemanticsContext;
+bool FinalizeOMP(SemanticsContext &context, parser::Program &program);
+} // namespace Fortran::semantics
+
+#endif // FORTRAN_SEMANTICS_FINALIZE_OMP_H_

flang/lib/Semantics/finalize-omp.cpp

+#include "finalize-omp.h"
+#include "flang/Parser/parse-tree-visitor.h"
+#include "flang/Semantics/tools.h"
+
+#include <list>
+#include <map>
+#include <variant>
+
+namespace Fortran::semantics {
+
+using namespace parser::literals;
+
+class GatherCallRefs {
+public:
+  GatherCallRefs() {}
+
+  // Default action for a parse tree node is to visit children.
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
+
+  void Post(parser::Call &call) {
+    if (std::holds_alternative<parser::Name>(std::get<0>(call.t).u))
+      callNames.push_back(std::get<parser::Name>(std::get<0>(call.t).u));
+  }
+
+  std::list<parser::Name> callNames;
+};
+
+// This pass works by passing over the modules PFT and collecting all of the
+// ProgramUnits(subroutines / functions) as it passes through these nodes.
+// When it meets a declare target node, it reads through the extended-list of
+// the declare target directive's clause finding functions (the current function
+// should be referred to in this declare target if a list is specified), if no
+// list is specified the function the declare target is in, is considered the
+// only function in the declare target list. These functions are then processed,
+// with the algorithm looking for calls in these functions that are not included
+// in the declare target but are implicitly declare target as they are invoked
+// by a declare target region. These functions are  searched for in the list of
+// ProgramUnits (check if it exists, and allows access to go through it's own
+// callees, to further find implicit functions) before being added to the
+// original declare target extended-list (either by extended it to add a list,
+// or just appending to the original list), now becoming directly declare target
+// and can be further lowered as declare target. Care is taken not to add
+// duplicate members to these lists, this also helps avoid infinite recursion
+// when encountering a recursive function.
+class ImplicitDeclareTargetCapture {
+public:
+  template <typename T> bool Pre(T &) { return true; }
+  template <typename T> void Post(T &) {}
+  ImplicitDeclareTargetCapture(SemanticsContext &context)
+      : messages_{context.messages()} {}
+
+  // Related to rewriting declare target specifiers to
+  // contain functions nested within the primary declare
+  // target function.
+  void Post(parser::OpenMPDeclareTargetConstruct &x) {
+    auto &spec{std::get<parser::OmpDeclareTargetSpecifier>(x.t)};
+    if (parser::OmpObjectList *
+        objectList{parser::Unwrap<parser::OmpObjectList>(spec.u)}) {
+      markDeclTarForEachProgramInList(programUnits_, *objectList);
+    } else if (auto *clauseList{
+                   parser::Unwrap<parser::OmpClauseList>(spec.u)}) {
+      for (auto &clause : clauseList->v) {
+        if (auto *toClause{std::get_if<parser::OmpClause::To>(&clause.u)}) {
+          markDeclTarForEachProgramInList(programUnits_, toClause->v);
+        } else if (auto *linkClause{
+                       std::get_if<parser::OmpClause::Link>(&clause.u)}) {
+          markDeclTarForEachProgramInList(programUnits_, linkClause->v);
+        }
+      }
+
+      // The default "declare target" inside of a function case, we must
+      // create and generate an to extended-list, containing at minimum the
+      // current function
+      if (clauseList->v.empty()) {
+        if (auto *name = getNameFromProgramUnit(*currentProgramUnit_)) {
+          std::list<parser::OmpObject> list;
+          list.push_back(parser::OmpObject{
+              parser::Designator{parser::DataRef{std::move(*name)}}});
+          auto objList = parser::OmpObjectList{std::move(list)};
+          markDeclTarForEachProgramInList(programUnits_, objList);
+          clauseList->v.push_back(parser::OmpClause::To{std::move(objList)});
+        }
+      }
+    }
+  }
+
+  bool Pre(parser::ProgramUnit &x) {
+    currentProgramUnit_ = &x;
+    if (auto *name = getNameFromProgramUnit(x))
+      programUnits_[name->ToString()] = &x;
+    return true;
+  }
+
+  parser::Name *getNameFromProgramUnit(parser::ProgramUnit &x) {
+    if (auto *func{parser::Unwrap<parser::FunctionSubprogram>(x.u)}) {
+      parser::FunctionStmt &Stmt = std::get<0>(func->t).statement;
+      return &std::get<parser::Name>(Stmt.t);
+    } else if (auto *subr{parser::Unwrap<parser::SubroutineSubprogram>(x.u)}) {
+      parser::SubroutineStmt &Stmt = std::get<0>(subr->t).statement;
+      return &std::get<parser::Name>(Stmt.t);
+    }
+    return nullptr;
+  }
+
+  void markDeclTarForEachProgramInList(
+      std::map<std::string, parser::ProgramUnit *> programUnits,
+      parser::OmpObjectList &objList) {
+    auto existsInList = [](parser::OmpObjectList &objList, parser::Name name) {
+      for (auto &ompObject : objList.v)
+        if (auto *objName{parser::Unwrap<parser::Name>(ompObject)})
+          if (objName->ToString() == name.ToString())
+            return true;
+      return false;
+    };
+
+    GatherCallRefs gatherer{};
+    for (auto &ompObject : objList.v) {
+      if (auto *name{parser::Unwrap<parser::Name>(ompObject)}) {
+        auto programUnit = programUnits.find(name->ToString());
+        // something other than a subroutine or function, skip it
+        if (programUnit == programUnits.end())
+          continue;
+
+        parser::Walk(*programUnit->second, gatherer);
+
+        // Currently using the Function Name rather than the CallRef name,
+        // unsure if these are interchangeable. However, ideally functions
+        // and subroutines should probably be parser::PorcedureDesignator's
+        // rather than parser::Designator's, but regular designators seem
+        // to be all that is utilised in the PFT definition for OmpObjects.
+        for (auto v : gatherer.callNames) {
+          if (!existsInList(objList, v)) {
+            objList.v.push_back(parser::OmpObject{parser::Designator{
+                parser::DataRef{std::move(*getNameFromProgramUnit(
+                    *programUnits.find(v.ToString())->second))}}});
+          }
+        }
+
+        gatherer.callNames.clear();
+      }
+    }
+  }
+
+private:
+  std::map<std::string, parser::ProgramUnit *> programUnits_;
+  parser::ProgramUnit *currentProgramUnit_ = nullptr;
+
+  parser::Messages &messages_;
+};
+
+bool FinalizeOMP(SemanticsContext &context, parser::Program &program) {
+  ImplicitDeclareTargetCapture impCap{context};
+  Walk(program, impCap);
+  return !context.AnyFatalError();
+}
+
+} // namespace Fortran::semantics

flang/lib/Semantics/semantics.cpp

 #include "check-nullify.h"
 #include "check-omp-structure.h"
 #include "check-purity.h"
 #include "check-return.h"
 #include "check-select-rank.h"
 #include "check-select-type.h"
 #include "check-stop.h"
 #include "compute-offsets.h"
+#include "finalize-omp.h"
 #include "mod-file.h"
 #include "resolve-labels.h"
 #include "resolve-names.h"
 #include "rewrite-parse-tree.h"
 #include "flang/Common/default-kinds.h"
 #include "flang/Parser/parse-tree-visitor.h"
 #include "flang/Parser/tools.h"
 #include "flang/Semantics/expression.h"
using StatementSemanticsPass2 = SemanticsVisitor<AccStructureChecker,
     OmpStructureChecker, PurityChecker, ReturnStmtChecker,
     SelectRankConstructChecker, SelectTypeChecker, StopChecker>;
 
 static bool PerformStatementSemantics(
     SemanticsContext &context, parser::Program &program) {
   ResolveNames(context, program, context.globalScope());
   RewriteParseTree(context, program);
   ComputeOffsets(context, context.globalScope());
+  FinalizeOMP(context, program);
   CheckDeclarations(context);
   StatementSemanticsPass1{context}.Walk(program);
   StatementSemanticsPass2 pass2{context};
   pass2.Walk(program);
   if (!context.AnyFatalError()) {
     pass2.CompileDataInitializationsIntoInitializers();
   }
   return !context.AnyFatalError();

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
+  }
+}

flang/test/Lower/OpenMP/Todo/omp-declare-target.f90

-! This test checks lowering of OpenMP declare target Directive.
-
-// RUN: not flang-new -fc1 -emit-fir -fopenmp %s 2>&1 | FileCheck %s
-
-module mod1
-contains
-  subroutine sub()
-    integer :: x, y
-    // CHECK: not yet implemented: OpenMPDeclareTargetConstruct
-    !$omp declare target
-  end
-end module

flang/test/Lower/OpenMP/omp-declare-target-data.f90

+!RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s 
+!RUN: %flang_fc1 -emit-fir -fopenmp -fopenmp-is-device %s -o - | FileCheck %s
+
+module test_0
+    implicit none
+
+!CHECK-DAG: fir.global @_QMtest_0Edata_int {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : i32
+INTEGER :: data_int = 10
+!$omp declare target link(data_int)
+
+!CHECK-DAG: 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>
+INTEGER :: array_1d(3) = (/1,2,3/)
+!$omp declare target link(array_1d)
+
+!CHECK-DAG: fir.global @_QMtest_0Earray_2d {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : !fir.array<2x2xi32> 
+INTEGER :: array_2d(2,2) = reshape((/1,2,3,4/), (/2,2/))
+!$omp declare target link(array_2d)
+
+!CHECK-DAG: fir.global @_QMtest_0Ept1 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : !fir.box<!fir.ptr<i32>>
+INTEGER, POINTER :: pt1
+!$omp declare target link(pt1)
+
+!CHECK-DAG: fir.global @_QMtest_0Ept2_tar {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} target : i32
+INTEGER, TARGET :: pt2_tar = 5 
+!$omp declare target link(pt2_tar)
+
+!CHECK-DAG: fir.global @_QMtest_0Ept2 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : !fir.box<!fir.ptr<i32>>
+INTEGER, POINTER :: pt2 => pt2_tar
+!$omp declare target link(pt2)
+
+!CHECK-DAG: fir.global @_QMtest_0Edata_int_to {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : i32
+INTEGER :: data_int_to = 5
+!$omp declare target to(data_int_to)
+
+!CHECK-DAG: fir.global @_QMtest_0Edata_int_clauseless {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : i32
+INTEGER :: data_int_clauseless = 1
+!$omp declare target(data_int_clauseless)
+
+!CHECK-DAG: fir.global @_QMtest_0Edata_extended_to_1 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : f32
+!CHECK-DAG: fir.global @_QMtest_0Edata_extended_to_2 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : f32
+REAL :: data_extended_to_1 = 2
+REAL :: data_extended_to_2 = 3
+!$omp declare target to(data_extended_to_1, data_extended_to_2)
+
+!CHECK-DAG: fir.global @_QMtest_0Edata_extended_link_1 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : f32
+!CHECK-DAG: fir.global @_QMtest_0Edata_extended_link_2 {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (link)>} : f32
+REAL :: data_extended_link_1 = 2
+REAL :: data_extended_link_2 = 3
+!$omp declare target link(data_extended_link_1, data_extended_link_2)
+
+contains
+end module test_0

flang/test/Lower/OpenMP/omp-declare-target-func-and-subr.f90

+!RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s
+
+! Check specification valid forms of declare target with functions 
+! utilising device_type and to clauses as well as the default 
+! zero clause declare target
+
+! CHECK-LABEL: func.func @_QPfunc_t_device()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+FUNCTION FUNC_T_DEVICE() RESULT(I)
+!$omp declare target to(FUNC_T_DEVICE) device_type(nohost)
+    INTEGER :: I
+    I = 1
+END FUNCTION FUNC_T_DEVICE
+
+! CHECK-LABEL: func.func @_QPfunc_t_host()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>{{.*}}
+FUNCTION FUNC_T_HOST() RESULT(I)
+!$omp declare target to(FUNC_T_HOST) device_type(host)
+    INTEGER :: I
+    I = 1
+END FUNCTION FUNC_T_HOST
+
+! CHECK-LABEL: func.func @_QPfunc_t_any()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION FUNC_T_ANY() RESULT(I)
+!$omp declare target to(FUNC_T_ANY) device_type(any)
+    INTEGER :: I
+    I = 1
+END FUNCTION FUNC_T_ANY
+
+! CHECK-LABEL: func.func @_QPfunc_default_t_any()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION FUNC_DEFAULT_T_ANY() RESULT(I)
+!$omp declare target to(FUNC_DEFAULT_T_ANY)
+    INTEGER :: I
+    I = 1
+END FUNCTION FUNC_DEFAULT_T_ANY
+
+! CHECK-LABEL: func.func @_QPfunc_default_any()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION FUNC_DEFAULT_ANY() RESULT(I)
+!$omp declare target
+    INTEGER :: I
+    I = 1
+END FUNCTION FUNC_DEFAULT_ANY
+
+! CHECK-LABEL: func.func @_QPfunc_default_extendedlist()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION FUNC_DEFAULT_EXTENDEDLIST() RESULT(I)
+!$omp declare target(FUNC_DEFAULT_EXTENDEDLIST)
+    INTEGER :: I
+    I = 1
+END FUNCTION FUNC_DEFAULT_EXTENDEDLIST
+
+! CHECK-LABEL: func.func @_QPexist_on_both()
+! CHECK-NOT: {{.*}}attributes {omp.declare_target = #omp.declaretarget<({{.*}})>{{.*}}
+FUNCTION EXIST_ON_BOTH() RESULT(I)
+    INTEGER :: I
+    I = 1
+END FUNCTION EXIST_ON_BOTH
+
+!! -----
+
+! Check specification valid forms of declare target with subroutines 
+! utilising device_type and to clauses as well as the default 
+! zero clause declare target
+
+! CHECK-LABEL: func.func @_QPsubr_t_device()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+SUBROUTINE SUBR_T_DEVICE()
+!$omp declare target to(SUBR_T_DEVICE) device_type(nohost)
+END
+
+! CHECK-LABEL: func.func @_QPsubr_t_host()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>{{.*}}
+SUBROUTINE SUBR_T_HOST()
+!$omp declare target to(SUBR_T_HOST) device_type(host)
+END
+
+! CHECK-LABEL: func.func @_QPsubr_t_any()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+SUBROUTINE SUBR_T_ANY()
+!$omp declare target to(SUBR_T_ANY) device_type(any)
+END
+
+! CHECK-LABEL: func.func @_QPsubr_default_t_any()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+SUBROUTINE SUBR_DEFAULT_T_ANY()
+!$omp declare target to(SUBR_DEFAULT_T_ANY)
+END
+
+! CHECK-LABEL: func.func @_QPsubr_default_any()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+SUBROUTINE SUBR_DEFAULT_ANY()
+!$omp declare target
+END
+
+! CHECK-LABEL: func.func @_QPsubr_default_extendedlist()
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+SUBROUTINE SUBR_DEFAULT_EXTENDEDLIST()
+!$omp declare target(SUBR_DEFAULT_EXTENDEDLIST)
+END
+
+! CHECK-LABEL: func.func @_QPsubr_exist_on_both()
+! CHECK-NOT: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type({{.*}})>{{.*}}
+SUBROUTINE SUBR_EXIST_ON_BOTH()
+END
+
+!! -----
+
+! Check declare target in conjunction with implicitly 
+! invoked functions, this tests the declare target 
+! implicit capture pass within Flang. Functions 
+! invoked within an explicitly declare target function 
+! are marked as declare target with the callers 
+! device_type clause
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION IMPLICITLY_CAPTURED(TOGGLE) RESULT(K)
+    INTEGER :: I, J, K
+    LOGICAL :: TOGGLE
+    I = 10
+    J = 5
+    IF (TOGGLE) THEN
+        K = I
+    ELSE
+        K = J
+    END IF
+END FUNCTION IMPLICITLY_CAPTURED
+
+
+! CHECK-LABEL: func.func @_QPtarget_function
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION TARGET_FUNCTION(TOGGLE) RESULT(I)
+!$omp declare target
+    INTEGER :: I
+    LOGICAL :: TOGGLE
+    I = IMPLICITLY_CAPTURED(TOGGLE)
+END FUNCTION TARGET_FUNCTION
+
+!! -----
+
+! Check declare target in conjunction with implicitly 
+! invoked functions, this tests the declare target 
+! implicit capture pass within Flang. Functions 
+! invoked within an explicitly declare target function 
+! are marked as declare target with the callers 
+! device_type clause, however, if they are found with 
+! distinct device_type clauses i.e. host and nohost, 
+! then they should be marked as any
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured_twice
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION IMPLICITLY_CAPTURED_TWICE() RESULT(K)
+    INTEGER :: I
+    I = 10
+    K = I
+END FUNCTION IMPLICITLY_CAPTURED_TWICE
+
+! CHECK-LABEL: func.func @_QPtarget_function_twice_host
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>{{.*}}
+FUNCTION TARGET_FUNCTION_TWICE_HOST() RESULT(I)
+!$omp declare target to(TARGET_FUNCTION_TWICE_HOST) device_type(host)
+    INTEGER :: I
+    I = IMPLICITLY_CAPTURED_TWICE()
+END FUNCTION TARGET_FUNCTION_TWICE_HOST
+
+! CHECK-LABEL: func.func @_QPtarget_function_twice_device
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+FUNCTION TARGET_FUNCTION_TWICE_DEVICE() RESULT(I)
+!$omp declare target to(TARGET_FUNCTION_TWICE_DEVICE) device_type(nohost)
+    INTEGER :: I
+    I = IMPLICITLY_CAPTURED_TWICE()
+END FUNCTION TARGET_FUNCTION_TWICE_DEVICE
+
+!! -----
+
+! Check declare target in conjunction with implicitly 
+! invoked functions, this tests the declare target 
+! implicit capture pass within Flang. A slightly more 
+! complex test checking functions are marked implicitly
+! appropriately. 
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured_nest
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+FUNCTION IMPLICITLY_CAPTURED_NEST() RESULT(K)
+    INTEGER :: I
+    I = 10
+    K = I
+END FUNCTION IMPLICITLY_CAPTURED_NEST
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured_one
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+FUNCTION IMPLICITLY_CAPTURED_ONE() RESULT(K)
+    K = IMPLICITLY_CAPTURED_NEST()
+END FUNCTION IMPLICITLY_CAPTURED_ONE
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured_two
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+FUNCTION IMPLICITLY_CAPTURED_TWO() RESULT(K)
+    INTEGER :: I
+    I = 10
+    K = I
+END FUNCTION IMPLICITLY_CAPTURED_TWO
+
+! CHECK-LABEL: func.func @_QPtarget_function_test
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+FUNCTION TARGET_FUNCTION_TEST() RESULT(J)
+!$omp declare target to(TARGET_FUNCTION_TEST) device_type(nohost)
+    INTEGER :: I, J
+    I = IMPLICITLY_CAPTURED_ONE()
+    J = IMPLICITLY_CAPTURED_TWO() + I
+END FUNCTION TARGET_FUNCTION_TEST
+
+!! -----
+
+! Check declare target in conjunction with implicitly 
+! invoked functions, this tests the declare target 
+! implicit capture pass within Flang. A slightly more 
+! complex test checking functions are marked implicitly
+! appropriately. 
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured_nest_twice
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION IMPLICITLY_CAPTURED_NEST_TWICE() RESULT(K)
+    INTEGER :: I
+    I = 10
+    K = I
+END FUNCTION IMPLICITLY_CAPTURED_NEST_TWICE
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured_one_twice
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION IMPLICITLY_CAPTURED_ONE_TWICE() RESULT(K)
+    K = IMPLICITLY_CAPTURED_NEST_TWICE()
+END FUNCTION IMPLICITLY_CAPTURED_ONE_TWICE
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured_two_twice
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION IMPLICITLY_CAPTURED_TWO_TWICE() RESULT(K)
+    INTEGER :: I
+    I = 10
+    K = I
+END FUNCTION IMPLICITLY_CAPTURED_TWO_TWICE
+
+! CHECK-LABEL: func.func @_QPtarget_function_test_device
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+FUNCTION TARGET_FUNCTION_TEST_DEVICE() RESULT(J)
+    !$omp declare target to(TARGET_FUNCTION_TEST_DEVICE) device_type(nohost)
+        INTEGER :: I, J
+        I = IMPLICITLY_CAPTURED_ONE_TWICE()
+        J = IMPLICITLY_CAPTURED_TWO_TWICE() + I 
+END FUNCTION TARGET_FUNCTION_TEST_DEVICE
+
+! CHECK-LABEL: func.func @_QPtarget_function_test_host
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>{{.*}}
+FUNCTION TARGET_FUNCTION_TEST_HOST() RESULT(J)
+    !$omp declare target to(TARGET_FUNCTION_TEST_HOST) device_type(host)
+        INTEGER :: I, J
+        I = IMPLICITLY_CAPTURED_ONE_TWICE()
+        J = IMPLICITLY_CAPTURED_TWO_TWICE() + I
+END FUNCTION TARGET_FUNCTION_TEST_HOST
+
+!! -----
+
+! CHECK-LABEL: func.func @_QPimplicitly_captured_recursive
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+RECURSIVE FUNCTION IMPLICITLY_CAPTURED_RECURSIVE(INCREMENT) RESULT(K)
+    INTEGER :: INCREMENT, K
+    IF (INCREMENT == 10) THEN
+        K = INCREMENT
+    ELSE
+        K = IMPLICITLY_CAPTURED_RECURSIVE(INCREMENT + 1)
+    END IF
+END FUNCTION IMPLICITLY_CAPTURED_RECURSIVE
+
+! CHECK-LABEL: func.func @_QPtarget_function_recurse
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>{{.*}}
+FUNCTION TARGET_FUNCTION_RECURSE() RESULT(I)
+!$omp declare target(TARGET_FUNCTION_RECURSE)
+    INTEGER :: I
+    I = IMPLICITLY_CAPTURED_RECURSIVE(0)
+END FUNCTION TARGET_FUNCTION_RECURSE
+
+!! -----
+
+! CHECK-LABEL: func.func @_QPrecursive_declare_target
+! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+RECURSIVE FUNCTION RECURSIVE_DECLARE_TARGET(INCREMENT) RESULT(K)
+!$omp declare target to(RECURSIVE_DECLARE_TARGET) device_type(nohost)
+    INTEGER :: INCREMENT, K
+    IF (INCREMENT == 10) THEN
+        K = INCREMENT
+    ELSE
+        K = RECURSIVE_DECLARE_TARGET(INCREMENT + 1)
+    END IF
+END FUNCTION RECURSIVE_DECLARE_TARGET

flang/test/Semantics/OpenMP/declare-target-implicit-capture-rewrite.f90

+! RUN: %flang_fc1 -fopenmp -fdebug-dump-parse-tree %s 2>&1 | FileCheck %s
+!
+! Ensure that functions and subroutines referenced within 
+! declare target functions are themselves made declare target 
+! as specified by more recent iterations of the OpenMP 
+! specification. This is done through a semantic pass which 
+! appends the implicitly captured functions to the original 
+! declare target declaration rather than generating and 
+! inserting new ones within the captured functions.
+! 
+! For example a declare target inside of a function named 'ORIGINAL', 
+! would initially be empty, after the pass, the declare target 
+! would be expanded to declare target to(ORIGINAL). If 
+! there is a function named 'CAPTURED' called within 'ORIGINAL' 
+! the declare target inside of 'ORIGINAL' would be further 
+! expanded to declare target to(ORIGINAL, CAPTURED)
+
+FUNCTION IMPLICITLY_CAPTURED_NEST_TWICE() RESULT(I)
+    INTEGER :: I
+    I = 10
+END FUNCTION IMPLICITLY_CAPTURED_NEST_TWICE
+
+FUNCTION IMPLICITLY_CAPTURED_ONE_TWICE() RESULT(K)
+    K = IMPLICITLY_CAPTURED_NEST_TWICE()
+END FUNCTION IMPLICITLY_CAPTURED_ONE_TWICE
+
+FUNCTION IMPLICITLY_CAPTURED_TWO_TWICE() RESULT(Y)
+    INTEGER :: Y
+    Y = 5
+END FUNCTION IMPLICITLY_CAPTURED_TWO_TWICE
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'target_function_test_device'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_one_twice'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_two_twice'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_nest_twice'
+! CHECK: OmpClause -> DeviceType -> OmpDeviceTypeClause -> Type = Nohost
+FUNCTION TARGET_FUNCTION_TEST_DEVICE() RESULT(J)
+!$omp declare target to(TARGET_FUNCTION_TEST_DEVICE) device_type(nohost)
+    INTEGER :: I, J
+    I = IMPLICITLY_CAPTURED_ONE_TWICE()
+    J = IMPLICITLY_CAPTURED_TWO_TWICE() + I 
+END FUNCTION TARGET_FUNCTION_TEST_DEVICE
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'target_function_test_host'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_one_twice'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_two_twice'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_nest_twice'
+! CHECK: OmpClause -> DeviceType -> OmpDeviceTypeClause -> Type = Host
+FUNCTION TARGET_FUNCTION_TEST_HOST() RESULT(J)
+!$omp declare target to(TARGET_FUNCTION_TEST_HOST) device_type(host)
+    INTEGER :: I, J
+    I = IMPLICITLY_CAPTURED_ONE_TWICE()
+    J = IMPLICITLY_CAPTURED_TWO_TWICE() + I
+END FUNCTION TARGET_FUNCTION_TEST_HOST
+
+!! -----
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'func_t_device'
+! CHECK: OmpClause -> DeviceType -> OmpDeviceTypeClause -> Type = Nohost
+FUNCTION FUNC_T_DEVICE() RESULT(I)
+!$omp declare target to(FUNC_T_DEVICE) device_type(nohost)
+    INTEGER :: I
+    I = 1
+END FUNCTION FUNC_T_DEVICE
+
+!! -----
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'subr_t_any'
+! CHECK: OmpClause -> DeviceType -> OmpDeviceTypeClause -> Type = Any
+SUBROUTINE SUBR_T_ANY()
+!$omp declare target to(SUBR_T_ANY) device_type(any)
+END
+
+!! -----
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithList -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'subr_default_extendedlist'
+SUBROUTINE SUBR_DEFAULT_EXTENDEDLIST()
+!$omp declare target(SUBR_DEFAULT_EXTENDEDLIST)
+END
+
+!! -----
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'subr_unspecified'
+SUBROUTINE SUBR_UNSPECIFIED()
+!$omp declare target
+END
+
+!! -----
+
+FUNCTION UNSPECIFIED_CAPTURE() RESULT(K)
+    REAL :: K
+    K = 1
+END FUNCTION UNSPECIFIED_CAPTURE
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'subr_unspecified_capture'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'unspecified_capture'
+SUBROUTINE SUBR_UNSPECIFIED_CAPTURE()
+!$omp declare target
+    REAL :: I
+    I = UNSPECIFIED_CAPTURE()
+END
+
+!! -----
+    
+FUNCTION IMPLICITLY_CAPTURED_NEST() RESULT(K)
+    INTEGER :: I
+    I = 10
+    K = I
+END FUNCTION IMPLICITLY_CAPTURED_NEST
+
+FUNCTION IMPLICITLY_CAPTURED_ONE() RESULT(K)
+    K = IMPLICITLY_CAPTURED_NEST()
+END FUNCTION IMPLICITLY_CAPTURED_ONE
+
+FUNCTION IMPLICITLY_CAPTURED_TWO() RESULT(K)
+    INTEGER :: I
+    I = 10
+    K = I
+END FUNCTION IMPLICITLY_CAPTURED_TWO
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'target_function_test'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_one'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_two'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_nest'
+! CHECK: OmpClause -> DeviceType -> OmpDeviceTypeClause -> Type = Nohost
+FUNCTION TARGET_FUNCTION_TEST() RESULT(J)
+!$omp declare target to(TARGET_FUNCTION_TEST) device_type(nohost)
+    INTEGER :: I, J
+    I = IMPLICITLY_CAPTURED_ONE()
+    J = IMPLICITLY_CAPTURED_TWO() + I
+END FUNCTION TARGET_FUNCTION_TEST
+
+!! -----
+
+FUNCTION NO_DECLARE_TARGET() RESULT(K)
+    implicit none
+    REAL :: I, K
+    I = 10.0
+    K = I
+END FUNCTION NO_DECLARE_TARGET
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'declare_target_two'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'no_declare_target'
+FUNCTION DECLARE_TARGET_TWO() RESULT(J)
+!$omp declare target to(DECLARE_TARGET_TWO)
+    implicit none
+    REAL :: I, J
+    I = NO_DECLARE_TARGET()
+    J = I
+END FUNCTION DECLARE_TARGET_TWO
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'declare_target_one'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'declare_target_two'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'no_declare_target'
+FUNCTION DECLARE_TARGET_ONE() RESULT(I)
+!$omp declare target to(DECLARE_TARGET_ONE)
+    implicit none
+    REAL :: K, I
+    I = DECLARE_TARGET_TWO()
+    K = I
+END FUNCTION DECLARE_TARGET_ONE
+
+!! -----
+
+RECURSIVE FUNCTION IMPLICITLY_CAPTURED_RECURSIVE(INCREMENT) RESULT(K)
+    INTEGER :: INCREMENT, K
+    IF (INCREMENT == 10) THEN
+        K = INCREMENT
+    ELSE
+        K = IMPLICITLY_CAPTURED_RECURSIVE(INCREMENT + 1)
+    END IF
+END FUNCTION IMPLICITLY_CAPTURED_RECURSIVE
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithList -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'target_function_recurse'
+! CHECK: OmpObject -> Designator -> DataRef -> Name = 'implicitly_captured_recursive'
+FUNCTION TARGET_FUNCTION_RECURSE() RESULT(I)
+!$omp declare target(TARGET_FUNCTION_RECURSE)
+    INTEGER :: I
+    I = IMPLICITLY_CAPTURED_RECURSIVE(0)
+END FUNCTION TARGET_FUNCTION_RECURSE
+
+!! -----
+
+! CHECK: SpecificationPart
+! CHECK: OpenMPDeclarativeConstruct -> OpenMPDeclareTargetConstruct
+! CHECK: Verbatim
+! CHECK: OmpDeclareTargetSpecifier -> OmpDeclareTargetWithClause -> OmpClauseList -> OmpClause -> To -> OmpObjectList -> OmpObject -> Designator -> DataRef -> Name = 'recursive_declare_target'
+RECURSIVE FUNCTION RECURSIVE_DECLARE_TARGET(INCREMENT) RESULT(K)
+!$omp declare target to(RECURSIVE_DECLARE_TARGET) device_type(nohost)
+    INTEGER :: INCREMENT, K
+    IF (INCREMENT == 10) THEN
+        K = INCREMENT
+    ELSE
+        K = RECURSIVE_DECLARE_TARGET(INCREMENT + 1)
+    END IF
+END FUNCTION RECURSIVE_DECLARE_TARGET

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
 //===----------------------------------------------------------------------===//
 
 class OpenMP_Attr<string name, string attrMnemonic,

 
 // 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
+}