[clang] Add -ffinite-loops & -fno-finite-loops options.

[fhahn]

Summary

This patch adds 2 new options to control when Clang adds mustprogress:

1. -ffinite-loops: assume all loops are finite; mustprogress is added to all loops, regardless of the selected language standard.
2. -fno-finite-loops: assume no loop is finite; mustprogress is not added to any loop or function. We could add mustprogress to functions without loops, but we would have to detect that in Clang, which is probably not worth it.

[fhahn]

Add description for options.

[xbolva00]

clang/lib/Frontend/CompilerInvocation.cpp

1923

Not needed

[fhahn]

Remove accidentally copied code.

clang/lib/Frontend/CompilerInvocation.cpp

1923

Removed, thanks!

[jdoerfert]

clang/include/clang/Basic/CodeGenOptions.h

147

Can we have different names?

FiniteLoopsKind::None sounds more like what `FiniteLoopsKind::No implies.

Maybe:

enum class FiniteLoopAssumptionKind {
LANGUAGE,
ALWAYS
NEVER,
};

[fhahn]

adjust naming of enum members as suggested, thanks! I think it cannot be an enum class unfortunately because the CodeGenOption machinery seems to use regular enums/unsigneds.

[fhahn]

clang/include/clang/Basic/CodeGenOptions.h

147

Updated the names, thanks! They are much better.

[jdoerfert]

LGTM

[xbolva00]

Maybe we want these options in llvm 12 as well?

(+ Release note)

[fhahn]

In D96419#2555513, @xbolva00 wrote:

Maybe we want these options in llvm 12 as well?

(+ Release note)

That's a good idea. The patch currently depends on D96418. Not sure if we should pull that one on the 12.x release branch though

[xbolva00]

In D96419#2556349, @fhahn wrote:

In D96419#2555513, @xbolva00 wrote:

Maybe we want these options in llvm 12 as well?

(+ Release note)

That's a good idea. The patch currently depends on D96418. Not sure if we should pull that one on the 12.x release branch though

I think we should to keep consistency with gcc and llvm 13+.

[fhahn]

Rebased the patch to apply wihtout D96418. Will land soon.

[fhahn]

In D96419#2556411, @xbolva00 wrote:

In D96419#2556349, @fhahn wrote:

In D96419#2555513, @xbolva00 wrote:

Maybe we want these options in llvm 12 as well?

(+ Release note)

That's a good idea. The patch currently depends on D96418. Not sure if we should pull that one on the 12.x release branch though

I think we should to keep consistency with gcc and llvm 13+.

Filed https://bugs.llvm.org/show_bug.cgi?id=49219 to pick this to 12.x

clang/include/clang/Basic/CodeGenOptions.h

public:
   std::string BinutilsVersion;
 
   enum class FramePointerKind {
     None,        // Omit all frame pointers.
     NonLeaf,     // Keep non-leaf frame pointers.
     All,         // Keep all frame pointers.
   };
 
+  enum FiniteLoopsKind {
+    None = 0, // Not specified, use language standard.
+    Yes = 1,  // All loops are assumed to be finite.
+    No = 2,   // No loop is assumed to be finite.
+  };
+
   /// The code model to use (-mcmodel).
   std::string CodeModel;
 
   /// The filename with path we use for coverage data files. The runtime
   /// allows further manipulation with the GCOV_PREFIX and GCOV_PREFIX_STRIP
   /// environment variables.
   std::string CoverageDataFile;
 

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(UnrollLoops       , 1, 0) ///< Control whether loops are unrolled.
 CODEGENOPT(RerollLoops       , 1, 0) ///< Control whether loops are rerolled.
 CODEGENOPT(NoUseJumpTables   , 1, 0) ///< Set when -fno-jump-tables is enabled.
 CODEGENOPT(UnwindTables      , 1, 0) ///< Emit unwind tables.
 CODEGENOPT(VectorizeLoop     , 1, 0) ///< Run loop vectorizer.
 CODEGENOPT(VectorizeSLP      , 1, 0) ///< Run SLP vectorizer.
 CODEGENOPT(ProfileSampleAccurate, 1, 0) ///< Sample profile is accurate.
 
+ENUM_CODEGENOPT(FiniteLoops, FiniteLoopsKind, 2, FiniteLoopsKind::None) /// finite-loops: none, yes, no
+
   /// Attempt to use register sized accesses to bit-fields in structures, when
   /// possible.
 CODEGENOPT(UseRegisterSizedBitfieldAccess , 1, 0)
 
 CODEGENOPT(VerifyModule      , 1, 1) ///< Control whether the module should be run
                                      ///< through the LLVM Verifier.
 
 CODEGENOPT(StackRealignment  , 1, 0) ///< Control whether to force stack

clang/include/clang/Driver/Options.td

 def funit_at_a_time : Flag<["-"], "funit-at-a-time">, Group<f_Group>;
 def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>,
   HelpText<"Turn on loop unroller">, Flags<[CC1Option]>;
 def fno_unroll_loops : Flag<["-"], "fno-unroll-loops">, Group<f_Group>,
   HelpText<"Turn off loop unroller">, Flags<[CC1Option]>;
 defm reroll_loops : BoolFOption<"reroll-loops",
   CodeGenOpts<"RerollLoops">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Turn on loop reroller">, NegFlag<SetFalse>>;
+def ffinite_loops: Flag<["-"],  "ffinite-loops">, Group<f_Group>,
+  HelpText<"Assume all loops are finite.">, Flags<[CC1Option]>;
+def fno_finite_loops: Flag<["-"], "fno-finite-loops">, Group<f_Group>,
+  HelpText<"Do not assume that any loop is finite.">, Flags<[CC1Option]>;
+
 def ftrigraphs : Flag<["-"], "ftrigraphs">, Group<f_Group>,
   HelpText<"Process trigraph sequences">, Flags<[CC1Option]>;
 def fno_trigraphs : Flag<["-"], "fno-trigraphs">, Group<f_Group>,
   HelpText<"Do not process trigraph sequences">, Flags<[CC1Option]>;
 def funsigned_bitfields : Flag<["-"], "funsigned-bitfields">, Group<f_Group>;
 def funsigned_char : Flag<["-"], "funsigned-char">, Group<f_Group>;
 def fno_unsigned_char : Flag<["-"], "fno-unsigned-char">;
 def funwind_tables : Flag<["-"], "funwind-tables">, Group<f_Group>;

clang/lib/CodeGen/CodeGenFunction.h

public:
   /// True if the current statement has nomerge attribute.
   bool InNoMergeAttributedStmt = false;
 
   /// True if the current function should be marked mustprogress.
   bool FnIsMustProgress = false;
 
   /// Returns true if the function must make progress.
   bool functionMustProgress() {
+    if (CGM.getCodeGenOpts().getFiniteLoops() ==
+        CodeGenOptions::FiniteLoopsKind::No)
+      return false;
+
     return getLangOpts().CPlusPlus11 || getLangOpts().CPlusPlus14 ||
            getLangOpts().CPlusPlus17 || getLangOpts().CPlusPlus20;
   }
 
   /// Returns true if either the containing function must make progress.
   /// Otherwise return false if the loop condition is a known constant and true
   /// if the language standard is C11+.
   bool loopMustProgress(bool HasConstantCond) {
+    if (CGM.getCodeGenOpts().getFiniteLoops() ==
+        CodeGenOptions::FiniteLoopsKind::Yes)
+      return true;
+    if (CGM.getCodeGenOpts().getFiniteLoops() ==
+        CodeGenOptions::FiniteLoopsKind::No)
+      return false;
+
     if (functionMustProgress())
       return true;
     if (HasConstantCond)
       return false;
     return getLangOpts().C11 || getLangOpts().C17 || getLangOpts().C2x;
   }
 
   const CodeGen::CGBlockInfo *BlockInfo = nullptr;

clang/lib/Driver/ToolChains/Clang.cpp

if (A->getOption().matches(options::OPT_fno_strict_overflow))
       CmdArgs.push_back("-fwrapv");
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_freroll_loops,
                                options::OPT_fno_reroll_loops))
     if (A->getOption().matches(options::OPT_freroll_loops))
       CmdArgs.push_back("-freroll-loops");
 
+  Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
+                  options::OPT_fno_finite_loops);
+
   Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings);
   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
                   options::OPT_fno_unroll_loops);
 
   Args.AddLastArg(CmdArgs, options::OPT_pthread);
 
   if (Args.hasFlag(options::OPT_mspeculative_load_hardening,
                    options::OPT_mno_speculative_load_hardening, false))

clang/lib/Frontend/CompilerInvocation.cpp

Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
                            Args.hasArg(OPT_new_struct_path_tbaa);
   Opts.OptimizeSize = getOptimizationLevelSize(Args);
   Opts.SimplifyLibCalls = !LangOpts->NoBuiltin;
   if (Opts.SimplifyLibCalls)
     Opts.NoBuiltinFuncs = LangOpts->NoBuiltinFuncs;
   Opts.UnrollLoops =
       Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
                    (Opts.OptimizationLevel > 1));
-
   Opts.BinutilsVersion =
       std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
 
   Opts.DebugNameTable = static_cast<unsigned>(
       Args.hasArg(OPT_ggnu_pubnames)
           ? llvm::DICompileUnit::DebugNameTableKind::GNU
           : Args.hasArg(OPT_gpubnames)
                 ? llvm::DICompileUnit::DebugNameTableKind::Default
parseSanitizerKinds("-fsanitize-recover=",
                       Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
                       Opts.SanitizeRecover);
   parseSanitizerKinds("-fsanitize-trap=",
                       Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
                       Opts.SanitizeTrap);
 
   Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true);
 
+  if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
+    Opts.SaveTempsFilePrefix =
+        llvm::StringSwitch<std::string>(A->getValue())
+            .Case("obj", OutputFile)
+            .Default(llvm::sys::path::filename(OutputFile).str());
+
+  if (Args.hasArg(options::OPT_ffinite_loops))
+    Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::Yes;
+  else if (Args.hasArg(options::OPT_fno_finite_loops))
+    Opts.FiniteLoops = CodeGenOptions::FiniteLoopsKind::No;
+
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
 bool CompilerInvocation::ParseCodeGenArgs(
     CompilerInvocation &Res, CodeGenOptions &Opts, ArgList &Args, InputKind IK,
     DiagnosticsEngine &Diags, const llvm::Triple &T,
     const std::string &OutputFile, const LangOptions &LangOptsRef) {
   CodeGenOptions DummyOpts;

clang/test/CodeGen/attr-mustprogress.c

 // RUN: %clang_cc1 -std=c99 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=C99 %s
 // RUN: %clang_cc1 -std=c11 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=C11 %s
 // RUN: %clang_cc1 -std=c18 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=C11 %s
 // RUN: %clang_cc1 -std=c2x -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=C11 %s
+//
+// RUN: %clang_cc1 -std=c11 -ffinite-loops -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=FINITE %s
+// RUN: %clang_cc1 -std=c11 -fno-finite-loops -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=C99 %s
 
 int a = 0;
 int b = 0;
 
 // CHECK: datalayout
 //
 // CHECK-NOT: mustprogress
 // CHECK-LABEL: @f0(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %for.cond
 // CHECK:       for.cond:
-// CHECK-NOT:    br {{.*}}!llvm.loop
+// C99-NOT:    br {{.*}}!llvm.loop
+// C11-NOT:    br {{.*}}!llvm.loop
+// FINITE:     br label %for.cond, !llvm.loop
 //
 void f0() {
   for (; ;) ;
 }
 
 // CHECK-NOT: mustprogress
 // CHECK-LABEL: @f1(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %for.cond
 // CHECK:       for.cond:
 // CHECK-NEXT:    br i1 true, label %for.body, label %for.end
 // CHECK:       for.body:
-// CHECK-NOT:     br {{.*}}, !llvm.loop
+// C99-NOT:     br {{.*}}, !llvm.loop
+// C11-NOT:     br {{.*}}, !llvm.loop
+// FINITE:      br label %for.cond, !llvm.loop
 // CHECK:       for.end:
 // CHECK-NEXT:    ret void
 //
 void f1() {
   for (; 1;) {
   }
 }
 
 // CHECK-NOT: mustprogress
 // CHECK-LABEL: @f2(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %for.cond
 // CHECK:       for.cond:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br i1 [[CMP]], label %for.body, label %for.end
 // CHECK:       for.body:
-// C99-NOT:      br {{.*}} !llvm.loop
-// C11:          br label %for.cond, !llvm.loop [[LOOP1:!.*]]
+// C99-NOT:       br {{.*}} !llvm.loop
+// C11:           br label %for.cond, !llvm.loop [[LOOP1:!.*]]
+// FINITE:        br label %for.cond, !llvm.loop [[LOOP1:!.*]]
 // CHECK:       for.end:
 // CHECK-NEXT:    ret void
 //
 void f2() {
   for (; a == b;) {
   }
 }
 
 // CHECK-NOT: mustprogress
 // CHECK-LABEL: @F(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %for.cond
 // CHECK:       for.cond:
 // CHECK-NEXT:    br i1 true, label %for.body, label %for.end
 // CHECK:       for.body:
-// CHECK-NOT:     br {{.*}}, !llvm.loop
+// C99-NOT:       br {{.*}}, !llvm.loop
+// C11-NOT:       br {{.*}}, !llvm.loop
+// FINITE:        br label %for.cond, !llvm.loop
 // CHECK:       for.end:
 // CHECK-NEXT:    br label %for.cond1
 // CHECK:       for.cond1:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br i1 [[CMP]], label %for.body2, label %for.end3
 // CHECK:       for.body2:
void F() {
   }
 }
 
 // CHECK-NOT: mustprogress
 // CHECK-LABEL: @w1(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %while.body
 // CHECK:       while.body:
-// CHECK-NOT:    br {{.*}}, !llvm.loop
+// C99-NOT:    br {{.*}}, !llvm.loop
+// C11-NOT:    br {{.*}}, !llvm.loop
+// FINITE:     br {{.*}}, !llvm.loop
 void w1() {
   while (1) {
   }
 }
 
 // CHECK-NOT: mustprogress
 // CHECK-LABEL: @w2(
 // CHECK-NEXT:  entry:

 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br i1 [[CMP]], label %while.body, label %while.end
 // CHECK:       while.body:
 // C99-NOT:       br {{.*}} !llvm.loop
 // C11-NEXT:      br label %while.cond, !llvm.loop [[LOOP4:!.*]]
 // CHECK:       while.body2:
-// CHECK-NOT:     br {{.*}} !llvm.loop
+// C99-NOT:       br {{.*}} !llvm.loop
+// C11-NOT:       br {{.*}} !llvm.loop
+// FINITE:        br label %while.body2, !llvm.loop
 //
 void W() {
   while (a == b) {
   }
   while (1) {
   }
 }
 
 // CHECK-NOT: mustprogress
 // CHECK-LABEL: @d1(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %do.body
 // CHECK:       do.body:
 // CHECK-NEXT:    br label %do.cond
 // CHECK:       do.cond:
-// CHECK-NOT:     br {{.*}}, !llvm.loop
+// C99-NOT:       br {{.*}}, !llvm.loop
+// C11-NOT:       br {{.*}}, !llvm.loop
+// FINITE:        br i1 true, label %do.body, label %do.end, !llvm.loop
 // CHECK:       do.end:
 // CHECK-NEXT:    ret void
 //
 void d1() {
   do {
   } while (1);
 }
 

clang/test/CodeGenCXX/attr-mustprogress.cpp

 // RUN: %clang_cc1 -std=c++98 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=CXX98 %s
 // RUN: %clang_cc1 -std=c++11 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=CXX11 %s
 // RUN: %clang_cc1 -std=c++14 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=CXX11 %s
 // RUN: %clang_cc1 -std=c++17 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=CXX11 %s
 // RUN: %clang_cc1 -std=c++20 -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=CXX11 %s
 
+// Make sure -ffinite-loops overrides -std=c++98 for loops.
+// RUN: %clang_cc1 -std=c++98 -ffinite-loops -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=FINITE %s
+
+// Make sure -fno_finite-loops overrides -std=c++11
+// RUN: %clang_cc1 -std=c++11 -fno-finite-loops -triple=x86_64-unknown-linux-gnu -S -emit-llvm %s -o - | FileCheck --check-prefix=CHECK --check-prefix=CXX98 %s
+
 int a = 0;
 int b = 0;
 
 // CHECK: datalayout
 
 // CXX98-NOT: mustprogress
 // CXX11:     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:!.*]]
 void f0() {
   for (; ;) ;
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT: mustprogress
 // CHECK-LABEL: @_Z2f1v(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %for.cond
 // 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:!.*]]
 // CHECK:       for.end:
 // CHECK-NEXT:    ret void
 //
 void f1() {
   for (; 1;)
     ;
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT: mustprogress
 // CHECK-LABEL: @_Z2f2v(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %for.cond
 // CHECK:       for.cond:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br i1 [[CMP]], label %for.body, label %for.end
 // CHECK:       for.body:
 // CXX98-NOT:     br {{.*}}, !llvm.loop
 // CXX11-NEXT:    br label %for.cond, !llvm.loop [[LOOP3:!.*]]
+// FINITE-NEXT:   br label %for.cond, !llvm.loop [[LOOP3:!.*]]
 // CHECK:       for.end:
 // CHECK-NEXT:    ret void
 //
 void f2() {
   for (; a == b;)
     ;
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT: mustprogress
 // CHECK-LABEL: @_Z1Fv(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %for.cond
 // 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 [[LOOP4:!.*]]
+// FINITE-NEXT:    br label %for.cond, !llvm.loop [[LOOP4:!.*]]
 // CHECK:       for.end:
 // CHECK-NEXT:    br label %for.cond1
 // CHECK:       for.cond1:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br i1 [[CMP]], label %for.body2, label %for.end3
 // CHECK:       for.body2:
 // CXX98-NOT:     br {{.*}}, !llvm.loop
 // CXX11-NEXT:    br label %for.cond1, !llvm.loop [[LOOP5:!.*]]
+// FINITE-NEXT:    br label %for.cond1, !llvm.loop [[LOOP5:!.*]]
 // CHECK:       for.end3:
 // CHECK-NEXT:    ret void
 //
 void F() {
   for (; 1;)
     ;
   for (; a == b;)
     ;
 }
 
 // CXX98-NOT: mustprogress
-// CXX11_NOT: mustprogress
+// CXX11:     mustprogress
+// FINITE-NOT: mustprogress
 // CHECK-LABEL: @_Z2F2v(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %for.cond
 // CHECK:       for.cond:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br i1 [[CMP]], label %for.body, label %for.end
 // CHECK:       for.body:
 // CXX98_NOT:     br {{.*}} !llvm.loop
 // CXX11-NEXT:    br label %for.cond, !llvm.loop [[LOOP6:!.*]]
+// FINITE-NEXT:    br label %for.cond, !llvm.loop [[LOOP6:!.*]]
 // CHECK:       for.end:
 // CHECK-NEXT:    br label %for.cond1
 // CHECK:       for.cond1:
 // 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:!.*]]
 // CHECK:       for.end3:
 // CHECK-NEXT:    ret void
 //
 void F2() {
   for (; a == b;)
     ;
   for (; 1;)
     ;
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     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:!.*]]
 //
 void w1() {
   while (1)
     ;
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT: mustprogress
 // CHECK-LABEL: @_Z2w2v(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %while.cond
 // CHECK:       while.cond:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br i1 [[CMP]], label %while.body, label %while.end
 // CHECK:       while.body:
 // CXX98-NOT:     br {{.*}}, !llvm.loop
 // CXX11-NEXT:    br label %while.cond, !llvm.loop [[LOOP9:!.*]]
+// FINITE-NEXT:    br label %while.cond, !llvm.loop [[LOOP9:!.*]]
 // CHECK:       while.end:
 // CHECK-NEXT:    ret void
 //
 void w2() {
   while (a == b)
     ;
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT: mustprogress
 // CHECK-LABEL: @_Z1Wv(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %while.cond
 // CHECK:       while.cond:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CHECK-NEXT:    br i1 [[CMP]], label %while.body, label %while.end
 // CHECK:       while.body:
 // CXX98-NOT:     br {{.*}}, !llvm.loop
 // CXX11-NEXT:    br label %while.cond, !llvm.loop [[LOOP10:!.*]]
+// FINITE-NEXT:    br label %while.cond, !llvm.loop [[LOOP10:!.*]]
 // CHECK:       while.end:
 // 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:!.*]]
 //
 void W() {
   while (a == b)
     ;
   while (1)
     ;
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     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:!.*]]
 //
 void W2() {
   while (1)
     ;
   while (a == b)
     ;
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT: mustprogress
 // CHECK-LABEL: @_Z2d1v(
 // 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-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:!.*]]
 // CHECK:       do.end:
 // CHECK-NEXT:    ret void
 //
 void d1() {
   do
     ;
   while (1);
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT:  mustprogress
 // CHECK-LABEL: @_Z2d2v(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %do.body
 // CHECK:       do.body:
 // CHECK-NEXT:    br label %do.cond
 // CHECK:       do.cond:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CXX98-NOT:     br {{.*}}, !llvm.loop
 // CXX11-NEXT:    br i1 [[CMP]], label %do.body, label %do.end, !llvm.loop [[LOOP14:!.*]]
+// FINITE-NEXT:   br i1 [[CMP]], label %do.body, label %do.end, !llvm.loop [[LOOP14:!.*]]
 // CHECK:       do.end:
 // CHECK-NEXT:    ret void
 //
 void d2() {
   do
     ;
   while (a == b);
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT:     mustprogress
 // CHECK-LABEL: @_Z1Dv(
 // 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-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:!.*]]
 // CHECK:       do.end:
 // CHECK-NEXT:    br label %do.body1
 // CHECK:       do.body1:
 // CHECK-NEXT:    br label %do.cond2
 // CHECK:       do.cond2:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CXX98-NOT:     br {{.*}}, !llvm.loop
 // CXX11-NEXT:    br i1 [[CMP]], label %do.body1, label %do.end3, !llvm.loop [[LOOP16:!.*]]
+// FINITE-NEXT:   br i1 [[CMP]], label %do.body1, label %do.end3, !llvm.loop [[LOOP16:!.*]]
 // CHECK:       do.end3:
 // CHECK-NEXT:    ret void
 //
 void D() {
   do
     ;
   while (1);
   do
     ;
   while (a == b);
 }
 
 // CXX98-NOT: mustprogress
 // CXX11:     mustprogress
+// FINITE-NOT:     mustprogress
 // CHECK-LABEL: @_Z2D2v(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    br label %do.body
 // CHECK:       do.body:
 // CHECK-NEXT:    br label %do.cond
 // CHECK:       do.cond:
 // CHECK-NEXT:    [[TMP0:%.*]] = load i32, i32* @a, align 4
 // CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @b, align 4
 // CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[TMP0]], [[TMP1]]
 // CXX98-NOT:     br {{.*}}, !llvm.loop
 // CXX11-NEXT:    br i1 [[CMP]], label %do.body, label %do.end, !llvm.loop [[LOOP17:!.*]]
+// FINITE-NEXT:   br i1 [[CMP]], label %do.body, label %do.end, !llvm.loop [[LOOP17:!.*]]
 // CHECK:       do.end:
 // CHECK-NEXT:    br label %do.body1
 // CHECK:       do.body1:
 // 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:!.*]]
 // CHECK:       do.end3:
 // CHECK-NEXT:    ret void
 //
 void D2() {
   do
     ;
   while (a == b);
   do