[OpenMP] [OMPIRBuilder] Create a new datatype to hold the unique target region info

[jsjodin]

Summary

This patch puts the individual target region information attributes into a struct so that the nested mappings are not needed and passing the information around is simplified.

[jdoerfert]

LG, one suggestions, not necessary to address

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

1826

const & for all of them?

[mikerice]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3030

Needed StringRef(EntryInfo.ParentName) for this to compile for me.

[jsjodin]

Fixed comments

[jsjodin]

I updated the patch to address the comment.

[kda]

This may have broken HWASAN buildbot:
https://lab.llvm.org/buildbot/#/builders/236/builds/786

Running a build just before and after to validate guess based on stack.

log snippet:

==956880==ERROR: HWAddressSanitizer: tag-mismatch on address 0xffffc09c0031 at pc 0xaaaab749fd64
READ of size 1 at 0xffffc09c0031 tags: c6/00 (ptr/mem) in thread T0
    #0 0xaaaab749fd64 in djbHash /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/llvm/include/llvm/Support/DJB.h:22:24
    #1 0xaaaab749fd64 in llvm::StringMapImpl::FindKey(llvm::StringRef) const /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/llvm/lib/Support/StringMap.cpp:142:28
    #2 0xaaaab6ab1128 in find /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/llvm/include/llvm/ADT/StringMap.h:225:18
    #3 0xaaaab6ab1128 in lookup /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/llvm/include/llvm/ADT/StringMap.h:234:25
    #4 0xaaaab6ab1128 in lookup /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/llvm/include/llvm/IR/ValueSymbolTable.h:78:17
    #5 0xaaaab6ab1128 in llvm::Module::getNamedValue(llvm::StringRef) const /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/llvm/lib/IR/Module.cpp:111:58
    #6 0xaaaab7c47d2c in clang::CodeGen::CGOpenMPRuntime::createOffloadEntriesAndInfoMetadata() /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/CodeGen/CGOpenMPRuntime.cpp:3077:18
    #7 0xaaaab7946c3c in clang::CodeGen::CodeGenModule::Release() /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/CodeGen/CodeGenModule.cpp:537:20
    #8 0xaaaab86e223c in (anonymous namespace)::CodeGeneratorImpl::HandleTranslationUnit(clang::ASTContext&) /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/CodeGen/ModuleBuilder.cpp:286:18
    #9 0xaaaab86de0d4 in clang::BackendConsumer::HandleTranslationUnit(clang::ASTContext&) /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/CodeGen/CodeGenAction.cpp:306:14
    #10 0xaaaaba028aac in clang::ParseAST(clang::Sema&, bool, bool) /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/Parse/ParseAST.cpp:196:13
    #11 0xaaaab86db730 in clang::CodeGenAction::ExecuteAction() /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/CodeGen/CodeGenAction.cpp:1144:30
    #12 0xaaaab85971c0 in clang::FrontendAction::Execute() /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/Frontend/FrontendAction.cpp:1055:8
    #13 0xaaaab84ebd70 in clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/Frontend/CompilerInstance.cpp:1044:33
    #14 0xaaaab86d43d4 in clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:266:25
    #15 0xaaaab42e5520 in cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/tools/driver/cc1_main.cpp:250:15
    #16 0xaaaab42e07f0 in ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/tools/driver/driver.cpp:316:12
    #17 0xaaaab42e01b8 in clang_main(int, char**) /b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm-project/clang/tools/driver/driver.cpp:388:12
    #18 0xffff8d6c73f8  (/lib/aarch64-linux-gnu/libc.so.6+0x273f8) (BuildId: f37f3aa07c797e333fd106472898d361f71798f5)
    #19 0xffff8d6c74c8 in __libc_start_main (/lib/aarch64-linux-gnu/libc.so.6+0x274c8) (BuildId: f37f3aa07c797e333fd106472898d361f71798f5)
    #20 0xaaaab42b5c6c in _start (/b/sanitizer-aarch64-linux-bootstrap-hwasan/build/llvm_build_hwasan/bin/clang-16+0x5a85c6c)

[kda]

The bracket builds have finished and they seem to have a conclusive result. The test starts failing with this patch.

Built at this patch: https://lab.llvm.org/buildbot/#/builders/236/builds/803
Built at prior patch: https://lab.llvm.org/buildbot/#/builders/236/builds/804

[vitalybuka]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3030

StringRef(EntryInfo.ParentName) is ref to the scope-local EntryInfo info, so you have HWASAN report here

[mikerice]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3030

Probably meant to change this to const llvm::TargetRegionEntryInfo &EntryInfo to match OffloadTargetRegionEntryInfoActTy?

[jsjodin]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

3030

Yes, I think there was an inconsistency introduced when I was splitting up my patch. I will work on a fix.

[jsjodin]

In D136601#3889822, @kda wrote:

The bracket builds have finished and they seem to have a conclusive result. The test starts failing with this patch.

Built at this patch: https://lab.llvm.org/buildbot/#/builders/236/builds/803
Built at prior patch: https://lab.llvm.org/buildbot/#/builders/236/builds/804

When I have a fix, is there a way for me to test my code on the buildbot? I don't seem to be able to reproduce the problem on my machine.

[mikerice]

In D136601#3892410, @jsjodin wrote:

When I have a fix, is there a way for me to test my code on the buildbot? I don't seem to be able to reproduce the problem on my machine.

If you have access to valgrind it can be reproduced with that too:

