[OpenACC] Prototype OpenMP TR8 present map type modifier

The OpenMP TR8 `present` map type modifier is needed to support the
OpenACC `present` clause, which will be implemented in a following
commit.  Currently, all testing of OpenMP TR8 `present` is via testing
for OpenACC `present`.  That is, OpenMP TR8 `present` is not well
tested outside of translations from OpenACC to OpenMP, so it is not
yet recommended for general use in OpenMP code.

Author: jdenny-ornl

clang/include/clang/AST/OpenMPClause.h

@@ -5278,7 +5278,7 @@ class OMPMapClause final : public OMPMappableExprListClause<OMPMapClause>,
   /// Map-type-modifiers for the 'map' clause.
   OpenMPMapModifierKind MapTypeModifiers[NumberOfOMPMapClauseModifiers] = {
       OMPC_MAP_MODIFIER_unknown, OMPC_MAP_MODIFIER_unknown,
-      OMPC_MAP_MODIFIER_unknown};
+      OMPC_MAP_MODIFIER_unknown, OMPC_MAP_MODIFIER_unknown};
 
   /// Location of map-type-modifiers for the 'map' clause.
   SourceLocation MapTypeModifiersLoc[NumberOfOMPMapClauseModifiers];

clang/include/clang/Basic/OpenMPKinds.def

@@ -124,6 +124,7 @@ OPENMP_MAP_KIND(release)
 OPENMP_MAP_MODIFIER_KIND(always)
 OPENMP_MAP_MODIFIER_KIND(close)
 OPENMP_MAP_MODIFIER_KIND(mapper)
+OPENMP_MAP_MODIFIER_KIND(present)
 
 // Modifiers for 'to' clause.
 OPENMP_TO_MODIFIER_KIND(mapper)

clang/lib/CodeGen/CGOpenMPRuntime.cpp

@@ -7838,6 +7838,8 @@ class MappableExprsHandler {
     /// Close is a hint to the runtime to allocate memory close to
     /// the target device.
     OMP_MAP_CLOSE = 0x400,
+    /// Produce a runtime error if the data is not already allocated.
+    OMP_MAP_PRESENT = 0x800,
     /// The 16 MSBs of the flags indicate whether the entry is member of some
     /// struct/class.
     OMP_MAP_MEMBER_OF = 0xffff000000000000,
@@ -8054,6 +8056,9 @@ class MappableExprsHandler {
     if (llvm::find(MapModifiers, OMPC_MAP_MODIFIER_close)
         != MapModifiers.end())
       Bits |= OMP_MAP_CLOSE;
+    if (llvm::find(MapModifiers, OMPC_MAP_MODIFIER_present)
+        != MapModifiers.end())
+      Bits |= OMP_MAP_PRESENT;
     return Bits;
   }
 
@@ -8713,7 +8718,8 @@ class MappableExprsHandler {
                                                   /*isSigned=*/false);
     Sizes.push_back(Size);
     // Map type is always TARGET_PARAM
-    Types.push_back(OMP_MAP_TARGET_PARAM);
+    Types.push_back(OMP_MAP_TARGET_PARAM |
+                    ((*CurTypes.begin()) & OMP_MAP_PRESENT));
     // Remove TARGET_PARAM flag from the first element
     (*CurTypes.begin()) &= ~OMP_MAP_TARGET_PARAM;
 
@@ -9282,6 +9288,62 @@ class MappableExprsHandler {
     }
   }
 
