[Flang][OpenMP][MLIR] Add early outlining pass for omp.target operations to flang

[jsjodin]

Summary

This patch implements an early outlining transform of omp.target operations in flang. The pass is needed because optimizations may cross target op region boundaries, but with the outlining the resulting functions only contain a single omp.target op plus a func.return, so there should not be any opportunity to optimize across region boundaries.
The patch also adds an interface to be able to store and retrieve the parent function name of the original target operation. This is needed to be able to create correct kernel function names when lowering to LLVM-IR.

[jsjodin]

Fix a couple of comments.

[domada]

flang/test/Lower/OpenMP/omp-target-early-outlining.f90

6

Nit: Could you add some CHECK-NOT llvm-lit directives to ensure that unwanted mlir operations are not present? (For example: check if there are no instructions from the second target region)

Nit: could you make your checks more flexible? We do not need to check the exact names of constants. IMO these checks are more future proof:

!CHECK: %[[CONSTANT_VALUE:.*]] = arith.constant 10 : i32
!CHECK fir.store %[[CONSTANT_VALUE]] to %arg0 : !fir.ref<i32>

[kiranchandramohan]

I had a quick look. Some comments and Nits inline.

The build is failing with the following error.

FrontendActions.cpp:309:29: error: no member named 'getIsDevice' in 'mlir::omp::OffloadModuleInterface'
      isDevice = offloadMod.getIsDevice();

Can you add a test that demonstrates the issue that the outlined function solves?

We probably have a test that lists the passes that are run in order. Didn't you have to update that to get tests to pass?

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

303

Can you add some additional info on where this pass is called (immediate after lowering) and only required for the device flow?

flang/lib/Frontend/FrontendActions.cpp

303–313

Can this be added in a common place so that the bbc driver also gets this?

Would eraseDeadCodeAndBlocks in Bridge.cpp be a good place to add this? That function eliminates dead-code and is a pre-requisite for running other MLIR passes.

flang/lib/Optimizer/Transforms/OMPEarlyOutlining.cpp

16–17

Can these two MLIR includes be moved up?

39–41

Nit: braces not required.

flang/test/Fir/external-mangling.fir

101

Nit: newline

flang/test/Lower/OpenMP/omp-target-early-outlining.f90

2

Nit: Could you add one other target triple?

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

292

Nit: Something is missing at the end of this sentence.

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

3

Nit: Could you add a comment on what the test is testing?
Should it test the existence of func @writeindex_omp_outline_0_ in the LLVM IR? And the call to outlining and the outlined target region?

4

Nit: What is this comment for?

35–38

Nit: remove extra lines.

[jsjodin]

Address review comments

[jsjodin]

flang/lib/Frontend/FrontendActions.cpp

303–313

Can this be added in a common place so that the bbc driver also gets this?

Would eraseDeadCodeAndBlocks in Bridge.cpp be a good place to add this? That function eliminates dead-code and is a pre-requisite for running other MLIR passes.

I'm not exactly sure how to add it in there since the entire generated function should be deleted after outlining. I was looking to see if it would be easy to add it to a function higher up in the call chain, but there seems to be some implicit state that is used to generate the function. I will take a closer look to see if it is doable. Otherwise, should this pass added to the bbc driver?

flang/test/Lower/OpenMP/omp-target-early-outlining.f90

6

Nit: Could you add some CHECK-NOT llvm-lit directives to ensure that unwanted mlir operations are not present? (For example: check if there are no instructions from the second target region)

That should not be possible since the functions are created before any optimizations. I suppose there could be a bug in the frond-end, but that is not what this test is checking.

Nit: could you make your checks more flexible? We do not need to check the exact names of constants. IMO these checks are more future proof:

Done.

!CHECK: %[[CONSTANT_VALUE:.*]] = arith.constant 10 : i32
!CHECK fir.store %[[CONSTANT_VALUE]] to %arg0 : !fir.ref<i32>

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

3

Nit: Could you add a comment on what the test is testing?
Should it test the existence of func @writeindex_omp_outline_0_ in the LLVM IR? And the call to outlining and the outlined target region?

It should only tests that the resulting name of the generated function is correct and use the parent name that is stored in the attribute. I removed the extra checks since they are really not useful.

4

Nit: What is this comment for?

Junk, removed.

[jsjodin]

In D154879#4488533, @kiranchandramohan wrote:

I had a quick look. Some comments and Nits inline.

The build is failing with the following error.

