Add support for #pragma nounroll

[meheff]

Summary

Following up on recently added "#pragma unroll" support, this patch adds support for "#pragma nounroll" which disables unrolling for a loop. Both xlc and icc support "#pragma nounroll". Compatibility with these compilers (along with CUDA) motivated the original "#pragma unroll" support.

This patch was originally part of the patch which added support for "#pragma unroll" but was pulled out to make that patch more incremental.

docs/ReleaseNotes.rst

 -----------------------
 
 Loop optimization hints can be specified using the new `#pragma clang loop`
 directive just prior to the desired loop. The directive allows vectorization,
 interleaving, and unrolling to be enabled or disabled. Vector width as well
 as interleave and unrolling count can be manually specified.  See language
 extensions for details.
 
-Clang now supports the `#pragma unroll` directive to specify loop unrolling
-optimization hints.  Placed just prior to the desired loop, `#pragma unroll`
-directs the loop unroller to attempt to fully unroll the loop.  The pragma may
-also be specified with a positive integer parameter indicating the desired
-unroll count: `#pragma unroll _value_`.  The unroll count parameter can be
-optionally enclosed in parentheses.
+Clang now supports the `#pragma unroll` and `#pragma nounroll` directives to
+specify loop unrolling optimization hints.  Placed just prior to the desired
+loop, `#pragma unroll` directs the loop unroller to attempt to fully unroll the
+loop.  The pragma may also be specified with a positive integer parameter
+indicating the desired unroll count: `#pragma unroll _value_`.  The unroll count
+parameter can be optionally enclosed in parentheses. The directive `#pragma
+nounroll` indicates that the loop should not be unrolled.
 
 C Language Changes in Clang
 ---------------------------
 
 ...
 
 C11 Feature Support
 ^^^^^^^^^^^^^^^^^^^

include/clang/Basic/Attr.td

 def LoopHint : Attr {
   /// vectorize: vectorizes loop operations if 'value != 0'.
   /// vectorize_width: vectorize loop operations with width 'value'.
   /// interleave: interleave multiple loop iterations if 'value != 0'.
   /// interleave_count: interleaves 'value' loop interations.
   /// unroll: fully unroll loop if 'value != 0'.
   /// unroll_count: unrolls loop 'value' times.
 
-  let Spellings = [Pragma<"clang", "loop">, Pragma<"", "unroll">];
+  let Spellings = [Pragma<"clang", "loop">, Pragma<"", "unroll">,
+                   Pragma<"", "nounroll">];
 
   /// State of the loop optimization specified by the spelling.
   let Args = [EnumArgument<"Option", "OptionType",
                           ["vectorize", "vectorize_width", "interleave", "interleave_count",
                            "unroll", "unroll_count"],
                           ["Vectorize", "VectorizeWidth", "Interleave", "InterleaveCount",
                            "Unroll", "UnrollCount"]>,
               DefaultIntArgument<"Value", 1>];
def LoopHint : Attr {
   static StringRef getValueName(int Value) {
     if (Value)
       return "enable";
     return "disable";
   }
 
   void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
     unsigned SpellingIndex = getSpellingListIndex();
+    // For "#pragma unroll" and "#pragma nounroll" the string "unroll" or
+    // "nounroll" is already emitted as the pragma name.
+    if (SpellingIndex == Pragma_nounroll) {
+      OS << "\n";
+      return;
+    }
     if (SpellingIndex == Pragma_unroll) {
-      // String "unroll" of "#pragma unroll" is already emitted as the
-      // pragma name.
       if (option == UnrollCount)
         printArgument(OS);
       OS << "\n";
       return;
     }
     assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
     OS << getOptionName(option);
     printArgument(OS);
void printArgument(raw_ostream &OS) const {
     OS << ")";
   }
 
   // Return a string suitable for identifying this attribute in diagnostics.
   std::string getDiagnosticName() const {
     std::string DiagnosticName;
     llvm::raw_string_ostream OS(DiagnosticName);
     unsigned SpellingIndex = getSpellingListIndex();
-    if (SpellingIndex == Pragma_unroll && option == Unroll)
-      OS << "#pragma unroll";
-    else if (SpellingIndex == Pragma_unroll && option == UnrollCount) {
+    if (SpellingIndex == Pragma_nounroll)
+      OS << "#pragma nounroll";
+    else if (SpellingIndex == Pragma_unroll) {
       OS << "#pragma unroll";
+      if (option == UnrollCount)
         printArgument(OS);
     } else {
       assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
       OS << getOptionName(option);
       printArgument(OS);
     }
     return OS.str();
   }
   }];
 
   let Documentation = [LoopHintDocs, UnrollHintDocs];
 }