+  /// Generate the base pointers, section pointers, sizes and map types
+  /// associated with variables with "present" map type modifiers.
+  void generateInfoForMapTypeModPresent(
+      MapBaseValuesArrayTy &BasePointers, MapValuesArrayTy &Pointers,
+      MapValuesArrayTy &Sizes, MapFlagsArrayTy &Types,
+      llvm::DenseSet<const ValueDecl *> CapturedVarSet) {
+    assert(CurDir.is<const OMPExecutableDirective *>() &&
+           "Expect an executable directive");
+    const auto *CurExecDir = CurDir.get<const OMPExecutableDirective *>();
+    // Map other list items in the map clause which are not captured variables
+    // but "declare target link" global variables.
+    for (const auto *C : CurExecDir->getClausesOfKind<OMPMapClause>()) {
+      ArrayRef<OpenMPMapModifierKind> Mods = C->getMapTypeModifiers();
+      if (llvm::find(Mods, OMPC_MAP_MODIFIER_present) == Mods.end())
+        continue;
+      for (const auto L : C->component_lists()) {
+        if (!L.first)
+          continue;
+        const auto *VD = dyn_cast<VarDecl>(L.first);
+        if (!VD)
+          continue;
+
+        // If it was captured because it was referenced in the construct, don't
+        // generate another map entry.  Thus, IsFirstComponentList below is
+        // false, suppressing the flag OMP_TGT_MAPTYPE_TARGET_PARAM.
+        if (CapturedVarSet.count(VD))
+          continue;
+
+        // Temporary versions of arrays
+        MapBaseValuesArrayTy CurBasePointers;
+        MapValuesArrayTy CurPointers;
+        MapValuesArrayTy CurSizes;
+        MapFlagsArrayTy CurTypes;
+        StructRangeInfoTy PartialStruct;
+
+        generateInfoForComponentList(
+            C->getMapType(), C->getMapTypeModifiers(), L.second,
+            CurBasePointers, CurPointers, CurSizes, CurTypes, PartialStruct,
+            /*IsFirstComponentList=*/false, C->isImplicit());
+
+        // If there is an entry in PartialStruct it means we have a struct with
+        // individual members mapped. Emit an extra combined entry.
+        if (PartialStruct.Base.isValid())
+          emitCombinedEntry(BasePointers, Pointers, Sizes, Types, CurTypes,
+                            PartialStruct);
+
+        // We need to append the results of this capture to what we already
+        // have.
+        BasePointers.append(CurBasePointers.begin(), CurBasePointers.end());
+        Pointers.append(CurPointers.begin(), CurPointers.end());
+        Sizes.append(CurSizes.begin(), CurSizes.end());
+        Types.append(CurTypes.begin(), CurTypes.end());
+      }
+    }
+  }
+
   /// Generate the default map information for a given capture \a CI,
   /// record field declaration \a RI and captured value \a CV.
   void generateDefaultMapInfo(const CapturedStmt::Capture &CI,
@@ -10171,6 +10233,7 @@ void CGOpenMPRuntime::emitTargetCall(
     // Get mappable expression information.
     MappableExprsHandler MEHandler(D, CGF);
     llvm::DenseMap<llvm::Value *, llvm::Value *> LambdaPointers;
+    llvm::DenseSet<const ValueDecl *> CapturedVarSet;
 
     auto RI = CS.getCapturedRecordDecl()->field_begin();
     auto CV = CapturedVars.begin();
@@ -10199,6 +10262,8 @@ void CGOpenMPRuntime::emitTargetCall(
         // just do a default mapping.
         MEHandler.generateInfoForCapture(CI, *CV, CurBasePointers, CurPointers,
                                          CurSizes, CurMapTypes, PartialStruct);
+        if (!CI->capturesThis())
+          CapturedVarSet.insert(CI->getCapturedVar()->getCanonicalDecl());
         if (CurBasePointers.empty())
           MEHandler.generateDefaultMapInfo(*CI, **RI, *CV, CurBasePointers,
                                            CurPointers, CurSizes, CurMapTypes);
@@ -10236,6 +10301,10 @@ void CGOpenMPRuntime::emitTargetCall(
     // but "declare target link" global variables.
     MEHandler.generateInfoForDeclareTargetLink(BasePointers, Pointers, Sizes,
                                                MapTypes);
+    // Map other list items in the map clause which are not captured variables
+    // but have "present" map type modifiers.
+    MEHandler.generateInfoForMapTypeModPresent(BasePointers, Pointers, Sizes,
+                                               MapTypes, CapturedVarSet);
 
     TargetDataInfo Info;
     // Fill up the arrays and create the arguments.

clang/lib/Parse/ParseOpenMP.cpp

@@ -3094,7 +3094,8 @@ bool Parser::parseMapTypeModifiers(OpenMPVarListDataTy &Data) {
   while (getCurToken().isNot(tok::colon)) {
     OpenMPMapModifierKind TypeModifier = isMapModifier(*this);
     if (TypeModifier == OMPC_MAP_MODIFIER_always ||
-        TypeModifier == OMPC_MAP_MODIFIER_close) {
+        TypeModifier == OMPC_MAP_MODIFIER_close ||
+        TypeModifier == OMPC_MAP_MODIFIER_present) {
       Data.MapTypeModifiers.push_back(TypeModifier);
       Data.MapTypeModifiersLoc.push_back(Tok.getLocation());
       ConsumeToken();

clang/lib/Sema/SemaOpenMP.cpp

@@ -17328,9 +17328,9 @@ OMPClause *Sema::ActOnOpenMPMapClause(
     OpenMPMapClauseKind MapType, bool IsMapTypeImplicit, SourceLocation MapLoc,
     SourceLocation ColonLoc, ArrayRef<Expr *> VarList,
     const OMPVarListLocTy &Locs, ArrayRef<Expr *> UnresolvedMappers) {
-  OpenMPMapModifierKind Modifiers[] = {OMPC_MAP_MODIFIER_unknown,
-                                       OMPC_MAP_MODIFIER_unknown,
-                                       OMPC_MAP_MODIFIER_unknown};
+  OpenMPMapModifierKind Modifiers[] = {
+      OMPC_MAP_MODIFIER_unknown, OMPC_MAP_MODIFIER_unknown,
+      OMPC_MAP_MODIFIER_unknown, OMPC_MAP_MODIFIER_unknown};
   SourceLocation ModifiersLoc[NumberOfOMPMapClauseModifiers];
 
   // Process map-type-modifiers, flag errors for duplicate modifiers.

openmp/libomptarget/include/omptarget.h

@@ -49,6 +49,8 @@ enum tgt_map_type {
   OMP_TGT_MAPTYPE_IMPLICIT        = 0x200,
   // copy data to device
   OMP_TGT_MAPTYPE_CLOSE           = 0x400,
+  // runtime error if not already allocated
+  OMP_TGT_MAPTYPE_PRESENT         = 0x800,
   // member of struct, member given by [16 MSBs] - 1
   OMP_TGT_MAPTYPE_MEMBER_OF       = 0xffff000000000000
 };

openmp/libomptarget/src/device.cpp

@@ -154,7 +154,7 @@ LookupResult DeviceTy::lookupMapping(void *HstPtrBegin, int64_t Size) {
 // to do an illegal mapping.
 void *DeviceTy::getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase,
     int64_t Size, bool &IsNew, bool &IsHostPtr, bool IsImplicit,
-    bool UpdateRefCount, bool HasCloseModifier) {
+    bool UpdateRefCount, bool HasCloseModifier, bool HasPresentModifier) {
   void *rc = NULL;
   IsHostPtr = false;
   IsNew = false;
@@ -196,6 +196,10 @@ void *DeviceTy::getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase,
          DPxPTR((uintptr_t)HstPtrBegin), Size, (UpdateRefCount ? " updated" : ""));
       IsHostPtr = true;
       rc = HstPtrBegin;
+    } else if (HasPresentModifier) {
+      DP("Mapping required but does not exist%s for HstPtrBegin=" DPxMOD
+         ", Size=%ld\n",
+         (IsImplicit ? " (implicit)" : ""), DPxPTR(HstPtrBegin), Size);
     } else {
       // If it is not contained and Size > 0 we should create a new entry for it.
       IsNew = true;

openmp/libomptarget/src/device.h

@@ -175,7 +175,7 @@ struct DeviceTy {
   LookupResult lookupMapping(void *HstPtrBegin, int64_t Size);
   void *getOrAllocTgtPtr(void *HstPtrBegin, void *HstPtrBase, int64_t Size,
       bool &IsNew, bool &IsHostPtr, bool IsImplicit, bool UpdateRefCount = true,
-      bool HasCloseModifier = false);
+      bool HasCloseModifier = false, bool HasPresentModifier = false);
   void *getTgtPtrBegin(void *HstPtrBegin, int64_t Size);
   void *getTgtPtrBegin(void *HstPtrBegin, int64_t Size, bool &IsLast,
       bool UpdateRefCount, bool &IsHostPtr);

openmp/libomptarget/src/omptarget.cpp

@@ -346,6 +346,7 @@ int target_data_begin(DeviceTy &Device, int32_t arg_num, void **args_base,
     // Force the creation of a device side copy of the data when:
     // a close map modifier was associated with a map that contained a to.
     bool HasCloseModifier = arg_types[i] & OMP_TGT_MAPTYPE_CLOSE;
+    bool HasPresentModifier = arg_types[i] & OMP_TGT_MAPTYPE_PRESENT;
     // UpdateRef is based on MEMBER_OF instead of TARGET_PARAM because if we
     // have reached this point via __tgt_target_data_begin and not __tgt_target
     // then no argument is marked as TARGET_PARAM ("omp target data map" is not
@@ -374,12 +375,14 @@ int target_data_begin(DeviceTy &Device, int32_t arg_num, void **args_base,
     }
 
     void *TgtPtrBegin = Device.getOrAllocTgtPtr(HstPtrBegin, HstPtrBase,
-        data_size, IsNew, IsHostPtr, IsImplicit, UpdateRef, HasCloseModifier);
+        data_size, IsNew, IsHostPtr, IsImplicit, UpdateRef, HasCloseModifier,
+        HasPresentModifier);
+    // If data_size==0, then the argument could be a zero-length pointer to
+    // NULL, so getOrAlloc() returning NULL is not an error.
     if (!TgtPtrBegin && data_size) {
-      // If data_size==0, then the argument could be a zero-length pointer to
-      // NULL, so getOrAlloc() returning NULL is not an error.
-      DP("Call to getOrAllocTgtPtr returned null pointer (device failure or "
-          "illegal mapping).\n");
+      DP("Call to getOrAllocTgtPtr returned null pointer (%s).\n",
+         HasPresentModifier ? "'present' map type modifier"
+                            : "device failure or illegal mapping");
       OMPT_DISPATCH_CALLBACK_TARGET_MAP();
       return OFFLOAD_FAIL;
     }