Skip to content

Commit a0c2051

Browse files
SagarRathodeSagarRathode
authored
Merge pull request #1 from swiftlang/next
from next to base
2 parents 7d32fda + 585cd36 commit a0c2051

File tree

9 files changed

+369
-38
lines changed

9 files changed

+369
-38
lines changed

‎clang/include/clang/Driver/Options.td‎

Lines changed: 20 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -3950,10 +3950,26 @@ let Visibility = [ClangOption, CC1Option, FC1Option, FlangOption] in {
39503950
let Group = f_Group in {
39513951

39523952
def fopenmp_target_debug_EQ : Joined<["-"], "fopenmp-target-debug=">;
3953-
def fopenmp_assume_teams_oversubscription : Flag<["-"], "fopenmp-assume-teams-oversubscription">;
3954-
def fopenmp_assume_threads_oversubscription : Flag<["-"], "fopenmp-assume-threads-oversubscription">;
3955-
def fno_openmp_assume_teams_oversubscription : Flag<["-"], "fno-openmp-assume-teams-oversubscription">;
3956-
def fno_openmp_assume_threads_oversubscription : Flag<["-"], "fno-openmp-assume-threads-oversubscription">;
3953+
def fopenmp_assume_teams_oversubscription : Flag<["-"], "fopenmp-assume-teams-oversubscription">,
3954+
HelpText<"Allow the optimizer to discretely increase the number of "
3955+
"teams. May cause ignore environment variables that set "
3956+
"the number of teams to be ignored. The combination of "
3957+
"-fopenmp-assume-teams-oversubscription "
3958+
"and -fopenmp-assume-threads-oversubscription "
3959+
"may allow the conversion of loops into sequential code by "
3960+
"ensuring that each team/thread executes at most one iteration.">;
3961+
def fopenmp_assume_threads_oversubscription : Flag<["-"], "fopenmp-assume-threads-oversubscription">,
3962+
HelpText<"Allow the optimizer to discretely increase the number of "
3963+
"threads. May cause ignore environment variables that set "
3964+
"the number of threads to be ignored. The combination of "
3965+
"-fopenmp-assume-teams-oversubscription "
3966+
"and -fopenmp-assume-threads-oversubscription "
3967+
"may allow the conversion of loops into sequential code by "
3968+
"ensuring that each team/thread executes at most one iteration.">;
3969+
def fno_openmp_assume_teams_oversubscription : Flag<["-"], "fno-openmp-assume-teams-oversubscription">,
3970+
HelpText<"Do not assume teams oversubscription.">;
3971+
def fno_openmp_assume_threads_oversubscription : Flag<["-"], "fno-openmp-assume-threads-oversubscription">,
3972+
HelpText<"Do not assume threads oversubscription.">;
39573973
def fopenmp_assume_no_thread_state : Flag<["-"], "fopenmp-assume-no-thread-state">,
39583974
HelpText<"Assert no thread in a parallel region modifies an ICV">,
39593975
MarshallingInfoFlag<LangOpts<"OpenMPNoThreadState">>;

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

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1085,11 +1085,13 @@ class OpenMPIRBuilder {
10851085
/// preheader of the loop.
10861086
/// \param LoopType Information about type of loop worksharing.
10871087
/// It corresponds to type of loop workshare OpenMP pragma.
1088+
/// \param NoLoop If true, no-loop code is generated.
10881089
///
10891090
/// \returns Point where to insert code after the workshare construct.
10901091
InsertPointTy applyWorkshareLoopTarget(DebugLoc DL, CanonicalLoopInfo *CLI,
10911092
InsertPointTy AllocaIP,
1092-
omp::WorksharingLoopType LoopType);
1093+
omp::WorksharingLoopType LoopType,
1094+
bool NoLoop);
10931095

10941096
/// Modifies the canonical loop to be a statically-scheduled workshare loop.
10951097
///
@@ -1209,6 +1211,7 @@ class OpenMPIRBuilder {
12091211
/// present.
12101212
/// \param LoopType Information about type of loop worksharing.
12111213
/// It corresponds to type of loop workshare OpenMP pragma.
1214+
/// \param NoLoop If true, no-loop code is generated.
12121215
///
12131216
/// \returns Point where to insert code after the workshare construct.
12141217
LLVM_ABI InsertPointOrErrorTy applyWorkshareLoop(
@@ -1219,7 +1222,8 @@ class OpenMPIRBuilder {
12191222
bool HasMonotonicModifier = false, bool HasNonmonotonicModifier = false,
12201223
bool HasOrderedClause = false,
12211224
omp::WorksharingLoopType LoopType =
1222-
omp::WorksharingLoopType::ForStaticLoop);
1225+
omp::WorksharingLoopType::ForStaticLoop,
1226+
bool NoLoop = false);
12231227

12241228
/// Tile a loop nest.
12251229
///

‎llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp‎

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -4979,7 +4979,7 @@ static void createTargetLoopWorkshareCall(OpenMPIRBuilder *OMPBuilder,
49794979
WorksharingLoopType LoopType,
49804980
BasicBlock *InsertBlock, Value *Ident,
49814981
Value *LoopBodyArg, Value *TripCount,
4982-
Function &LoopBodyFn) {
4982+
Function &LoopBodyFn, bool NoLoop) {
49834983
Type *TripCountTy = TripCount->getType();
49844984
Module &M = OMPBuilder->M;
49854985
IRBuilder<> &Builder = OMPBuilder->Builder;
@@ -5007,16 +5007,18 @@ static void createTargetLoopWorkshareCall(OpenMPIRBuilder *OMPBuilder,
50075007
RealArgs.push_back(ConstantInt::get(TripCountTy, 0));
50085008
if (LoopType == WorksharingLoopType::DistributeForStaticLoop) {
50095009
RealArgs.push_back(ConstantInt::get(TripCountTy, 0));
5010+
RealArgs.push_back(ConstantInt::get(Builder.getInt8Ty(), NoLoop));
5011+
} else {
5012+
RealArgs.push_back(ConstantInt::get(Builder.getInt8Ty(), 0));
50105013
}
5011-
RealArgs.push_back(ConstantInt::get(Builder.getInt8Ty(), 0));
50125014

50135015
Builder.CreateCall(RTLFn, RealArgs);
50145016
}
50155017

50165018
static void workshareLoopTargetCallback(
50175019
OpenMPIRBuilder *OMPIRBuilder, CanonicalLoopInfo *CLI, Value *Ident,
50185020
Function &OutlinedFn, const SmallVector<Instruction *, 4> &ToBeDeleted,
5019-
WorksharingLoopType LoopType) {
5021+
WorksharingLoopType LoopType, bool NoLoop) {
50205022
IRBuilder<> &Builder = OMPIRBuilder->Builder;
50215023
BasicBlock *Preheader = CLI->getPreheader();
50225024
Value *TripCount = CLI->getTripCount();
@@ -5063,17 +5065,16 @@ static void workshareLoopTargetCallback(
50635065
OutlinedFnCallInstruction->eraseFromParent();
50645066

50655067
createTargetLoopWorkshareCall(OMPIRBuilder, LoopType, Preheader, Ident,
5066-
LoopBodyArg, TripCount, OutlinedFn);
5068+
LoopBodyArg, TripCount, OutlinedFn, NoLoop);
50675069

50685070
for (auto &ToBeDeletedItem : ToBeDeleted)
50695071
ToBeDeletedItem->eraseFromParent();
50705072
CLI->invalidate();
50715073
}
50725074

5073-
OpenMPIRBuilder::InsertPointTy
5074-
OpenMPIRBuilder::applyWorkshareLoopTarget(DebugLoc DL, CanonicalLoopInfo *CLI,
5075-
InsertPointTy AllocaIP,
5076-
WorksharingLoopType LoopType) {
5075+
OpenMPIRBuilder::InsertPointTy OpenMPIRBuilder::applyWorkshareLoopTarget(
5076+
DebugLoc DL, CanonicalLoopInfo *CLI, InsertPointTy AllocaIP,
5077+
WorksharingLoopType LoopType, bool NoLoop) {
50775078
uint32_t SrcLocStrSize;
50785079
Constant *SrcLocStr = getOrCreateSrcLocStr(DL, SrcLocStrSize);
50795080
Value *Ident = getOrCreateIdent(SrcLocStr, SrcLocStrSize);
@@ -5156,7 +5157,7 @@ OpenMPIRBuilder::applyWorkshareLoopTarget(DebugLoc DL, CanonicalLoopInfo *CLI,
51565157
OI.PostOutlineCB = [=, ToBeDeletedVec =
51575158
std::move(ToBeDeleted)](Function &OutlinedFn) {
51585159
workshareLoopTargetCallback(this, CLI, Ident, OutlinedFn, ToBeDeletedVec,
5159-
LoopType);
5160+
LoopType, NoLoop);
51605161
};
51615162
addOutlineInfo(std::move(OI));
51625163
return CLI->getAfterIP();
@@ -5167,9 +5168,9 @@ OpenMPIRBuilder::InsertPointOrErrorTy OpenMPIRBuilder::applyWorkshareLoop(
51675168
bool NeedsBarrier, omp::ScheduleKind SchedKind, Value *ChunkSize,
51685169
bool HasSimdModifier, bool HasMonotonicModifier,
51695170
bool HasNonmonotonicModifier, bool HasOrderedClause,
5170-
WorksharingLoopType LoopType) {
5171+
WorksharingLoopType LoopType, bool NoLoop) {
51715172
if (Config.isTargetDevice())
5172-
return applyWorkshareLoopTarget(DL, CLI, AllocaIP, LoopType);
5173+
return applyWorkshareLoopTarget(DL, CLI, AllocaIP, LoopType, NoLoop);
51735174
OMPScheduleType EffectiveScheduleType = computeOpenMPScheduleType(
51745175
SchedKind, ChunkSize, HasSimdModifier, HasMonotonicModifier,
51755176
HasNonmonotonicModifier, HasOrderedClause);

‎llvm/test/Analysis/ScalarEvolution/trip-multiple-guard-info.ll‎

Lines changed: 159 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -574,5 +574,164 @@ exit:
574574
ret void
575575
}
576576

577+
define void @test_ptr_aligned_by_2_and_4_via_assumption(ptr %start, ptr %end) {
578+
; CHECK-LABEL: 'test_ptr_aligned_by_2_and_4_via_assumption'
579+
; CHECK-NEXT: Classifying expressions for: @test_ptr_aligned_by_2_and_4_via_assumption
580+
; CHECK-NEXT: %iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ]
581+
; CHECK-NEXT: --> {%start,+,4}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
582+
; CHECK-NEXT: %iv.next = getelementptr i8, ptr %iv, i64 4
583+
; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
584+
; CHECK-NEXT: Determining loop execution counts for: @test_ptr_aligned_by_2_and_4_via_assumption
585+
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
586+
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
587+
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
588+
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4)
589+
; CHECK-NEXT: Predicates:
590+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
591+
; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 4611686018427387903
592+
; CHECK-NEXT: Predicates:
593+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
594+
; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4)
595+
; CHECK-NEXT: Predicates:
596+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
597+
;
598+
entry:
599+
call void @llvm.assume(i1 true) [ "align"(ptr %start, i64 2) ]
600+
call void @llvm.assume(i1 true) [ "align"(ptr %end, i64 4) ]
601+
br label %loop
602+
603+
loop:
604+
%iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ]
605+
store ptr %iv, ptr %iv
606+
%iv.next = getelementptr i8, ptr %iv, i64 4
607+
%ec = icmp ne ptr %iv.next, %end
608+
br i1 %ec, label %loop, label %exit
609+
610+
exit:
611+
ret void
612+
}
613+
614+
define void @test_ptrs_aligned_by_4_via_assumption(ptr %start, ptr %end) {
615+
; CHECK-LABEL: 'test_ptrs_aligned_by_4_via_assumption'
616+
; CHECK-NEXT: Classifying expressions for: @test_ptrs_aligned_by_4_via_assumption
617+
; CHECK-NEXT: %iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ]
618+
; CHECK-NEXT: --> {%start,+,4}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
619+
; CHECK-NEXT: %iv.next = getelementptr i8, ptr %iv, i64 4
620+
; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
621+
; CHECK-NEXT: Determining loop execution counts for: @test_ptrs_aligned_by_4_via_assumption
622+
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
623+
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
624+
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
625+
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4)
626+
; CHECK-NEXT: Predicates:
627+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
628+
; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 4611686018427387903
629+
; CHECK-NEXT: Predicates:
630+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
631+
; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4)
632+
; CHECK-NEXT: Predicates:
633+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
634+
;
635+
entry:
636+
call void @llvm.assume(i1 true) [ "align"(ptr %start, i64 4) ]
637+
call void @llvm.assume(i1 true) [ "align"(ptr %end, i64 4) ]
638+
br label %loop
639+
640+
loop:
641+
%iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ]
642+
store ptr %iv, ptr %iv
643+
%iv.next = getelementptr i8, ptr %iv, i64 4
644+
%ec = icmp ne ptr %iv.next, %end
645+
br i1 %ec, label %loop, label %exit
646+
647+
exit:
648+
ret void
649+
}
650+
651+
define void @test_ptrs_aligned_by_8_via_assumption(ptr %start, ptr %end) {
652+
; CHECK-LABEL: 'test_ptrs_aligned_by_8_via_assumption'
653+
; CHECK-NEXT: Classifying expressions for: @test_ptrs_aligned_by_8_via_assumption
654+
; CHECK-NEXT: %iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ]
655+
; CHECK-NEXT: --> {%start,+,4}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
656+
; CHECK-NEXT: %iv.next = getelementptr i8, ptr %iv, i64 4
657+
; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
658+
; CHECK-NEXT: Determining loop execution counts for: @test_ptrs_aligned_by_8_via_assumption
659+
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
660+
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
661+
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
662+
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4)
663+
; CHECK-NEXT: Predicates:
664+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
665+
; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 4611686018427387903
666+
; CHECK-NEXT: Predicates:
667+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
668+
; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4)
669+
; CHECK-NEXT: Predicates:
670+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
671+
;
672+
entry:
673+
call void @llvm.assume(i1 true) [ "align"(ptr %start, i64 8) ]
674+
call void @llvm.assume(i1 true) [ "align"(ptr %end, i64 8) ]
675+
br label %loop
676+
677+
loop:
678+
%iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ]
679+
store ptr %iv, ptr %iv
680+
%iv.next = getelementptr i8, ptr %iv, i64 4
681+
%ec = icmp ne ptr %iv.next, %end
682+
br i1 %ec, label %loop, label %exit
683+
684+
exit:
685+
ret void
686+
}
687+
688+
declare i1 @cond()
689+
690+
define void @test_ptr_aligned_by_4_via_assumption_multiple_loop_predecessors(ptr %start, ptr %end) {
691+
; CHECK-LABEL: 'test_ptr_aligned_by_4_via_assumption_multiple_loop_predecessors'
692+
; CHECK-NEXT: Classifying expressions for: @test_ptr_aligned_by_4_via_assumption_multiple_loop_predecessors
693+
; CHECK-NEXT: %c = call i1 @cond()
694+
; CHECK-NEXT: --> %c U: full-set S: full-set
695+
; CHECK-NEXT: %iv = phi ptr [ %start, %then ], [ %start, %else ], [ %iv.next, %loop ]
696+
; CHECK-NEXT: --> {%start,+,4}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
697+
; CHECK-NEXT: %iv.next = getelementptr i8, ptr %iv, i64 4
698+
; CHECK-NEXT: --> {(4 + %start),+,4}<%loop> U: full-set S: full-set Exits: <<Unknown>> LoopDispositions: { %loop: Computable }
699+
; CHECK-NEXT: Determining loop execution counts for: @test_ptr_aligned_by_4_via_assumption_multiple_loop_predecessors
700+
; CHECK-NEXT: Loop %loop: Unpredictable backedge-taken count.
701+
; CHECK-NEXT: Loop %loop: Unpredictable constant max backedge-taken count.
702+
; CHECK-NEXT: Loop %loop: Unpredictable symbolic max backedge-taken count.
703+
; CHECK-NEXT: Loop %loop: Predicated backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4)
704+
; CHECK-NEXT: Predicates:
705+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
706+
; CHECK-NEXT: Loop %loop: Predicated constant max backedge-taken count is i64 4611686018427387903
707+
; CHECK-NEXT: Predicates:
708+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
709+
; CHECK-NEXT: Loop %loop: Predicated symbolic max backedge-taken count is ((-4 + (-1 * (ptrtoint ptr %start to i64)) + (ptrtoint ptr %end to i64)) /u 4)
710+
; CHECK-NEXT: Predicates:
711+
; CHECK-NEXT: Equal predicate: (zext i2 ((trunc i64 (ptrtoint ptr %end to i64) to i2) + (-1 * (trunc i64 (ptrtoint ptr %start to i64) to i2))) to i64) == 0
712+
;
713+
entry:
714+
call void @llvm.assume(i1 true) [ "align"(ptr %start, i64 2) ]
715+
call void @llvm.assume(i1 true) [ "align"(ptr %end, i64 4) ]
716+
%c = call i1 @cond()
717+
br i1 %c, label %then, label %else
718+
719+
then:
720+
br label %loop
721+
722+
else:
723+
br label %loop
724+
725+
loop:
726+
%iv = phi ptr [ %start, %then] , [ %start, %else ], [ %iv.next, %loop ]
727+
store ptr %iv, ptr %iv
728+
%iv.next = getelementptr i8, ptr %iv, i64 4
729+
%ec = icmp ne ptr %iv.next, %end
730+
br i1 %ec, label %loop, label %exit
731+
732+
exit:
733+
ret void
734+
}
735+
577736
declare void @llvm.assume(i1)
578737
declare void @llvm.experimental.guard(i1, ...)