include/clang/Basic/AttrDocs.td

 for that function.
 
 This attribute is incompatible with the ``always_inline`` attribute.
   }];
 }
 
 def LoopHintDocs : Documentation {
   let Category = DocCatStmt;
-  let Heading = "#pragma clang loop, #pragma unroll";
+  let Heading = "#pragma clang loop, #pragma unroll, #pragma nounroll";
   let Content = [{
 The ``#pragma clang loop`` directive allows loop optimization hints to be
 specified for the subsequent loop. The directive allows vectorization,
 interleaving, and unrolling to be enabled or disabled. Vector width as well
 as interleave and unrolling count can be manually specified. See
 `language extensions
 <http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_
 for details.
   }];
 }
 
 def UnrollHintDocs : Documentation {
   let Category = DocCatStmt;
   let Content = [{
-Loop unrolling optimization hints can be specified with ``#pragma unroll``. The
-pragma is placed immediately before a for, while, do-while, or c++11 range-based
-for loop.
+Loop unrolling optimization hints can be specified with ``#pragma unroll`` and
+``#pragma nounroll``. The pragma is placed immediately before a for, while,
+do-while, or c++11 range-based for loop.
 
 Specifying ``#pragma unroll`` without a parameter directs the loop unroller to
 attempt to fully unroll the loop if the trip count is known at compile time:
 
 .. code-block:: c++
 
   #pragma unroll
   for (...) {
for (...) {
     ...
   }
 
   #pragma unroll(16)
   for (...) {
     ...
   }
 
+Specifying ``#pragma nounroll`` indicates that the loop should not be unrolled:
+
+.. code-block:: c++
+
+  #pragma nounroll
+  for (...) {
+    ...
+  }
+
 ``#pragma unroll`` and ``#pragma unroll _value_`` have identical semantics to
-``#pragma clang loop unroll(full)`` and ``#pragma clang loop
-unroll_count(_value_)`` respectively. See `language extensions
+``#pragma clang loop unroll(full)`` and
+``#pragma clang loop unroll_count(_value_)`` respectively. ``#pragma nounroll``
+is equivalent to ``#pragma clang loop unroll(disable)``.  See
+`language extensions
 <http://clang.llvm.org/docs/LanguageExtensions.html#extensions-for-loop-hint-optimizations>`_
 for further details including limitations of the unroll hints.
   }];
 }
 

include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
   std::unique_ptr<PragmaHandler> MSDataSeg;
   std::unique_ptr<PragmaHandler> MSBSSSeg;
   std::unique_ptr<PragmaHandler> MSConstSeg;
   std::unique_ptr<PragmaHandler> MSCodeSeg;
   std::unique_ptr<PragmaHandler> MSSection;
   std::unique_ptr<PragmaHandler> OptimizeHandler;
   std::unique_ptr<PragmaHandler> LoopHintHandler;
   std::unique_ptr<PragmaHandler> UnrollHintHandler;
