[Clang][Driver] Add -ffinite-loops flags

[atmnpatel]

Summary

Following D94366, clang will strictly adheres to the language standard
when deciding whether or not to emit mustprogress attributes for
loops. This patch adds two flags: -ffinite-loops and
-fno-finite-loops that override the language standard into either
never emitting mustprogress attributes or emitting mustprogress
attributes for all loops/functions.

[atmnpatel]

Update CommandLineReference.rst to also include -fno-finite-loops

[fhahn]

Thanks for putting up the patch!

I think the code here and D94366 could be simplified if we would introduce 2 codegen options to distinguish the differences between C and C++:

• functions-must-progress=true/false: C++ behavior >= c++11; all threads must make forward progress, we should be able to mark all functions as mustprogress and there should be no need to mark the individual loops as mustprogress.
• loops-must-progress=all/none/c11: all -> all loops are marked mustprogress, none -> no loops are marked, c11 -> all loops that do not match the C11 escape hatch are marked mustprogress.

Now

• c++11 and above, functions-must-progress=true, loops-must-progress=none,
• c11 and above functions-must-progress=false, loops-must-progress=c11,
• -ffinite-loops -> loops-must-progress=all,
• -fnofinite-loops -> , functions-must-progress=false, loops-must-progress=false

In CodeGen, we always add mustprogress to functions exactly if functions-must-progress=true. For loops, we could have a helper shouldMarkLoopAsMustProgress(bool C11Exception), which returns true depending on loops-must-progress and C11Exceptions, which the caller sets to true if the loop condition is one that is allowed for infinite loops in C11.

This should allow us to remove CGF::FnIsMustProgress and the code to update it; now either all functions have mustprogress or none have, depending on functions-must-progress. We still need CGLoopInfo::MustProgress, but we only need to update it depending on loops-must-progress,

I think this would overall simplify the handling in Codegen, but it's very possible that I am missing something from earlier discussions. I am also adding a few additional people who may have additional thought.

One things that's slightly odd with the proposal is that for C++, loops-must-progress would be none, which has the potential to be a bit confusing. We could make this clear in the documentation or just set it to all, although as I mentioned in the beginning, that should not really be necessary. It might be helpful/necessary if loops inlined from C++ function inside C functions should keep their mustprogress property.

clang/docs/ClangCommandLineReference.rst

2290

It looks like the options are mostly ordered. Could you move it to the right place?

[xbolva00]

Just note: gcc enables -ffinite-loops with opt level -O2 and higher.

Maybe we should have -ffinite-functions as well?

It is kinda strange to mix loops with functions. (-fnofiniteloops changes the progress behaviour of functions....)

[lebedev.ri]

In D94367#2489090, @fhahn wrote:

Thanks for putting up the patch!

I think the code here and D94366 could be simplified if we would introduce 2 codegen options to distinguish the differences between C and C++:

• functions-must-progress=true/false: C++ behavior >= c++11; all threads must make forward progress, we should be able to mark all functions as mustprogress and there should be no need to mark the individual loops as mustprogress.
• loops-must-progress=all/none/c11: all -> all loops are marked mustprogress, none -> no loops are marked, c11 -> all loops that do not match the C11 escape hatch are marked mustprogress.

Now

• c++11 and above, functions-must-progress=true, loops-must-progress=none,
• c11 and above functions-must-progress=false, loops-must-progress=c11,
• -ffinite-loops -> loops-must-progress=all,
• -fnofinite-loops -> , functions-must-progress=false, loops-must-progress=false

In CodeGen, we always add mustprogress to functions exactly if functions-must-progress=true. For loops, we could have a helper shouldMarkLoopAsMustProgress(bool C11Exception), which returns true depending on loops-must-progress and C11Exceptions, which the caller sets to true if the loop condition is one that is allowed for infinite loops in C11.

This should allow us to remove CGF::FnIsMustProgress and the code to update it; now either all functions have mustprogress or none have, depending on functions-must-progress. We still need CGLoopInfo::MustProgress, but we only need to update it depending on loops-must-progress,

I think this would overall simplify the handling in Codegen, but it's very possible that I am missing something from earlier discussions. I am also adding a few additional people who may have additional thought.

One things that's slightly odd with the proposal is that for C++, loops-must-progress would be none, which has the potential to be a bit confusing. We could make this clear in the documentation or just set it to all, although as I mentioned in the beginning, that should not really be necessary. It might be helpful/necessary if loops inlined from C++ function inside C functions should keep their mustprogress property.