clang -cc1 -fopenmp -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm-bc target_messages.cpp -o target_messages.cpp.tmp-ppc-host.bc -DREGION_HOST

valgrind clang -cc1 -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm target_messages.cpp -fopenmp-is-device -fopenmp-host-ir-file-path target_messages.cpp.tmp-ppc-host.bc -o - -DREGION_DEVICE

[mikerice]

clang/lib/CodeGen/CGOpenMPRuntime.cpp

1909

Just noticed this debug code left in here.

[jsjodin]

Fix reference error.

[jsjodin]

What is the procedure to redo a patch that was reverted?

clang/lib/CodeGen/CGOpenMPRuntime.cpp

1909

Good catch! I am updating the patch again, on top of the reference fix.

3030

Probably meant to change this to const llvm::TargetRegionEntryInfo &EntryInfo to match OffloadTargetRegionEntryInfoActTy?

[jsjodin]

Remove debug code.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

CGOpenMPRuntime::createDispatchNextFunction(unsigned IVSize, bool IVSigned) {
   auto *FnTy =
       llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
   return CGM.CreateRuntimeFunction(FnTy, Name);
 }
 
 /// Obtain information that uniquely identifies a target entry. This
 /// consists of the file and device IDs as well as line number associated with
 /// the relevant entry source location.
