[Flang][OpenMP][MLIR] Filter emitted code depending on declare target and device

[skatrak]

Summary

This patch adds support for selecting which functions are lowered to LLVM IR from MLIR depending on declare target information and whether host or device code is being generated.

The approach proposed by this patch is to perform the filtering in two stages:

• An MLIR transformation pass, which is added to the Flang translation flow before the VerifierPass. The functions that are kept are those that match the OpenMP processor (host or device) the compiler invocation is targeting, according to the presence of the -fopenmp-is-device compiler option and declare target information. All functions contaning an omp.target are also kept, regardless of the declare target information of the function, due to the need for keeping target regions visible for both host and device compilation.
• A filtering step during translation to LLVM IR, which is peformed for those functions that were kept because of the presence of a target region inside. If the targeted OpenMP processor does not match the declare target information of the function, then it is removed from the LLVM IR after its contents have been processed and translated. Since they should only contain an omp.target operation which, in turn, should have been outlined into another LLVM function, the wrapper can be deleted at that point.

Depends on D150328 and D150329.

[skatrak]

Update and add test.

[skatrak]

Rebase and fix tests

[jdoerfert]

generating functions and then deleting them is costly and will likely not work. We need to not emit them in the first place.

[skatrak]

In D147641#4313262, @jdoerfert wrote:

generating functions and then deleting them is costly and will likely not work. We need to not emit them in the first place.

I agree that we should strive to avoid doing unnecessary work rather than discarding it after the fact. However, the current implementation of target region outlining interacts with this in a way that prevents us from doing that in all cases. Let's say we implemented this function filtering patch as a semantic analysis pass:

• We could forward the information from the frontend about whether we're compiling for the host or device (-fopenmp-is-device) to this new pass.
• We could add the pass after the ImplicitDeclareTargetCapture pass implemented in D146063 or similar, so implicit declare target information is already propagated and available.
• Using the knowledge about whether functions are only intended for the host, device or both, and what we're compiling for, we could remove from the parse tree those functions that won't need lowering.
• For the host that would mean removing declare target device_type(nohost) functions, and for the device it would mean removing declare target device_type(host) and non-declare target functions.

However, the issues come when we consider the interaction of that approach with target regions:

• Target regions (which should be lowered for the device) can appear inside of host functions.
• Reverse-offload target regions (which should eventually be lowered for the host) can appear inside of device functions and target regions.
• The first two points mean that, while generating host code, you must also look for target regions inside device functions and vice versa.
• Target region outlining currently happens very late, at the MLIR to LLVM IR translation stage, during the lowering of their parent function, when the related omp.target MLIR operation is visited. D147172 was the main patch implementing this, and D147940 is a proposal to extend it for the device.
• If we remove a function before that point due to being intended for another device, then there won't be any outlining of the target regions defined inside of it either.

I've got a couple of ideas about to handle this problem, but I'm not particularly convinced about any of them:

• We could relax the requirement of the hypothetical semantics pass to avoid discarding too early functions that contain target regions, so that they can be outlined later. But then they will have to be pruned after translating them from MLIR to LLVM IR, like this patch is doing. We would be implementing the same kind of idea in two different places so that we could reduce the number of functions that we unnecessarily lower. Perhaps it would also be possible to reduce further the work done on these functions by only lowering the target regions inside (perhaps by hijacking ModuleTranslation::convertBlock), and not the rest of operations in them.
• Another option could be to try to move part of the outlining work into a semantics pass as well, so that we wouldn't have to keep around the parent functions intended for the other device. We would have to do all of the used variable capturing there (which it's not currently implemented AFAIK), so that they can be part of the new function as well. The result of this would be that at the MLIR level there would be some compiler-generated functions with just an omp.target operation inside (not called from anywhere else), together with the rest of functions in the module that apply to the device we're compiling for (possibly containing other omp.target operations that should actually be implemented by the opposite device). We would have to mark these compiler-generated functions somehow to make sure that they are treated differently during MLIR to LLVM IR translation -- for compiler-generated functions, only the contents of the omp.target operation inside should be lowered, whereas for other functions everything should be lowered and any occurrences of that operation should become a kernel call or a reverse-offload call, ignoring the region attached to them.

The implementation in this patch, although not very efficient, is a very simple first approach that doesn't require significantly reworking different parts of offloading support. I'd like to know what you think about this, or if @jsjodin, @domada, @agozillon, @kiranchandramohan or others have any thoughts about it as well. It'd be good to reach some sort of consensus before committing to significant work.

[jsjodin]