What happens when inlining mustprogress function into non-mustprogress function (or more generally, cross-language LTO)?
We'd need to ensure that in such cases the loops get annotated as mustprogress,
so they don't loose that status, which is why i think it may be better
to always annotate loops, even if their functions already are mustprogress

[fhahn]

@atmnpatel reverse ping. Just curious if you think you'll have time to follow up on this patch soonish?

Otherwise I'm probably going to add at least the -fno-finite-loops option, because we have users which code breaks due to the mustprogress loop deletion changes (because of problems in the source code, but they need a way to disable until they can fix all sources)

[atmnpatel]

@fhahn Sorry for the hold up, I don't think I'll get to this relatively soon, I'll abandon this one and D94366 to sweep the board.

[atmnpatel]

Wait actually, we're gonna need D94366 anyways, I'll get address @xbolva00's comments by eod.

[fhahn]

In D94367#2542809, @atmnpatel wrote:

Wait actually, we're gonna need D94366 anyways, I'll get address @xbolva00's comments by eod.

FWIW I think we should sort this one (D94367) first, because it may simplify D94366

clang/docs/ClangCommandLineReference.rst

 .. option:: -funique-section-names, -fno-unique-section-names
 
 .. option:: -funit-at-a-time, -fno-unit-at-a-time
 
 .. option:: -funroll-loops, -fno-unroll-loops
 
 Turn on loop unroller
 
+.. option:: -ffinite-loops, -fno-finite-loops
+
+Assume that all loops terminate or never assume that they do. This takes precedence over the language standard.
+
 .. option:: -funsafe-math-optimizations, -fno-unsafe-math-optimizations
 
 .. option:: -funsigned-bitfields
 
 .. option:: -funsigned-char, -fno-unsigned-char, --unsigned-char
 
 .. option:: -funwind-tables, -fno-unwind-tables
 

clang/include/clang/Basic/CodeGenOptions.h

public:
   std::string BBSections;
 
   enum class FramePointerKind {
     None,        // Omit all frame pointers.
     NonLeaf,     // Keep non-leaf frame pointers.
     All,         // Keep all frame pointers.
   };
 
+  enum FiniteLoopsKind {
+    Default,      // Follow the language standard
+    Enforce,      // Enforce finite loops
+    NeverEnforce, // Never enforce finite loops
+  };
+
   /// 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(StrictVTablePointers, 1, 0) ///< Optimize based on the strict vtable pointers
 CODEGENOPT(TimePasses        , 1, 0) ///< Set when -ftime-report or -ftime-report= is enabled.
 CODEGENOPT(TimePassesPerRun  , 1, 0) ///< Set when -ftime-report=per-pass-run is enabled.
 CODEGENOPT(TimeTrace         , 1, 0) ///< Set when -ftime-trace is enabled.
 VALUE_CODEGENOPT(TimeTraceGranularity, 32, 500) ///< Minimum time granularity (in microseconds),
                                                ///< traced by time profiler
 CODEGENOPT(UnrollLoops       , 1, 0) ///< Control whether loops are unrolled.
 CODEGENOPT(RerollLoops       , 1, 0) ///< Control whether loops are rerolled.
+CODEGENOPT(FiniteLoops       , 2, 0) ///< Control whether loops are assumed to terminate.
 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.
 
   /// Attempt to use register sized accesses to bit-fields in structures, when
   /// possible.

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", DefaultsToFalse,
   ChangedBy<PosFlag, [], "Turn on loop reroller">, ResetBy<NegFlag>>;
+def ffinite_loops : Flag<["-"], "ffinite-loops">, Group<f_Group>, HelpText<"Assume that loops terminate">, Flags<[CC1Option]>;
+def fno_finite_loops : Flag<["-"], "fno-finite-loops">, Group<f_Group>, HelpText<"Don't assume that loops terminate">, 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/CGStmt.cpp

if (C->isOne()) {
       if (CWithProgress())
         FnIsMustProgress = false;
       else if (CPlusPlusWithProgress())
         LoopMustProgress = true;
     }
   } else if (LanguageRequiresProgress())
     LoopMustProgress = true;
 