-static void getTargetEntryUniqueInfo(ASTContext &C, SourceLocation Loc,
-                                     unsigned &DeviceID, unsigned &FileID,
-                                     unsigned &LineNum) {
+static llvm::TargetRegionEntryInfo
+getTargetEntryUniqueInfo(ASTContext &C, SourceLocation Loc,
+                         StringRef ParentName = "") {
   SourceManager &SM = C.getSourceManager();
 
   // The loc should be always valid and have a file ID (the user cannot use
   // #pragma directives in macros)
 
   assert(Loc.isValid() && "Source location is expected to be always valid.");
 
   PresumedLoc PLoc = SM.getPresumedLoc(Loc);
   assert(PLoc.isValid() && "Source location is expected to be always valid.");
 
   llvm::sys::fs::UniqueID ID;
   if (auto EC = llvm::sys::fs::getUniqueID(PLoc.getFilename(), ID)) {
     PLoc = SM.getPresumedLoc(Loc, /*UseLineDirectives=*/false);
     assert(PLoc.isValid() && "Source location is expected to be always valid.");
     if (auto EC = llvm::sys::fs::getUniqueID(PLoc.getFilename(), ID))
       SM.getDiagnostics().Report(diag::err_cannot_open_file)
           << PLoc.getFilename() << EC.message();
   }
 
-  DeviceID = ID.getDevice();
-  FileID = ID.getFile();
-  LineNum = PLoc.getLine();
+  return llvm::TargetRegionEntryInfo(ParentName, ID.getDevice(), ID.getFile(),
+                                     PLoc.getLine());
 }
 
 Address CGOpenMPRuntime::getAddrOfDeclareTargetVar(const VarDecl *VD) {
   if (CGM.getLangOpts().OpenMPSimd)
     return Address::invalid();
   llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
       OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD);
   if (Res && (*Res == OMPDeclareTargetDeclAttr::MT_Link ||
               (*Res == OMPDeclareTargetDeclAttr::MT_To &&
                HasRequiresUnifiedSharedMemory))) {
     SmallString<64> PtrName;
     {
       llvm::raw_svector_ostream OS(PtrName);
       OS << CGM.getMangledName(GlobalDecl(VD));
       if (!VD->isExternallyVisible()) {
-        unsigned DeviceID, FileID, Line;
-        getTargetEntryUniqueInfo(CGM.getContext(),
-                                 VD->getCanonicalDecl()->getBeginLoc(),
-                                 DeviceID, FileID, Line);
-        OS << llvm::format("_%x", FileID);
+        auto EntryInfo = getTargetEntryUniqueInfo(
+            CGM.getContext(), VD->getCanonicalDecl()->getBeginLoc());
+        OS << llvm::format("_%x", EntryInfo.FileID);
       }
       OS << "_decl_tgt_ref_ptr";
     }
     llvm::Value *Ptr = CGM.getModule().getNamedValue(PtrName);
     QualType PtrTy = CGM.getContext().getPointerType(VD->getType());
     llvm::Type *LlvmPtrTy = CGM.getTypes().ConvertTypeForMem(PtrTy);
     if (!Ptr) {
       Ptr = getOrCreateInternalVariable(LlvmPtrTy, PtrName);
if (!DeclareTargetWithDefinition.insert(CGM.getMangledName(VD)).second)
     return CGM.getLangOpts().OpenMPIsDevice;
 
   QualType ASTTy = VD->getType();
   SourceLocation Loc = VD->getCanonicalDecl()->getBeginLoc();
 
   // Produce the unique prefix to identify the new target regions. We use
   // the source location of the variable declaration which we know to not
   // conflict with any target region.
-  unsigned DeviceID;
-  unsigned FileID;
-  unsigned Line;
-  getTargetEntryUniqueInfo(CGM.getContext(), Loc, DeviceID, FileID, Line);
+  auto EntryInfo =
+      getTargetEntryUniqueInfo(CGM.getContext(), Loc, VD->getName());
   SmallString<128> Buffer, Out;
-  {
-    llvm::raw_svector_ostream OS(Buffer);
-    OS << "__omp_offloading_" << llvm::format("_%x", DeviceID)
-       << llvm::format("_%x_", FileID) << VD->getName() << "_l" << Line;
-  }
+  EntryInfo.getTargetRegionEntryFnName(Buffer);
 
   const Expr *Init = VD->getAnyInitializer();
   if (CGM.getLangOpts().CPlusPlus && PerformInit) {
     llvm::Constant *Ctor;
     llvm::Constant *ID;
     if (CGM.getLangOpts().OpenMPIsDevice) {
       // Generate function that re-emits the declaration's initializer into
       // the threadprivate copy of the variable VD
if (CGM.getLangOpts().OpenMPIsDevice) {
           CGM.getModule(), CGM.Int8Ty, /*isConstant=*/true,
           llvm::GlobalValue::PrivateLinkage,
           llvm::Constant::getNullValue(CGM.Int8Ty), Twine(Buffer, "_ctor"));
       ID = Ctor;
     }
 
     // Register the information for the entry associated with the constructor.
     Out.clear();
+    auto CtorEntryInfo = EntryInfo;
+    CtorEntryInfo.ParentName = Twine(Buffer, "_ctor").toStringRef(Out);
     OffloadEntriesInfoManager.registerTargetRegionEntryInfo(
-        DeviceID, FileID, Twine(Buffer, "_ctor").toStringRef(Out), Line, Ctor,
-        ID, llvm::OffloadEntriesInfoManager::OMPTargetRegionEntryCtor,
+        CtorEntryInfo, Ctor, ID,
+        llvm::OffloadEntriesInfoManager::OMPTargetRegionEntryCtor,
         CGM.getLangOpts().OpenMPIsDevice);
   }
   if (VD->getType().isDestructedType() != QualType::DK_none) {
     llvm::Constant *Dtor;
     llvm::Constant *ID;
     if (CGM.getLangOpts().OpenMPIsDevice) {
       // Generate function that emits destructor call for the threadprivate
       // copy of the variable VD
if (CGM.getLangOpts().OpenMPIsDevice) {
       Dtor = new llvm::GlobalVariable(
           CGM.getModule(), CGM.Int8Ty, /*isConstant=*/true,
           llvm::GlobalValue::PrivateLinkage,
           llvm::Constant::getNullValue(CGM.Int8Ty), Twine(Buffer, "_dtor"));
       ID = Dtor;
     }
     // Register the information for the entry associated with the destructor.
     Out.clear();
+    auto DtorEntryInfo = EntryInfo;
+    DtorEntryInfo.ParentName = Twine(Buffer, "_dtor").toStringRef(Out);
     OffloadEntriesInfoManager.registerTargetRegionEntryInfo(
-        DeviceID, FileID, Twine(Buffer, "_dtor").toStringRef(Out), Line, Dtor,
-        ID, llvm::OffloadEntriesInfoManager::OMPTargetRegionEntryDtor,
+        DtorEntryInfo, Dtor, ID,
+        llvm::OffloadEntriesInfoManager::OMPTargetRegionEntryDtor,
         CGM.getLangOpts().OpenMPIsDevice);
   }
   return CGM.getLangOpts().OpenMPIsDevice;
 }
 
 Address CGOpenMPRuntime::getAddrOfArtificialThreadPrivate(CodeGenFunction &CGF,
                                                           QualType VarType,
                                                           StringRef Name) {
void CGOpenMPRuntime::createOffloadEntriesAndInfoMetadata() {
 
   // Create the offloading info metadata node.
   llvm::NamedMDNode *MD = M.getOrInsertNamedMetadata("omp_offload.info");
 
   // Create function that emits metadata for each target region entry;
   auto &&TargetRegionMetadataEmitter =
       [this, &C, MD, &OrderedEntries, &ParentFunctions, &GetMDInt,
        &GetMDString](
-          unsigned DeviceID, unsigned FileID, StringRef ParentName,
-          unsigned Line,
+          const llvm::TargetRegionEntryInfo &EntryInfo,
           const llvm::OffloadEntriesInfoManager::OffloadEntryInfoTargetRegion
               &E) {
         // Generate metadata for target regions. Each entry of this metadata
         // contains:
         // - Entry 0 -> Kind of this type of metadata (0).
         // - Entry 1 -> Device ID of the file where the entry was identified.
         // - Entry 2 -> File ID of the file where the entry was identified.
         // - Entry 3 -> Mangled name of the function where the entry was
         // identified.
         // - Entry 4 -> Line in the file where the entry was identified.
         // - Entry 5 -> Order the entry was created.
         // The first element of the metadata node is the kind.
-        llvm::Metadata *Ops[] = {GetMDInt(E.getKind()), GetMDInt(DeviceID),
-                                 GetMDInt(FileID),      GetMDString(ParentName),
-                                 GetMDInt(Line),        GetMDInt(E.getOrder())};
+        llvm::Metadata *Ops[] = {
+            GetMDInt(E.getKind()),      GetMDInt(EntryInfo.DeviceID),
+            GetMDInt(EntryInfo.FileID), GetMDString(EntryInfo.ParentName),
+            GetMDInt(EntryInfo.Line),   GetMDInt(E.getOrder())};
 
         SourceLocation Loc;
         for (auto I = CGM.getContext().getSourceManager().fileinfo_begin(),
                   E = CGM.getContext().getSourceManager().fileinfo_end();
              I != E; ++I) {
-          if (I->getFirst()->getUniqueID().getDevice() == DeviceID &&
-              I->getFirst()->getUniqueID().getFile() == FileID) {
+          if (I->getFirst()->getUniqueID().getDevice() == EntryInfo.DeviceID &&
+              I->getFirst()->getUniqueID().getFile() == EntryInfo.FileID) {
             Loc = CGM.getContext().getSourceManager().translateFileLineCol(
-                I->getFirst(), Line, 1);
+                I->getFirst(), EntryInfo.Line, 1);
             break;
           }
         }
         // Save this entry in the right position of the ordered entries array.
-        OrderedEntries[E.getOrder()] = std::make_tuple(&E, Loc, ParentName);
-        ParentFunctions[E.getOrder()] = ParentName;
+        OrderedEntries[E.getOrder()] =
+            std::make_tuple(&E, Loc, StringRef(EntryInfo.ParentName));
+        ParentFunctions[E.getOrder()] = StringRef(EntryInfo.ParentName);
 
         // Add metadata to the named metadata node.
         MD->addOperand(llvm::MDNode::get(C, Ops));
       };
 
   OffloadEntriesInfoManager.actOnTargetRegionEntriesInfo(
       TargetRegionMetadataEmitter);
 
auto &&GetMDString = [MN](unsigned Idx) {
       return V->getString();
     };
 
     switch (GetMDInt(0)) {
     default:
       llvm_unreachable("Unexpected metadata!");
       break;
     case llvm::OffloadEntriesInfoManager::OffloadEntryInfo::
-        OffloadingEntryInfoTargetRegion:
+        OffloadingEntryInfoTargetRegion: {
       assert(CGM.getLangOpts().OpenMPIsDevice && "Initialization of entries is "
                                                  "only required for the "
                                                  "device code generation.");
+      llvm::TargetRegionEntryInfo EntryInfo(/*ParentName=*/GetMDString(3),
+                                            /*DeviceID=*/GetMDInt(1),
+                                            /*FileID=*/GetMDInt(2),
+                                            /*Line=*/GetMDInt(4));
       OffloadEntriesInfoManager.initializeTargetRegionEntryInfo(
-          /*DeviceID=*/GetMDInt(1), /*FileID=*/GetMDInt(2),
-          /*ParentName=*/GetMDString(3), /*Line=*/GetMDInt(4),
-          /*Order=*/GetMDInt(5));
+          EntryInfo, /*Order=*/GetMDInt(5));
       break;
+    }
     case llvm::OffloadEntriesInfoManager::OffloadEntryInfo::
         OffloadingEntryInfoDeviceGlobalVar:
       assert(CGM.getLangOpts().OpenMPIsDevice && "Initialization of entries is "
                                                  "only required for the "
                                                  "device code generation.");
       OffloadEntriesInfoManager.initializeDeviceGlobalVarEntryInfo(
           /*MangledName=*/GetMDString(1),
           static_cast<
public:
   }
 };
 } // namespace
 
 void CGOpenMPRuntime::emitTargetOutlinedFunction(
     const OMPExecutableDirective &D, StringRef ParentName,
     llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID,
     bool IsOffloadEntry, const RegionCodeGenTy &CodeGen) {
-  assert(!ParentName.empty() && "Invalid target region parent name!");
+  assert(!ParentName.empty() && "Invalid target entry parent name!");
   HasEmittedTargetRegion = true;
   SmallVector<std::pair<const Expr *, const Expr *>, 4> Allocators;
   for (const auto *C : D.getClausesOfKind<OMPUsesAllocatorsClause>()) {
     for (unsigned I = 0, E = C->getNumberOfAllocators(); I < E; ++I) {
       const OMPUsesAllocatorsClause::Data D = C->getAllocatorData(I);
       if (!D.AllocatorTraits)
         continue;
       Allocators.emplace_back(D.Allocator, D.AllocatorTraits);
void CGOpenMPRuntime::emitTargetOutlinedFunctionHelper(
   // __omp_offloading_DD_FFFF_PP_lBB
   //
   // where DD_FFFF is an ID unique to the file (device and file IDs), PP is the
   // mangled name of the function that encloses the target region and BB is the
   // line number of the target region.
 
   const bool BuildOutlinedFn = CGM.getLangOpts().OpenMPIsDevice ||
                                !CGM.getLangOpts().OpenMPOffloadMandatory;
-  unsigned DeviceID;
-  unsigned FileID;
-  unsigned Line;
-  getTargetEntryUniqueInfo(CGM.getContext(), D.getBeginLoc(), DeviceID, FileID,
-                           Line);
+  auto EntryInfo =
+      getTargetEntryUniqueInfo(CGM.getContext(), D.getBeginLoc(), ParentName);
   SmallString<64> EntryFnName;
-  {
-    llvm::raw_svector_ostream OS(EntryFnName);
-    OS << "__omp_offloading" << llvm::format("_%x", DeviceID)
-       << llvm::format("_%x_", FileID) << ParentName << "_l" << Line;
-  }
+  EntryInfo.getTargetRegionEntryFnName(EntryFnName);
 
   const CapturedStmt &CS = *D.getCapturedStmt(OMPD_target);
 
   CodeGenFunction CGF(CGM, true);
   CGOpenMPTargetRegionInfo CGInfo(CS, CodeGen, EntryFnName);
   CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
 
   if (BuildOutlinedFn)
if (!BuildOutlinedFn) {
     TargetRegionEntryAddr = new llvm::GlobalVariable(
         CGM.getModule(), CGM.Int8Ty, /*isConstant=*/true,
         llvm::GlobalValue::InternalLinkage,
         llvm::Constant::getNullValue(CGM.Int8Ty), EntryFnName);
   }
 
   // Register the information for the entry associated with this target region.
   OffloadEntriesInfoManager.registerTargetRegionEntryInfo(
-      DeviceID, FileID, ParentName, Line, TargetRegionEntryAddr, OutlinedFnID,
+      EntryInfo, TargetRegionEntryAddr, OutlinedFnID,
       llvm::OffloadEntriesInfoManager::OMPTargetRegionEntryTargetRegion,
       CGM.getLangOpts().OpenMPIsDevice);
 
   // Add NumTeams and ThreadLimit attributes to the outlined GPU function
   int32_t DefaultValTeams = -1;
   getNumTeamsExprForTargetDirective(CGF, D, DefaultValTeams);
   if (DefaultValTeams > 0 && OutlinedFn) {
     OutlinedFn->addFnAttr("omp_target_num_teams",
void CGOpenMPRuntime::scanForTargetRegionsFunctions(const Stmt *S,
   // Codegen OMP target directives that offload compute to the device.
   bool RequiresDeviceCodegen =
       isa<OMPExecutableDirective>(S) &&
       isOpenMPTargetExecutionDirective(
           cast<OMPExecutableDirective>(S)->getDirectiveKind());
 
   if (RequiresDeviceCodegen) {
     const auto &E = *cast<OMPExecutableDirective>(S);
-    unsigned DeviceID;
-    unsigned FileID;
-    unsigned Line;
-    getTargetEntryUniqueInfo(CGM.getContext(), E.getBeginLoc(), DeviceID,
-                             FileID, Line);
+    auto EntryInfo =
+        getTargetEntryUniqueInfo(CGM.getContext(), E.getBeginLoc(), ParentName);
 
     // Is this a target region that should not be emitted as an entry point? If
     // so just signal we are done with this target region.
-    if (!OffloadEntriesInfoManager.hasTargetRegionEntryInfo(DeviceID, FileID,
-                                                            ParentName, Line))
+    if (!OffloadEntriesInfoManager.hasTargetRegionEntryInfo(EntryInfo))
       return;
 
     switch (E.getDirectiveKind()) {
     case OMPD_target:
       CodeGenFunction::EmitOMPTargetDeviceFunction(CGM, ParentName,
                                                    cast<OMPTargetDirective>(E));
       break;
     case OMPD_target_parallel:

clang/test/OpenMP/declare_target_codegen.cpp

 // CHECK-DAG: [[STAT:@.+stat]] = internal global %struct.S zeroinitializer,
 // CHECK-DAG: [[STAT_REF:@.+]] = internal constant ptr [[STAT]]
 // CHECK-DAG: @out_decl_target ={{ protected | }}global i32 0,
 // CHECK-DAG: @llvm.compiler.used = appending global [1 x ptr] [ptr [[STAT_REF]]],
 
 // CHECK-DAG: define {{.*}}i32 @{{.*}}{{foo|bar|baz2|baz3|FA|f_method}}{{.*}}()
 // CHECK-DAG: define {{.*}}void @{{.*}}TemplateClass{{.*}}(ptr {{[^,]*}} %{{.*}})
 // CHECK-DAG: define {{.*}}i32 @{{.*}}TemplateClass{{.*}}f_method{{.*}}(ptr {{[^,]*}} %{{.*}})
-// CHECK-DAG: define {{.*}}void @__omp_offloading__{{.*}}_globals_l[[@LINE+78]]_ctor()
+// CHECK-DAG: define {{.*}}void @__omp_offloading_{{.*}}_globals_l[[@LINE+78]]_ctor()
 
 #ifndef HEADER
 #define HEADER
 #pragma omp declare target
 bool flag [[clang::loader_uninitialized]];
 extern int bbb;
 #pragma omp end declare target
 #pragma omp declare target

clang/test/OpenMP/nvptx_declare_target_var_ctor_dtor_codegen.cpp

 // DEVICE-DAG: define hidden noundef i32 [[BAR:@.*bar.*]]()
 // DEVICE-DAG: define hidden noundef i32 [[BAZ:@.*baz.*]]()
 // DEVICE-DAG: define hidden noundef i32 [[DOO:@.*doo.*]]()
 // DEVICE-DAG: define hidden noundef i32 [[CAR:@.*car.*]]()
 // DEVICE-DAG: define hidden noundef i32 [[CAZ:@.*caz.*]]()
 
 static int c = foo() + bar() + baz();
 #pragma omp declare target (c)
-// HOST-DAG: @[[C_CTOR:__omp_offloading__.+_c_l44_ctor]] = private constant i8 0
-// DEVICE-DAG: define weak_odr protected void [[C_CTOR:@__omp_offloading__.+_c_l44_ctor]]()
+// HOST-DAG: @[[C_CTOR:__omp_offloading_.+_c_l44_ctor]] = private constant i8 0
+// DEVICE-DAG: define weak_odr protected void [[C_CTOR:@__omp_offloading_.+_c_l44_ctor]]()
 // DEVICE-DAG: call noundef i32 [[FOO]]()
 // DEVICE-DAG: call noundef i32 [[BAR]]()
 // DEVICE-DAG: call noundef i32 [[BAZ]]()
 // DEVICE-DAG: ret void
 
 struct S {
   int a;
   S() = default;
   S(int a) : a(a) {}
   ~S() { a = 0; }
 };
 
 #pragma omp declare target
 S cd = doo() + car() + caz() + baz();
 #pragma omp end declare target
-// HOST-DAG: @[[CD_CTOR:__omp_offloading__.+_cd_l61_ctor]] = private constant i8 0
-// DEVICE-DAG: define weak_odr protected void [[CD_CTOR:@__omp_offloading__.+_cd_l61_ctor]]()
+// HOST-DAG: @[[CD_CTOR:__omp_offloading_.+_cd_l61_ctor]] = private constant i8 0
+// DEVICE-DAG: define weak_odr protected void [[CD_CTOR:@__omp_offloading_.+_cd_l61_ctor]]()
 // DEVICE-DAG: call noundef i32 [[DOO]]()
 // DEVICE-DAG: call noundef i32 [[CAR]]()
 // DEVICE-DAG: call noundef i32 [[CAZ]]()
 // DEVICE-DAG: ret void
 
-// HOST-DAG: @[[CD_DTOR:__omp_offloading__.+_cd_l61_dtor]] = private constant i8 0
-// DEVICE-DAG: define weak_odr protected void [[CD_DTOR:@__omp_offloading__.+_cd_l61_dtor]]()
+// HOST-DAG: @[[CD_DTOR:__omp_offloading_.+_cd_l61_dtor]] = private constant i8 0
+// DEVICE-DAG: define weak_odr protected void [[CD_DTOR:@__omp_offloading_.+_cd_l61_dtor]]()
 // DEVICE-DAG: call void
 // DEVICE-DAG: ret void
 
 // HOST-DAG: @.omp_offloading.entry_name{{.*}} = internal unnamed_addr constant [{{[0-9]+}} x i8] c"[[CD_ADDR]]\00"
 // HOST-DAG: @.omp_offloading.entry.[[CD_ADDR]] = weak{{.*}} constant %struct.__tgt_offload_entry { ptr @[[CD_ADDR]], ptr @.omp_offloading.entry_name{{.*}}, i64 4, i32 0, i32 0 }, section "omp_offloading_entries", align 1
 // HOST-DAG: @.omp_offloading.entry_name{{.*}} = internal unnamed_addr constant [{{[0-9]+}} x i8] c"[[C_CTOR]]\00"
 // HOST-DAG: @.omp_offloading.entry.[[C_CTOR]] = weak{{.*}} constant %struct.__tgt_offload_entry { ptr @[[C_CTOR]], ptr @.omp_offloading.entry_name{{.*}}, i64 0, i32 2, i32 0 }, section "omp_offloading_entries", align 1
 // HOST-DAG: @.omp_offloading.entry_name{{.*}}= internal unnamed_addr constant [{{[0-9]+}} x i8] c"[[CD_CTOR]]\00"

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

 #define LLVM_FRONTEND_OPENMP_OMPIRBUILDER_H
 
 #include "llvm/Analysis/MemorySSAUpdater.h"
 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/Support/Allocator.h"
 #include <forward_list>
+#include <map>
 
 namespace llvm {
 class CanonicalLoopInfo;
+class OffloadEntriesInfoManager;
 
 /// Move the instruction after an InsertPoint to the beginning of another
 /// BasicBlock.
 ///
 /// The instructions after \p IP are moved to the beginning of \p New which must
 /// not have any PHINodes. If \p CreateBranch is true, a branch instruction to
 /// \p New will be added such that there is no semantic change. Otherwise, the
 /// \p IP insert block remains degenerate and it is up to the caller to insert a
public:
   /// \returns The CanonicalLoopInfo that represents the emitted loop.
   CanonicalLoopInfo *createLoopSkeleton(DebugLoc DL, Value *TripCount,
                                         Function *F,
                                         BasicBlock *PreInsertBefore,
                                         BasicBlock *PostInsertBefore,
                                         const Twine &Name = {});
 };
 
+/// Data structure to contain the information needed to uniquely identify
+/// a target entry.
+struct TargetRegionEntryInfo {
+  std::string ParentName;
+  unsigned DeviceID;
+  unsigned FileID;
+  unsigned Line;
+
+  TargetRegionEntryInfo() : ParentName(""), DeviceID(0), FileID(0), Line(0) {}
+  TargetRegionEntryInfo(StringRef ParentName, unsigned DeviceID,
+                        unsigned FileID, unsigned Line)
+      : ParentName(ParentName), DeviceID(DeviceID), FileID(FileID), Line(Line) {
+  }
+
+  static void getTargetRegionEntryFnName(SmallVectorImpl<char> &Name,
+                                         StringRef ParentName,
+                                         unsigned DeviceID, unsigned FileID,
+                                         unsigned Line);
+
+  void getTargetRegionEntryFnName(SmallVectorImpl<char> &Name);
+
+  bool operator<(const TargetRegionEntryInfo RHS) const {
+    return std::make_tuple(ParentName, DeviceID, FileID, Line) <
+           std::make_tuple(RHS.ParentName, RHS.DeviceID, RHS.FileID, RHS.Line);
+  }
+};
+
 /// Class that manages information about offload code regions and data
 class OffloadEntriesInfoManager {
   /// Number of entries registered so far.
   unsigned OffloadingEntriesNum = 0;
 
 public:
   /// Base class of the entries info.
   class OffloadEntryInfo {
public:
     }
     static bool classof(const OffloadEntryInfo *Info) {
       return Info->getKind() == OffloadingEntryInfoTargetRegion;
     }
   };
 
   /// Initialize target region entry.
   /// This is ONLY needed for DEVICE compilation.
-  void initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
-                                       StringRef ParentName, unsigned LineNum,
+  void initializeTargetRegionEntryInfo(const TargetRegionEntryInfo &EntryInfo,
                                        unsigned Order);
   /// Register target region entry.
-  void registerTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
-                                     StringRef ParentName, unsigned LineNum,
+  void registerTargetRegionEntryInfo(const TargetRegionEntryInfo &EntryInfo,
                                      Constant *Addr, Constant *ID,
                                      OMPTargetRegionEntryKind Flags,
                                      bool IsDevice);
   /// Return true if a target region entry with the provided information
   /// exists.
-  bool hasTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID,
-                                StringRef ParentName, unsigned LineNum,
+  bool hasTargetRegionEntryInfo(const TargetRegionEntryInfo &EntryInfo,
                                 bool IgnoreAddressId = false) const;
   /// brief Applies action \a Action on all registered entries.
-  typedef function_ref<void(unsigned, unsigned, StringRef, unsigned,
+  typedef function_ref<void(const TargetRegionEntryInfo &EntryInfo,
                             const OffloadEntryInfoTargetRegion &)>
       OffloadTargetRegionEntryInfoActTy;
   void
   actOnTargetRegionEntriesInfo(const OffloadTargetRegionEntryInfoActTy &Action);
 
   //
   // Device global variable entries related.
   //
public:
   }
   /// Applies action \a Action on all registered entries.
   typedef function_ref<void(StringRef, const OffloadEntryInfoDeviceGlobalVar &)>
       OffloadDeviceGlobalVarEntryInfoActTy;
   void actOnDeviceGlobalVarEntriesInfo(
       const OffloadDeviceGlobalVarEntryInfoActTy &Action);
 
 private:
-  // Storage for target region entries kind. The storage is to be indexed by
-  // file ID, device ID, parent function name and line number.
-  typedef DenseMap<unsigned, OffloadEntryInfoTargetRegion>
-      OffloadEntriesTargetRegionPerLine;
-  typedef StringMap<OffloadEntriesTargetRegionPerLine>
-      OffloadEntriesTargetRegionPerParentName;
-  typedef DenseMap<unsigned, OffloadEntriesTargetRegionPerParentName>
-      OffloadEntriesTargetRegionPerFile;
-  typedef DenseMap<unsigned, OffloadEntriesTargetRegionPerFile>
-      OffloadEntriesTargetRegionPerDevice;
-  typedef OffloadEntriesTargetRegionPerDevice OffloadEntriesTargetRegionTy;
+  // Storage for target region entries kind.
+  typedef std::map<TargetRegionEntryInfo, OffloadEntryInfoTargetRegion>
+      OffloadEntriesTargetRegionTy;
   OffloadEntriesTargetRegionTy OffloadEntriesTargetRegion;
   /// Storage for device global variable entries kind. The storage is to be
   /// indexed by mangled name.
   typedef StringMap<OffloadEntryInfoDeviceGlobalVar>
       OffloadEntriesDeviceGlobalVarTy;
   OffloadEntriesDeviceGlobalVarTy OffloadEntriesDeviceGlobalVar;
 };
 

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

while (!Worklist.empty()) {
     BasicBlock *BB = Worklist.pop_back_val();
     BlockVector.push_back(BB);
     for (BasicBlock *SuccBB : successors(BB))
       if (BlockSet.insert(SuccBB).second)
         Worklist.push_back(SuccBB);
   }
 }
 
+void TargetRegionEntryInfo::getTargetRegionEntryFnName(
+    SmallVectorImpl<char> &Name, StringRef ParentName, unsigned DeviceID,
+    unsigned FileID, unsigned Line) {
+  raw_svector_ostream OS(Name);
+  OS << "__omp_offloading" << llvm::format("_%x", DeviceID)
+     << llvm::format("_%x_", FileID) << ParentName << "_l" << Line;
+}
+
+void TargetRegionEntryInfo::getTargetRegionEntryFnName(
+    SmallVectorImpl<char> &Name) {
+  getTargetRegionEntryFnName(Name, ParentName, DeviceID, FileID, Line);
+}
+
 bool OffloadEntriesInfoManager::empty() const {
   return OffloadEntriesTargetRegion.empty() &&
          OffloadEntriesDeviceGlobalVar.empty();
 }
 
 /// Initialize target region entry.
 void OffloadEntriesInfoManager::initializeTargetRegionEntryInfo(
-    unsigned DeviceID, unsigned FileID, StringRef ParentName, unsigned LineNum,
-    unsigned Order) {
-  OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] =
+    const TargetRegionEntryInfo &EntryInfo, unsigned Order) {
+  OffloadEntriesTargetRegion[EntryInfo] =
       OffloadEntryInfoTargetRegion(Order, /*Addr=*/nullptr, /*ID=*/nullptr,
                                    OMPTargetRegionEntryTargetRegion);
   ++OffloadingEntriesNum;
 }
 
 void OffloadEntriesInfoManager::registerTargetRegionEntryInfo(
-    unsigned DeviceID, unsigned FileID, StringRef ParentName, unsigned LineNum,
-    Constant *Addr, Constant *ID, OMPTargetRegionEntryKind Flags,
-    bool IsDevice) {
+    const TargetRegionEntryInfo &EntryInfo, Constant *Addr, Constant *ID,
+    OMPTargetRegionEntryKind Flags, bool IsDevice) {
   // If we are emitting code for a target, the entry is already initialized,
   // only has to be registered.
   if (IsDevice) {
     // This could happen if the device compilation is invoked standalone.
-    if (!hasTargetRegionEntryInfo(DeviceID, FileID, ParentName, LineNum))
+    if (!hasTargetRegionEntryInfo(EntryInfo)) {
       return;
-    auto &Entry =
-        OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum];
+    }
+    auto &Entry = OffloadEntriesTargetRegion[EntryInfo];
     Entry.setAddress(Addr);
     Entry.setID(ID);
     Entry.setFlags(Flags);
   } else {
     if (Flags == OffloadEntriesInfoManager::OMPTargetRegionEntryTargetRegion &&
-        hasTargetRegionEntryInfo(DeviceID, FileID, ParentName, LineNum,
-                                 /*IgnoreAddressId*/ true))
+        hasTargetRegionEntryInfo(EntryInfo, /*IgnoreAddressId*/ true))
       return;
-    assert(!hasTargetRegionEntryInfo(DeviceID, FileID, ParentName, LineNum) &&
+    assert(!hasTargetRegionEntryInfo(EntryInfo) &&
            "Target region entry already registered!");
     OffloadEntryInfoTargetRegion Entry(OffloadingEntriesNum, Addr, ID, Flags);
-    OffloadEntriesTargetRegion[DeviceID][FileID][ParentName][LineNum] = Entry;
+    OffloadEntriesTargetRegion[EntryInfo] = Entry;
     ++OffloadingEntriesNum;
   }
 }
 
 bool OffloadEntriesInfoManager::hasTargetRegionEntryInfo(
-    unsigned DeviceID, unsigned FileID, StringRef ParentName, unsigned LineNum,
-    bool IgnoreAddressId) const {
-  auto PerDevice = OffloadEntriesTargetRegion.find(DeviceID);
-  if (PerDevice == OffloadEntriesTargetRegion.end())
-    return false;
-  auto PerFile = PerDevice->second.find(FileID);
-  if (PerFile == PerDevice->second.end())
-    return false;
-  auto PerParentName = PerFile->second.find(ParentName);
-  if (PerParentName == PerFile->second.end())
-    return false;
-  auto PerLine = PerParentName->second.find(LineNum);
-  if (PerLine == PerParentName->second.end())
+    const TargetRegionEntryInfo &EntryInfo, bool IgnoreAddressId) const {
+  auto It = OffloadEntriesTargetRegion.find(EntryInfo);
+  if (It == OffloadEntriesTargetRegion.end()) {
     return false;
+  }
   // Fail if this entry is already registered.
-  if (!IgnoreAddressId &&
-      (PerLine->second.getAddress() || PerLine->second.getID()))
+  if (!IgnoreAddressId && (It->second.getAddress() || It->second.getID()))
     return false;
   return true;
 }
 
 void OffloadEntriesInfoManager::actOnTargetRegionEntriesInfo(
     const OffloadTargetRegionEntryInfoActTy &Action) {
   // Scan all target region entries and perform the provided action.
-  for (const auto &D : OffloadEntriesTargetRegion)
-    for (const auto &F : D.second)
-      for (const auto &P : F.second)
-        for (const auto &L : P.second)
-          Action(D.first, F.first, P.first(), L.first, L.second);
+  for (const auto &It : OffloadEntriesTargetRegion) {
+    Action(It.first, It.second);
+  }
 }
 
 void OffloadEntriesInfoManager::initializeDeviceGlobalVarEntryInfo(
     StringRef Name, OMPTargetGlobalVarEntryKind Flags, unsigned Order) {
   OffloadEntriesDeviceGlobalVar.try_emplace(Name, Order, Flags);
   ++OffloadingEntriesNum;
 }
 

llvm/unittests/Frontend/OpenMPIRBuilderTest.cpp

TEST_F(OpenMPIRBuilderTest, EmitOffloadingArraysArguments) {
   EXPECT_EQ(RTArgs.SizesArray->getType(), Int64PtrTy);
   EXPECT_EQ(RTArgs.MapTypesArray->getType(), Int64PtrTy);
   EXPECT_EQ(RTArgs.MappersArray->getType(), VoidPtrPtrTy);
   EXPECT_EQ(RTArgs.MapNamesArray->getType(), VoidPtrPtrTy);
 }
 
 TEST_F(OpenMPIRBuilderTest, OffloadEntriesInfoManager) {
   OffloadEntriesInfoManager InfoManager;
-  InfoManager.initializeTargetRegionEntryInfo(1, 2, "parent", 4, 0);
+  TargetRegionEntryInfo EntryInfo("parent", 1, 2, 4);
+  InfoManager.initializeTargetRegionEntryInfo(EntryInfo, 0);
   InfoManager.initializeDeviceGlobalVarEntryInfo(
       "gvar", OffloadEntriesInfoManager::OMPTargetGlobalVarEntryTo, 0);
   InfoManager.registerTargetRegionEntryInfo(
-      1, 2, "parent", 4, nullptr, nullptr,
+      EntryInfo, nullptr, nullptr,
       OffloadEntriesInfoManager::OMPTargetRegionEntryTargetRegion, true);
   InfoManager.registerDeviceGlobalVarEntryInfo(
       "gvar", 0x0, 8, OffloadEntriesInfoManager::OMPTargetGlobalVarEntryTo,
       GlobalValue::WeakAnyLinkage, true);
-  EXPECT_TRUE(InfoManager.hasTargetRegionEntryInfo(1, 2, "parent", 4, true));
+  EXPECT_TRUE(InfoManager.hasTargetRegionEntryInfo(EntryInfo, true));
   EXPECT_TRUE(InfoManager.hasDeviceGlobalVarEntryInfo("gvar"));
 }
 } // namespace