[OpenMPIRBuilder] Add createOffloadMaptypes and createOffloadMapnames functions

[clementval]

Summary

Add function to create the offload_maptypes and the offload_mapnames globals. These two functions
are used in clang. They will be used in the Flang/MLIR lowering as well.

[clementval]

Fix global variable names. Separator comes from OpenMP runtime information.

[Meinersbur]

That is, something that calls createOffloadMaptypes/createOffloadMapnames independently of any front-end. Can be as simply as calling it and checking that the returned variable has the expected type and name.

clang/lib/CodeGen/CGOpenMPRuntime.cpp

9378

With SmallVectorImpl for createOffloadMaptypes, this change is not necessary anymore

9400

With SmallVectorImpl for createOffloadMapnames, this change is not necessary anymore

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

619

Use SmallVectorImpl

623

Use SmallVectorImpl

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

2098

A description at the declaration is sufficient

[jdoerfert]

I assume clang tests apply here. It replaces clang functionality after all.

[Meinersbur]

In D101503#2729385, @jdoerfert wrote:

I assume clang tests apply here. It replaces clang functionality after all.

The policy so far was to have LLVM functionality tested in LLVM itself. See https://reviews.llvm.org/D91470#2395409 and D91643.

[clementval]

Address review comments

[clementval]

In D101503#2727906, @Meinersbur wrote:

That is, something that calls createOffloadMaptypes/createOffloadMapnames independently of any front-end. Can be as simply as calling it and checking that the returned variable has the expected type and name.

Unit tests added :-)

[Meinersbur]

LGTM, thank you.

[clementval]

Rebase

[clementval]

Rebase 2

clang/lib/CodeGen/CGOpenMPRuntime.cpp

if (hasRuntimeEvaluationCaptureSize) {
           /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage,
           SizesArrayInit, Name);
       SizesArrayGbl->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
       Info.SizesArray = SizesArrayGbl;
     }
 
     // The map types are always constant so we don't need to generate code to
     // fill arrays. Instead, we create an array constant.
-    SmallVector<uint64_t, 4> Mapping(CombinedInfo.Types.size(), 0);
+    SmallVector<uint64_t> Mapping(CombinedInfo.Types.size(), 0);
     llvm::copy(CombinedInfo.Types, Mapping.begin());