+  if (CGM.getCodeGenOpts().FiniteLoops ==
+      CodeGenOptions::FiniteLoopsKind::Enforce) {
+    FnIsMustProgress = true;
+    LoopMustProgress = true;
+  } else if (CGM.getCodeGenOpts().FiniteLoops ==
+             CodeGenOptions::FiniteLoopsKind::NeverEnforce) {
+    FnIsMustProgress = false;
+    LoopMustProgress = false;
+  }
+
   const SourceRange &R = S.getSourceRange();
   LoopStack.push(LoopHeader.getBlock(), CGM.getContext(), CGM.getCodeGenOpts(),
                  WhileAttrs, SourceLocToDebugLoc(R.getBegin()),
                  SourceLocToDebugLoc(R.getEnd()), LoopMustProgress);
 
   // As long as the condition is true, go to the loop body.
   llvm::BasicBlock *LoopBody = createBasicBlock("while.body");
   if (EmitBoolCondBranch) {
if (C->isZero())
       EmitBoolCondBranch = false;
     else if (C->isOne() && CWithProgress())
       FnIsMustProgress = false;
     else if (CPlusPlusWithProgress())
       LoopMustProgress = true;
   } else if (LanguageRequiresProgress())
     LoopMustProgress = true;
 
+  if (CGM.getCodeGenOpts().FiniteLoops ==
+      CodeGenOptions::FiniteLoopsKind::Enforce) {
+    FnIsMustProgress = true;
+    LoopMustProgress = true;
+  } else if (CGM.getCodeGenOpts().FiniteLoops ==
+             CodeGenOptions::FiniteLoopsKind::NeverEnforce) {
+    FnIsMustProgress = false;
+    LoopMustProgress = false;
+  }
+
   const SourceRange &R = S.getSourceRange();
   LoopStack.push(LoopBody, CGM.getContext(), CGM.getCodeGenOpts(), DoAttrs,
                  SourceLocToDebugLoc(R.getBegin()),
                  SourceLocToDebugLoc(R.getEnd()), LoopMustProgress);
 
   // As long as the condition is true, iterate the loop.
   if (EmitBoolCondBranch) {
     uint64_t BackedgeCount = getProfileCount(S.getBody()) - ParentCount;
void CodeGenFunction::EmitForStmt(const ForStmt &S,
   if (LanguageRequiresProgress()) {
     if (!S.getCond() && CWithProgress())
       FnIsMustProgress = false;
     else if (CPlusPlusWithProgress() ||
              !S.getCond()->EvaluateAsInt(Result, getContext()))
       LoopMustProgress = true;
   }
 
+  if (CGM.getCodeGenOpts().FiniteLoops ==
+      CodeGenOptions::FiniteLoopsKind::Enforce) {
+    LoopMustProgress = true;
+  } else if (CGM.getCodeGenOpts().FiniteLoops ==
+             CodeGenOptions::FiniteLoopsKind::NeverEnforce) {
+    LoopMustProgress = false;
+  }
+
   const SourceRange &R = S.getSourceRange();
   LoopStack.push(CondBlock, CGM.getContext(), CGM.getCodeGenOpts(), ForAttrs,
                  SourceLocToDebugLoc(R.getBegin()),
                  SourceLocToDebugLoc(R.getEnd()), LoopMustProgress);
 
   // If the for loop doesn't have an increment we can just use the
   // condition as the continue block.  Otherwise we'll need to create
   // a block for it (in the current scope, i.e. in the scope of the
if (S.getCond()) {
 
     EmitBlock(ForBody);
   } else {
     // Treat it as a non-zero constant.  Don't even create a new block for the
     // body, just fall into it.
   }
   incrementProfileCounter(&S);
 
+  if (CGM.getCodeGenOpts().FiniteLoops ==
+      CodeGenOptions::FiniteLoopsKind::Enforce) {
+    FnIsMustProgress = true;
+  } else if (CGM.getCodeGenOpts().FiniteLoops ==
+             CodeGenOptions::FiniteLoopsKind::NeverEnforce) {
+    FnIsMustProgress = false;
+  }
+
   {
     // Create a separate cleanup scope for the body, in case it is not
     // a compound statement.
     RunCleanupsScope BodyScope(*this);
     EmitStmt(S.getBody());
   }
 
   // If there is an increment, emit it next.

clang/lib/Driver/ToolChains/Clang.cpp

   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_fwritable_strings);
   Args.AddLastArg(CmdArgs, options::OPT_funroll_loops,
                   options::OPT_fno_unroll_loops);
-
   Args.AddLastArg(CmdArgs, options::OPT_pthread);
+  Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops,
+                  options::OPT_fno_finite_loops);
 
   if (Args.hasFlag(options::OPT_mspeculative_load_hardening,
                    options::OPT_mno_speculative_load_hardening, false))
     CmdArgs.push_back(Args.MakeArgString("-mspeculative-load-hardening"));
 
   RenderSSPOptions(D, TC, Args, CmdArgs, KernelOrKext);
   RenderSCPOptions(TC, Args, CmdArgs);
   RenderTrivialAutoVarInitOptions(D, TC, Args, CmdArgs);