FrontendActions.cpp:309:29: error: no member named 'getIsDevice' in 'mlir::omp::OffloadModuleInterface'
      isDevice = offloadMod.getIsDevice();

Rebased and fixed.

Can you add a test that demonstrates the issue that the outlined function solves?

Yes, where do we add tests that compile from Fortran + optimizations? It requires both the front-end and optimizations.

We probably have a test that lists the passes that are run in order. Didn't you have to update that to get tests to pass?

No, I made no changes to existing tests. This is something that happens to not be triggered by the existing tests. I have an example in the abandoned patch that was supposed to fix CSE.

[kiranchandramohan]

Can you add a test that demonstrates the issue that the outlined function solves?

Yes, where do we add tests that compile from Fortran + optimizations? It requires both the front-end and optimizations.

You can add the test in the Driver test directory.

LG. Please wait for another acceptance.

flang/lib/Frontend/FrontendActions.cpp

303–313

If it is too difficult then no need to add.
Please add a Note or a warning message saying that the location of this pass is important and other mlir transformations should not be called before this.

Also, please verify that the code/passes in eraseDeadCodeAndBlocks do not cause any unnecessary transformation that violates what you achieve by outlining.

flang/lib/Optimizer/Transforms/OMPEarlyOutlining.cpp

52

Should the visibility be set here to setVisibility(mlir::SymbolTable::Visibility::Private)?

[jsjodin]

flang/lib/Frontend/FrontendActions.cpp

303–313

If it is too difficult then no need to add.
Please add a Note or a warning message saying that the location of this pass is important and other mlir transformations should not be called before this.

Also, please verify that the code/passes in eraseDeadCodeAndBlocks do not cause any unnecessary transformation that violates what you achieve by outlining.

The passes in eraseDeadCodeAndBlocks are fine. I added a warning here as well so that people are aware to not add the wrong kind of optimization.

flang/lib/Optimizer/Transforms/OMPEarlyOutlining.cpp

52

Should the visibility be set here to setVisibility(mlir::SymbolTable::Visibility::Private)?

I just checked if this was doable, but since there are no uses of these functions and setting the visibility to Private causes them to be deleted prematurely. They should be deleted once the code generation is done for the omp.target op (outlined into a kernel function) in the module translation to LLVM IR,.

[jsjodin]

Rebase, fix review comments.

[domada]

LGTM

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

3

nit typo: stoared

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

 #include <memory>
 
 namespace mlir {
 class IRMapping;
 class GreedyRewriteConfig;
 class Operation;
 class Pass;
 class Region;
+class ModuleOp;
 } // namespace mlir
 
 namespace fir {
 
 //===----------------------------------------------------------------------===//
 // Passes defined in Passes.td
 //===----------------------------------------------------------------------===//
 

 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();
 // 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 = [{
     array is an assumed shape array, to optimize for the (often common) case where
     an array has element sized stride. The element sizes stride allows some
     loops to be vectorized as well as other loop optimizations.
   }];
   let constructor = "::fir::createLoopVersioningPass()";
   let dependentDialects = [ "fir::FIROpsDialect" ];
 }
 