-    llvm::Constant *MapTypesArrayInit =
-        llvm::ConstantDataArray::get(CGF.Builder.getContext(), Mapping);
-    std::string MaptypesName =
-        CGM.getOpenMPRuntime().getName({"offload_maptypes"});
-    auto *MapTypesArrayGbl = new llvm::GlobalVariable(
-        CGM.getModule(), MapTypesArrayInit->getType(),
-        /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage,
-        MapTypesArrayInit, MaptypesName);
-    MapTypesArrayGbl->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
+    auto *MapTypesArrayGbl = OMPBuilder.createOffloadMaptypes(Mapping);
     Info.MapTypesArray = MapTypesArrayGbl;
 
     // The information types are only built if there is debug information
     // requested.
     if (CGM.getCodeGenOpts().getDebugInfo() == codegenoptions::NoDebugInfo) {
       Info.MapNamesArray = llvm::Constant::getNullValue(
           llvm::Type::getInt8Ty(CGF.Builder.getContext())->getPointerTo());
     } else {
       auto fillInfoMap = [&](MappableExprsHandler::MappingExprInfo &MapExpr) {
         return emitMappingInformation(CGF, OMPBuilder, MapExpr);
       };
-      SmallVector<llvm::Constant *, 4> InfoMap(CombinedInfo.Exprs.size());
+      SmallVector<llvm::Constant *> InfoMap(CombinedInfo.Exprs.size());
       llvm::transform(CombinedInfo.Exprs, InfoMap.begin(), fillInfoMap);
 
-      llvm::Constant *MapNamesArrayInit = llvm::ConstantArray::get(
-          llvm::ArrayType::get(
-              llvm::Type::getInt8Ty(CGF.Builder.getContext())->getPointerTo(),
-              CombinedInfo.Exprs.size()),
-          InfoMap);
-      auto *MapNamesArrayGbl = new llvm::GlobalVariable(
-          CGM.getModule(), MapNamesArrayInit->getType(),
-          /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage,
-          MapNamesArrayInit,
-          CGM.getOpenMPRuntime().getName({"offload_mapnames"}));
+      auto *MapNamesArrayGbl = OMPBuilder.createOffloadMapnames(InfoMap);
       Info.MapNamesArray = MapNamesArrayGbl;
     }
 
     // If there's a present map type modifier, it must not be applied to the end
     // of a region, so generate a separate map type array in that case.
     if (Info.separateBeginEndCalls()) {
       bool EndMapTypesDiffer = false;
       for (uint64_t &Type : Mapping) {
         if (Type & MappableExprsHandler::OMP_MAP_PRESENT) {
           Type &= ~MappableExprsHandler::OMP_MAP_PRESENT;
           EndMapTypesDiffer = true;
         }
       }
       if (EndMapTypesDiffer) {
-        MapTypesArrayInit =
-            llvm::ConstantDataArray::get(CGF.Builder.getContext(), Mapping);
-        MaptypesName = CGM.getOpenMPRuntime().getName({"offload_maptypes"});
-        MapTypesArrayGbl = new llvm::GlobalVariable(
-            CGM.getModule(), MapTypesArrayInit->getType(),
-            /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage,
-            MapTypesArrayInit, MaptypesName);
-        MapTypesArrayGbl->setUnnamedAddr(
-            llvm::GlobalValue::UnnamedAddr::Global);
+        MapTypesArrayGbl = OMPBuilder.createOffloadMaptypes(Mapping);
         Info.MapTypesArrayEnd = MapTypesArrayGbl;
       }
     }
 
     for (unsigned I = 0; I < Info.NumberOfPtrs; ++I) {
       llvm::Value *BPVal = *CombinedInfo.BasePointers[I];
       llvm::Value *BP = CGF.Builder.CreateConstInBoundsGEP2_32(
           llvm::ArrayType::get(CGM.VoidPtrTy, Info.NumberOfPtrs),

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

public:
 
   /// An ordered map of auto-generated variables to their unique names.
   /// It stores variables with the following names: 1) ".gomp_critical_user_" +
   /// <critical_section_name> + ".var" for "omp critical" directives; 2)
   /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
   /// variables.
   StringMap<AssertingVH<Constant>, BumpPtrAllocator> InternalVars;
 
+  /// Create the global variable holding the offload mappings information.
+  GlobalVariable *createOffloadMaptypes(SmallVector<uint64_t> &Mappings);
+
+  /// Create the global variable holding the offload names information.
+  GlobalVariable *createOffloadMapnames(SmallVector<llvm::Constant *> &Names);
+
 public:
   /// Generator for __kmpc_copyprivate
   ///
   /// \param Loc The source location description.
   /// \param BufSize Number of elements in the buffer.
   /// \param CpyBuf List of pointers to data to be copied.
   /// \param CpyFn function to call for copying data.
   /// \param DidIt flag variable; 1 for 'single' thread, 0 otherwise.

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

 }
 
 Value *OpenMPIRBuilder::getOMPCriticalRegionLock(StringRef CriticalName) {
   std::string Prefix = Twine("gomp_critical_user_", CriticalName).str();
   std::string Name = getNameWithSeparators({Prefix, "var"}, ".", ".");
   return getOrCreateOMPInternalVariable(KmpCriticalNameTy, Name);
 }
 
+// Create the global variable holding the offload mappings information.
+GlobalVariable *
+OpenMPIRBuilder::createOffloadMaptypes(SmallVector<uint64_t> &Mappings) {
+  llvm::Constant *MaptypesArrayInit =
+      llvm::ConstantDataArray::get(M.getContext(), Mappings);
+  auto *MaptypesArrayGlobal = new llvm::GlobalVariable(
+      M, MaptypesArrayInit->getType(),
+      /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, MaptypesArrayInit,
+      "offload_maptypes");
+  MaptypesArrayGlobal->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
+  return MaptypesArrayGlobal;
+}
+
+// Create the global variables holding the offload names information.
+GlobalVariable *
+OpenMPIRBuilder::createOffloadMapnames(SmallVector<llvm::Constant *> &Names) {
+  llvm::Constant *MapNamesArrayInit = llvm::ConstantArray::get(
+      llvm::ArrayType::get(
+          llvm::Type::getInt8Ty(M.getContext())->getPointerTo(), Names.size()),
+      Names);
+  auto *MapNamesArrayGlobal = new llvm::GlobalVariable(
+      M, MapNamesArrayInit->getType(),
+      /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, MapNamesArrayInit,
+      "offload_mapnames");
+  return MapNamesArrayGlobal;
+}
+
 // Create all simple and struct types exposed by the runtime and remember
 // the llvm::PointerTypes of them for easy access later.
 void OpenMPIRBuilder::initializeTypes(Module &M) {
   LLVMContext &Ctx = M.getContext();
   StructType *T;
 #define OMP_TYPE(VarName, InitValue) VarName = InitValue;
 #define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)                             \
   VarName##Ty = ArrayType::get(ElemTy, ArraySize);                             \