clang/lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.OptimizeSize = getOptimizationLevelSize(Args);
   Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
                             Args.hasArg(OPT_ffreestanding));
   if (Opts.SimplifyLibCalls)
     getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
   Opts.UnrollLoops =
       Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
                    (Opts.OptimizationLevel > 1));
+  Opts.FiniteLoops = Args.hasArg(OPT_ffinite_loops)
+                         ? CodeGenOptions::FiniteLoopsKind::Enforce
+                         : (Args.hasArg(OPT_fno_finite_loops)
+                                ? CodeGenOptions::FiniteLoopsKind::NeverEnforce
+                                : CodeGenOptions::FiniteLoopsKind::Default);
 
   Opts.DebugNameTable = static_cast<unsigned>(
       Args.hasArg(OPT_ggnu_pubnames)
           ? llvm::DICompileUnit::DebugNameTableKind::GNU
           : Args.hasArg(OPT_gpubnames)
                 ? llvm::DICompileUnit::DebugNameTableKind::Default
                 : llvm::DICompileUnit::DebugNameTableKind::None);
 

clang/test/CodeGen/finite-loops.c

+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c99 -o - %s | FileCheck %s -check-prefix=CHECK-C99-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c99 -ffinite-loops -o - %s | FileCheck %s -check-prefix=CHECK-FINITE-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c99 -fno-finite-loops -o - %s | FileCheck %s -check-prefix=CHECK-INFINITE-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c11 -o - %s | FileCheck %s -check-prefix=CHECK-C11-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c11 -ffinite-loops -o - %s | FileCheck %s -check-prefix=CHECK-FINITE-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c11 -fno-finite-loops -o - %s | FileCheck %s -check-prefix=CHECK-INFINITE-LOOPS
+
+// CHECK-C99-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-C99-LOOPS-LABEL: @f(
+// CHECK-C99-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+// CHECK-FINITE-LOOPS: Function Attrs: noinline nounwind optnone mustprogress
+// CHECK-FINITE-LOOPS-LABEL: @f(
+// CHECK-FINITE-LOOPS:    {{.}} !llvm.loop !
+// CHECK-FINITE-LOOPS:    {{.}} !llvm.loop !
+//
+// CHECK-INFINITE-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-INFINITE-LOOPS-LABEL: @f(
+// CHECK-INFINITE-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+// CHECK-C11-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-C11-LOOPS-LABEL: @f(
+// CHECK-C11-LOOPS:        {{.}} !llvm.loop !
+// CHECK-C11-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+int f(int a, int b) {
+  for (; a != b; ) {
+    if (a == b)
+      return 1;
+  }
+
+  for (;;) {
+    if (a != b)
+      return 1;
+  }
+  return 0;
+}
+
+// CHECK-C99-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-C99-LOOPS-LABEL: @dw(
+// CHECK-C99-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+// CHECK-FINITE-LOOPS: Function Attrs: noinline nounwind optnone mustprogress
+// CHECK-FINITE-LOOPS-LABEL: @dw(
+// CHECK-FINITE-LOOPS:    {{.}} !llvm.loop !
+// CHECK-FINITE-LOOPS:    {{.}} !llvm.loop !
+//
+// CHECK-INFINITE-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-INFINITE-LOOPS-LABEL: @dw(
+// CHECK-INFINITE-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+// CHECK-C11-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-C11-LOOPS-LABEL: @dw(
+// CHECK-C11-LOOPS:        {{.}} !llvm.loop !
+// CHECK-C11-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+int dw(int a, int b) {
+  do {
+    if (a == b)
+      return 1;
+  } while (a != b);
+
+  do {
+    if (a != b)
+      return 1;
+  } while (1);
+  return 0;
+}
+
+// CHECK-C99-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-C99-LOOPS-LABEL: @w(
+// CHECK-C99-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+// CHECK-FINITE-LOOPS: Function Attrs: noinline nounwind optnone mustprogress
+// CHECK-FINITE-LOOPS-LABEL: @w(
+// CHECK-FINITE-LOOPS:    {{.}} !llvm.loop !
+// CHECK-FINITE-LOOPS:    {{.}} !llvm.loop !
+//
+// CHECK-INFINITE-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-INFINITE-LOOPS-LABEL: @w(
+// CHECK-INFINITE-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+// CHECK-C11-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-C11-LOOPS-LABEL: @w(
+// CHECK-C11-LOOPS:        {{.}} !llvm.loop !
+// CHECK-C11-LOOPS-NOT:    {{.}} !llvm.loop !
+//
+int w(int a, int b) {
+  while(a != b) {
+    if (a == b) return 2;
+  }
+
+  while(1) {
+    if (a != b)
+      return 1;
+  }
+  return 0;
+}
+

