[clang] [Clang][OpenMP] Support multidimensional target launch codegen with dims modifier (PR #239860)

via cfe-commits cfe-commits at lists.llvm.org
Fri Nov 6 16:51:42 PST 2026


llvmorg-github-actions[bot] wrote:


<!--LLVM PR SUMMARY COMMENT-->

@llvm/pr-subscribers-clang-codegen

Author: Kevin Sala Penades (kevinsala)

<details>
<summary>Changes</summary>

Propagate the dimensions of `num_teams`, `thread_limit`, and `num_threads` into target launch arguments. Apply thread limits and conditional parallel counts per dimension while preserving unidimensional behavior.

---

Patch is 1.11 MiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/239860.diff


3 Files Affected:

- (modified) clang/lib/CodeGen/CGOpenMPRuntime.cpp (+240-166) 
- (modified) clang/lib/CodeGen/CGOpenMPRuntime.h (+14-12) 
- (added) clang/test/OpenMP/dims_modifier_codegen.cpp (+14789) 


``````````diff
diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.cpp b/clang/lib/CodeGen/CGOpenMPRuntime.cpp
index d3a6ffee3ea748..efb9a7e6825be3 100644
--- a/clang/lib/CodeGen/CGOpenMPRuntime.cpp
+++ b/clang/lib/CodeGen/CGOpenMPRuntime.cpp
@@ -6558,13 +6558,10 @@ void CGOpenMPRuntime::computeMinAndMaxThreadsAndTeams(
     llvm::OpenMPIRBuilder::TargetKernelDefaultAttrs &Attrs) {
   assert(Attrs.MaxTeams.size() == 1 && Attrs.MaxThreads.size() == 1 &&
          "invalid default attrs structure");
-  int32_t &MaxTeamsVal = Attrs.MaxTeams.front();
-  int32_t &MaxThreadsVal = Attrs.MaxThreads.front();
 
-  getNumTeamsExprForTargetDirective(CGF, D, Attrs.MinTeams.front(),
-                                    MaxTeamsVal);
-  getNumThreadsExprForTargetDirective(CGF, D, MaxThreadsVal,
-                                      /*UpperBoundOnly=*/true);
+  getNumTeamsExprForTargetDirective(CGF, D, Attrs.MinTeams, Attrs.MaxTeams);
+  getNumThreadsExprForTargetDirective(CGF, D, Attrs.MaxThreads,
+                                      /*UppersBoundOnly=*/true);
 
   for (auto *C : D.getClausesOfKind<OMPXAttributeClause>()) {
     for (auto *A : C->getAttrs()) {
@@ -6580,17 +6577,24 @@ void CGOpenMPRuntime::computeMinAndMaxThreadsAndTeams(
       else
         continue;
 
-      Attrs.MinThreads.front() =
-          std::max(Attrs.MinThreads.front(), AttrMinThreadsVal);
-      if (AttrMaxThreadsVal > 0)
-        MaxThreadsVal = MaxThreadsVal > 0
-                            ? std::min(MaxThreadsVal, AttrMaxThreadsVal)
-                            : AttrMaxThreadsVal;
-      Attrs.MinTeams.front() =
-          std::max(Attrs.MinTeams.front(), AttrMinBlocksVal);
-      if (AttrMaxBlocksVal > 0)
-        MaxTeamsVal = MaxTeamsVal > 0 ? std::min(MaxTeamsVal, AttrMaxBlocksVal)
-                                      : AttrMaxBlocksVal;
+      // Ignore attributes if requesting multidimensional teams.
+      if (Attrs.MinThreads.size() == 1 && Attrs.MaxThreads.size() == 1) {
+        Attrs.MinThreads[0] = std::max(Attrs.MinThreads[0], AttrMinThreadsVal);
+        if (AttrMaxThreadsVal > 0)
+          Attrs.MaxThreads[0] =
+              Attrs.MaxThreads[0] > 0
+                  ? std::min(Attrs.MaxThreads[0], AttrMaxThreadsVal)
+                  : AttrMaxThreadsVal;
+      }
+      // Ignore attributes if requesting multidimensional leagues.
+      if (Attrs.MinTeams.size() == 1 && Attrs.MaxTeams.size() == 1) {
+        Attrs.MinTeams[0] = std::max(Attrs.MinTeams[0], AttrMinBlocksVal);
+        if (AttrMaxBlocksVal > 0)
+          Attrs.MaxTeams[0] =
+              Attrs.MaxTeams[0] > 0
+                  ? std::min(Attrs.MaxTeams[0], AttrMaxBlocksVal)
+                  : AttrMaxBlocksVal;
+      }
     }
   }
 }
@@ -6689,9 +6693,14 @@ const Stmt *CGOpenMPRuntime::getSingleCompoundChild(ASTContext &Ctx,
   return Child;
 }
 
-const Expr *CGOpenMPRuntime::getNumTeamsExprForTargetDirective(
-    CodeGenFunction &CGF, const OMPExecutableDirective &D, int32_t &MinTeamsVal,
-    int32_t &MaxTeamsVal) {
+llvm::SmallVector<const Expr *>
+CGOpenMPRuntime::getNumTeamsExprForTargetDirective(
+    CodeGenFunction &CGF, const OMPExecutableDirective &D,
+    llvm::SmallVectorImpl<int32_t> &MinTeamsValues,
+    llvm::SmallVectorImpl<int32_t> &MaxTeamsValues) {
+  llvm::SmallVector<const Expr *> Exprs;
+  MinTeamsValues.assign(1, -1);
+  MaxTeamsValues.assign(1, -1);
 
   OpenMPDirectiveKind DirectiveKind = D.getDirectiveKind();
   assert(isOpenMPTargetExecutionDirective(DirectiveKind) &&
@@ -6707,24 +6716,29 @@ const Expr *CGOpenMPRuntime::getNumTeamsExprForTargetDirective(
             dyn_cast_or_null<OMPExecutableDirective>(ChildStmt)) {
       if (isOpenMPTeamsDirective(NestedDir->getDirectiveKind())) {
         if (NestedDir->hasClausesOfKind<OMPNumTeamsClause>()) {
-          const Expr *NumTeams = NestedDir->getSingleClause<OMPNumTeamsClause>()
-                                     ->getNumTeams()
-                                     .front();
-          if (NumTeams->isIntegerConstantExpr(CGF.getContext()))
-            if (auto Constant =
-                    NumTeams->getIntegerConstantExpr(CGF.getContext()))
-              MinTeamsVal = MaxTeamsVal = Constant->getExtValue();
-          return NumTeams;
+          auto NumTeamsArray =
+              NestedDir->getSingleClause<OMPNumTeamsClause>()->getNumTeams();
+          MinTeamsValues.resize(NumTeamsArray.size(), -1);
+          MaxTeamsValues.resize(NumTeamsArray.size(), -1);
+          for (const auto [Idx, NumTeams] : llvm::enumerate(NumTeamsArray)) {
+            if (NumTeams->isIntegerConstantExpr(CGF.getContext()))
+              if (auto Constant =
+                      NumTeams->getIntegerConstantExpr(CGF.getContext()))
+                MinTeamsValues[Idx] = MaxTeamsValues[Idx] =
+                    Constant->getExtValue();
+            Exprs.push_back(NumTeams);
+          }
+          return Exprs;
         }
-        MinTeamsVal = MaxTeamsVal = 0;
-        return nullptr;
+        MinTeamsValues[0] = MaxTeamsValues[0] = 0;
+        return Exprs;
       }
-      MinTeamsVal = MaxTeamsVal = 1;
-      return nullptr;
+      MinTeamsValues[0] = MaxTeamsValues[0] = 1;
+      return Exprs;
     }
     // A value of -1 is used to check if we need to emit no teams region
-    MinTeamsVal = MaxTeamsVal = -1;
-    return nullptr;
+    MinTeamsValues[0] = MaxTeamsValues[0] = -1;
+    return Exprs;
   }
   case OMPD_target_teams_loop:
   case OMPD_target_teams:
@@ -6733,23 +6747,29 @@ const Expr *CGOpenMPRuntime::getNumTeamsExprForTargetDirective(
   case OMPD_target_teams_distribute_parallel_for:
   case OMPD_target_teams_distribute_parallel_for_simd: {
     if (D.hasClausesOfKind<OMPNumTeamsClause>()) {
-      const Expr *NumTeams =
-          D.getSingleClause<OMPNumTeamsClause>()->getNumTeams().front();
-      if (NumTeams->isIntegerConstantExpr(CGF.getContext()))
-        if (auto Constant = NumTeams->getIntegerConstantExpr(CGF.getContext()))
-          MinTeamsVal = MaxTeamsVal = Constant->getExtValue();
-      return NumTeams;
-    }
-    MinTeamsVal = MaxTeamsVal = 0;
-    return nullptr;
+      auto NumTeamsArray =
+          D.getSingleClause<OMPNumTeamsClause>()->getNumTeams();
+      MinTeamsValues.resize(NumTeamsArray.size(), -1);
+      MaxTeamsValues.resize(NumTeamsArray.size(), -1);
+      for (const auto [Idx, NumTeams] : llvm::enumerate(NumTeamsArray)) {
+        if (NumTeams->isIntegerConstantExpr(CGF.getContext()))
+          if (auto Constant =
+                  NumTeams->getIntegerConstantExpr(CGF.getContext()))
+            MinTeamsValues[Idx] = MaxTeamsValues[Idx] = Constant->getExtValue();
+        Exprs.push_back(NumTeams);
+      }
+      return Exprs;
+    }
+    MinTeamsValues[0] = MaxTeamsValues[0] = 0;
+    return Exprs;
   }
   case OMPD_target_parallel:
   case OMPD_target_parallel_for:
   case OMPD_target_parallel_for_simd:
   case OMPD_target_parallel_loop:
   case OMPD_target_simd:
-    MinTeamsVal = MaxTeamsVal = 1;
-    return nullptr;
+    MinTeamsValues[0] = MaxTeamsValues[0] = 1;
+    return Exprs;
   case OMPD_parallel:
   case OMPD_for:
   case OMPD_parallel_for:
@@ -6818,16 +6838,18 @@ const Expr *CGOpenMPRuntime::getNumTeamsExprForTargetDirective(
   llvm_unreachable("Unexpected directive kind.");
 }
 
-llvm::Value *CGOpenMPRuntime::emitNumTeamsForTargetDirective(
-    CodeGenFunction &CGF, const OMPExecutableDirective &D) {
+void CGOpenMPRuntime::emitNumTeamsForTargetDirective(
+    CodeGenFunction &CGF, const OMPExecutableDirective &D,
+    llvm::SmallVectorImpl<llvm::Value *> &NumTeamsValues) {
   assert(!CGF.getLangOpts().OpenMPIsTargetDevice &&
          "Clauses associated with the teams directive expected to be emitted "
          "only for the host!");
+  NumTeamsValues.clear();
+
   CGBuilderTy &Bld = CGF.Builder;
-  int32_t MinNT = -1, MaxNT = -1;
-  const Expr *NumTeams =
-      getNumTeamsExprForTargetDirective(CGF, D, MinNT, MaxNT);
-  if (NumTeams != nullptr) {
+  llvm::SmallVector<int32_t> MinNT, MaxNT;
+  auto Exprs = getNumTeamsExprForTargetDirective(CGF, D, MinNT, MaxNT);
+  if (!Exprs.empty()) {
     OpenMPDirectiveKind DirectiveKind = D.getDirectiveKind();
 
     switch (DirectiveKind) {
@@ -6835,10 +6857,12 @@ llvm::Value *CGOpenMPRuntime::emitNumTeamsForTargetDirective(
       const auto *CS = D.getInnermostCapturedStmt();
       CGOpenMPInnerExprInfo CGInfo(CGF, *CS);
       CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
-      llvm::Value *NumTeamsVal = CGF.EmitScalarExpr(NumTeams,
-                                                  /*IgnoreResultAssign*/ true);
-      return Bld.CreateIntCast(NumTeamsVal, CGF.Int32Ty,
-                             /*isSigned=*/true);
+      for (const Expr *E : Exprs) {
+        llvm::Value *Val = CGF.EmitScalarExpr(E, /*IgnoreResultAssign*/ true);
+        NumTeamsValues.push_back(
+            Bld.CreateIntCast(Val, CGF.Int32Ty, /*isSigned=*/true));
+      }
+      return;
     }
     case OMPD_target_teams:
     case OMPD_target_teams_distribute:
@@ -6846,10 +6870,12 @@ llvm::Value *CGOpenMPRuntime::emitNumTeamsForTargetDirective(
     case OMPD_target_teams_distribute_parallel_for:
     case OMPD_target_teams_distribute_parallel_for_simd: {
       CodeGenFunction::RunCleanupsScope NumTeamsScope(CGF);
-      llvm::Value *NumTeamsVal = CGF.EmitScalarExpr(NumTeams,
-                                                  /*IgnoreResultAssign*/ true);
-      return Bld.CreateIntCast(NumTeamsVal, CGF.Int32Ty,
-                             /*isSigned=*/true);
+      for (const Expr *E : Exprs) {
+        llvm::Value *Val = CGF.EmitScalarExpr(E, /*IgnoreResultAssign*/ true);
+        NumTeamsValues.push_back(
+            Bld.CreateIntCast(Val, CGF.Int32Ty, /*isSigned=*/true));
+      }
+      return;
     }
     default:
       break;
@@ -6857,7 +6883,9 @@ llvm::Value *CGOpenMPRuntime::emitNumTeamsForTargetDirective(
   }
 
   assert(MinNT == MaxNT && "Num threads ranges require handling here.");
-  return llvm::ConstantInt::getSigned(CGF.Int32Ty, MinNT);
+
+  for (auto NT : MinNT)
+    NumTeamsValues.push_back(llvm::ConstantInt::getSigned(CGF.Int32Ty, NT));
 }
 
 /// Merge the thread count upper bound \p Val into \p UpperBound.
@@ -6874,13 +6902,50 @@ static void mergeThreadCountUpperBound(int32_t &UpperBound, int32_t Val) {
   UpperBound = UpperBound > 0 ? std::min(UpperBound, Val) : Val;
 }
 
+void getThreadExprsAndMergeUpperBound(
+    CodeGenFunction &CGF, llvm::ArrayRef<const Expr *> Exprs,
+    llvm::SmallVectorImpl<int32_t> &UpperBounds,
+    llvm::SmallVectorImpl<const Expr *> *ExprsPtr = nullptr) {
+  assert(!Exprs.empty() && "Invalid array of expressions.");
+  // All expressions must be constant to have an upperbound.
+  llvm::SmallVector<int32_t> Constants;
+  for (const Expr *E : Exprs)
+    if (E->isIntegerConstantExpr(CGF.getContext()))
+      if (auto Constant = E->getIntegerConstantExpr(CGF.getContext()))
+        Constants.push_back(static_cast<int32_t>(Constant->getZExtValue()));
+
+  if (Exprs.size() == Constants.size()) {
+    // All expressions are constant.
+    if (UpperBounds.empty()) {
+      // No bounds limiting clause were found before.
+      UpperBounds = Constants;
+    } else {
+      // Bounds were set previously. Truncate dimensions to the minimum and set
+      // the bounds to the minimum value in each dimension.
+      size_t MinSize = std::min(Exprs.size(), UpperBounds.size());
+      UpperBounds.truncate(MinSize);
+      for (size_t I = 0; I < MinSize; ++I)
+        mergeThreadCountUpperBound(UpperBounds[I], Constants[I]);
+    }
+  } else {
+    // Some of the expressions are not constant.
+    if (UpperBounds.empty())
+      UpperBounds.resize(Exprs.size(), 0);
+    else
+      UpperBounds.truncate(Exprs.size());
+  }
+  if (ExprsPtr)
+    (*ExprsPtr).assign(Exprs.begin(), Exprs.end());
+}
+
 /// Check for a num threads constant value (stored in \p DefaultVal), or
 /// expression (stored in \p E). If the value is conditional (via an if-clause),
 /// store the condition in \p CondVal. If \p E, and \p CondVal respectively, are
 /// nullptr, no expression evaluation is perfomed.
 static void getNumThreads(CodeGenFunction &CGF, const CapturedStmt *CS,
-                          const Expr **E, int32_t &UpperBound,
-                          bool UpperBoundOnly, llvm::Value **CondVal) {
+                          llvm::SmallVectorImpl<const Expr *> &Exprs,
+                          llvm::SmallVectorImpl<int32_t> &UpperBounds,
+                          bool UpperBoundsOnly, llvm::Value **CondVal) {
   const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
       CGF.getContext(), CS->getCapturedStmt());
   const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child);
@@ -6906,7 +6971,7 @@ static void getNumThreads(CodeGenFunction &CGF, const CapturedStmt *CS,
         bool Result;
         if (CondExpr->EvaluateAsBooleanCondition(Result, CGF.getContext())) {
           if (!Result) {
-            UpperBound = 1;
+            UpperBounds.assign(1, 1);
             return;
           }
         } else {
@@ -6934,18 +6999,12 @@ static void getNumThreads(CodeGenFunction &CGF, const CapturedStmt *CS,
       CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
       const auto *NumThreadsClause =
           Dir->getSingleClause<OMPNumThreadsClause>();
-      const Expr *NTExpr = NumThreadsClause->getNumThreads().front();
-      if (NTExpr->isIntegerConstantExpr(CGF.getContext()))
-        if (auto Constant = NTExpr->getIntegerConstantExpr(CGF.getContext()))
-          mergeThreadCountUpperBound(
-              UpperBound, static_cast<int32_t>(Constant->getZExtValue()));
-      // If we haven't found a upper bound, remember we saw a thread limiting
-      // clause.
-      if (UpperBound == -1)
-        UpperBound = 0;
-      if (!E)
+      llvm::ArrayRef<const Expr *> NTExprs = NumThreadsClause->getNumThreads();
+      getThreadExprsAndMergeUpperBound(CGF, NTExprs, UpperBounds);
+      if (UpperBoundsOnly)
         return;
-      CodeGenFunction::LexicalScope Scope(CGF, NTExpr->getSourceRange());
+
+      CodeGenFunction::LexicalScope Scope(CGF, NTExprs[0]->getSourceRange());
       if (const auto *PreInit =
               cast_or_null<DeclStmt>(NumThreadsClause->getPreInitStmt())) {
         for (const auto *I : PreInit->decls()) {
@@ -6958,50 +7017,41 @@ static void getNumThreads(CodeGenFunction &CGF, const CapturedStmt *CS,
           }
         }
       }
-      *E = NTExpr;
+      Exprs.assign(NTExprs.begin(), NTExprs.end());
     }
     return;
   }
   if (isOpenMPSimdDirective(Dir->getDirectiveKind()))
-    UpperBound = 1;
+    UpperBounds.assign(1, 1);
 }
 
-const Expr *CGOpenMPRuntime::getNumThreadsExprForTargetDirective(
-    CodeGenFunction &CGF, const OMPExecutableDirective &D, int32_t &UpperBound,
-    bool UpperBoundOnly, llvm::Value **CondVal, const Expr **ThreadLimitExpr) {
-  assert((!CGF.getLangOpts().OpenMPIsTargetDevice || UpperBoundOnly) &&
+llvm::SmallVector<const Expr *>
+CGOpenMPRuntime::getNumThreadsExprForTargetDirective(
+    CodeGenFunction &CGF, const OMPExecutableDirective &D,
+    llvm::SmallVectorImpl<int32_t> &UpperBounds, bool UpperBoundsOnly,
+    llvm::Value **CondVal,
+    llvm::SmallVectorImpl<const Expr *> *ThreadLimitExprs) {
+  assert((!CGF.getLangOpts().OpenMPIsTargetDevice || UpperBoundsOnly) &&
          "Clauses associated with the teams directive expected to be emitted "
          "only for the host!");
   OpenMPDirectiveKind DirectiveKind = D.getDirectiveKind();
   assert(isOpenMPTargetExecutionDirective(DirectiveKind) &&
          "Expected target-based executable directive.");
 
-  const Expr *NT = nullptr;
-  const Expr **NTPtr = UpperBoundOnly ? nullptr : &NT;
+  llvm::SmallVector<const Expr *> NTExprs;
+  UpperBounds.clear();
 
-  auto CheckForConstExpr = [&](const Expr *E, const Expr **EPtr) {
-    if (E->isIntegerConstantExpr(CGF.getContext())) {
-      if (auto Constant = E->getIntegerConstantExpr(CGF.getContext()))
-        mergeThreadCountUpperBound(
-            UpperBound, static_cast<int32_t>(Constant->getZExtValue()));
-    }
-    // If we haven't found a upper bound, remember we saw a thread limiting
-    // clause.
-    if (UpperBound == -1)
-      UpperBound = 0;
-    if (EPtr)
-      *EPtr = E;
-  };
-
-  auto ReturnSequential = [&]() {
-    UpperBound = 1;
-    return NT;
+  auto SerializeBounds = [&]() { UpperBounds.assign(1, 1); };
+  auto NormalizeBounds = [&]() {
+    // Never return the upper bounds empty.
+    if (UpperBounds.empty())
+      UpperBounds.assign(1, -1);
   };
 
   switch (DirectiveKind) {
   case OMPD_target: {
     const CapturedStmt *CS = D.getInnermostCapturedStmt();
-    getNumThreads(CGF, CS, NTPtr, UpperBound, UpperBoundOnly, CondVal);
+    getNumThreads(CGF, CS, NTExprs, UpperBounds, UpperBoundsOnly, CondVal);
     const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
         CGF.getContext(), CS->getCapturedStmt());
     // TODO: The standard is not clear how to resolve two thread limit clauses,
@@ -7010,7 +7060,7 @@ const Expr *CGOpenMPRuntime::getNumThreadsExprForTargetDirective(
     if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) {
       if (const auto *TLC = Dir->getSingleClause<OMPThreadLimitClause>()) {
         ThreadLimitClause = TLC;
-        if (ThreadLimitExpr) {
+        if (ThreadLimitExprs) {
           CGOpenMPInnerExprInfo CGInfo(CGF, *CS);
           CodeGenFunction::CGCapturedStmtRAII CapInfoRAII(CGF, &CGInfo);
           CodeGenFunction::LexicalScope Scope(
@@ -7032,8 +7082,8 @@ const Expr *CGOpenMPRuntime::getNumThreadsExprForTargetDirective(
       }
     }
     if (ThreadLimitClause)
-      CheckForConstExpr(ThreadLimitClause->getThreadLimit().front(),
-                        ThreadLimitExpr);
+      getThreadExprsAndMergeUpperBound(CGF, ThreadLimitClause->getThreadLimit(), UpperBounds,
+                         ThreadLimitExprs);
     if (const auto *Dir = dyn_cast_or_null<OMPExecutableDirective>(Child)) {
       if (isOpenMPTeamsDirective(Dir->getDirectiveKind()) &&
           !isOpenMPDistributeDirective(Dir->getDirectiveKind())) {
@@ -7044,10 +7094,10 @@ const Expr *CGOpenMPRuntime::getNumThreadsExprForTargetDirective(
         // below does. Without this the upper bound of a construct written as
         // 'target' / 'teams' / 'distribute parallel for' would stay at the
         // default, while every combined spelling of the same construct honors
-        // the clause. Only the bound is taken here: passing null for the
-        // expression and the condition keeps this from emitting anything, so
-        // the value the host passes to the kernel launch is left as it was.
-        getNumThreads(CGF, CS, /*E=*/nullptr, UpperBound, UpperBoundOnly,
+        // the clause. Only the bounds are taken here expression and the
+        // condition keeps this from emitting anything, so the value the host
+        // passes to the kernel launch is left as it was.
+        getNumThreads(CGF, CS, NTExprs, UpperBounds, /*UpperBoundsOnly=*/true,
                       /*CondVal=*/nullptr);
         const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
             CGF.getContext(), CS->getCapturedStmt());
@@ -7055,41 +7105,46 @@ const Expr *CGOpenMPRuntime::getNumThreadsExprForTargetDirective(
       }
       if (Dir && isOpenMPParallelDirective(Dir->getDirectiveKind())) {
         CS = Dir->getInnermostCapturedStmt();
-        getNumThreads(CGF, CS, NTPtr, UpperBound, UpperBoundOnly, CondVal);
-      } else if (Dir && isOpenMPSimdDirective(Dir->getDirectiveKind()))
-        return ReturnSequential();
+        getNumThreads(CGF, CS, NTExprs, UpperBounds, UpperBoundsOnly, CondVal);
+      } else if (Dir && isOpenMPSimdDirective(Dir->getDirectiveKind())) {
+        SerializeBounds();
+        return NTExprs;
+      }
     }
-    return NT;
+    NormalizeBounds();
+    return NTExprs;
   }
   case OMPD_target_teams: {
     if (D.hasClausesOfKind<OMPThreadLimitClause>()) {
       CodeGenFunction::RunCleanupsScope ThreadLimitScope(CGF);
       const auto *ThreadLimitClause = D.getSingleClause<OMPThreadLimitClause>();
-      CheckForConstExpr(ThreadLimitClause->getThreadLimit().front(),
-                        ThreadLimitExpr);
+      getThreadExprsAndMergeUpperBound(CGF, ThreadLimitClause->getThreadLimit(), UpperBounds,
+                         ThreadLimitEx...
[truncated]

``````````

</details>


https://github.com/llvm/llvm-project/pull/239860


More information about the cfe-commits mailing list