I don't think moving the outlining early on is the best approach since we want this code to be shared with clang. Would it be sufficient to filter the functions that do not contain target regions after the analysis in https://reviews.llvm.org/D146063 somewhere in the front-end and let the MLIR->LLVM IR translation handle the functions that has target regions?

[skatrak]

Ping @jdoerfert. Do you have any other thoughts different to what Jan's suggesting? Just looking to make sure we're in the same page to avoid redoing the work multiple times.

[skatrak]

Rebase and update to depend on declare target work split into multiple patches.

[jsjodin]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

1051 ↗

(On Diff #523385)

The maskedFunction information lives only inside this function. Can we make it in to a local variable and pass it in to convertOneFunction?

[skatrak]

Ping again in case there any opinions against following Jan's suggestion before starting its implementation. In summary, the idea would be to:

• Add a semantics pass to filter out functions that are not intended for the device we're compiling, according to implicit/explicit declare target information, except for those with a target region inside.
• Keep also the approach in this first patch, so that the IR for the enclosing functions where target regions are located is deleted after the target regions themselves are outlined by the OpenMPIRBuilder.

I am thinking that there could be situations where this approach might break. Let's say there's a host-only subroutine f() called by a host-only subroutine g() that contains a target region as well (f() not called from inside the target region). Then, during compilation for the device, f() would be removed in semantics whereas g() would be kept due to it having a target region to be processed later during MLIR to LLVM IR translation. What would happen then with the call to the f() subroutine that would have become undefined?

Should we just replace the body of functions to be deleted in semantics by an empty body or a default 'return' statement instead? Or would it maybe be a preferable alternative to delete these functions altogether but also delete any calls to them? The first option could become difficult if these subroutines/functions return complex data types, and also we may end up generating many unused functions. The only issue I see with the second option is what would happen if function calls are used as part of an expression to initialize some data. I'm leaning towards just deleting all statements except variable declarations and target regions from functions intended for another device, which seems like solves all of the issues above.

Let me know if you have any more thoughts on this, and thank you for taking the time.

[jsjodin]

In D147641#4413305, @skatrak wrote:

Ping again in case there any opinions against following Jan's suggestion before starting its implementation. In summary, the idea would be to:

• Add a semantics pass to filter out functions that are not intended for the device we're compiling, according to implicit/explicit declare target information, except for those with a target region inside.
• Keep also the approach in this first patch, so that the IR for the enclosing functions where target regions are located is deleted after the target regions themselves are outlined by the OpenMPIRBuilder.

I am thinking that there could be situations where this approach might break. Let's say there's a host-only subroutine f() called by a host-only subroutine g() that contains a target region as well (f() not called from inside the target region). Then, during compilation for the device, f() would be removed in semantics whereas g() would be kept due to it having a target region to be processed later during MLIR to LLVM IR translation. What would happen then with the call to the f() subroutine that would have become undefined?

Should we just replace the body of functions to be deleted in semantics by an empty body or a default 'return' statement instead? Or would it maybe be a preferable alternative to delete these functions altogether but also delete any calls to them? The first option could become difficult if these subroutines/functions return complex data types, and also we may end up generating many unused functions. The only issue I see with the second option is what would happen if function calls are used as part of an expression to initialize some data. I'm leaning towards just deleting all statements except variable declarations and target regions from functions intended for another device, which seems like solves all of the issues above.

Let me know if you have any more thoughts on this, and thank you for taking the time.

Can we add declarations for them instead of having empty bodies?

[skatrak]

In D147641#4417720, @jsjodin wrote:

Can we add declarations for them instead of having empty bodies?

Since semantics work at the PFT level, I've looked into how to define the Fortran-equivalent to forward declarations. It seems like external procedures could be one solution to this. So it should be possible to delete all function and subroutine definitions intended for another device and add an external declaration to all their callers. These calls and external procedure declarations will remain in MLIR but they will be removed in the MLIR to LLVM IR translation step.

[skatrak]

Implement early function filtering as an MLIR pass.

[skatrak]

Update after splitting off pass infrastructure into D154194.

[skatrak]

Move MLIR transformation pass to Flang and implement 2-stage filtering to work together with early target region outlining.

[jsjodin]

flang/lib/Frontend/FrontendActions.cpp

712

I don't think this is needed. The FIR should already have been filtered by the front end.

flang/lib/Optimizer/Transforms/OMPFunctionFiltering.cpp

49

This could potentially be simplified if the early outlining is run before this pass. I think this is still okay though since the first instruction in the outlined functions is a TargetOp so it should be efficient, and it still works without the early outlining. So I think it is okay to keep as-is.

[skatrak]

Address review comments and integrate with recently-landed early target region outlining. Small refactor to improve readability and minimize TargetOp search overhead.

[skatrak]

Move misplaced function.

[skatrak]

Thank you for your feedback Jan, your comments should have been addressed.

flang/lib/Optimizer/Transforms/OMPFunctionFiltering.cpp

49

I thought about this, but I think it's still necessary to check here whether there are omp.target ops inside because the outlined functions are host functions in the device pass. So they would by default be filtered out here and the omp.target inside wouldn't reach the MLIR to LLVM IR translation stage.

But you're right. By running this after early outlining, the check should be very quick.

[jsjodin]

LGTM, Please wait for another acceptance.

flang/lib/Optimizer/Transforms/OMPFunctionFiltering.cpp

49

It would be possible to check the early outlining interface to see if the parent function name is set, but that solution is less desirable imo.

[kiranchandramohan]

See comment inline.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

The change in convertOneFunction is intrusive. Code here must not be aware of the OpenMP attributes.

[jsjodin]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

The change in convertOneFunction is intrusive. Code here must not be aware of the OpenMP attributes.

Would it be ensure that the omp.declare_target dialect attribute is available so that convertDialectAttributes can handle everything?

[jsjodin]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

The change in convertOneFunction is intrusive. Code here must not be aware of the OpenMP attributes.

Would it be ensure that the omp.declare_target dialect attribute is available so that convertDialectAttributes can handle everything?

934–944 ↗

(On Diff #540368)

The change in convertOneFunction is intrusive. Code here must not be aware of the OpenMP attributes.

Would it be ensure that the omp.declare_target dialect attribute is available so that convertDialectAttributes can handle everything?

Correction: Would it be possible to ensure that the omp.declare_target dialect attribute is available so that convertDialectAttributes can handle everything?

[skatrak]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

The change in convertOneFunction is intrusive. Code here must not be aware of the OpenMP attributes.

The problem here is that the amendOperation flow is called if there is an omp.declare_target attribute explicitly set for the function. However, functions without the attribute must also be treated as declare target with device type = host, so they must be filtered out during device compilation.

So, the options I see are either to access the attribute directly here or ensure that all functions have the attribute, either by setting it here or at an earlier stage. Though it might be enough to mark outlined functions with the attribute, which should be the only ones that will be removed at this stage.

[jsjodin]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

The change in convertOneFunction is intrusive. Code here must not be aware of the OpenMP attributes.

The problem here is that the amendOperation flow is called if there is an omp.declare_target attribute explicitly set for the function. However, functions without the attribute must also be treated as declare target with device type = host, so they must be filtered out during device compilation.

So, the options I see are either to access the attribute directly here or ensure that all functions have the attribute, either by setting it here or at an earlier stage. Though it might be enough to mark outlined functions with the attribute, which should be the only ones that will be removed at this stage.

I think the best option is to modify the early outlining to set the attribute. You can add that to this patch and a test if the current tests don't already cover this.

[agozillon]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

The type of the attribute is just a boolean though, so it has no dependencies on the OpenMPDialect, we already use something similar inside of the getOpenMPBuilder call: https://github.com/llvm/llvm-project/blob/main/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp#L1311 Is it possible to do a similar segment of code inside of the destructor of ModuleTranslation, where we already have some OpenMP specific code (destruction of the OMPIRBuilder)? And is that a more acceptable approach?

[skatrak]

Remove handling of OpenMP dialect attributes from generic translation. Not needed because the early outlining pass already adds the omp.declare_target attribute to the new function, so the second-stage filter can assume it will be always explicitly set.

[kiranchandramohan]

Thanks @skatrak.

[skatrak]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

After some testing it turns out that, in this specific case, we can assume that the attribute will be explicitly set by the early outlining. So there is no need to check for implicit host functions here.

The type of the attribute is just a boolean though, so it has no dependencies on the OpenMPDialect, we already use something similar inside of the getOpenMPBuilder call: https://github.com/llvm/llvm-project/blob/main/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp#L1311 Is it possible to do a similar segment of code inside of the destructor of ModuleTranslation, where we already have some OpenMP specific code (destruction of the OMPIRBuilder)? And is that a more acceptable approach?

I think that is also something we should try to remove from this file if we can. In D147219 I implemented an approach that moves the OMPIRBuilder configuration to the amendOperation flow as well, which has the advantage of allowing the use of OpenMP custom attribute types. It's not been accepted, but I think it's a better way to go about that.

[agozillon]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

While I'm all for doing that, I don't think moving it into amendOperation would work at this time, as the attributes are tied to the ModuleOp and I believe the amendOperation for the ModuleOp is ran as one of the final things in the lowering process. The information in the Config for IRBuilder is required very early on, before lowering global ops (for declare target) which happens prior to even the function lowering which is when TargetOp will currently need it. I could be incorrect though!

[skatrak]

Thank you all for the comments, I'll land this patch shortly.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

934–944 ↗

(On Diff #540368)

Yes, I noticed that issue as well. If you look at that patch, you can see that I moved the convertOperation() call to the module inside of translateModuleToLLVMIR() to be before translating the functions inside. Doing it in that order means that the OpenMPIRBuilder is initialized before translating the contents of the module. I believe that is a good approach to avoid having dialect-specific attributes handling in the generic ModuleTranslation, since (at least at this time) there is no particular reason why the module should be converted/amended last.

flang/include/flang/Optimizer/Transforms/Passes.h

 std::unique_ptr<mlir::Pass>
 createMemoryAllocationPass(bool dynOnHeap, std::size_t maxStackSize);
 std::unique_ptr<mlir::Pass> createAnnotateConstantOperandsPass();
 std::unique_ptr<mlir::Pass> createSimplifyRegionLitePass();
 std::unique_ptr<mlir::Pass> createAlgebraicSimplificationPass();
 std::unique_ptr<mlir::Pass>
 createAlgebraicSimplificationPass(const mlir::GreedyRewriteConfig &config);
 std::unique_ptr<mlir::Pass> createPolymorphicOpConversionPass();
+
 std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
 createOMPEarlyOutliningPass();
+std::unique_ptr<mlir::Pass> createOMPFunctionFilteringPass();
+
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_TRANSFORMS_PASSES_H

flang/include/flang/Optimizer/Transforms/Passes.td

let description = [{
     It is invoked in the front end after the initial FIR has been constructed.
     This pass is only needed when compiling for the target device to prevent
     the optimizer to perform transforms across target region boundaries.
   }];
   let constructor = "::fir::createOMPEarlyOutliningPass()";
   let dependentDialects = ["mlir::omp::OpenMPDialect"];
 }
 
+def OMPFunctionFiltering : Pass<"omp-function-filtering"> {
+  let summary = "Filters out functions intended for the host when compiling "
+                "for the device and vice versa.";
+  let constructor = "::fir::createOMPFunctionFilteringPass()";
+  let dependentDialects = [
+    "mlir::func::FuncDialect"
+  ];
+}
+
 #endif // FLANG_OPTIMIZER_TRANSFORMS_PASSES

flang/lib/Frontend/FrontendActions.cpp

if (ci.getInvocation().getFrontendOpts().features.IsEnabled(
           Fortran::common::LanguageFeature::OpenMP)) {
     bool isDevice = false;
     if (auto offloadMod = llvm::dyn_cast<mlir::omp::OffloadModuleInterface>(
             mlirModule->getOperation()))
       isDevice = offloadMod.getIsTargetDevice();
 
     if (isDevice)
       pm.addPass(fir::createOMPEarlyOutliningPass());
+    pm.addPass(fir::createOMPFunctionFilteringPass());
   }
 
   pm.enableVerifier(/*verifyPasses=*/true);
   pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
 
   if (mlir::failed(pm.run(*mlirModule))) {
     unsigned diagID = ci.getDiagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error,
void CodeGenAction::generateLLVMIR() {
 
   // Set-up the MLIR pass manager
   mlir::PassManager pm((*mlirModule)->getName(),
                        mlir::OpPassManager::Nesting::Implicit);
 
   pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
   pm.enableVerifier(/*verifyPasses=*/true);
 
   // Create the pass pipeline
   fir::createMLIRToLLVMPassPipeline(pm, level, opts.StackArrays,
                                     opts.Underscoring, opts.LoopVersioning,
                                     opts.getDebugInfo());
   (void)mlir::applyPassManagerCLOptions(pm);
 
   // run the pass manager
   if (!mlir::succeeded(pm.run(*mlirModule))) {
     unsigned diagID = ci.getDiagnostics().getCustomDiagID(

flang/lib/Optimizer/Transforms/CMakeLists.txt

add_flang_library(FIRTransforms
   MemRefDataFlowOpt.cpp
   SimplifyRegionLite.cpp
   AlgebraicSimplification.cpp
   SimplifyIntrinsics.cpp
   AddDebugFoundation.cpp
   PolymorphicOpConversion.cpp
   LoopVersioning.cpp
   OMPEarlyOutlining.cpp
+  OMPFunctionFiltering.cpp
 
   DEPENDS
   FIRDialect
   FIROptTransformsPassIncGen
 
   LINK_LIBS
   FIRBuilder
   FIRCodeGen

flang/lib/Optimizer/Transforms/OMPFunctionFiltering.cpp

+//===- OMPFunctionFiltering.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements transforms to filter out functions intended for the host
+// when compiling for the device and vice versa.
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Optimizer/Transforms/Passes.h"
+
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "mlir/Dialect/OpenMP/OpenMPInterfaces.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace fir {
+#define GEN_PASS_DEF_OMPFUNCTIONFILTERING
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
+using namespace fir;
+using namespace mlir;
+
+namespace {
+class OMPFunctionFilteringPass
+    : public fir::impl::OMPFunctionFilteringBase<OMPFunctionFilteringPass> {
+public:
+  OMPFunctionFilteringPass() = default;
+
+  void runOnOperation() override {
+    auto op = dyn_cast<omp::OffloadModuleInterface>(getOperation());
+    if (!op)
+      return;
+
+    bool isDeviceCompilation = op.getIsTargetDevice();
+    op->walk<WalkOrder::PostOrder>([&](func::FuncOp funcOp) {
+      // Do not filter functions with target regions inside, because they have
+      // to be available for both host and device so that regular and reverse
+      // offloading can be supported.
+      bool hasTargetRegion =
+          funcOp
+              ->walk<WalkOrder::PreOrder>(
+                  [&](omp::TargetOp) { return WalkResult::interrupt(); })
+              .wasInterrupted();
+      if (hasTargetRegion)
+        return;
+
+      omp::DeclareTargetDeviceType declareType =
+          omp::DeclareTargetDeviceType::host;
+      auto declareTargetOp =
+          dyn_cast<omp::DeclareTargetInterface>(funcOp.getOperation());
+      if (declareTargetOp && declareTargetOp.isDeclareTarget())
+        declareType = declareTargetOp.getDeclareTargetDeviceType();
+
+      if ((isDeviceCompilation &&
+           declareType == omp::DeclareTargetDeviceType::host) ||
+          (!isDeviceCompilation &&
+           declareType == omp::DeclareTargetDeviceType::nohost))
+        funcOp->erase();
+    });
+  }
+};
+} // namespace
+
+std::unique_ptr<Pass> fir::createOMPFunctionFilteringPass() {
+  return std::make_unique<OMPFunctionFilteringPass>();
+}

flang/test/Lower/OpenMP/function-filtering.f90

+! RUN: %flang_fc1 -fopenmp -emit-llvm %s -o - | FileCheck --check-prefixes=LLVM-HOST,LLVM-ALL %s
+! RUN: %flang_fc1 -fopenmp -emit-mlir %s -o - | FileCheck --check-prefix=MLIR-HOST %s
+! RUN: %flang_fc1 -fopenmp -fopenmp-is-target-device -emit-llvm %s -o - | FileCheck --check-prefixes=LLVM-DEVICE,LLVM-ALL %s
+! RUN: %flang_fc1 -fopenmp -fopenmp-is-target-device -emit-mlir %s -o - | FileCheck --check-prefix=MLIR-DEVICE %s
+
+! Check that the correct LLVM IR functions are kept for the host and device
+! after running the whole set of translation and transformation passes from
+! Fortran.
+
+! MLIR-HOST-NOT: func.func @{{.*}}device_fn(
+! MLIR-DEVICE: func.func @{{.*}}device_fn(
+! LLVM-HOST-NOT: define {{.*}} @{{.*}}device_fn{{.*}}(
+! LLVM-DEVICE: define {{.*}} @{{.*}}device_fn{{.*}}(
+function device_fn() result(x)
+  !$omp declare target to(device_fn) device_type(nohost)
+  integer :: x
+  x = 10
+end function device_fn
+
+! MLIR-HOST: func.func @{{.*}}host_fn(
+! MLIR-DEVICE-NOT: func.func @{{.*}}host_fn(
+! LLVM-HOST: define {{.*}} @{{.*}}host_fn{{.*}}(
+! LLVM-DEVICE-NOT: define {{.*}} @{{.*}}host_fn{{.*}}(
+function host_fn() result(x)
+  !$omp declare target to(host_fn) device_type(host)
+  integer :: x
+  x = 10
+end function host_fn
+
+! MLIR-HOST: func.func @{{.*}}target_subr(
+! MLIR-HOST-NOT: func.func @{{.*}}target_subr_omp_outline_0(
+! MLIR-DEVICE-NOT: func.func @{{.*}}target_subr(
+! MLIR-DEVICE: func.func @{{.*}}target_subr_omp_outline_0(
+
+! LLVM-ALL-NOT: define {{.*}} @{{.*}}target_subr_omp_outline_0{{.*}}(
+! LLVM-HOST: define {{.*}} @{{.*}}target_subr{{.*}}(
+! LLVM-DEVICE-NOT: define {{.*}} @{{.*}}target_subr{{.*}}(
+! LLVM-ALL: define {{.*}} @__omp_offloading_{{.*}}_{{.*}}_target_subr__{{.*}}(
+subroutine target_subr(x)
+  integer, intent(out) :: x
+  !$omp target map(from:x)
+    x = 10
+  !$omp end target
+end subroutine target_subr

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

-!RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s
+!RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s --check-prefixes ALL,HOST
+!RUN: %flang_fc1 -emit-fir -fopenmp -fopenmp-is-device %s -o - | FileCheck %s --check-prefixes ALL,DEVICE
 
 ! 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)>{{.*}}
+! DEVICE-LABEL: func.func @_QPfunc_t_device()
+! DEVICE-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)>{{.*}}
+! HOST-LABEL: func.func @_QPfunc_t_host()
+! HOST-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)>{{.*}}
+! ALL-LABEL: func.func @_QPfunc_t_any()
+! ALL-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)>{{.*}}
+! ALL-LABEL: func.func @_QPfunc_default_t_any()
+! ALL-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)>{{.*}}
+! ALL-LABEL: func.func @_QPfunc_default_any()
+! ALL-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)>{{.*}}
+! ALL-LABEL: func.func @_QPfunc_default_extendedlist()
+! ALL-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 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)>{{.*}}
+! DEVICE-LABEL: func.func @_QPsubr_t_device()
+! DEVICE-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)>{{.*}}
+! HOST-LABEL: func.func @_QPsubr_t_host()
+! HOST-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)>{{.*}}
+! ALL-LABEL: func.func @_QPsubr_t_any()
+! ALL-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)>{{.*}}
+! ALL-LABEL: func.func @_QPsubr_default_t_any()
+! ALL-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)>{{.*}}
+! ALL-LABEL: func.func @_QPsubr_default_any()
+! ALL-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)>{{.*}}
+! ALL-LABEL: func.func @_QPsubr_default_extendedlist()
+! ALL-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 @_QPrecursive_declare_target
-! CHECK-SAME: {{.*}}attributes {omp.declare_target = #omp.declaretarget<device_type = (nohost), capture_clause = (to)>{{.*}}
+! DEVICE-LABEL: func.func @_QPrecursive_declare_target
+! DEVICE-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/Lower/OpenMP/omp-declare-target-program-var.f90

-!RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s 
-!RUN: %flang_fc1 -emit-fir -fopenmp -fopenmp-is-target-device %s -o - | FileCheck %s
+!RUN: %flang_fc1 -emit-fir -fopenmp %s -o - | FileCheck %s --check-prefixes=HOST,ALL
+!RUN: %flang_fc1 -emit-fir -fopenmp -fopenmp-is-target-device %s -o - | FileCheck %s --check-prefix=ALL
 
 PROGRAM main
-    ! CHECK-DAG: %0 = fir.alloca f32 {bindc_name = "i", uniq_name = "_QFEi"}
+    ! HOST-DAG: %0 = fir.alloca f32 {bindc_name = "i", uniq_name = "_QFEi"}
     REAL :: I
-    ! CHECK-DAG: fir.global internal @_QFEi {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : f32 {
-    ! CHECK-DAG: %0 = fir.undefined f32
-    ! CHECK-DAG: fir.has_value %0 : f32
-    ! CHECK-DAG: }
+    ! ALL-DAG: fir.global internal @_QFEi {omp.declare_target = #omp.declaretarget<device_type = (any), capture_clause = (to)>} : f32 {
+    ! ALL-DAG: %0 = fir.undefined f32
+    ! ALL-DAG: fir.has_value %0 : f32
+    ! ALL-DAG: }
     !$omp declare target(I)
 END

flang/test/Transforms/omp-function-filtering.mlir

+// RUN: fir-opt -split-input-file --omp-function-filtering %s | FileCheck %s
+
+// CHECK:     func.func @any
+// CHECK:     func.func @nohost
+// CHECK-NOT: func.func @host
+// CHECK-NOT: func.func @none
+// CHECK:     func.func @nohost_target
+// CHECK:     func.func @host_target
+// CHECK:     func.func @none_target
+module attributes {omp.is_target_device = true} {
+  func.func @any() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (any), capture_clause = (to)>
+      } {
+    func.return
+  }
+  func.func @nohost() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (nohost), capture_clause = (to)>
+      } {
+    func.return
+  }
+  func.func @host() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (host), capture_clause = (to)>
+      } {
+    func.return
+  }
+  func.func @none() -> () {
+    func.return
+  }
+  func.func @nohost_target() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (nohost), capture_clause = (to)>
+      } {
+    omp.target {}
+    func.return
+  }
+  func.func @host_target() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (host), capture_clause = (to)>
+      } {
+    omp.target {}
+    func.return
+  }
+  func.func @none_target() -> () {
+    omp.target {}
+    func.return
+  }
+}
+
+// -----
+
+// CHECK:     func.func @any
+// CHECK-NOT: func.func @nohost
+// CHECK:     func.func @host
+// CHECK:     func.func @none
+// CHECK:     func.func @nohost_target
+// CHECK:     func.func @host_target
+// CHECK:     func.func @none_target
+module attributes {omp.is_target_device = false} {
+  func.func @any() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (any), capture_clause = (to)>
+      } {
+    func.return
+  }
+  func.func @nohost() -> ()
+      attributes {
+          omp.declare_target =
+            #omp.declaretarget<device_type = (nohost), capture_clause = (to)>
+      } {
+    func.return
+  }
+  func.func @host() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (host), capture_clause = (to)>
+      } {
+    func.return
+  }
+  func.func @none() -> () {
+    func.return
+  }
+  func.func @nohost_target() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (nohost), capture_clause = (to)>
+      } {
+    omp.target {}
+    func.return
+  }
+  func.func @host_target() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (host), capture_clause = (to)>
+      } {
+    omp.target {}
+    func.return
+  }
+  func.func @none_target() -> () {
+    omp.target {}
+    func.return
+  }
+}

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

 //===- OpenMPToLLVMIRTranslation.cpp - Translate OpenMP dialect to LLVM IR-===//
 //
 // 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 a translation between the MLIR OpenMP dialect and LLVM
 // IR.
 //
 //===----------------------------------------------------------------------===//
 #include "mlir/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/OpenMP/OpenMPInterfaces.h"
 #include "mlir/IR/IRMapping.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Target/LLVMIR/Dialect/OpenMPCommon.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 #include "mlir/Transforms/RegionUtils.h"
convertOmpTarget(Operation &opInst, llvm::IRBuilderBase &builder,
 
   builder.restoreIP(moduleTranslation.getOpenMPBuilder()->createTarget(
       ompLoc, builder.saveIP(), entryInfo, defaultValTeams, defaultValThreads,
       inputs, bodyCB));
 
   return bodyGenStatus;
 }
 
+static LogicalResult
+convertDeclareTargetAttr(Operation *op,
+                         omp::DeclareTargetAttr declareTargetAttr,
+                         LLVM::ModuleTranslation &moduleTranslation) {
+  // Amend omp.declare_target by deleting the IR of the outlined functions
+  // created for target regions. They cannot be filtered out from MLIR earlier
+  // because the omp.target operation inside must be translated to LLVM, but the
+  // wrapper functions themselves must not remain at the end of the process.
+  // We know that functions where omp.declare_target does not match
+  // omp.is_target_device at this stage can only be wrapper functions because
+  // those that aren't are removed earlier as an MLIR transformation pass.
+  if (FunctionOpInterface funcOp = dyn_cast<FunctionOpInterface>(op)) {
+    if (auto offloadMod = dyn_cast<omp::OffloadModuleInterface>(
+            op->getParentOfType<ModuleOp>().getOperation())) {
+      bool isDeviceCompilation = offloadMod.getIsTargetDevice();
+      omp::DeclareTargetDeviceType declareType =
+          declareTargetAttr.getDeviceType().getValue();
+
+      if ((isDeviceCompilation &&
+           declareType == omp::DeclareTargetDeviceType::host) ||
+          (!isDeviceCompilation &&
+           declareType == omp::DeclareTargetDeviceType::nohost)) {
+        llvm::Function *llvmFunc =
+            moduleTranslation.lookupFunction(funcOp.getName());
+        llvmFunc->dropAllReferences();
+        llvmFunc->eraseFromParent();
+      }
+    }
+  }
+  return success();
+}
+
 namespace {
 
 /// Implementation of the dialect interface that converts operations belonging
 /// to the OpenMP dialect to LLVM IR.
 class OpenMPDialectLLVMIRTranslationInterface
     : public LLVMTranslationDialectInterface {
 public:
   using LLVMTranslationDialectInterface::LLVMTranslationDialectInterface;

 
 } // namespace
 
 /// Given an OpenMP MLIR attribute, create the corresponding LLVM-IR, runtime
 /// calls, or operation amendments
 LogicalResult OpenMPDialectLLVMIRTranslationInterface::amendOperation(
     Operation *op, NamedAttribute attribute,
     LLVM::ModuleTranslation &moduleTranslation) const {
-
   return llvm::TypeSwitch<Attribute, LogicalResult>(attribute.getValue())
       .Case([&](mlir::omp::FlagsAttr rtlAttr) {
         return convertFlagsAttr(op, rtlAttr, moduleTranslation);
       })
       .Case([&](mlir::omp::VersionAttr versionAttr) {
         llvm::OpenMPIRBuilder *ompBuilder =
             moduleTranslation.getOpenMPBuilder();
         ompBuilder->M.addModuleFlag(llvm::Module::Max, "openmp",
                                     versionAttr.getVersion());
         return success();
       })
+      .Case([&](mlir::omp::DeclareTargetAttr declareTargetAttr) {
+        return convertDeclareTargetAttr(op, declareTargetAttr,
+                                        moduleTranslation);
+      })
       .Default([&](Attribute attr) {
         // fall through for omp attributes that do not require lowering and/or
         // have no concrete definition and thus no type to define a case on
         return success();
       });
 
   return failure();
 }

mlir/test/Target/LLVMIR/omptarget-region-llvm-target-device.mlir

 // This test checks that the name of the generated kernel function is using the
 // name stored in the omp.outline_parent_name attribute.
 // RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
 
-module attributes {omp.is_device = true} {
+module attributes {omp.is_target_device = true} {
   llvm.func @writeindex_omp_outline_0_(%arg0: !llvm.ptr<i32>, %arg1: !llvm.ptr<i32>) attributes {omp.outline_parent_name = "writeindex_"} {
     omp.target   map((from -> %arg0 : !llvm.ptr<i32>), (implicit -> %arg1: !llvm.ptr<i32>)) {
       %0 = llvm.mlir.constant(20 : i32) : i32
       %1 = llvm.mlir.constant(10 : i32) : i32
       llvm.store %1, %arg0 : !llvm.ptr<i32>
       llvm.store %0, %arg1 : !llvm.ptr<i32>
       omp.terminator
     }
     llvm.return
   }
 }
 
 // CHECK: define {{.*}} void @__omp_offloading_{{.*}}_{{.*}}_writeindex__l7(ptr {{.*}}, ptr {{.*}}) {

mlir/test/Target/LLVMIR/openmp-llvm.mlir

 // -----
 
 // CHECK: @__omp_rtl_debug_kind = weak_odr hidden constant i32 0
 // CHECK: @__omp_rtl_assume_teams_oversubscription = weak_odr hidden constant i32 1
 // CHECK: @__omp_rtl_assume_threads_oversubscription = weak_odr hidden constant i32 0
 // CHECK: @__omp_rtl_assume_no_thread_state = weak_odr hidden constant i32 1
 // CHECK: @__omp_rtl_assume_no_nested_parallelism = weak_odr hidden constant i32 0
 module attributes {omp.flags = #omp.flags<assume_teams_oversubscription = true, assume_no_thread_state = true>} {}
+
+// -----
+
+module attributes {omp.is_target_device = false} {
+  // CHECK-NOT: @filter_host_nohost
+  llvm.func @filter_host_nohost() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (nohost), capture_clause = (to)>
+      } {
+    llvm.return
+  }
+
+  // CHECK: @filter_host_host
+  llvm.func @filter_host_host() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (host), capture_clause = (to)>
+      } {
+    llvm.return
+  }
+}
+
+// -----
+
+module attributes {omp.is_target_device = true} {
+  // CHECK: @filter_device_nohost
+  llvm.func @filter_device_nohost() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (nohost), capture_clause = (to)>
+      } {
+    llvm.return
+  }
+
+  // CHECK-NOT: @filter_device_host
+  llvm.func @filter_device_host() -> ()
+      attributes {
+        omp.declare_target =
+          #omp.declaretarget<device_type = (host), capture_clause = (to)>
+      } {
+    llvm.return
+  }
+}