clang/test/CodeGenCXX/finite-loops.cpp

+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c++03 -o - %s | FileCheck %s -check-prefix=CHECK-CPP03-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c++03 -ffinite-loops -o - %s | FileCheck %s -check-prefix=CHECK-FINITE-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c++03 -fno-finite-loops -o - %s | FileCheck %s -check-prefix=CHECK-INFINITE-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c++11 -o - %s | FileCheck %s -check-prefix=CHECK-CPP11-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c++11 -ffinite-loops -o - %s | FileCheck %s -check-prefix=CHECK-FINITE-LOOPS
+// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -std=c++11 -fno-finite-loops -o - %s | FileCheck %s -check-prefix=CHECK-INFINITE-LOOPS
+
+// CHECK-CPP03-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-CPP03-LOOPS-LABEL: @_Z1fii(
+// CHECK-CPP03-LOOPS-NOT:    {{.*}} !llvm.loop !
+//
+// CHECK-FINITE-LOOPS: Function Attrs: noinline nounwind optnone mustprogress
+// CHECK-FINITE-LOOPS-LABEL: @_Z1fii(
+// CHECK-FINITE-LOOPS:    {{.*}} !llvm.loop !
+// CHECK-FINITE-LOOPS:    {{.*}} !llvm.loop !
+//
+// CHECK-INFINITE-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-INFINITE-LOOPS-LABEL: @_Z1fii(
+// CHECK-INFINITE-LOOPS-NOT:    {{.*}} !llvm.loop !
+//
+// CHECK-CPP11-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-CPP11-LOOPS-LABEL: @_Z1fii(
+// CHECK-CPP11-LOOPS:        {{.*}} !llvm.loop !
+// CHECK-CPP11-LOOPS:        {{.*}} !llvm.loop !
+//
+int f(int a, int b) {
+  for (; a != b; ) {
+    if (a == b)
+      return 1;
+  }
+
+  for (;;) {
+    if (a != b)
+      return 1;
+  }
+  return 0;
+}
+
+// CHECK-CPP03-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-CPP03-LOOPS-LABEL: @_Z2dwii(
+// CHECK-CPP03-LOOPS-NOT:    {{.*}} !llvm.loop !
+//
+// CHECK-FINITE-LOOPS: Function Attrs: noinline nounwind optnone mustprogress
+// CHECK-FINITE-LOOPS-LABEL: @_Z2dwii(
+// CHECK-FINITE-LOOPS:    {{.*}} !llvm.loop !
+// CHECK-FINITE-LOOPS:    {{.*}} !llvm.loop !
+//
+// CHECK-INFINITE-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-INFINITE-LOOPS-LABEL: @_Z2dwii(
+// CHECK-INFINITE-LOOPS-NOT:    {{.*}} !llvm.loop !
+//
+// CHECK-CPP11-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-CPP11-LOOPS-LABEL: @_Z2dwii(
+// CHECK-CPP11-LOOPS:        {{.*}} !llvm.loop !
+// CHECK-CPP11-LOOPS:        {{.*}} !llvm.loop !
+//
+int dw(int a, int b) {
+  do {
+    if (a == b)
+      return 1;
+  } while (a != b);
+
+  do {
+    if (a != b)
+      return 1;
+  } while (1);
+  return 0;
+}
+
+// CHECK-CPP03-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-CPP03-LOOPS-LABEL: @_Z1wii(
+// CHECK-CPP03-LOOPS-NOT:    {{.*}} !llvm.loop !
+//
+// CHECK-FINITE-LOOPS: Function Attrs: noinline nounwind optnone mustprogress
+// CHECK-FINITE-LOOPS-LABEL: @_Z1wii(
+// CHECK-FINITE-LOOPS:    {{.*}} !llvm.loop !
+// CHECK-FINITE-LOOPS:    {{.*}} !llvm.loop !
+//
+// CHECK-INFINITE-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-INFINITE-LOOPS-LABEL: @_Z1wii(
+// CHECK-INFINITE-LOOPS-NOT:    {{.*}} !llvm.loop !
+//
+// CHECK-CPP11-LOOPS: Function Attrs: noinline nounwind optnone
+// CHECK-CPP11-LOOPS-LABEL: @_Z1wii(
+// CHECK-CPP11-LOOPS:        {{.*}} !llvm.loop !
+// CHECK-CPP11-LOOPS:        {{.*}} !llvm.loop !
+//
+int w(int a, int b) {
+  while(a != b) {
+    if (a == b) return 2;
+  }
+
+  while(1) {
+    if (a != b)
+      return 1;
+  }
+  return 0;
+}
+

