[clang] 6421171 - [Clang] Implement P2809: Trivial infinite loops are not Undefined Behavior (#90066)
via cfe-commits
cfe-commits at lists.llvm.org
Fri May 3 05:10:59 PDT 2024
Author: cor3ntin
Date: 2024-05-03T14:10:54+02:00
New Revision: 642117105d4f7944b7944f9b2a6ba9993fb68ed9
URL: https://github.com/llvm/llvm-project/commit/642117105d4f7944b7944f9b2a6ba9993fb68ed9
DIFF: https://github.com/llvm/llvm-project/commit/642117105d4f7944b7944f9b2a6ba9993fb68ed9.diff
LOG: [Clang] Implement P2809: Trivial infinite loops are not Undefined Behavior (#90066)
https://wg21.link/P2809R3
This is applied as a DR to C++11 (C++98 did not guarantee forward
progress and is left untouched)
As an extension (and to preserve existing behavior in C), we consider
all controlling expression that can be constant folded
in the front end, not just standard constant expressions.
Added:
Modified:
clang/docs/ReleaseNotes.rst
clang/include/clang/Driver/Options.td
clang/lib/CodeGen/CGStmt.cpp
clang/lib/CodeGen/CodeGenFunction.cpp
clang/lib/CodeGen/CodeGenFunction.h
clang/test/CodeGen/attr-mustprogress.c
clang/test/CodeGenCXX/attr-mustprogress.cpp
clang/www/cxx_status.html
Removed:
################################################################################
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 280d272f2c1b22..54b58b1ae99fbd 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -190,6 +190,9 @@ C++2c Feature Support
- Implemented `P2748R5 Disallow Binding a Returned Glvalue to a Temporary <https://wg21.link/P2748R5>`_.
+- Implemented `P2809R3: Trivial infinite loops are not Undefined Behavior <https://wg21.link/P2809R3>`_.
+
+
Resolutions to C++ Defect Reports
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- Substitute template parameter pack, when it is not explicitly specified
@@ -334,6 +337,10 @@ Modified Compiler Flags
- Carved out ``-Wformat`` warning about scoped enums into a subwarning and
make it controlled by ``-Wformat-pedantic``. Fixes #GH88595.
+- Trivial infinite loops (i.e loops with a constant controlling expresion
+ evaluating to ``true`` and an empty body such as ``while(1);``)
+ are considered infinite, even when the ``-ffinite-loop`` flag is set.
+
Removed Compiler Flags
-------------------------
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
index 2801560ddaf648..938d5358eeda6b 100644
--- a/clang/include/clang/Driver/Options.td
+++ b/clang/include/clang/Driver/Options.td
@@ -3971,7 +3971,7 @@ def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>,
def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>,
HelpText<"Turn off loop unroller">, Visibility<[ClangOption, CC1Option]>;
def ffinite_loops: Flag<["-"], "ffinite-loops">, Group<f_Group>,
- HelpText<"Assume all loops are finite.">, Visibility<[ClangOption, CC1Option]>;
+ HelpText<"Assume all non-trivial loops are finite.">, Visibility<[ClangOption, CC1Option]>;
def fno_finite_loops: Flag<["-"], "fno-finite-loops">, Group<f_Group>,
HelpText<"Do not assume that any loop is finite.">,
Visibility<[ClangOption, CC1Option]>;
diff --git a/clang/lib/CodeGen/CGStmt.cpp b/clang/lib/CodeGen/CGStmt.cpp
index 576fe2f7a2d46f..479945e3b4cb56 100644
--- a/clang/lib/CodeGen/CGStmt.cpp
+++ b/clang/lib/CodeGen/CGStmt.cpp
@@ -908,6 +908,69 @@ void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
incrementProfileCounter(&S);
}
+bool CodeGenFunction::checkIfLoopMustProgress(const Expr *ControllingExpression,
+ bool HasEmptyBody) {
+ if (CGM.getCodeGenOpts().getFiniteLoops() ==
+ CodeGenOptions::FiniteLoopsKind::Never)
+ return false;
+
+ // Now apply rules for plain C (see 6.8.5.6 in C11).
+ // Loops with constant conditions do not have to make progress in any C
+ // version.
+ // As an extension, we consisider loops whose constant expression
+ // can be constant-folded.
+ Expr::EvalResult Result;
+ bool CondIsConstInt =
+ !ControllingExpression ||
+ (ControllingExpression->EvaluateAsInt(Result, getContext()) &&
+ Result.Val.isInt());
+
+ bool CondIsTrue = CondIsConstInt && (!ControllingExpression ||
+ Result.Val.getInt().getBoolValue());
+
+ // Loops with non-constant conditions must make progress in C11 and later.
+ if (getLangOpts().C11 && !CondIsConstInt)
+ return true;
+
+ // [C++26][intro.progress] (DR)
+ // The implementation may assume that any thread will eventually do one of the
+ // following:
+ // [...]
+ // - continue execution of a trivial infinite loop ([stmt.iter.general]).
+ if (CGM.getCodeGenOpts().getFiniteLoops() ==
+ CodeGenOptions::FiniteLoopsKind::Always ||
+ getLangOpts().CPlusPlus11) {
+ if (HasEmptyBody && CondIsTrue) {
+ CurFn->removeFnAttr(llvm::Attribute::MustProgress);
+ return false;
+ }
+ return true;
+ }
+ return false;
+}
+
+// [C++26][stmt.iter.general] (DR)
+// A trivially empty iteration statement is an iteration statement matching one
+// of the following forms:
+// - while ( expression ) ;
+// - while ( expression ) { }
+// - do ; while ( expression ) ;
+// - do { } while ( expression ) ;
+// - for ( init-statement expression(opt); ) ;
+// - for ( init-statement expression(opt); ) { }
+template <typename LoopStmt> static bool hasEmptyLoopBody(const LoopStmt &S) {
+ if constexpr (std::is_same_v<LoopStmt, ForStmt>) {
+ if (S.getInc())
+ return false;
+ }
+ const Stmt *Body = S.getBody();
+ if (!Body || isa<NullStmt>(Body))
+ return true;
+ if (const CompoundStmt *Compound = dyn_cast<CompoundStmt>(Body))
+ return Compound->body_empty();
+ return false;
+}
+
void CodeGenFunction::EmitWhileStmt(const WhileStmt &S,
ArrayRef<const Attr *> WhileAttrs) {
// Emit the header for the loop, which will also become
@@ -942,13 +1005,12 @@ void CodeGenFunction::EmitWhileStmt(const WhileStmt &S,
// while(1) is common, avoid extra exit blocks. Be sure
// to correctly handle break/continue though.
llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal);
- bool CondIsConstInt = C != nullptr;
- bool EmitBoolCondBranch = !CondIsConstInt || !C->isOne();
+ bool EmitBoolCondBranch = !C || !C->isOne();
const SourceRange &R = S.getSourceRange();
LoopStack.push(LoopHeader.getBlock(), CGM.getContext(), CGM.getCodeGenOpts(),
WhileAttrs, SourceLocToDebugLoc(R.getBegin()),
SourceLocToDebugLoc(R.getEnd()),
- checkIfLoopMustProgress(CondIsConstInt));
+ checkIfLoopMustProgress(S.getCond(), hasEmptyLoopBody(S)));
// When single byte coverage mode is enabled, add a counter to loop condition.
if (llvm::EnableSingleByteCoverage)
@@ -1059,14 +1121,13 @@ void CodeGenFunction::EmitDoStmt(const DoStmt &S,
// "do {} while (0)" is common in macros, avoid extra blocks. Be sure
// to correctly handle break/continue though.
llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal);
- bool CondIsConstInt = C;
bool EmitBoolCondBranch = !C || !C->isZero();
const SourceRange &R = S.getSourceRange();
LoopStack.push(LoopBody, CGM.getContext(), CGM.getCodeGenOpts(), DoAttrs,
SourceLocToDebugLoc(R.getBegin()),
SourceLocToDebugLoc(R.getEnd()),
- checkIfLoopMustProgress(CondIsConstInt));
+ checkIfLoopMustProgress(S.getCond(), hasEmptyLoopBody(S)));
// As long as the condition is true, iterate the loop.
if (EmitBoolCondBranch) {
@@ -1109,15 +1170,11 @@ void CodeGenFunction::EmitForStmt(const ForStmt &S,
llvm::BasicBlock *CondBlock = CondDest.getBlock();
EmitBlock(CondBlock);
- Expr::EvalResult Result;
- bool CondIsConstInt =
- !S.getCond() || S.getCond()->EvaluateAsInt(Result, getContext());
-
const SourceRange &R = S.getSourceRange();
LoopStack.push(CondBlock, CGM.getContext(), CGM.getCodeGenOpts(), ForAttrs,
SourceLocToDebugLoc(R.getBegin()),
SourceLocToDebugLoc(R.getEnd()),
- checkIfLoopMustProgress(CondIsConstInt));
+ checkIfLoopMustProgress(S.getCond(), hasEmptyLoopBody(S)));
// Create a cleanup scope for the condition variable cleanups.
LexicalScope ConditionScope(*this, S.getSourceRange());
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index 87766a758311d5..546beae4af59e5 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -1471,6 +1471,8 @@ void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
// Ensure that the function adheres to the forward progress guarantee, which
// is required by certain optimizations.
+ // In C++11 and up, the attribute will be removed if the body contains a
+ // trivial empty loop.
if (checkIfFunctionMustProgress())
CurFn->addFnAttr(llvm::Attribute::MustProgress);
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index ba24831b158662..e1e687af6a781b 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -636,28 +636,7 @@ class CodeGenFunction : public CodeGenTypeCache {
/// Returns true if a loop must make progress, which means the mustprogress
/// attribute can be added. \p HasConstantCond indicates whether the branch
/// condition is a known constant.
- bool checkIfLoopMustProgress(bool HasConstantCond) {
- if (CGM.getCodeGenOpts().getFiniteLoops() ==
- CodeGenOptions::FiniteLoopsKind::Always)
- return true;
- if (CGM.getCodeGenOpts().getFiniteLoops() ==
- CodeGenOptions::FiniteLoopsKind::Never)
- return false;
-
- // If the containing function must make progress, loops also must make
- // progress (as in C++11 and later).
- if (checkIfFunctionMustProgress())
- return true;
-
- // Now apply rules for plain C (see 6.8.5.6 in C11).
- // Loops with constant conditions do not have to make progress in any C
- // version.
- if (HasConstantCond)
- return false;
-
- // Loops with non-constant conditions must make progress in C11 and later.
- return getLangOpts().C11;
- }
+ bool checkIfLoopMustProgress(const Expr *, bool HasEmptyBody);
const CodeGen::CGBlockInfo *BlockInfo = nullptr;
llvm::Value *BlockPointer = nullptr;
diff --git a/clang/test/CodeGen/attr-mustprogress.c b/clang/test/CodeGen/attr-mustprogress.c
index b4f8710a9d6922..a5e8dc5cd5d5ee 100644
--- a/clang/test/CodeGen/attr-mustprogress.c
+++ b/clang/test/CodeGen/attr-mustprogress.c
@@ -30,7 +30,7 @@ int b = 0;
// CHECK: for.cond:
// C99-NOT: br {{.*}}!llvm.loop
// C11-NOT: br {{.*}}!llvm.loop
-// FINITE-NEXT: br {{.*}}!llvm.loop
+// FINITE-NOR: br {{.*}}!llvm.loop
//
void f0(void) {
for (; ;) ;
@@ -45,7 +45,7 @@ void f0(void) {
// CHECK: for.body:
// C99-NOT: br {{.*}}, !llvm.loop
// C11-NOT: br {{.*}}, !llvm.loop
-// FINITE-NEXT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
// CHECK: for.end:
// CHECK-NEXT: ret void
//
@@ -84,7 +84,7 @@ void f2(void) {
// CHECK: for.body:
// C99-NOT: br {{.*}}, !llvm.loop
// C11-NOT: br {{.*}}, !llvm.loop
-// FINITE-NEXT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
// CHECK: for.end:
// CHECK-NEXT: br label %for.cond1
// CHECK: for.cond1:
@@ -113,7 +113,7 @@ void F(void) {
// CHECK: while.body:
// C99-NOT: br {{.*}}, !llvm.loop
// C11-NOT: br {{.*}}, !llvm.loop
-// FINITE-NEXT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
//
void w1(void) {
while (1) {
@@ -159,7 +159,7 @@ void w2(void) {
// CHECK: while.body2:
// C99-NOT: br {{.*}} !llvm.loop
// C11-NOT: br {{.*}} !llvm.loop
-// FINITE-NEXT: br {{.*}} !llvm.loop
+// FINITE-NOT: br {{.*}} !llvm.loop
//
void W(void) {
while (a == b) {
@@ -177,7 +177,7 @@ void W(void) {
// CHECK: do.cond:
// C99-NOT: br {{.*}}, !llvm.loop
// C11-NOT: br {{.*}}, !llvm.loop
-// FINITE-NEXT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
// CHECK: do.end:
// CHECK-NEXT: ret void
//
diff --git a/clang/test/CodeGenCXX/attr-mustprogress.cpp b/clang/test/CodeGenCXX/attr-mustprogress.cpp
index 843f5460426ccf..0cb18df25223e8 100644
--- a/clang/test/CodeGenCXX/attr-mustprogress.cpp
+++ b/clang/test/CodeGenCXX/attr-mustprogress.cpp
@@ -24,21 +24,21 @@ int b = 0;
// CHECK: datalayout
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z2f0v(
// CHECK-NEXT: entry:
// CHECK-NEXT: br label %for.cond
// CHECK: for.cond:
// CXX98-NOT: br {{.*}} llvm.loop
-// CXX11-NEXT: br label %for.cond, !llvm.loop [[LOOP1:!.*]]
-// FINITE-NEXT: br label %for.cond, !llvm.loop [[LOOP1:!.*]]
+// CXX11-NOT: br {{.*}} llvm.loop
+// FINITE-NOT: br {{.*}} llvm.loop
void f0() {
for (; ;) ;
}
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z2f1v(
// CHECK-NEXT: entry:
@@ -46,9 +46,9 @@ void f0() {
// CHECK: for.cond:
// CHECK-NEXT: br i1 true, label %for.body, label %for.end
// CHECK: for.body:
-// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br label %for.cond, !llvm.loop [[LOOP2:!.*]]
-// FINITE-NEXT: br label %for.cond, !llvm.loop [[LOOP2:!.*]]
+// CXX98-NOT: br {{.*}}, !llvm.loop
+// CXX11-NOT: br {{.*}} llvm.loop
+// FINITE-NOT: br {{.*}} llvm.loop
// CHECK: for.end:
// CHECK-NEXT: ret void
//
@@ -81,7 +81,7 @@ void f2() {
}
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z1Fv(
// CHECK-NEXT: entry:
@@ -90,8 +90,8 @@ void f2() {
// CHECK-NEXT: br i1 true, label %for.body, label %for.end
// CHECK: for.body:
// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br label %for.cond, !llvm.loop [[LOOP4:!.*]]
-// FINITE-NEXT: br label %for.cond, !llvm.loop [[LOOP4:!.*]]
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
// CHECK: for.end:
// CHECK-NEXT: br label %for.cond1
// CHECK: for.cond1:
@@ -114,7 +114,7 @@ void F() {
}
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z2F2v(
// CHECK-NEXT: entry:
@@ -134,8 +134,8 @@ void F() {
// CHECK-NEXT: br i1 true, label %for.body2, label %for.end3
// CHECK: for.body2:
// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br label %for.cond1, !llvm.loop [[LOOP7:!.*]]
-// FINITE-NEXT: br label %for.cond1, !llvm.loop [[LOOP7:!.*]]
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
// CHECK: for.end3:
// CHECK-NEXT: ret void
//
@@ -147,15 +147,15 @@ void F2() {
}
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z2w1v(
// CHECK-NEXT: entry:
// CHECK-NEXT: br label %while.body
// CHECK: while.body:
// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br label %while.body, !llvm.loop [[LOOP8:!.*]]
-// FINITE-NEXT: br label %while.body, !llvm.loop [[LOOP8:!.*]]
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
//
void w1() {
while (1)
@@ -186,7 +186,7 @@ void w2() {
}
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z1Wv(
// CHECK-NEXT: entry:
@@ -204,8 +204,8 @@ void w2() {
// CHECK-NEXT: br label %while.body2
// CHECK: while.body2:
// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br label %while.body2, !llvm.loop [[LOOP11:!.*]]
-// FINITE-NEXT: br label %while.body2, !llvm.loop [[LOOP11:!.*]]
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
//
void W() {
while (a == b)
@@ -215,15 +215,15 @@ void W() {
}
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z2W2v(
// CHECK-NEXT: entry:
// CHECK-NEXT: br label %while.body
// CHECK: while.body:
// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br label %while.body, !llvm.loop [[LOOP12:!.*]]
-// FINITE-NEXT: br label %while.body, !llvm.loop [[LOOP12:!.*]]
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
//
void W2() {
while (1)
@@ -233,7 +233,7 @@ void W2() {
}
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z2d1v(
// CHECK-NEXT: entry:
@@ -242,8 +242,8 @@ void W2() {
// CHECK-NEXT: br label %do.cond
// CHECK: do.cond:
// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br i1 true, label %do.body, label %do.end, !llvm.loop [[LOOP13:!.*]]
-// FINITE-NEXT: br i1 true, label %do.body, label %do.end, !llvm.loop [[LOOP13:!.*]]
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
// CHECK: do.end:
// CHECK-NEXT: ret void
//
@@ -278,7 +278,7 @@ void d2() {
}
// CXX98-NOT: mustprogress
-// CXX11: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z1Dv(
// CHECK-NEXT: entry:
@@ -287,8 +287,8 @@ void d2() {
// CHECK-NEXT: br label %do.cond
// CHECK: do.cond:
// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br i1 true, label %do.body, label %do.end, !llvm.loop [[LOOP15:!.*]]
-// FINITE-NEXT: br i1 true, label %do.body, label %do.end, !llvm.loop [[LOOP15:!.*]]
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
// CHECK: do.end:
// CHECK-NEXT: br label %do.body1
// CHECK: do.body1:
@@ -312,8 +312,8 @@ void D() {
while (a == b);
}
-// CXX98-NOT : mustprogress
-// CXX11: mustprogress
+// CXX98-NOT: mustprogress
+// CXX11-NOT: mustprogress
// FINITE-NOT: mustprogress
// CHECK-LABEL: @_Z2D2v(
// CHECK-NEXT: entry:
@@ -333,8 +333,8 @@ void D() {
// CHECK-NEXT: br label %do.cond2
// CHECK: do.cond2:
// CXX98-NOT: br {{.*}}, !llvm.loop
-// CXX11-NEXT: br i1 true, label %do.body1, label %do.end3, !llvm.loop [[LOOP18:!.*]]
-// FINITE-NEXT: br i1 true, label %do.body1, label %do.end3, !llvm.loop [[LOOP18:!.*]]
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
// CHECK: do.end3:
// CHECK-NEXT: ret void
//
@@ -347,22 +347,75 @@ void D2() {
while (1);
}
-// CXX11: [[LOOP1]] = distinct !{[[LOOP1]], [[MP:!.*]]}
+// CXX98-NOT: mustprogress
+// CXX11-NOT: mustprogress
+// FINITE-NOT: mustprogress
+// CHECK-LABEL: @_Z9compound0v(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: br label %for.cond
+// CHECK: for.cond:
+// CXX98-NOT: br {{.*}}, !llvm.loop
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
+void compound0() {
+ for (; ;) {}
+}
+
+// CXX98-NOT: mustprogress
+// CXX11-NOT: mustprogress
+// FINITE-NOT: mustprogress
+// CHECK-LABEL: @_Z9compound1v(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: br label %for.cond
+// CHECK: for.cond:
+// CXX98-NOT: br {{.*}}, llvm.loop
+// CXX11-NOT: br {{.*}}, llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
+void compound1() {
+ for (; ;) {/*! */}
+}
+
+// CXX98-NOT: mustprogress
+// CXX11-NOT: mustprogress
+// FINITE-NOT: mustprogress
+// CHECK-LABEL: @_Z9compound2v(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: br label %do.body
+// CHECK: do.body:
+// CHECK-NEXT: br label %do.cond
+// CHECK: do.cond:
+// CXX98-NOT: br {{.*}}, !llvm.loop
+// CXX11-NOT: br {{.*}}, !llvm.loop
+// FINITE-NOT: br {{.*}}, !llvm.loop
+// CHECK: do.end:
+// CHECK-NEXT: ret void
+//
+void compound2() {
+ do {} while (1+1);
+}
+
+// CXX98-NOT: mustprogress
+// CXX11 : mustprogress
+// FINITE : mustprogress
+// CHECK-LABEL: @_Z5Falsev(
+// CHECK-NEXT: entry:
+// CHECK-NEXT: br label %do.body
+// CHECK: do.body:
+// CHECK-NEXT: br label %do.end
+// CHECK: do.end:
+// CHECK-NEXT: ret void
+//
+void False() {
+ do {} while (1-1);
+}
+
+
+// CXX11: [[LOOP3]] = distinct !{[[LOOP3]], [[MP:.*]]}
// CXX11: [[MP]] = !{!"llvm.loop.mustprogress"}
-// CXX11: [[LOOP2]] = distinct !{[[LOOP2]], [[MP]]}
-// CXX11: [[LOOP3]] = distinct !{[[LOOP3]], [[MP]]}
-// CXX11: [[LOOP4]] = distinct !{[[LOOP4]], [[MP]]}
// CXX11: [[LOOP5]] = distinct !{[[LOOP5]], [[MP]]}
// CXX11: [[LOOP6]] = distinct !{[[LOOP6]], [[MP]]}
-// CXX11: [[LOOP7]] = distinct !{[[LOOP7]], [[MP]]}
-// CXX11: [[LOOP8]] = distinct !{[[LOOP8]], [[MP]]}
// CXX11: [[LOOP9]] = distinct !{[[LOOP9]], [[MP]]}
// CXX11: [[LOOP10]] = distinct !{[[LOOP10]], [[MP]]}
-// CXX11: [[LOOP11]] = distinct !{[[LOOP11]], [[MP]]}
-// CXX11: [[LOOP12]] = distinct !{[[LOOP12]], [[MP]]}
-// CXX11: [[LOOP13]] = distinct !{[[LOOP13]], [[MP]]}
// CXX11: [[LOOP14]] = distinct !{[[LOOP14]], [[MP]]}
-// CXX11: [[LOOP15]] = distinct !{[[LOOP15]], [[MP]]}
// CXX11: [[LOOP16]] = distinct !{[[LOOP16]], [[MP]]}
// CXX11: [[LOOP17]] = distinct !{[[LOOP17]], [[MP]]}
-// CXX11: [[LOOP18]] = distinct !{[[LOOP18]], [[MP]]}
diff --git a/clang/www/cxx_status.html b/clang/www/cxx_status.html
index b39cfbd76df253..6e0599cc9fe0d5 100755
--- a/clang/www/cxx_status.html
+++ b/clang/www/cxx_status.html
@@ -187,7 +187,7 @@ <h2 id="cxx26">C++2c implementation status</h2>
<tr>
<td>Trivial infinite loops are not Undefined Behavior</td>
<td><a href="https://wg21.link/P2809R3">P2809R3</a> (<a href="#dr">DR</a>)</td>
- <td class="none" align="center">No</td>
+ <td class="unreleased" align="center">Clang 19</td>
</tr>
<tr>
<td>Erroneous behaviour for uninitialized reads</td>
More information about the cfe-commits
mailing list