diff --git a/flang/lib/Lower/OpenMP.cpp b/flang/lib/Lower/OpenMP.cpp
--- a/flang/lib/Lower/OpenMP.cpp
+++ b/flang/lib/Lower/OpenMP.cpp
@@ -2469,6 +2469,112 @@
   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,
@@ -2491,8 +2597,7 @@
           },
           [&](const Fortran::parser::OpenMPDeclareTargetConstruct
                   &declareTargetConstruct) {
-            TODO(converter.getCurrentLocation(),
-                 "OpenMPDeclareTargetConstruct");
+            handleDeclareTarget(converter, eval, declareTargetConstruct);
           },
           [&](const Fortran::parser::OpenMPRequiresConstruct
                   &requiresConstruct) {
diff --git a/flang/test/Lower/OpenMP/Todo/omp-declare-target.f90 b/flang/test/Lower/OpenMP/Todo/omp-declare-target.f90
deleted file mode 100644
--- a/flang/test/Lower/OpenMP/Todo/omp-declare-target.f90
+++ /dev/null
@@ -1,12 +0,0 @@
-! 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
diff --git a/flang/test/Lower/OpenMP/omp-declare-target-data.f90 b/flang/test/Lower/OpenMP/omp-declare-target-data.f90
new file mode 100644
--- /dev/null
+++ b/flang/test/Lower/OpenMP/omp-declare-target-data.f90
@@ -0,0 +1,52 @@
+!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
diff --git a/flang/test/Lower/OpenMP/omp-declare-target-func-and-subr.f90 b/flang/test/Lower/OpenMP/omp-declare-target-func-and-subr.f90
new file mode 100644
--- /dev/null
+++ b/flang/test/Lower/OpenMP/omp-declare-target-func-and-subr.f90
@@ -0,0 +1,297 @@
+!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