clang/test/Driver/clang_f_opts.c

 
 // RUN: %clang -### -S -freroll-loops %s 2>&1 | FileCheck -check-prefix=CHECK-REROLL-LOOPS %s
 // RUN: %clang -### -S -fno-reroll-loops %s 2>&1 | FileCheck -check-prefix=CHECK-NO-REROLL-LOOPS %s
 // RUN: %clang -### -S -fno-reroll-loops -freroll-loops %s 2>&1 | FileCheck -check-prefix=CHECK-REROLL-LOOPS %s
 // RUN: %clang -### -S -freroll-loops -fno-reroll-loops %s 2>&1 | FileCheck -check-prefix=CHECK-NO-REROLL-LOOPS %s
 // CHECK-REROLL-LOOPS: "-freroll-loops"
 // CHECK-NO-REROLL-LOOPS-NOT: "-freroll-loops"
 
+// RUN: %clang -### -S -ffinite-loops %s 2>&1 | FileCheck -check-prefix=CHECK-FINITE-LOOPS %s
+// RUN: %clang -### -S -fno-finite-loops %s 2>&1 | FileCheck -check-prefix=CHECK-NO-FINITE-LOOPS %s
+// RUN: %clang -### -S -fno-finite-loops -ffinite-loops %s 2>&1 | FileCheck -check-prefix=CHECK-FINITE-LOOPS %s
+// RUN: %clang -### -S -ffinite-loops -fno-finite-loops %s 2>&1 | FileCheck -check-prefix=CHECK-NO-FINITE-LOOPS %s
+// CHECK-FINITE-LOOPS: "-ffinite-loops"
+// CHECK-FINITE-LOOPS-NOT: "-fno-finite-loops"
+// CHECK-NO-FINITE-LOOPS: "-fno-finite-loops"
+// CHECK-NO-FINITE-LOOPS-NOT: "-ffinite-loops"
+
 // RUN: %clang -### -S -fprofile-sample-accurate %s 2>&1 | FileCheck -check-prefix=CHECK-PROFILE-SAMPLE-ACCURATE %s
 // CHECK-PROFILE-SAMPLE-ACCURATE: "-fprofile-sample-accurate"
 
 // RUN: %clang -### -S -fprofile-sample-use=%S/Inputs/file.prof %s 2>&1 | FileCheck -check-prefix=CHECK-SAMPLE-PROFILE %s
 // CHECK-SAMPLE-PROFILE: "-fprofile-sample-use={{.*}}/file.prof"
 
 // RUN: %clang -### -S -fauto-profile=%S/Inputs/file.prof %s 2>&1 | FileCheck -check-prefix=CHECK-AUTO-PROFILE %s
 // CHECK-AUTO-PROFILE: "-fprofile-sample-use={{.*}}/file.prof"

 // RUN:     -fno-check-new -fcheck-new                                        \
 // RUN:     -ffriend-injection                                                \
 // RUN:     -fno-implement-inlines -fimplement-inlines                        \
 // RUN:     -fstack-check                                                     \
 // RUN:     -fforce-addr                                                      \
 // RUN:     -malign-functions=100                                             \
 // RUN:     -malign-loops=100                                                 \
 // RUN:     -malign-jumps=100                                                 \
+// RUN:     -ffinite-loops -fno-finite-loops                                  \
 // RUN:     %s 2>&1 | FileCheck --check-prefix=IGNORE %s
 // IGNORE-NOT: error: unknown argument
 
 // Test that the warning is displayed on these.
 // RUN: %clang -###                                                           \
 // RUN: -finline-limit=1000                                                   \
 // RUN: -finline-limit                                                        \
 // RUN: -fexpensive-optimizations                                             \