+  std::unique_ptr<PragmaHandler> NoUnrollHintHandler;
 
   std::unique_ptr<CommentHandler> CommentSemaHandler;
 
   /// Whether the '>' token acts as an operator or not. This will be
   /// true except when we are parsing an expression within a C++
   /// template argument list, where the '>' closes the template
   /// argument list.
   bool GreaterThanIsOperator;

include/clang/Sema/LoopHint.h

 struct LoopHint {
   // Source range of the directive.
   SourceRange Range;
   // Identifier corresponding to the name of the pragma.  "loop" for
   // "#pragma clang loop" directives and "unroll" for "#pragma unroll"
   // hints.
   IdentifierLoc *PragmaNameLoc;
   // Name of the loop hint.  Examples: "unroll", "vectorize".  In the
-  // "#pragma unroll" case, this is identical to PragmaNameLoc.
+  // "#pragma unroll" and "#pragma nounroll" cases, this is identical to
+  // PragmaNameLoc.
   IdentifierLoc *OptionLoc;
   // Identifier for the hint argument.  If null, then the hint has no argument
   // such as for "#pragma unroll".
   IdentifierLoc *ValueLoc;
   // Expression for the hint argument if it exists, null otherwise.
   Expr *ValueExpr;
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_SEMA_LOOPHINT_H

lib/Parse/ParsePragma.cpp

void Parser::initializePragmaHandlers() {
   OptimizeHandler.reset(new PragmaOptimizeHandler(Actions));
   PP.AddPragmaHandler("clang", OptimizeHandler.get());
 
   LoopHintHandler.reset(new PragmaLoopHintHandler());
   PP.AddPragmaHandler("clang", LoopHintHandler.get());
 
   UnrollHintHandler.reset(new PragmaUnrollHintHandler("unroll"));
   PP.AddPragmaHandler(UnrollHintHandler.get());
+
+  NoUnrollHintHandler.reset(new PragmaUnrollHintHandler("nounroll"));
+  PP.AddPragmaHandler(NoUnrollHintHandler.get());
 }
 
 void Parser::resetPragmaHandlers() {
   // Remove the pragma handlers we installed.
   PP.RemovePragmaHandler(AlignHandler.get());
   AlignHandler.reset();
   PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get());
   GCCVisibilityHandler.reset();
void Parser::resetPragmaHandlers() {
   PP.RemovePragmaHandler("clang", OptimizeHandler.get());
   OptimizeHandler.reset();
 
   PP.RemovePragmaHandler("clang", LoopHintHandler.get());
   LoopHintHandler.reset();
 
   PP.RemovePragmaHandler(UnrollHintHandler.get());
   UnrollHintHandler.reset();
+
+  PP.RemovePragmaHandler(NoUnrollHintHandler.get());
+  NoUnrollHintHandler.reset();
 }
 
 /// \brief Handle the annotation token produced for #pragma unused(...)
 ///
 /// Each annot_pragma_unused is followed by the argument token so e.g.
 /// "#pragma unused(x,y)" becomes:
 /// annot_pragma_unused 'x' annot_pragma_unused 'y'
 void Parser::HandlePragmaUnused() {
PP.EnterTokenStream(TokenArray, TokenList.size(),
                       /*DisableMacroExpansion=*/false,
                       /*OwnsTokens=*/true);
 }
 
 /// \brief Handle the loop unroll optimization pragmas.
 ///  #pragma unroll
 ///  #pragma unroll unroll-hint-value
 ///  #pragma unroll '(' unroll-hint-value ')'
+///  #pragma nounroll
 ///
 ///  unroll-hint-value:
 ///    constant-expression
 ///
-/// Loop unrolling hints are specified with '#pragma unroll'. '#pragma unroll'
-/// can take a numeric argument optionally contained in parentheses. With no
-/// argument the directive instructs llvm to try to unroll the loop
-/// completely. A positive integer argument can be specified to indicate the
-/// number of times the loop should be unrolled.  To maximize compatibility with
-/// other compilers the unroll count argument can be specified with or without
-/// parentheses.
+/// Loop unrolling hints can be specified with '#pragma unroll' or
+/// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally
+/// contained in parentheses. With no argument the directive instructs llvm to
+/// try to unroll the loop completely. A positive integer argument can be
+/// specified to indicate the number of times the loop should be unrolled.  To
+/// maximize compatibility with other compilers the unroll count argument can be
+/// specified with or without parentheses.  Specifying, '#pragma nounroll'
+/// disables unrolling of the loop.
 void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP,
                                            PragmaIntroducerKind Introducer,
                                            Token &Tok) {
-  // Incoming token is "unroll" of "#pragma unroll".
+  // Incoming token is "unroll" for "#pragma unroll", or "nounroll" for
+  // "#pragma nounroll".
   Token PragmaName = Tok;
   PP.Lex(Tok);
   auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
   if (Tok.is(tok::eod)) {
-    // Unroll pragma without an argument.
+    // nounroll or unroll pragma without an argument.
     Info->PragmaName = PragmaName;
     Info->Option = PragmaName;
     Info->HasValue = false;
+  } else if (PragmaName.getIdentifierInfo()->getName() == "nounroll") {
+    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
+        << "nounroll";
+    return;
   } else {
     // Unroll pragma with an argument: "#pragma unroll N" or
     // "#pragma unroll(N)".
     bool ValueInParens;
     if (ParseLoopHintValue(PP, Tok, PragmaName, PragmaName, ValueInParens,
                            *Info))
       return;
 

lib/Sema/SemaStmtAttr.cpp

static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const AttributeList &A,
   Expr *ValueExpr = A.getArgAsExpr(3);
 
   assert(OptionInfo && "Attribute must have valid option info.");
 
   if (St->getStmtClass() != Stmt::DoStmtClass &&
       St->getStmtClass() != Stmt::ForStmtClass &&
       St->getStmtClass() != Stmt::CXXForRangeStmtClass &&
       St->getStmtClass() != Stmt::WhileStmtClass) {
-    const char *Pragma = PragmaNameLoc->Ident->getName() == "unroll"
-                             ? "#pragma unroll"
-                             : "#pragma clang loop";
+    const char *Pragma =
+        llvm::StringSwitch<const char *>(PragmaNameLoc->Ident->getName())
+            .Case("unroll", "#pragma unroll")
+            .Case("nounroll", "#pragma nounroll")
+            .Default("#pragma clang loop");
     S.Diag(St->getLocStart(), diag::err_pragma_loop_precedes_nonloop) << Pragma;
     return nullptr;
   }
 
   LoopHintAttr::OptionType Option;
   LoopHintAttr::Spelling Spelling;
   if (PragmaNameLoc->Ident->getName() == "unroll") {
     Option = ValueLoc ? LoopHintAttr::UnrollCount : LoopHintAttr::Unroll;
     Spelling = LoopHintAttr::Pragma_unroll;
+  } else if (PragmaNameLoc->Ident->getName() == "nounroll") {
+    Option = LoopHintAttr::Unroll;
+    Spelling = LoopHintAttr::Pragma_nounroll;
   } else {
     Option = llvm::StringSwitch<LoopHintAttr::OptionType>(OptionInfo->getName())
                  .Case("vectorize", LoopHintAttr::Vectorize)
                  .Case("vectorize_width", LoopHintAttr::VectorizeWidth)
                  .Case("interleave", LoopHintAttr::Interleave)
                  .Case("interleave_count", LoopHintAttr::InterleaveCount)
                  .Case("unroll", LoopHintAttr::Unroll)
                  .Case("unroll_count", LoopHintAttr::UnrollCount)
                  .Default(LoopHintAttr::Vectorize);
     Spelling = LoopHintAttr::Pragma_clang_loop;
   }
 
   int ValueInt;
   if (Option == LoopHintAttr::Unroll &&
       Spelling == LoopHintAttr::Pragma_unroll) {
     ValueInt = 1;
+  } else if (Option == LoopHintAttr::Unroll &&
+             Spelling == LoopHintAttr::Pragma_nounroll) {
+    ValueInt = 0;
   } else if (Option == LoopHintAttr::Vectorize ||
              Option == LoopHintAttr::Interleave ||
              Option == LoopHintAttr::Unroll) {
     // Unrolling uses the keyword "full" rather than "enable" to indicate full
     // unrolling.
     const char *TrueKeyword =
         Option == LoopHintAttr::Unroll ? "full" : "enable";
     if (!ValueInfo) {

test/CodeGen/pragma-unroll.cpp

while (i < Length) {
     i++;
   }
 }
 
 // Verify do loop is recognized after multi-option pragma clang loop directive.
 void do_test(int *List, int Length) {
   int i = 0;
 
-#pragma unroll 16
+#pragma nounroll
   do {
     // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_2:.*]]
     List[i] = i * 2;
     i++;
   } while (i < Length);
 }
 
 // Verify for loop is recognized after unroll pragma.
void template_test(double *List, int Length) {
   double Value = 10;
 
   for_template_test<double>(List, Length, Value);
   for_template_define_test<double>(List, Length, Value);
 }
 
 // CHECK: ![[LOOP_1]] = metadata !{metadata ![[LOOP_1]], metadata ![[UNROLL_FULL:.*]]}
 // CHECK: ![[UNROLL_FULL]] = metadata !{metadata !"llvm.loop.unroll.full"}
-// CHECK: ![[LOOP_2]] = metadata !{metadata ![[LOOP_2:.*]], metadata ![[UNROLL_16:.*]]}
-// CHECK: ![[UNROLL_16]] = metadata !{metadata !"llvm.loop.unroll.count", i32 16}
+// CHECK: ![[LOOP_2]] = metadata !{metadata ![[LOOP_2:.*]], metadata ![[UNROLL_DISABLE:.*]]}
+// CHECK: ![[UNROLL_DISABLE]] = metadata !{metadata !"llvm.loop.unroll.disable"}
 // CHECK: ![[LOOP_3]] = metadata !{metadata ![[LOOP_3]], metadata ![[UNROLL_8:.*]]}
 // CHECK: ![[UNROLL_8]] = metadata !{metadata !"llvm.loop.unroll.count", i32 8}
 // CHECK: ![[LOOP_4]] = metadata !{metadata ![[LOOP_4]], metadata ![[UNROLL_4:.*]]}
 // CHECK: ![[UNROLL_4]] = metadata !{metadata !"llvm.loop.unroll.count", i32 4}
 // CHECK: ![[LOOP_5]] = metadata !{metadata ![[LOOP_5]], metadata ![[UNROLL_8:.*]]}
 // CHECK: ![[LOOP_6]] = metadata !{metadata ![[LOOP_6]], metadata ![[UNROLL_8:.*]]}
 // CHECK: ![[LOOP_7]] = metadata !{metadata ![[LOOP_7]], metadata ![[UNROLL_8:.*]]}

test/PCH/pragma-loop.cpp

 // CHECK: #pragma clang loop unroll(disable)
 // CHECK: #pragma clang loop interleave(disable)
 // CHECK: #pragma clang loop vectorize(enable)
 // CHECK: #pragma clang loop unroll(full)
 // CHECK: #pragma clang loop interleave(enable)
 // CHECK: #pragma clang loop vectorize(disable)
 // CHECK: #pragma unroll
 // CHECK: #pragma unroll (32)
+// CHECK: #pragma nounroll
 
 #ifndef HEADER
 #define HEADER
 
 class pragma_test {
 public:
   inline void run1(int *List, int Length) {
     int i = 0;
#pragma unroll
   inline void run5(int *List, int Length) {
     int i = 0;
 #pragma unroll 32
     while (i - 3 < Length) {
       List[i] = i;
       i++;
     }
   }
-};
 
+  inline void run6(int *List, int Length) {
+    int i = 0;
+#pragma nounroll
+    while (i - 3 < Length) {
+      List[i] = i;
+      i++;
+    }
+  }
+};
 #else
 
 void test() {
   int List[100];
 
   pragma_test pt;
 
   pt.run1(List, 100);
   pt.run2(List, 100);
   pt.run3(List, 100);
   pt.run4(List, 100);
   pt.run5(List, 100);
+  pt.run6(List, 100);
 }
 
 #endif

test/Parser/pragma-unroll.cpp

 // RUN: %clang_cc1 -std=c++11 -verify %s
 
 // Note that this puts the expected lines before the directives to work around
 // limitations in the -verify mode.
 
 void test(int *List, int Length) {
   int i = 0;
 
 #pragma unroll
   while (i + 1 < Length) {
     List[i] = i;
   }
 
+#pragma nounroll
+  while (i < Length) {
+    List[i] = i;
+  }
+
 #pragma unroll 4
   while (i - 1 < Length) {
     List[i] = i;
   }
 
 #pragma unroll(8)
   while (i - 2 < Length) {
     List[i] = i;
   }
 
 /* expected-error {{expected ')'}} */ #pragma unroll(4
 /* expected-error {{missing argument to '#pragma unroll'}} */ #pragma unroll()
 /* expected-warning {{extra tokens at end of '#pragma unroll'}} */ #pragma unroll 1 2
   while (i-6 < Length) {
     List[i] = i;
   }
 
+/* expected-warning {{extra tokens at end of '#pragma nounroll'}} */ #pragma nounroll 1
+  while (i-7 < Length) {
+    List[i] = i;
+  }
+
 /* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll(()
 /* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll -
 /* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll(0)
 /* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll 0
 /* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll(3000000000)
 /* expected-error {{invalid argument; expected a positive integer value}} */ #pragma unroll 3000000000
   while (i-8 < Length) {
     List[i] = i;
   }
 
 #pragma unroll
 /* expected-error {{expected a for, while, or do-while loop to follow '#pragma unroll'}} */ int j = Length;
 #pragma unroll 4
 /* expected-error {{expected a for, while, or do-while loop to follow '#pragma unroll'}} */ int k = Length;
+#pragma nounroll
+/* expected-error {{expected a for, while, or do-while loop to follow '#pragma nounroll'}} */ int l = Length;
 
 /* expected-error {{incompatible directives 'unroll(disable)' and '#pragma unroll(4)'}} */ #pragma unroll 4
 #pragma clang loop unroll(disable)
   while (i-10 < Length) {
     List[i] = i;
   }
 
 /* expected-error {{incompatible directives 'unroll(full)' and '#pragma unroll(4)'}} */ #pragma unroll(4)
 #pragma clang loop unroll(full)
   while (i-11 < Length) {
     List[i] = i;
   }
 
 /* expected-error {{incompatible directives '#pragma unroll' and '#pragma unroll(4)'}} */ #pragma unroll(4)
 #pragma unroll
   while (i-11 < Length) {
     List[i] = i;
   }
 
+/* expected-error {{incompatible directives '#pragma nounroll' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4)
+#pragma nounroll
+  while (i-12 < Length) {
+    List[i] = i;
+  }
+
+/* expected-error {{duplicate directives '#pragma nounroll' and '#pragma nounroll'}} */ #pragma nounroll
+#pragma nounroll
+  while (i-13 < Length) {
+    List[i] = i;
+  }
+
 /* expected-error {{duplicate directives '#pragma unroll' and '#pragma unroll'}} */ #pragma unroll
 #pragma unroll
   while (i-14 < Length) {
     List[i] = i;
   }
 
 /* expected-error {{duplicate directives 'unroll(full)' and '#pragma unroll'}} */ #pragma unroll
 #pragma clang loop unroll(full)