Add support for unroll pragma

[meheff]

Summary

This patch adds support for loop unroll pragma syntax:

// Fully unroll loop.
#pragma unroll
for (...) { }

// Unroll loop N times.
#pragma unroll N
for (...) { }

// Unroll loop N times (same effect as without the parentheses around N).
#pragma unroll(N)
for (...) { }

These pragmas replace the "#pragma clang loop unroll" and "#pragma clang loop unroll_count" directives.

Mark

[eliben]

include/clang/Parse/Parser.h

1615

How about a comment above the method declaration that explains what those arguments are? I know the surrounding code doesn't do this, but with new code we can do better :)

include/clang/Sema/CudaUnrollHint.h

19 ↗

(On Diff #10856)

Ditto... Documentation of every field in this struct.

lib/CodeGen/CGStmt.cpp

554 ↗

(On Diff #10856)

Since MDNode::get accepts a ArrayRef, I wonder if there's a way to not have the OpValues vector at all?

At the minimum:

llvm::Value *Values[] = {MetadataPair.first, MetadataPair.second};
... MDNode::get(Context, Values);

It may be possible to inline the {...} into the ::get too, I haven't checked.

lib/Sema/SemaStmtAttr.cpp

141

You could fold this into the if (...)

[meheff]

Thanks for the comments, Eli. This patch addresses them all.

include/clang/Parse/Parser.h

1615

Done.

include/clang/Sema/CudaUnrollHint.h

19 ↗

(On Diff #10856)

Done.

lib/CodeGen/CGStmt.cpp

554 ↗

(On Diff #10856)

Done.

lib/Sema/SemaStmtAttr.cpp

141

Done.

[hfinkel]

lib/Parse/ParsePragma.cpp

695

If this gets committed, please also add a corresponding note in the bug report that there is another instance of the issue to fix :)

[meheff]

Thanks all for your comments. This patch reduces much of the implementation duplication from the previous patch. Unroll and loop optimization hints now both share the same attribute.

Also, the loop unroll pragma now replaces the "#pragma clang loop unroll/unroll_count" directives which have been removed. The following unroll pragma forms are supported:

#pragma unroll
#pragma unroll N
#pragma unroll(N)

The parentheses around the unroll count argument are optional. The form with parentheses is included to maximize compatibility with existing compilers (Intel and IBM compiler use the form with parentheses, CUDA uses the form without).

[meheff]

Thanks for the comments. Responses are below. With this patch "#pragma unroll" and "#pragma clang loop unroll" syntaxes are both supported. I also added "#pragma nounroll" as both icc and xlc support this pragma.

On Wed, Jul 2, 2014 at 7:54 AM, Aaron Ballman <[e-mail]> wrote:

/// 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>];

+ DefaultIntArgument<"Value", 1>,
+ DefaultBoolArgument<"ValueInParens", 0>];

Hmm... we usually want the arguments to match the syntax of the
attribute unless the argument is really key to the semantics.
ValueInParens doesn't really fit that model. I would prefer for this
to be an AdditionalMembers entry.

I tried putting ValueInParens in the AdditionalMembers, but then ran into issues with test/PCH/pragma-loop. I just added a member variable and a method to set it, but then ValueInParens is then not set when reading in the PCH file. It only works if ValueInParens is not in Args. Am I missing something?

"%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, "
"vectorize_width, interleave, interleave_count, unroll, or unroll_count">;

def err_pragma_loop_missing_argument : Error<

• "missing argument to loop pragma %0">;

+ "missing argument to %0 pragma">;

The name of this diagnostic should probably change given how generic
the text now is.

Done.

+def err_pragma_loop_duplicate : Error<
+ "duplicate '%0' directives">;
+def err_pragma_loop_incompatible : Error<
+ "incompatible directives '%0(%1)' and '%2(%3)'">;

Why was this split into two errors?

This was originally done because the duplicate form was also used when there was no parameter such as '#pragma unroll'. I've refactored it and now they are back to being one error.

+// Parses loop or unroll pragma hint value and fills in Info.

+bool ParseLoopHintValue(Preprocessor &PP, Token Tok, Token &PragmaName,
+ Token &Option, PragmaLoopHintInfo &Info) {
+ bool ValueInParens;

Could simply initialize to Tok.is(tok::l_paren), then not need the
else clause at all.

Good point. Done.

-static void
-CheckForIncompatibleAttributes(Sema &S, SmallVectorImpl<const Attr *> &Attrs) {
+static void CheckForIncompatibleAttributes(
+ Sema &S, SmallVectorImpl<const Attr *> &Attrs) {

Attrs should be const.

Done.

[meheff]

I added a warning if the wrong pragma unroll syntax is used with CUDA. When Tyler's change adding support for expressions in loop pragmas lands, I'll add a warning for the case when the pragma argument is not an integer literal in CUDA mode. Responses to Aaron's comments inline.

On Wed, Jul 9, 2014 at 7:42 AM, Aaron Ballman <[e-mail]> wrote:

On Wed, Jul 9, 2014 at 2:14 AM, Mark Heffernan <[e-mail]> wrote:

I also added "#pragma nounroll" as both icc and xlc support this pragma.

Please split nounroll out into a separate patch. The idea is certainly
reasonable, but it's preferable for patches to cover a limited,
incremental change.

Done.

On Wed, Jul 2, 2014 at 7:54 AM, Aaron Ballman <[e-mail]> wrote:

Okay, I can see why that would happen. ClangAtterEmitter.cpp generates
code for serialization and deserialization, but it doesn't have any
way of handling additional members (since those are just copy/pasted
into the attribute class definition itself).

I wonder how horrible it would be to simply canonicalize based on
compiler options when pretty printing, and skip this field entirely.
Eg) when CUDA is on, pretty print does not emit the parens. When CUDA
mode is off, it does emit the parens. Yes, this isn't *exactly* what
the user wrote, but the semantics are identical either way.

It's now cannonicalized to the form with parentheses '#pragma unroll(n)'.  Tracking of the existence of parentheses is gone.

Index: include/clang/Basic/DiagnosticParseKinds.td

• include/clang/Basic/DiagnosticParseKinds.td

+++ include/clang/Basic/DiagnosticParseKinds.td
@@ -811,6 +811,9 @@
   InGroup<IgnoredPragmas>;
 def warn_pragma_expected_punc : Warning<
   "expected ')' or ',' in '#pragma %0'">, InGroup<IgnoredPragmas>;
+// - Generic errors
+def err_pragma_missing_argument : Error<
+  "missing argument to %0 directive">;

Since it's a generic parsing diagnostic, presumably we know what kind
of argument is missing, and we could tell the user that information.
What's more, since pragmas can have multiple arguments, this doesn't
say *which* argument is missing (there could be more than one).

I also think the word "directive" could be dropped.

Created a generic diagnostic: "missing argument to '#pragma %0'; expected %1".  This new warning is also now shared with one pragma optimize warning.  Regarding stating which argument is missing, all of the pragmas using this warning only take a single argument.  I think it makes sense not to specify argument position unless multiple arguments are allowed.  That is, "missing first argument to '#pragma unroll'" suggests pragma unroll accepts more than one argument.  If this error is later used for pragmas with multiple parameters, the format string can be adjusted accordingly.

 def err_pragma_loop_precedes_nonloop : Error<

•  "expected a for, while, or do-while loop to follow the '#pragma clang loop' "
•  "directive">;

+  "expected a for, while, or do-while loop to follow the '%0' directive">;

I would drop "directive" (and "the") here too.

Done.

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` 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: unroll loop if 'value != 0'.
   /// unroll_count: unrolls loop 'value' times.
 
-  let Spellings = [Pragma<"clang", "loop">];
+  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>];
+              DefaultIntArgument<"Value", 1>,
+              DefaultBoolArgument<"ValueInParens", 0>];
 
   let AdditionalMembers = [{
   static StringRef getOptionName(int Option) {
     switch(Option) {
     case Vectorize: return "vectorize";
     case VectorizeWidth: return "vectorize_width";
     case Interleave: return "interleave";
     case InterleaveCount: return "interleave_count";
     case Unroll: return "unroll";
     case UnrollCount: return "unroll_count";
     }
     llvm_unreachable("Unhandled LoopHint option.");
   }
 
-  static StringRef getValueName(int Value) {
-    if (Value)
-      return "enable";
-    return "disable";
-  }
-
   void printPrettyPragma(raw_ostream &OS, const PrintingPolicy &Policy) const {
-    OS << getOptionName(option) << "(";
+    unsigned SpellingIndex = getSpellingListIndex();
+    if (SpellingIndex == Pragma_nounroll ||
+        (SpellingIndex == Pragma_unroll && option == Unroll)) {
+      // "#pragma unroll" or "#pragma nounroll".  String "unroll" or "nounroll"
+      // is already emitted as the pragma name and there is no argument to emit.
+      OS << "\n";
+      return;
+    }
+    if (SpellingIndex == Pragma_unroll) {
+      // "#pragma unroll N" or "#pragma unroll (N)".
+      assert(option == UnrollCount && "Unexpected option type");
+      OS << getValueString() << "\n";
+      return;
+    }
+    assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling");
+    OS << getOptionName(option) << getValueString() << "\n";
+  }
+
+  // Return a string containing the loop hint argument including the
+  // optional enclosing parentheses.
+  std::string getValueString() const {
+    std::string ValueName;
     if (option == VectorizeWidth || option == InterleaveCount ||
         option == UnrollCount)
-      OS << value;
+      ValueName = std::to_string(value);
+    else if (value)
+      ValueName = "enable";
+    else
+      ValueName = "disable";
+        
+    if (valueInParens)
+      return "(" + ValueName + ")";
     else
-      OS << getValueName(value);
-    OS << ")\n";
+      return ValueName;
+  }
+
+  // Return a string suitable for identifying this attribute in diagnostics.
+  std::string getDiagnosticName() const {
+    unsigned SpellingIndex = getSpellingListIndex();
+    if (SpellingIndex == Pragma_nounroll)
+      return "#pragma nounroll";
+    else if (SpellingIndex == Pragma_unroll && option == Unroll)
+      return "#pragma unroll";
+    else if (SpellingIndex == Pragma_unroll && option == UnrollCount) {
+      std::string DiagnosticName = "#pragma unroll ";
+      return DiagnosticName + getValueString();
+    } else {
+      std::string DiagnosticName = getOptionName(option);
+      return DiagnosticName + getValueString();
+    }
   }
   }];
 
-  let Documentation = [LoopHintDocs];
+  let Documentation = [LoopHintDocs, UnrollHintDocs];
 }

include/clang/Basic/AttrDocs.td

 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 the ``#pragma unroll``
+and ``#pragma nounroll`` directives.  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 (...) {
+    ...
+  }
+
+Specifying the optional parameter, ``#pragma unroll _value_``, directs the
+unroller to unroll the loop ``_value_`` times.  The parameter may optionally be
+enclosed in parentheses:
+
+.. code-block:: c++
+
+  #pragma unroll 16
+  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(enable)`` 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/Basic/DiagnosticParseKinds.td

 def warn_pragma_ms_struct : Warning<
   "incorrect use of '#pragma ms_struct on|off' - ignored">,
   InGroup<IgnoredPragmas>;
 def warn_pragma_extra_tokens_at_eol : Warning<
   "extra tokens at end of '#pragma %0' - ignored">,
   InGroup<IgnoredPragmas>;
 def warn_pragma_expected_punc : Warning<
   "expected ')' or ',' in '#pragma %0'">, InGroup<IgnoredPragmas>;
+// - Generic errors
+def err_pragma_missing_argument : Error<
+  "missing argument to %0 directive">;
 // - #pragma options
 def warn_pragma_options_expected_align : Warning<
   "expected 'align' following '#pragma options' - ignored">,
   InGroup<IgnoredPragmas>;
 def warn_pragma_align_expected_equal : Warning<
   "expected '=' following '#pragma %select{align|options align}0' - ignored">,
   InGroup<IgnoredPragmas>;
 def warn_pragma_align_invalid_option : Warning<
def err_omp_unexpected_clause : Error<
   "unexpected OpenMP clause '%0' in directive '#pragma omp %1'">;
 def err_omp_more_one_clause : Error<
   "directive '#pragma omp %0' cannot contain more than one '%1' clause">;
 
 // Pragma loop support.
 def err_pragma_loop_invalid_option : Error<
   "%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, "
   "vectorize_width, interleave, interleave_count, unroll, or unroll_count">;
-def err_pragma_loop_missing_argument : Error<
-  "missing argument to loop pragma %0">;
 } // end of Parse Issue category.
 
 let CategoryName = "Modules Issue" in {
 def err_module_expected_ident : Error<
   "expected a module name after module import">;
 def err_module_expected_semi : Error<
   "expected ';' after module name">;
 }
 
 } // end of Parser diagnostics

include/clang/Basic/DiagnosticSemaKinds.td

def err_pragma_pop_visibility_mismatch : Error<
   "#pragma visibility pop with no matching #pragma visibility push">;
 def note_surrounding_namespace_starts_here : Note<
   "surrounding namespace with visibility attribute starts here">;
 def err_pragma_loop_invalid_value : Error<
   "invalid argument; expected a positive integer value">;
 def err_pragma_loop_invalid_keyword : Error<
   "invalid argument; expected 'enable' or 'disable'">;
 def err_pragma_loop_compatibility : Error<
-  "%select{incompatible|duplicate}0 directives '%1(%2)' and '%3(%4)'">;
+  "%select{incompatible|duplicate}0 directives '%1' and '%2'">;
 def err_pragma_loop_precedes_nonloop : Error<
-  "expected a for, while, or do-while loop to follow the '#pragma clang loop' "
-  "directive">;
+  "expected a for, while, or do-while loop to follow the '%0' directive">;
 
 /// Objective-C parser diagnostics
 def err_duplicate_class_def : Error<
   "duplicate interface definition for class %0">;
 def err_undef_superclass : Error<
   "cannot find interface declaration for %0, superclass of %1">;
 def err_forward_superclass : Error<
   "attempting to use the forward class %0 as superclass of %1">;

include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
   std::unique_ptr<PragmaHandler> MSInitSeg;
   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;
private:
   /// #pragma OPENCL EXTENSION...
   void HandlePragmaOpenCLExtension();
 
   /// \brief Handle the annotation token produced for
   /// #pragma clang __debug captured
   StmtResult HandlePragmaCaptured();
 
   /// \brief Handle the annotation token produced for
-  /// #pragma vectorize...
+  /// #pragma clang loop and #pragma unroll.
   LoopHint HandlePragmaLoopHint();
 
   /// GetLookAheadToken - This peeks ahead N tokens and returns that token
   /// without consuming any tokens.  LookAhead(0) returns 'Tok', LookAhead(1)
   /// returns the token after Tok, etc.
   ///
   /// Note that this differs from the Preprocessor's LookAhead method, because
   /// the Parser always has one token lexed that the preprocessor doesn't.
private:
   StmtResult ParseContinueStatement();
   StmtResult ParseBreakStatement();
   StmtResult ParseReturnStatement();
   StmtResult ParseAsmStatement(bool &msAsm);
   StmtResult ParseMicrosoftAsmStatement(SourceLocation AsmLoc);
   StmtResult ParsePragmaLoopHint(StmtVector &Stmts, bool OnlyStatement,
                                  SourceLocation *TrailingElseLoc,
                                  ParsedAttributesWithRange &Attrs);
 
   /// \brief Describes the behavior that should be taken for an __if_exists
   /// block.
   enum IfExistsBehavior {
     /// \brief Parse the block; this code is always used.
     IEB_Parse,
     /// \brief Skip the block entirely; this code is never used.
     IEB_Skip,
     /// \brief Parse the block as a dependent block, which may be used in

include/clang/Sema/LoopHint.h

 
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Sema/AttributeList.h"
 #include "clang/Sema/Ownership.h"
 
 namespace clang {
 
-/// \brief Loop hint specified by a pragma loop directive.
+/// \brief Loop optimization hint for loop and unroll pragmas.
 struct LoopHint {
+  // Source range of the directive.
   SourceRange Range;
-  Expr *ValueExpr;
-  IdentifierLoc *LoopLoc;
-  IdentifierLoc *ValueLoc;
+  // 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.
   IdentifierLoc *OptionLoc;
+  // Identifier for the hint argument.  If null, then the hint has no argument
+  // such as "#pragma unroll".
+  IdentifierLoc *ValueLoc;
+  // If the hint argument exists and is contained in parentheses (for example,
+  // "vectorize_width(8)") this contains the identifier for the closing
+  // parentheses.  Value is null otherwise.
+  IdentifierLoc *CloseParenLoc;
+  // 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

 };
 
 struct PragmaLoopHintHandler : public PragmaHandler {
   PragmaLoopHintHandler() : PragmaHandler("loop") {}
   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                     Token &FirstToken) override;
 };
 
+struct PragmaUnrollHintHandler : public PragmaHandler {
+  PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {}
+  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
+                    Token &FirstToken) override;
+};
+
 }  // end namespace
 
 void Parser::initializePragmaHandlers() {
   AlignHandler.reset(new PragmaAlignHandler());
   PP.AddPragmaHandler(AlignHandler.get());
 
   GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler());
   PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get());
if (getLangOpts().MicrosoftExt) {
     PP.AddPragmaHandler(MSSection.get());
   }
 
   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("STDC", FPContractHandler.get());
   FPContractHandler.reset();
 
   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() {

 
 unsigned Parser::HandlePragmaMSInitSeg(llvm::StringRef PragmaName,
                                        SourceLocation PragmaLocation) {
   return PP.getDiagnostics().getCustomDiagID(
       DiagnosticsEngine::Error, "'#pragma %0' not implemented.");
 }
 
 struct PragmaLoopHintInfo {
-  Token Loop;
-  Token Value;
+  Token PragmaName;
   Token Option;
+  Token Value;
+  Token CloseParen;
+  bool HasValue;
+  bool ValueInParens;
 };
 
 LoopHint Parser::HandlePragmaLoopHint() {
   assert(Tok.is(tok::annot_pragma_loop_hint));
   PragmaLoopHintInfo *Info =
       static_cast<PragmaLoopHintInfo *>(Tok.getAnnotationValue());
 
   LoopHint Hint;
-  Hint.LoopLoc =
-      IdentifierLoc::create(Actions.Context, Info->Loop.getLocation(),
-                            Info->Loop.getIdentifierInfo());
+  Hint.PragmaNameLoc =
+      IdentifierLoc::create(Actions.Context, Info->PragmaName.getLocation(),
+                            Info->PragmaName.getIdentifierInfo());
   Hint.OptionLoc =
       IdentifierLoc::create(Actions.Context, Info->Option.getLocation(),
                             Info->Option.getIdentifierInfo());
+  if (Info->HasValue) {
+    if (Info->ValueInParens) {
+      Hint.Range = SourceRange(Info->Option.getLocation(),
+                               Info->CloseParen.getLocation());
+      Hint.CloseParenLoc =
+          IdentifierLoc::create(Actions.Context, Info->CloseParen.getLocation(),
+                                Info->CloseParen.getIdentifierInfo());
+    } else {
+      Hint.Range =
+          SourceRange(Info->Option.getLocation(), Info->Value.getLocation());
+      Hint.CloseParenLoc = nullptr;
+    }
     Hint.ValueLoc =
         IdentifierLoc::create(Actions.Context, Info->Value.getLocation(),
                               Info->Value.getIdentifierInfo());
-  Hint.Range =
-      SourceRange(Info->Option.getLocation(), Info->Value.getLocation());
 
     // FIXME: We should allow non-type template parameters for the loop hint
     // value. See bug report #19610
     if (Info->Value.is(tok::numeric_constant))
       Hint.ValueExpr = Actions.ActOnNumericConstant(Info->Value).get();
     else
       Hint.ValueExpr = nullptr;
+  } else {
+    Hint.Range = SourceRange(Info->PragmaName.getLocation());
+    Hint.ValueLoc = nullptr;
+    Hint.ValueExpr = nullptr;
+    Hint.CloseParenLoc = nullptr;
+  }
 
   return Hint;
 }
 
 // #pragma GCC visibility comes in two variants:
 //   'push' '(' [visibility] ')'
 //   'pop'
 void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, 
void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
   if (PushPop && PushPop->isStr("pop")) {
     VisType = nullptr;
   } else if (PushPop && PushPop->isStr("push")) {
     PP.LexUnexpandedToken(Tok);
     if (Tok.isNot(tok::l_paren)) {
       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
         << "visibility";
       return;
     }
     PP.LexUnexpandedToken(Tok);
     VisType = Tok.getIdentifierInfo();
     if (!VisType) {
       PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
         << "visibility";
       return;
     }
     PP.LexUnexpandedToken(Tok);
if (Tok.isNot(tok::eod)) {
     PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument)
       << PP.getSpelling(Tok);
     return;
   }
 
   Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
 }
 
+// Parses loop or unroll pragma hint value and fills in Info.
+bool ParseLoopHintValue(Preprocessor &PP, Token Tok, Token PragmaName,
+                        Token &Option, PragmaLoopHintInfo &Info) {
+  bool ValueInParens = Tok.is(tok::l_paren);
+  if (ValueInParens) {
+    PP.Lex(Tok);
+    if (Tok.is(tok::r_paren)) {
+      // Nothing between the parentheses.
+      PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
+          << Option.getIdentifierInfo();
+      return true;
+    }
+  }
+
+  // FIXME: Value should be stored and parsed as a constant expression.
+  Token Value = Tok;
+
+  Token CloseParen;
+  if (ValueInParens) {
+    PP.Lex(Tok);
+    if (Tok.isNot(tok::r_paren)) {
+      PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
+      return true;
+    }
+    CloseParen = Tok;
+  }
+
+  Info.PragmaName = PragmaName;
+  Info.Option = Option;
+  Info.Value = Value;
+  Info.HasValue = true;
+  Info.ValueInParens = ValueInParens;
+  if (Info.ValueInParens)
+    Info.CloseParen = CloseParen;
+
+  return false;
+}
+
 /// \brief Handle the \#pragma clang loop directive.
 ///  #pragma clang 'loop' loop-hints
 ///
 ///  loop-hints:
 ///    loop-hint loop-hints[opt]
 ///
 ///  loop-hint:
 ///    'vectorize' '(' loop-hint-keyword ')'

 ///
 /// The unroll and unroll_count directives control the concatenation
 /// unroller. Specifying unroll(enable) instructs llvm to try to
 /// unroll the loop completely, and unroll(disable) disables unrolling
 /// for the loop. Specifying unroll_count(_value_) instructs llvm to
 /// try to unroll the loop the number of times indicated by the value.
 /// If unroll(enable) and unroll_count are both specified only
 /// unroll_count takes effect.
+
 void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP,
                                          PragmaIntroducerKind Introducer,
                                          Token &Tok) {
-  Token Loop = Tok;
+  // Incoming token is "loop" from "#pragma clang loop".
+  Token PragmaName = Tok;
   SmallVector<Token, 1> TokenList;
 
   // Lex the optimization option and verify it is an identifier.
   PP.Lex(Tok);
   if (Tok.isNot(tok::identifier)) {
     PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
         << /*MissingOption=*/true << "";
     return;
   }
 
   while (Tok.is(tok::identifier)) {
     Token Option = Tok;
     IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
 
     bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->getName())
                            .Case("vectorize", true)
                            .Case("interleave", true)
                            .Case("unroll", true)
                            .Case("vectorize_width", true)
                            .Case("interleave_count", true)
                            .Case("unroll_count", true)
                            .Default(false);
     if (!OptionValid) {
       PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
           << /*MissingOption=*/false << OptionInfo;
       return;
     }
 
-    // Read '('
-    PP.Lex(Tok);
-    if (Tok.isNot(tok::l_paren)) {
-      PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
-      return;
-    }
-
-    // FIXME: All tokens between '(' and ')' should be stored and parsed as a
-    // constant expression.
+    auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
     PP.Lex(Tok);
-    if (Tok.is(tok::r_paren)) {
-      // Nothing between the parentheses.
-      PP.Diag(Tok.getLocation(), diag::err_pragma_loop_missing_argument)
-          << OptionInfo;
+    if (ParseLoopHintValue(PP, Tok, PragmaName, Option, *Info))
       return;
-    }
-    Token Value = Tok;
 
-    // Read ')'
-    PP.Lex(Tok);
-    if (Tok.isNot(tok::r_paren)) {
-      PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
+    if (!Info->ValueInParens) {
+      PP.Diag(Info->Value.getLocation(), diag::err_expected) << tok::l_paren;
       return;
     }
 
-    // Get next optimization option.
-    PP.Lex(Tok);
-
-    auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
-    Info->Loop = Loop;
-    Info->Option = Option;
-    Info->Value = Value;
-
-    // Generate the vectorization hint token.
+    // Generate the loop hint token.
     Token LoopHintTok;
     LoopHintTok.startToken();
     LoopHintTok.setKind(tok::annot_pragma_loop_hint);
-    LoopHintTok.setLocation(Loop.getLocation());
+    LoopHintTok.setLocation(PragmaName.getLocation());
     LoopHintTok.setAnnotationValue(static_cast<void *>(Info));
     TokenList.push_back(LoopHintTok);
+
+    // Get next optimization option.
+    PP.Lex(Tok);
   }
 
   if (Tok.isNot(tok::eod)) {
     PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
         << "clang loop";
     return;
   }
 
   Token *TokenArray = new Token[TokenList.size()];
   std::copy(TokenList.begin(), TokenList.end(), TokenArray);
 
   PP.EnterTokenStream(TokenArray, TokenList.size(),
                       /*DisableMacroExpansion=*/false,
                       /*OwnsTokens=*/true);
 }
+
+/// \brief Handle the loop unroll optimization pragmas.
+///  #pragma unroll
+///  #pragma nounroll
+///  #pragma unroll unroll-hint-value
+///  #pragma unroll '(' unroll-hint-value ')'
+///
+///  unroll-hint-value:
+///    constant-expression
+///
+/// Loop unrolling hints are specified with '#pragma unroll' and
+/// '#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. '#pragma nounroll' indicates that
+/// the loop should not be unrolled.
+void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP,
+                                           PragmaIntroducerKind Introducer,
+                                           Token &Tok) {
+  // 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)) {
+    // nounroll pragma or unroll pragma without a argument.
+    Info->PragmaName = PragmaName;
+    Info->Option = PragmaName;
+    Info->HasValue = false;
+    Info->ValueInParens = 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)".
+    if (ParseLoopHintValue(PP, Tok, PragmaName, PragmaName, *Info))
+      return;
+    PP.Lex(Tok);
+
+    if (Tok.isNot(tok::eod)) {
+      PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
+          << "unroll";
+      return;
+    }
+  }
+
+  // Generate the hint token.
+  Token *TokenArray = new Token[1];
+  TokenArray[0].startToken();
+  TokenArray[0].setKind(tok::annot_pragma_loop_hint);
+  TokenArray[0].setLocation(PragmaName.getLocation());
+  TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
+  PP.EnterTokenStream(TokenArray, 1, /*DisableMacroExpansion=*/false,
+                      /*OwnsTokens=*/true);
+}

lib/Parse/ParseStmt.cpp

 }
 
 StmtResult Parser::ParsePragmaLoopHint(StmtVector &Stmts, bool OnlyStatement,
                                        SourceLocation *TrailingElseLoc,
                                        ParsedAttributesWithRange &Attrs) {
   // Create temporary attribute list.
   ParsedAttributesWithRange TempAttrs(AttrFactory);
 
-  // Get vectorize hints and consume annotated token.
+  // Get loop hints and consume annotated token.
   while (Tok.is(tok::annot_pragma_loop_hint)) {
     LoopHint Hint = HandlePragmaLoopHint();
     ConsumeToken();
 
-    if (!Hint.LoopLoc || !Hint.OptionLoc || !Hint.ValueLoc)
-      continue;
-
-    ArgsUnion ArgHints[] = {Hint.OptionLoc, Hint.ValueLoc,
-                            ArgsUnion(Hint.ValueExpr)};
-    TempAttrs.addNew(Hint.LoopLoc->Ident, Hint.Range, nullptr,
-                     Hint.LoopLoc->Loc, ArgHints, 3, AttributeList::AS_Pragma);
+    ArgsUnion ArgHints[] = {Hint.PragmaNameLoc, Hint.OptionLoc, Hint.ValueLoc,
+                            Hint.CloseParenLoc, ArgsUnion(Hint.ValueExpr)};
+    TempAttrs.addNew(Hint.PragmaNameLoc->Ident, Hint.Range, nullptr,
+                     Hint.PragmaNameLoc->Loc, ArgHints, 5,
+                     AttributeList::AS_Pragma);
   }
 
   // Get the next statement.
   MaybeParseCXX11Attributes(Attrs);
 
   StmtResult S = ParseStatementOrDeclarationAfterAttributes(
       Stmts, OnlyStatement, TrailingElseLoc, Attrs);
 

lib/Sema/SemaStmtAttr.cpp

if (S.getCurFunction()->SwitchStack.empty()) {
     return nullptr;
   }
   return ::new (S.Context) FallThroughAttr(A.getRange(), S.Context,
                                            A.getAttributeSpellingListIndex());
 }
 
 static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const AttributeList &A,
                                 SourceRange) {
+  IdentifierLoc *PragmaNameLoc = A.getArgAsIdent(0);
+  IdentifierLoc *OptionLoc = A.getArgAsIdent(1);
+  IdentifierInfo *OptionInfo = OptionLoc->Ident;
+  IdentifierLoc *ValueLoc = A.getArgAsIdent(2);
+  IdentifierInfo *ValueInfo = ValueLoc ? ValueLoc->Ident : nullptr;
+  IdentifierLoc *CloseParenLoc = A.getArgAsIdent(3);
+  Expr *ValueExpr = A.getArgAsExpr(4);
+
+  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) {
-    S.Diag(St->getLocStart(), diag::err_pragma_loop_precedes_nonloop);
+    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;
   }
 
-  IdentifierLoc *OptionLoc = A.getArgAsIdent(0);
-  IdentifierInfo *OptionInfo = OptionLoc->Ident;
-  IdentifierLoc *ValueLoc = A.getArgAsIdent(1);
-  IdentifierInfo *ValueInfo = ValueLoc->Ident;
-  Expr *ValueExpr = A.getArgAsExpr(2);
-
-  assert(OptionInfo && "Attribute must have valid option info.");
-
-  LoopHintAttr::OptionType Option =
-      llvm::StringSwitch<LoopHintAttr::OptionType>(OptionInfo->getName())
+  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::Vectorize || Option == LoopHintAttr::Interleave ||
+  if (Spelling == LoopHintAttr::Pragma_nounroll ||
+      (Option == LoopHintAttr::Unroll &&
+       Spelling == LoopHintAttr::Pragma_unroll)) {
+    ValueInt = (Spelling == LoopHintAttr::Pragma_nounroll ? 0 : 1);
+  } else if (Option == LoopHintAttr::Vectorize ||
+             Option == LoopHintAttr::Interleave ||
              Option == LoopHintAttr::Unroll) {
     if (!ValueInfo) {
       S.Diag(ValueLoc->Loc, diag::err_pragma_loop_invalid_keyword);
       return nullptr;
     }
     if (ValueInfo->isStr("disable"))
       ValueInt = 0;
     else if (ValueInfo->isStr("enable"))
       ValueInt = 1;
if (Spelling == LoopHintAttr::Pragma_nounroll ||
     if (!ValueExpr || !ValueExpr->isIntegerConstantExpr(ValueAPS, S.Context) ||
         (ValueInt = ValueAPS.getSExtValue()) < 1) {
       S.Diag(ValueLoc->Loc, diag::err_pragma_loop_invalid_value);
       return nullptr;
     }
   } else
     llvm_unreachable("Unknown loop hint option");
 
-  return LoopHintAttr::CreateImplicit(S.Context, Option, ValueInt,
-                                      A.getRange());
+  return LoopHintAttr::CreateImplicit(
+      S.Context, Spelling, Option, ValueInt,
+      /*ValueInParens=*/CloseParenLoc != nullptr, A.getRange());
 }
 
-static void
-CheckForIncompatibleAttributes(Sema &S, SmallVectorImpl<const Attr *> &Attrs) {
+static void CheckForIncompatibleAttributes(
+    Sema &S, const SmallVectorImpl<const Attr *> &Attrs) {
   // There are 3 categories of loop hints: vectorize, interleave, and
   // unroll. Each comes in two variants: an enable/disable form and a
   // form which takes a numeric argument. For example:
   // unroll(enable|disable) and unroll_count(N). The following array
   // accumulate the hints encountered while iterating through the
   // attributes to check for compatibility.
   struct {
-    int EnableOptionId;
-    int NumericOptionId;
-    bool EnabledIsSet;
-    bool ValueIsSet;
-    bool Enabled;
-    int Value;
-  } Options[] = {{LoopHintAttr::Vectorize, LoopHintAttr::VectorizeWidth, false,
-                  false, false, 0},
-                 {LoopHintAttr::Interleave, LoopHintAttr::InterleaveCount,
-                  false, false, false, 0},
-                 {LoopHintAttr::Unroll, LoopHintAttr::UnrollCount, false, false,
-                  false, 0}};
+    const LoopHintAttr *EnableAttr;
+    const LoopHintAttr *NumericAttr;
+  } HintAttrs[] = {{nullptr, nullptr}, {nullptr, nullptr}, {nullptr, nullptr}};
 
   for (const auto *I : Attrs) {
     const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(I);
 
     // Skip non loop hint attributes
     if (!LH)
       continue;
 
     int Option = LH->getOption();
-    int ValueInt = LH->getValue();
-
     int Category;
     switch (Option) {
     case LoopHintAttr::Vectorize:
     case LoopHintAttr::VectorizeWidth:
       Category = 0;
       break;
     case LoopHintAttr::Interleave:
     case LoopHintAttr::InterleaveCount:
       Category = 1;
       break;
     case LoopHintAttr::Unroll:
     case LoopHintAttr::UnrollCount:
       Category = 2;
       break;
     };
 
-    auto &CategoryState = Options[Category];
-    SourceLocation ValueLoc = LH->getRange().getEnd();
+    auto &CategoryState = HintAttrs[Category];
+    SourceLocation OptionLoc = LH->getRange().getBegin();
     if (Option == LoopHintAttr::Vectorize ||
         Option == LoopHintAttr::Interleave || Option == LoopHintAttr::Unroll) {
       // Enable|disable hint.  For example, vectorize(enable).
-      if (CategoryState.EnabledIsSet) {
+      if (CategoryState.EnableAttr) {
         // Cannot specify enable/disable state twice.
-        S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
-            << /*Duplicate=*/true << LoopHintAttr::getOptionName(Option)
-            << LoopHintAttr::getValueName(CategoryState.Enabled)
-            << LoopHintAttr::getOptionName(Option)
-            << LoopHintAttr::getValueName(ValueInt);
+        S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
+            << /*Duplicate=*/true
+            << CategoryState.EnableAttr->getDiagnosticName()
+            << LH->getDiagnosticName();
       }
-      CategoryState.EnabledIsSet = true;
-      CategoryState.Enabled = ValueInt;
+      CategoryState.EnableAttr = LH;
     } else {
-      // Numeric hint.  For example, unroll_count(8).
-      if (CategoryState.ValueIsSet) {
+      // Numeric hint.  For example, vectorize_width(8).
+      if (CategoryState.NumericAttr) {
         // Cannot specify numeric hint twice.
-        S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
-            << /*Duplicate=*/true << LoopHintAttr::getOptionName(Option)
-            << CategoryState.Value << LoopHintAttr::getOptionName(Option)
-            << ValueInt;
+        S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
+            << /*Duplicate=*/true
+            << CategoryState.NumericAttr->getDiagnosticName()
+            << LH->getDiagnosticName();
       }
-      CategoryState.ValueIsSet = true;
-      CategoryState.Value = ValueInt;
+      CategoryState.NumericAttr = LH;
     }
 
-    if (CategoryState.EnabledIsSet && !CategoryState.Enabled &&
-        CategoryState.ValueIsSet) {
+    if (CategoryState.EnableAttr && !CategoryState.EnableAttr->getValue() &&
+        CategoryState.NumericAttr) {
       // Disable hints are not compatible with numeric hints of the
       // same category.
-      S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
+      S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
           << /*Duplicate=*/false
-          << LoopHintAttr::getOptionName(CategoryState.EnableOptionId)
-          << LoopHintAttr::getValueName(CategoryState.Enabled)
-          << LoopHintAttr::getOptionName(CategoryState.NumericOptionId)
-          << CategoryState.Value;
+          << CategoryState.EnableAttr->getDiagnosticName()
+          << CategoryState.NumericAttr->getDiagnosticName();
     }
   }
 }
 
 static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const AttributeList &A,
                                   SourceRange Range) {
   switch (A.getKind()) {
   case AttributeList::UnknownAttribute:

test/CodeGen/pragma-unroll.cpp

+// RUN: %clang_cc1 -triple x86_64-apple-darwin -std=c++11 -emit-llvm -o - %s | FileCheck %s
+
+// Verify while loop is recognized after unroll pragma.
+void while_test(int *List, int Length) {
+  // CHECK: define {{.*}} @_Z10while_test
+  int i = 0;
+
+#pragma unroll
+  while (i < Length) {
+    // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_1:.*]]
+    List[i] = i * 2;
+    i++;
+  }
+}
+
+// Verify do loop is recognized after multi-option pragma clang loop directive.
+void do_test(int *List, int Length) {
+  int i = 0;
+
+#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 for_test(int *List, int Length) {
+#pragma unroll 8
+  for (int i = 0; i < Length; i++) {
+    // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_3:.*]]
+    List[i] = i * 2;
+  }
+}
+
+// Verify c++11 for range loop is recognized after unroll pragma.
+void for_range_test() {
+  double List[100];
+
+#pragma unroll(4)
+  for (int i : List) {
+    // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_4:.*]]
+    List[i] = i;
+  }
+}
+
+#define UNROLLCOUNT 8
+
+// Verify defines are correctly resolved in unroll pragmas.
+void for_define_test(int *List, int Length, int Value) {
+#pragma unroll(UNROLLCOUNT)
+  for (int i = 0; i < Length; i++) {
+    // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_5:.*]]
+    List[i] = i * Value;
+  }
+}
+
+// Verify metadata is generated when template is used.
+template <typename A>
+void for_template_test(A *List, int Length, A Value) {
+#pragma unroll 8
+  for (int i = 0; i < Length; i++) {
+    // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_6:.*]]
+    List[i] = i * Value;
+  }
+}
+
+// Verify define is resolved correctly when template is used.
+template <typename A>
+void for_template_define_test(A *List, int Length, A Value) {
+#pragma unroll(UNROLLCOUNT)
+  for (int i = 0; i < Length; i++) {
+    // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_7:.*]]
+    List[i] = i * Value;
+  }
+}
+
+#undef UNROLLCOUNT
+
+// Use templates defined above. Test verifies metadata is generated correctly.
+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 ![[UNROLLENABLE_1:.*]]}
+// CHECK: ![[UNROLLENABLE_1]] = metadata !{metadata !"llvm.loop.unroll.enable", i1 true}
+// CHECK: ![[LOOP_2]] = metadata !{metadata ![[LOOP_2:.*]], metadata ![[UNROLLENABLE_0:.*]]}
+// CHECK: ![[UNROLLENABLE_0]] = metadata !{metadata !"llvm.loop.unroll.enable", i1 false}
+// 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

 // RUN: %clang_cc1 -emit-pch -o %t.a %s
 // RUN: %clang_cc1 -include-pch %t.a %s -ast-print -o - | FileCheck %s
 
 // FIXME: A bug in ParsedAttributes causes the order of the attributes to be
 // reversed. The checks are consequently in the reverse order below.
 
 // CHECK: #pragma clang loop unroll_count(16)
 // CHECK: #pragma clang loop interleave_count(8)
 // CHECK: #pragma clang loop vectorize_width(4)
 // CHECK: #pragma clang loop unroll(disable)
 // CHECK: #pragma clang loop interleave(disable)
 // CHECK: #pragma clang loop vectorize(enable)
 // CHECK: #pragma clang loop unroll(enable)
 // CHECK: #pragma clang loop interleave(enable)
 // CHECK: #pragma clang loop vectorize(disable)
+// CHECK: #pragma unroll
+// CHECK: #pragma nounroll
+// CHECK: #pragma unroll 32
+// CHECK: #pragma unroll (4)
 
 #ifndef HEADER
 #define HEADER
 
 class pragma_test {
 public:
   inline void run1(int *List, int Length) {
     int i = 0;

 #pragma clang loop vectorize(disable)
 #pragma clang loop interleave(enable)
 #pragma clang loop unroll(enable)
     while (i - 3 < Length) {
       List[i] = i;
       i++;
     }
   }
+
+  inline void run4(int *List, int Length) {
+    int i = 0;
+#pragma unroll
+    while (i - 3 < Length) {
+      List[i] = i;
+      i++;
+    }
+  }
+
+  inline void run5(int *List, int Length) {
+    int i = 0;
+#pragma nounroll
+    while (i - 3 < Length) {
+      List[i] = i;
+      i++;
+    }
+  }
+
+  inline void run6(int *List, int Length) {
+    int i = 0;
+#pragma unroll 32
+    while (i - 3 < Length) {
+      List[i] = i;
+      i++;
+    }
+  }
+
+  inline void run7(int *List, int Length) {
+    int i = 0;
+#pragma unroll(4)
+    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);
+  pt.run7(List, 100);
 }
 
 #endif

test/Parser/pragma-loop.cpp

 /* expected-error {{expected ')'}} */ #pragma clang loop vectorize(enable
 /* expected-error {{expected ')'}} */ #pragma clang loop interleave(enable
 /* expected-error {{expected ')'}} */ #pragma clang loop unroll(enable
 
 /* expected-error {{expected ')'}} */ #pragma clang loop vectorize_width(4
 /* expected-error {{expected ')'}} */ #pragma clang loop interleave_count(4
 /* expected-error {{expected ')'}} */ #pragma clang loop unroll_count(4
 
-/* expected-error {{missing argument to loop pragma 'vectorize'}} */ #pragma clang loop vectorize()
-/* expected-error {{missing argument to loop pragma 'interleave_count'}} */ #pragma clang loop interleave_count()
-/* expected-error {{missing argument to loop pragma 'unroll'}} */ #pragma clang loop unroll()
+/* expected-error {{missing argument to 'vectorize' directive}} */ #pragma clang loop vectorize()
+/* expected-error {{missing argument to 'interleave_count' directive}} */ #pragma clang loop interleave_count()
+/* expected-error {{missing argument to 'unroll' directive}} */ #pragma unroll()
 
 /* expected-error {{missing option}} */ #pragma clang loop
 /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop badkeyword
 /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop badkeyword(enable)
 /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop vectorize(enable) badkeyword(4)
 /* expected-warning {{extra tokens at end of '#pragma clang loop'}} */ #pragma clang loop vectorize(enable) ,
 
   while (i-4 < Length) {

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;
+  }
+
+#pragma unroll
+#pragma unroll(8)
+  while (i - 3 < Length) {
+    List[i] = i;
+  }
+
+#pragma clang loop unroll(enable)
+#pragma unroll(8)
+  while (i - 4 < Length) {
+    List[i] = i;
+  }
+
+#pragma unroll
+#pragma clang loop unroll_count(4)
+  while (i - 5 < Length) {
+    List[i] = i;
+  }
+
+/* expected-error {{expected ')'}} */ #pragma unroll(4
+/* expected-error {{missing argument to 'unroll' directive}} */ #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 the '#pragma unroll' directive}} */ int j = Length;
+#pragma unroll 4
+/* expected-error {{expected a for, while, or do-while loop to follow the '#pragma unroll' directive}} */ int k = Length;
+#pragma nounroll
+/* expected-error {{expected a for, while, or do-while loop to follow the '#pragma nounroll' directive}} */ int l = Length;
+
+/* expected-error {{incompatible directives '#pragma nounroll' and '#pragma unroll 4'}} */ #pragma unroll 4
+#pragma nounroll
+  while (i-9 < Length) {
+    List[i] = i;
+  }
+
+/* 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 '#pragma nounroll' and 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4)
+#pragma nounroll
+  while (i-11 < Length) {
+    List[i] = i;
+  }
+
+/* expected-error {{duplicate directives '#pragma nounroll' and '#pragma nounroll'}} */ #pragma nounroll
+#pragma nounroll
+  while (i-12 < Length) {
+    List[i] = i;
+  }
+
+/* expected-error {{duplicate directives '#pragma nounroll' and '#pragma unroll'}} */ #pragma unroll
+#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(enable)' and '#pragma unroll'}} */ #pragma unroll
+#pragma clang loop unroll(enable)
+  while (i-15 < Length) {
+    List[i] = i;
+  }
+
+/* expected-error {{duplicate directives '#pragma unroll (4)' and '#pragma unroll 4'}} */ #pragma unroll 4
+#pragma unroll (4)
+  while (i-16 < Length) {
+    List[i] = i;
+  }
+
+#pragma unroll
+/* expected-error {{expected statement}} */ }