+def OMPEarlyOutliningPass
+    : Pass<"omp-early-target-outlining", "mlir::ModuleOp"> {
+  let summary = "Outlines all target ops into separate functions";
+  let description = [{
+    This pass outlines all omp.target operations into individual functions.
+    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"];
+}
+
 #endif // FLANG_OPTIMIZER_TRANSFORMS_PASSES

flang/lib/Frontend/FrontendActions.cpp

 #include "flang/Frontend/PreprocessorOptions.h"
 #include "flang/Lower/Bridge.h"
 #include "flang/Lower/PFTBuilder.h"
 #include "flang/Lower/Support/Verifier.h"
 #include "flang/Optimizer/Dialect/Support/FIRContext.h"
 #include "flang/Optimizer/Dialect/Support/KindMapping.h"
 #include "flang/Optimizer/Support/InitFIR.h"
 #include "flang/Optimizer/Support/Utils.h"
+#include "flang/Optimizer/Transforms/Passes.h"
 #include "flang/Parser/dump-parse-tree.h"
 #include "flang/Parser/parsing.h"
 #include "flang/Parser/provenance.h"
 #include "flang/Parser/source.h"
 #include "flang/Parser/unparse.h"
 #include "flang/Semantics/runtime-type-info.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/unparse-with-symbols.h"
bool CodeGenAction::beginSourceFileAction() {
 
   // Create a parse tree and lower it to FIR
   Fortran::parser::Program &parseTree{*ci.getParsing().parseTree()};
   lb.lower(parseTree, ci.getInvocation().getSemanticsContext());
 
   // run the default passes.
   mlir::PassManager pm((*mlirModule)->getName(),
                        mlir::OpPassManager::Nesting::Implicit);
+  // Add OpenMP-related passes
+  // WARNING: These passes must be run immediately after the lowering to ensure
+  // that the FIR is correct with respect to OpenMP operations/attributes.
+  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.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,
         "verification of lowering to FIR failed");
     ci.getDiagnostics().Report(diagID);

flang/lib/Lower/Bridge.cpp

   /// Conditionally switch code insertion to a new block.
   void maybeStartBlock(mlir::Block *newBlock) {
     if (newBlock)
       startBlock(newBlock);
   }
 
   void eraseDeadCodeAndBlocks(mlir::RewriterBase &rewriter,
                               llvm::MutableArrayRef<mlir::Region> regions) {
+    // WARNING: Do not add passes that can do folding or code motion here
+    // because they might cross omp.target region boundaries, which can result
+    // in incorrect code. Optimization passes like these must be added after
+    // OMP early outlining has been done.
     (void)mlir::eraseUnreachableBlocks(rewriter, regions);
     (void)mlir::runRegionDCE(rewriter, regions);
   }
 
   /// Finish translation of a function.
   void endNewFunction(Fortran::lower::pft::FunctionLikeUnit &funit) {
     setCurrentPosition(Fortran::lower::pft::stmtSourceLoc(funit.endStmt));
     if (funit.isMainProgram()) {

flang/lib/Optimizer/Transforms/CMakeLists.txt

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

flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp

if (result.first == fir::NameUniquer::NameKind::COMMON &&
     return "__BLNK__";
 
   if (appendUnderscore)
     return result.second.name + "_";
 
   return result.second.name;
 }
 
+/// Update the early outlining parent name
+void updateEarlyOutliningParentName(mlir::func::FuncOp funcOp,
+                                    bool appendUnderscore) {
+  if (auto earlyOutlineOp = llvm::dyn_cast<mlir::omp::EarlyOutliningInterface>(
+          funcOp.getOperation())) {
+    auto oldName = earlyOutlineOp.getParentName();
+    if (oldName != "") {
+      auto dName = fir::NameUniquer::deconstruct(oldName);
+      std::string newName = mangleExternalName(dName, appendUnderscore);
+      earlyOutlineOp.setParentName(newName);
+    }
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Rewrite patterns
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 struct MangleNameOnFuncOp : public mlir::OpRewritePattern<mlir::func::FuncOp> {
 public:
if (fir::NameUniquer::isExternalFacingUniquedName(result)) {
       // Try to update all SymbolRef's in the module that match the current op
       if (mlir::ModuleOp mod = op->getParentOfType<mlir::ModuleOp>())
         ret = op.replaceAllSymbolUses(newSymbol, mod);
 
       op.setSymNameAttr(newSymbol);
       mlir::SymbolTable::setSymbolName(op, newSymbol);
     }
 
+    updateEarlyOutliningParentName(op, appendUnderscore);
     rewriter.finalizeRootUpdate(op);
     return ret;
   }
 
 private:
   bool appendUnderscore;
 };
 

flang/lib/Optimizer/Transforms/OMPEarlyOutlining.cpp

+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/InternalNames.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/Func/IR/FuncOps.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/OpenMP/OpenMPDialect.h"
+#include "mlir/IR/BuiltinDialect.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/IRMapping.h"
+#include "mlir/IR/Operation.h"
+#include "mlir/IR/SymbolTable.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Support/LLVM.h"
+#include "mlir/Transforms/RegionUtils.h"
+#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
+
+namespace fir {
+#define GEN_PASS_DEF_OMPEARLYOUTLININGPASS
+#include "flang/Optimizer/Transforms/Passes.h.inc"
+} // namespace fir
+
+namespace {
+class OMPEarlyOutliningPass
+    : public fir::impl::OMPEarlyOutliningPassBase<OMPEarlyOutliningPass> {
+
+  std::string getOutlinedFnName(llvm::StringRef parentName, unsigned count) {
+    return std::string(parentName) + "_omp_outline_" + std::to_string(count);
+  }
+
+  mlir::func::FuncOp outlineTargetOp(mlir::OpBuilder &builder,
+                                     mlir::omp::TargetOp &targetOp,
+                                     mlir::func::FuncOp &parentFunc,
+                                     unsigned count) {
+    // Collect inputs
+    llvm::SetVector<mlir::Value> inputs;
+    for (auto operand : targetOp.getOperation()->getOperands())
+      inputs.insert(operand);
+
+    mlir::Region &targetRegion = targetOp.getRegion();
+    mlir::getUsedValuesDefinedAbove(targetRegion, inputs);
+
+    // Create new function and initialize
+    mlir::FunctionType funcType = builder.getFunctionType(
+        mlir::TypeRange(inputs.getArrayRef()), mlir::TypeRange());
+    std::string parentName(parentFunc.getName());
+    std::string funcName = getOutlinedFnName(parentName, count);
+    auto loc = targetOp.getLoc();
+    mlir::func::FuncOp newFunc =
+        mlir::func::FuncOp::create(loc, funcName, funcType);
+    mlir::Block *entryBlock = newFunc.addEntryBlock();
+    builder.setInsertionPointToStart(entryBlock);
+    mlir::ValueRange newInputs = entryBlock->getArguments();
+
+    // Set the declare target information, the outlined function
+    // is always a host function.
+    if (auto parentDTOp = llvm::dyn_cast<mlir::omp::DeclareTargetInterface>(
+            parentFunc.getOperation()))
+      if (auto newDTOp = llvm::dyn_cast<mlir::omp::DeclareTargetInterface>(
+              newFunc.getOperation()))
+        newDTOp.setDeclareTarget(mlir::omp::DeclareTargetDeviceType::host,
+                                 parentDTOp.getDeclareTargetCaptureClause());
+
+    // Set the early outlining interface parent name
+    if (auto earlyOutlineOp =
+            llvm::dyn_cast<mlir::omp::EarlyOutliningInterface>(
+                newFunc.getOperation()))
+      earlyOutlineOp.setParentName(parentName);
+
+    // Create input map from inputs to function parameters.
+    mlir::IRMapping valueMap;
+    for (auto InArg : llvm::zip(inputs, newInputs))
+      valueMap.map(std::get<0>(InArg), std::get<1>(InArg));
+
+    // Clone the target op into the new function
+    builder.clone(*(targetOp.getOperation()), valueMap);
+
+    // Create return op
+    builder.create<mlir::func::ReturnOp>(loc);
+
+    return newFunc;
+  }
+
+  void outlineTargetOps(mlir::OpBuilder &builder,
+                        mlir::func::FuncOp &functionOp,
+                        mlir::ModuleOp &moduleOp,
+                        llvm::SmallVectorImpl<mlir::func::FuncOp> &newFuncs) {
+    unsigned count = 0;
+    for (auto TargetOp : functionOp.getOps<mlir::omp::TargetOp>()) {
+      mlir::func::FuncOp outlinedFunc =
+          outlineTargetOp(builder, TargetOp, functionOp, count);
+      newFuncs.push_back(outlinedFunc);
+      count++;
+    }
+  }
+
+  void runOnOperation() override {
+    mlir::ModuleOp moduleOp = getOperation();
+    mlir::MLIRContext *context = &getContext();
+    mlir::OpBuilder builder(context);
+    llvm::SmallVector<mlir::func::FuncOp> newFuncs;
+
+    for (auto functionOp :
+         llvm::make_early_inc_range(moduleOp.getOps<mlir::func::FuncOp>())) {
+      outlineTargetOps(builder, functionOp, moduleOp, newFuncs);
+      functionOp.erase();
+    }
+
+    for (auto newFunc : newFuncs)
+      moduleOp.push_back(newFunc);
+  }
+};
+
+} // namespace
+
+namespace fir {
+std::unique_ptr<mlir::OperationPass<mlir::ModuleOp>>
+createOMPEarlyOutliningPass() {
+  return std::make_unique<OMPEarlyOutliningPass>();
+}
+} // namespace fir

flang/test/Driver/omp-cse-region-boundary.f90

+!This test checks that when compiling an OpenMP program for the target device
+!CSE is not done across target op region boundaries. It also checks that when
+!compiling for the host CSE is done.
+!RUN: %flang_fc1 -fopenmp-is-device -emit-mlir -fopenmp %s -o - | fir-opt -cse | FileCheck %s -check-prefix=CHECK-DEVICE
+!RUN: %flang_fc1 -emit-mlir -fopenmp %s -o - | fir-opt -cse | FileCheck %s -check-prefix=CHECK-HOST
+
+!Constant should be present inside target region.
+!CHECK-DEVICE: omp.target
+!CHECK-DEVICE: arith.constant 10
+!CHECK-DEVICE: omp.terminator
+
+!Constant should not be present inside target region.
+!CHECK-HOST: omp.target
+!CHECK-NOT-HOST: arith.constant 10
+!CHECK-HOST: omp.terminator
+
+subroutine writeIndex(sum)
+        integer :: sum
+        integer :: myconst1
+        integer :: myconst2
+        myconst1 = 10
+!$omp target map(from:new_len)
+        myconst2 = 10
+!$omp end target
+        sum = myconst2 + myconst2
+end subroutine writeIndex

flang/test/Fir/external-mangling.fir

 
 // CHECK-NOUNDER: func @callee(
 // CHECK-NOUNDER: fir.call @callee(
 // CHECK-NOUNDER: func @caller(
 // CHECK-NOUNDER: fir.call @callee(
 
 // LLVMIR-NOUNDER: llvm.call @callee() : () -> ()
 // LLVMIR-NOUNDER: llvm.call @callee() : () -> ()
+
+// -----
+
+func.func @_QPwriteindex_omp_outline_0() attributes {omp.outline_parent_name = "_QPwriteindex"} {
+   return
+}
+
+// CHECK-UNDER: attributes {omp.outline_parent_name = "writeindex_"}
+// CHECK-NOUNDER: attributes {omp.outline_parent_name = "writeindex"}

flang/test/Lower/OpenMP/omp-target-early-outlining.f90

+!RUN: %flang_fc1 -triple amdgcn-amd-amdhsa -emit-fir -fopenmp -fopenmp-is-device %s -o - | FileCheck %s
+!RUN: %flang_fc1 -triple x86_64-unknown-linux-gnu -emit-fir -fopenmp -fopenmp-is-device %s -o - | FileCheck %s
+
+!CHECK:  func.func @_QPwrite_index_omp_outline_0(%[[ARG0:.*]]: !fir.ref<i32>) attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>, omp.outline_parent_name = "_QPwrite_index"} {
+!CHECK-NEXT: omp.target  {{.*}} {
+!CHECK: %[[CONSTANT_VALUE_10:.*]] = arith.constant 10 : i32
+!CHECK: fir.store %[[CONSTANT_VALUE_10]] to %[[ARG0]] : !fir.ref<i32>
+!CHECK: omp.terminator
+!CHECK-NEXT: }
+!CHECK-NEXT: return
+
+!CHECK:  func.func @_QPwrite_index_omp_outline_1(%[[ARG1:.*]]: !fir.ref<i32>) attributes {omp.declare_target = #omp.declaretarget<device_type = (host), capture_clause = (to)>, omp.outline_parent_name = "_QPwrite_index"} {
+!CHECK-NEXT: omp.target  {{.*}} {
+!CHECK: %[[CONSTANT_VALUE_20:.*]] = arith.constant 20 : i32
+!CHECK: fir.store %[[CONSTANT_VALUE_20]] to %[[ARG1]] : !fir.ref<i32>
+!CHECK: omp.terminator
+!CHECK-NEXT: }
+!CHECK-NEXT: return
+
+
+SUBROUTINE WRITE_INDEX(INT_ARRAY)
+        INTEGER :: INT_ARRAY(*)
+        INTEGER :: NEW_LEN
+!$omp target map(from:new_len)
+        NEW_LEN = 10
+!$omp end target
+!$omp target map(from:new_len)
+        NEW_LEN = 20
+!$omp end target
+        do INDEX_ = 1, NEW_LEN
+                INT_ARRAY(INDEX_) = INDEX_
+        end do
+end subroutine WRITE_INDEX

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

struct OffloadModuleDefaultModel
     : public OffloadModuleInterface::ExternalModel<OffloadModuleDefaultModel,
                                                    mlir::ModuleOp> {};
 
 template <typename T>
 struct DeclareTargetDefaultModel
     : public DeclareTargetInterface::ExternalModel<DeclareTargetDefaultModel<T>,
                                                    T> {};
 
+template <typename T>
+struct EarlyOutliningDefaultModel
+    : public EarlyOutliningInterface::ExternalModel<
+          EarlyOutliningDefaultModel<T>, T> {};
+
 } // namespace mlir::omp
 
 #endif // MLIR_DIALECT_OPENMP_OPENMPINTERFACES_H_

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

InterfaceMethod<
       /*methodName=*/"setRequires",
       (ins "::mlir::omp::ClauseRequires":$clauses), [{}], [{
         $_op->setAttr(mlir::StringAttr::get($_op->getContext(), "omp.requires"),
           mlir::omp::ClauseRequiresAttr::get($_op->getContext(), clauses));
       }]>
   ];
 }
 
+def EarlyOutliningInterface : OpInterface<"EarlyOutliningInterface"> {
+  let description = [{
+    FuncOps that are a result of early outlining should have this interface.
+  }];
+
+  let cppNamespace = "::mlir::omp";
+
+  let methods = [
+    InterfaceMethod<
+      /*description=*/[{
+        Set a StringAttr on an outlined target region function containing the
+        name of the parent function where the target region was outlined
+        from. The parent name is used to construct the kernel names for target
+        regions.
+      }],
+      /*retTy=*/"void",
+      /*methodName=*/"setParentName",
+      (ins "std::string":$parentName), [{}], [{
+        $_op->setAttr(
+          mlir::StringAttr::get($_op->getContext(),
+                                llvm::Twine{"omp.outline_parent_name"}),
+          mlir::StringAttr::get($_op->getContext(), parentName));
+       }]>,
+
+    InterfaceMethod<
+      /*description=*/[{
+        Returns the parent function name from where the target op was outlined
+        from. If it doesn't exist it returns an empty string.
+      }],
+      /*retTy=*/"llvm::StringRef",
+      /*methodName=*/"getParentName",
+      (ins), [{}], [{
+        if (Attribute parentName = $_op->getAttr("omp.outline_parent_name"))
+          if (::llvm::isa<mlir::StringAttr>(parentName))
+            return ::llvm::dyn_cast<mlir::StringAttr>(parentName).getValue();
+        return {};
+      }]>
+  ];
+}
+
 #endif // OpenMP_OPS_INTERFACES

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

#include "mlir/Dialect/OpenMP/OpenMPOpsAttributes.cpp.inc"
   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());
+
+  // Attach default early outlining interface to func ops.
+  mlir::func::FuncOp::attachInterface<
+      mlir::omp::EarlyOutliningDefaultModel<mlir::func::FuncOp>>(*getContext());
+  mlir::LLVM::LLVMFuncOp::attachInterface<
+      mlir::omp::EarlyOutliningDefaultModel<mlir::LLVM::LLVMFuncOp>>(
+      *getContext());
 }
 
 //===----------------------------------------------------------------------===//
 // Parser and printer for Allocate Clause
 //===----------------------------------------------------------------------===//
 
 /// Parse an allocate clause with allocators and a list of operands with types.
 ///

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

auto bodyCB = [&](InsertPointTy allocaIP,
     llvm::BasicBlock *exitBlock = convertOmpOpRegions(
         targetRegion, "omp.target", builder, moduleTranslation, bodyGenStatus);
     builder.SetInsertPoint(exitBlock);
     return builder.saveIP();
   };
 
   llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
   StringRef parentName = opInst.getParentOfType<LLVM::LLVMFuncOp>().getName();
+
+  // Override parent name if early outlining function
+  if (auto earlyOutlineOp = llvm::dyn_cast<mlir::omp::EarlyOutliningInterface>(
+          opInst.getParentOfType<LLVM::LLVMFuncOp>().getOperation())) {
+    llvm::StringRef outlineParentName = earlyOutlineOp.getParentName();
+    parentName = outlineParentName.empty() ? parentName : outlineParentName;
+  }
+
   llvm::TargetRegionEntryInfo entryInfo;
 
   if (!getTargetEntryUniqueInfo(entryInfo, targetOp, parentName))
     return failure();
 
   int32_t defaultValTeams = -1;
   int32_t defaultValThreads = -1;
 

mlir/test/Dialect/OpenMP/attr.mlir

 }
 
 // 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
 }
+
+// ----
+
+// CHECK-LABEL: func @_QPwriteindex_omp_outline_0
+// CHECK-SAME: {{.*}} attributes {omp.outline_parent_name = "QPwriteindex"} {
+func.func @_QPwriteindex_omp_outline_0() attributes {omp.outline_parent_name = "QPwriteindex"} {
+   return
+}

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} {
+  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 {{.*}}) {