Update for fallback complex modifier

Author: kevinsala

clang/lib/CodeGen/CGOpenMPRuntime.cpp

@@ -10000,31 +10000,45 @@ static llvm::Value *emitDeviceID(
   return DeviceID;
 }
 
-static std::pair<llvm::Value *, bool>
+static std::pair<llvm::Value *, OMPDynGroupprivateFallbackType>
 emitDynCGroupMem(const OMPExecutableDirective &D, CodeGenFunction &CGF) {
   llvm::Value *DynGP = CGF.Builder.getInt32(0);
-  bool DynGPFallback = false;
+  OMPDynGroupprivateFallbackType DynGPFallback;
 
   if (auto *DynGPClause = D.getSingleClause<OMPDynGroupprivateClause>()) {
     CodeGenFunction::RunCleanupsScope DynGPScope(CGF);
     llvm::Value *DynGPVal =
         CGF.EmitScalarExpr(DynGPClause->getSize(), /*IgnoreResultAssign=*/true);
     DynGP = CGF.Builder.CreateIntCast(DynGPVal, CGF.Int32Ty,
                                       /*isSigned=*/false);
-    DynGPFallback = (DynGPClause->getFirstDynGroupprivateModifier() !=
-                         OMPC_DYN_GROUPPRIVATE_strict &&
-                     DynGPClause->getSecondDynGroupprivateModifier() !=
-                         OMPC_DYN_GROUPPRIVATE_strict);
+    auto FallbackModifier = DynGPClause->getDynGroupprivateFallbackModifier();
+    switch (FallbackModifier) {
+    case OMPC_DYN_GROUPPRIVATE_FALLBACK_abort:
+      DynGPFallback = OMPDynGroupprivateFallbackType::Abort;
+      break;
+    case OMPC_DYN_GROUPPRIVATE_FALLBACK_null:
+      DynGPFallback = OMPDynGroupprivateFallbackType::Null;
+      break;
+    case OMPC_DYN_GROUPPRIVATE_FALLBACK_default_mem:
+    case OMPC_DYN_GROUPPRIVATE_FALLBACK_unknown:
+      // This is the default for dyn_groupprivate.
+      DynGPFallback = OMPDynGroupprivateFallbackType::DefaultMem;
+      break;
+    default:
+      llvm_unreachable("Unknown fallback modifier for OpenMP dyn_groupprivate");
+    }
   } else if (auto *OMPXDynCGClause =
                  D.getSingleClause<OMPXDynCGroupMemClause>()) {
     CodeGenFunction::RunCleanupsScope DynCGMemScope(CGF);
     llvm::Value *DynCGMemVal = CGF.EmitScalarExpr(OMPXDynCGClause->getSize(),
                                                   /*IgnoreResultAssign=*/true);
     DynGP = CGF.Builder.CreateIntCast(DynCGMemVal, CGF.Int32Ty,
                                       /*isSigned=*/false);
+    DynGPFallback = OMPDynGroupprivateFallbackType::Abort;
   }
   return {DynGP, DynGPFallback};
 }
+
 static void genMapInfoForCaptures(
     MappableExprsHandler &MEHandler, CodeGenFunction &CGF,
     const CapturedStmt &CS, llvm::SmallVectorImpl<llvm::Value *> &CapturedVars,

llvm/include/llvm/Frontend/OpenMP/OMPConstants.h

@@ -190,6 +190,16 @@ enum class OMPScheduleType {
   LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue */ ModifierMask)
 };
 
+/// The fallback types for the dyn_groupprivate clause.
+enum class OMPDynGroupprivateFallbackType : uint64_t {
+  /// Abort the execution.
+  Abort = 0,
+  /// Return null pointer.
+  Null = 1,
+  /// Allocate from a implementation defined memory space.
+  DefaultMem = 2
+};
+
 // Default OpenMP mapper name suffix.
 inline constexpr const char *OmpDefaultMapperName = ".omp.default.mapper";
 

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

@@ -2449,20 +2449,21 @@ class OpenMPIRBuilder {
     Value *DynCGGroupMem = nullptr;
     /// True if the kernel has 'no wait' clause.
     bool HasNoWait = false;
-    /// True if the dynamic shared memory may fallback.
-    bool MayFallbackDynCGroupMem = false;
+    /// The fallback mechanism for the shared memory.
+    omp::OMPDynGroupprivateFallbackType DynCGroupMemFallback =
+        omp::OMPDynGroupprivateFallbackType::Abort;
 
     // Constructors for TargetKernelArgs.
     TargetKernelArgs() {}
     TargetKernelArgs(unsigned NumTargetItems, TargetDataRTArgs RTArgs,
                      Value *NumIterations, ArrayRef<Value *> NumTeams,
                      ArrayRef<Value *> NumThreads, Value *DynCGGroupMem,
-                     bool HasNoWait, bool MayFallbackDynCGroupMem)
+                     bool HasNoWait,
+                     omp::OMPDynGroupprivateFallbackType DynCGroupMemFallback)
         : NumTargetItems(NumTargetItems), RTArgs(RTArgs),
           NumIterations(NumIterations), NumTeams(NumTeams),
           NumThreads(NumThreads), DynCGGroupMem(DynCGGroupMem),
-          HasNoWait(HasNoWait),
-          MayFallbackDynCGroupMem(MayFallbackDynCGroupMem) {}
+          HasNoWait(HasNoWait), DynCGroupMemFallback(DynCGroupMemFallback) {}
   };
 
   /// Create the kernel args vector used by emitTargetKernel. This function

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

@@ -532,11 +532,11 @@ void OpenMPIRBuilder::getKernelArgsVector(TargetKernelArgs &KernelArgs,
   Value *ZeroArray = Constant::getNullValue(ArrayType::get(Int32Ty, MaxDim));
 
   Value *HasNoWaitFlag = Builder.getInt64(KernelArgs.HasNoWait);
-  Value *MayFallbackDynCGroupMemFlag =
-      Builder.getInt64(KernelArgs.MayFallbackDynCGroupMem);
-  MayFallbackDynCGroupMemFlag =
-      Builder.CreateShl(MayFallbackDynCGroupMemFlag, 2);
-  Value *Flags = Builder.CreateOr(HasNoWaitFlag, MayFallbackDynCGroupMemFlag);
+
+  Value *DynCGroupMemFallbackFlag =
+      Builder.getInt64(static_cast<uint64_t>(KernelArgs.DynCGroupMemFallback));
+  DynCGroupMemFallbackFlag = Builder.CreateShl(DynCGroupMemFallbackFlag, 2);
+  Value *Flags = Builder.CreateOr(HasNoWaitFlag, DynCGroupMemFallbackFlag);
 
   assert(!KernelArgs.NumTeams.empty() && !KernelArgs.NumThreads.empty());
 
@@ -8368,9 +8368,9 @@ static void emitTargetCall(
     // TODO: Use correct DynCGGroupMem
     Value *DynCGGroupMem = Builder.getInt32(0);
 
-    KArgs = OpenMPIRBuilder::TargetKernelArgs(NumTargetItems, RTArgs, TripCount,
-                                              NumTeamsC, NumThreadsC,
-                                              DynCGGroupMem, HasNoWait, false);
+    KArgs = OpenMPIRBuilder::TargetKernelArgs(
+        NumTargetItems, RTArgs, TripCount, NumTeamsC, NumThreadsC,
+        DynCGGroupMem, HasNoWait, OMPDynGroupprivateFallbackType::Abort);
 
     // Assume no error was returned because TaskBodyCB and
     // EmitTargetCallFallbackCB don't produce any.