‎mlir/include/mlir/Dialect/OpenMP/OpenMPEnums.td‎

Lines changed: 12 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -230,14 +230,24 @@ def TargetRegionFlagsNone : I32BitEnumAttrCaseNone<"none">;
230230
def TargetRegionFlagsGeneric : I32BitEnumAttrCaseBit<"generic", 0>;
231231
def TargetRegionFlagsSpmd : I32BitEnumAttrCaseBit<"spmd", 1>;
232232
def TargetRegionFlagsTripCount : I32BitEnumAttrCaseBit<"trip_count", 2>;
233+
def TargetRegionFlagsNoLoop : I32BitEnumAttrCaseBit<"no_loop", 3>;
233234

234235
def TargetRegionFlags : OpenMP_BitEnumAttr<
235236
"TargetRegionFlags",
236-
"target region property flags", [
237+
"These flags describe properties of the target kernel. "
238+
"TargetRegionFlagsGeneric - denotes generic kernel. "
239+
"TargetRegionFlagsSpmd - denotes SPMD kernel. "
240+
"TargetRegionFlagsNoLoop - denotes kernel where "
241+
"num_teams * num_threads >= loop_trip_count. It allows the conversion "
242+
"of loops into sequential code by ensuring that each team/thread "
243+
"executes at most one iteration. "
244+
"TargetRegionFlagsTripCount - checks if the loop trip count should be "
245+
"calculated.", [
237246
TargetRegionFlagsNone,
238247
TargetRegionFlagsGeneric,
239248
TargetRegionFlagsSpmd,
240-
TargetRegionFlagsTripCount
249+
TargetRegionFlagsTripCount,
250+
TargetRegionFlagsNoLoop
241251
]>;
242252

243253
//===----------------------------------------------------------------------===//

0 commit comments

Comments
 (0)