[OpenCL] Generate metadata for opencl_unroll_hint attribute

[yaxunl]

Summary

Add codegen and diagnostics for opencl_unroll_hint attribute as OpenCL v2.0 s6.11.5.

The code is based on Khronos OpenCL compiler (https://github.com/KhronosGroup/SPIR/tree/spirv-1.0).

Differential Revision: http://reviews.llvm.org/D16686

[pxli168]

include/clang/Basic/DiagnosticSemaKinds.td

7661 ↗

(On Diff #46288)

opencl_unroll_hint attribute

lib/Sema/SemaStmtAttr.cpp

216 ↗

(On Diff #46288)

miss a test to hit this.

test/Parser/opencl-unroll-hint.cl

7 ↗

(On Diff #46288)

Seems only this is a parser check?
You should put others in test/SemaOpenCL/

[pxli168]

include/clang/Basic/DiagnosticParseKinds.td

906 ↗

(On Diff #46288)

you can change it to opencl_unroll_hint attribute

[Anastasia]

include/clang/Basic/Attr.td

661 ↗

(On Diff #46288)

I think undocumented is not allowed any longer.

I suggest you to check OpenCLGenericAddressSpace here and also OpenCLAddressSpaceGenericDocs in AttrDocs.td for an example how it can be done!

lib/CodeGen/CGLoopInfo.cpp

126 ↗

(On Diff #46288)

I would like to see a bit of comments here and may be reference to spec if possible!

lib/Parse/ParseStmt.cpp

111 ↗

(On Diff #46288)

May be it's better to wrap in into MaybeParseOpenCLAttributes function to be consistent with the rest?

117 ↗

(On Diff #46288)

I am just thinking could we avoid checks on line 115 that are a bit complicated to read.

Could we just try to check if the attrList is empty or not. And if not NULL check the name of the attribute etc...

118 ↗

(On Diff #46288)

Assertion should have a message!

NULL -> nullptr

lib/Sema/SemaStmtAttr.cpp

210 ↗

(On Diff #46288)

Could you put a reference to spec here?

213 ↗

(On Diff #46288)

Variable names are not inline with the coding style.

Please, see:
http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

224 ↗

(On Diff #46288)

Assert should have a message!

227 ↗

(On Diff #46288)

Do we need these two checks? Seems C++ related.

230 ↗

(On Diff #46288)

This line is too long. Please make sure to format your code correctly.

Run clang-format on the final patch:

http://clang.llvm.org/docs/ClangFormat.html

234 ↗

(On Diff #46288)

could it be just an int type?

test/Parser/opencl-unroll-hint.cl

20 ↗

(On Diff #46288)

could we remove an empty line here please?

23 ↗

(On Diff #46288)

I think similarly to the test kernel below, we don't really need anything in the loop body... just to make the test simpler to understand. :)

[yaxunl]

Revised as Anastasia and Xiuli suggested.

[yaxunl]

update the tests.

[Anastasia]

include/clang/Parse/Parser.h

2200 ↗

(On Diff #46526)

May be better:
OpenCL 2.0+ -> OpenCL v2.0 or higher

lib/CodeGen/CGLoopInfo.cpp

131 ↗

(On Diff #46526)

Just to match the other comment style:

OpenCL 2.0 spec section 6.11.5 -> OpenCL v2.0 s6.11.5

lib/Sema/SemaStmtAttr.cpp

212 ↗

(On Diff #46526)

OpenCL v2.0 s6.11.5

221 ↗

(On Diff #46526)

Variable names are still not compliant to coding style. Could you please change.

234 ↗

(On Diff #46526)

Could you please change the type to int to match similar code in other places.

235 ↗

(On Diff #46526)

Also could you change variable name here too and in other places to follow the coding style.

test/CodeGenOpenCL/unroll-hint.cl

9 ↗

(On Diff #46526)

I would make all loops with an empty body here too as it doesn't play any role in testing. :)

[yaxunl]

Revised as Anastasia suggested.

[pxli168]

test/SemaOpenCL/unroll-hint.cl

22 ↗

(On Diff #46434)

It seems the negative integer invalid test is missing?
I think it was in your last diff.

[yaxunl]

Add test for negative unroll hint value as suggested by Xiuli.

[pxli168]

lib/Sema/SemaStmtAttr.cpp

208 ↗

(On Diff #46608)

This is also not necessary because this function can be called only if it is an OpenCLUnrollHint

210 ↗

(On Diff #46608)

You may put the reference at the begin and make a summary after that, I don't think see ... for details is need.
Just like what other OpenCL references.

217 ↗

(On Diff #46608)

def err_attribute_too_many_arguments : Error<"%0 attribute takes no more than %1 argument%s1">;

you should give this two arguments, one is name and another is the number you expected.

218 ↗

(On Diff #46608)

please use nullptr
should not use 0 in C++11.

225 ↗

(On Diff #46608)

Is this necessary as you have checked there is only one arg in this attr?

230 ↗

(On Diff #46608)

Why there is two getName?

test/SemaOpenCL/unroll-hint.cl

17 ↗

(On Diff #46608)

I think

expected-error {{1 attribute takes no more than 1 argument}}

should be opencl_unroll_hint

[Anastasia]

lib/Sema/SemaStmtAttr.cpp

225 ↗

(On Diff #46608)

I guess this might be the case if it's not an Expr, but not sure what else it could be. I think we probably don't need it.

230 ↗

(On Diff #46608)

1st returns IdentifierInfo and 2nd actual StringRef.

[yaxunl]

Revised as Xiuli and Anastasia suggested.

[pxli168]

lib/Sema/SemaStmtAttr.cpp

216 ↗

(On Diff #46651)

I think you should not use hard code here, just use A.getName(). And diag will find a good way to output is.

230 ↗

(On Diff #46651)

I think diag did not need StringRef, A.getName() is enough. It is Diag's job to find the best output form.

[yaxunl]

Revised as Xiuli suggested.

With the change, there will be quotation marks around the attribute name, so other diagnostics are also changed to be consistent.

[Anastasia]

lib/Sema/SemaStmtAttr.cpp

230 ↗

(On Diff #46783)

0 -> nullptr

[yaxunl]

Revised as Anastasia suggested.

[pxli168]

lib/CodeGen/CGLoopInfo.cpp

131 ↗

(On Diff #46838)

Can you also change this comment to the style that reference go first then summary.

lib/Sema/SemaStmtAttr.cpp

224 ↗

(On Diff #46838)

Should this assert be here?
Can it be something else?
And you shuold just use assert(E && ....).

test/SemaOpenCL/unroll-hint.cl

1 ↗

(On Diff #46838)

What will happen if using OpenCL 1.2 or 1.1 that earlier than 2.0?
You can also make a test for it, and can change this test case to
unroll-hint-cl2.0.cl
as you can see other cl2.0 features in the folder.

[yaxunl]

Revised as Xiuli suggested.
Add test for OpenCL below 2.0.
Add diagnostic for opencl_unroll_hint attribute used below OpenCL 2.0.

[pxli168]

Hi Pekka/Anastasia,

I find that most of the attribute parses was done in ParseDecl.cpp, should this also be in there?

Thanks
Xiuli

lib/Parse/ParseStmt.cpp

2214 ↗

(On Diff #46961)

I am wondering where should this function goes in, here or ParseDecl.cpp.

2220 ↗

(On Diff #46961)

Using string is not very strict, can use AttributeList Kind to check that.

Attrs.getList()->getKind() != AttributeList::AT_OpenCLUnrollHint

test/SemaOpenCL/unroll-hint.cl

1 ↗

(On Diff #46961)

I think one test case here is enough, since they all hint the same code.

[Anastasia]

lib/Parse/ParseStmt.cpp

2214 ↗

(On Diff #46961)

ParseGNUAttributes is in ParseDecl.cpp, but may be because it's generally applicable to Decls?

I am not aware of any rule here.

[pxli168]

Hi richard,

What is your opinion about where to put this ParseOpenCLUnrollHintAttribute?

Thanks
Xiuli

lib/Parse/ParseStmt.cpp

2214 ↗

(On Diff #46961)

Maybe we could ask richard for help?

[Anastasia]

lib/Parse/ParseStmt.cpp

2214 ↗

(On Diff #46961)

I am thinking of leaving it here for now as we are almost done.

We can always do fixes later on!

2220 ↗

(On Diff #46961)

ping!

test/SemaOpenCL/unroll-hint.cl

1 ↗

(On Diff #46961)

ping!

[yaxunl]

Sorry for the delay.

Revised as Xiuli suggested.

[Anastasia]

test/SemaOpenCL/unroll-hint-cl20.cl

1 ↗

(On Diff #47337)

Could we just combine this with test/SemaOpenCL/unroll-hint.cl.

You can have two RUN lines and pass something like -DCL20 in one of them (for CL2.0). It will then allow you to #ifdef the CL2.0 code. You can see the example in:

test/Parser/opencl-atomics-cl20.cl

[yaxunl]

merge two sema tests as one as Anastasia suggested.

[Anastasia]

LGTM!

lib/CodeGen/CGLoopInfo.cpp

134 ↗

(On Diff #47460)

. missing

[yaxunl]

Revised as Anastasia suggested.

Changed comments.

[Anastasia]

@pekka, Xiuli, Richard, any more comments here?

Thanks!

[pekka.jaaskelainen]

LGTM.

[yaxunl]

ping

[pxli168]

Sorry for the late reply, I was on a break.
LGTM!

cfe/trunk/include/clang/Basic/Attr.td

 }
 
 def OpenCLKernel : InheritableAttr {
   let Spellings = [Keyword<"__kernel">, Keyword<"kernel">];
   let Subjects = SubjectList<[Function], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
+def OpenCLUnrollHint : InheritableAttr {
+  let Spellings = [GNU<"opencl_unroll_hint">];
+  let Args = [UnsignedArgument<"UnrollHint">];
+  let Documentation = [OpenCLUnrollHintDocs];
+}
+
 // This attribute is both a type attribute, and a declaration attribute (for
 // parameter variables).
 def OpenCLImageAccess : Attr {
   let Spellings = [Keyword<"__read_only">, Keyword<"read_only">,
                    Keyword<"__write_only">, Keyword<"write_only">,
                    Keyword<"__read_write">, Keyword<"read_write">];
   let Subjects = SubjectList<[ParmVar], ErrorDiag>;
   let Accessors = [Accessor<"isReadOnly", [Keyword<"__read_only">,

cfe/trunk/include/clang/Basic/AttrDocs.td

 ``#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.
   }];
 }
 
+def OpenCLUnrollHintDocs : Documentation {
+  let Category = DocCatStmt;
+  let Heading = "__attribute__((opencl_unroll_hint))";
+  let Content = [{
+The opencl_unroll_hint attribute qualifier can be used to specify that a loop
+(for, while and do loops) can be unrolled. This attribute qualifier can be
+used to specify full unrolling or partial unrolling by a specified amount.
+This is a compiler hint and the compiler may ignore this directive. See
+`OpenCL v2.0 <https://www.khronos.org/registry/cl/specs/opencl-2.0.pdf>`_
+s6.11.5 for details.
+  }];
+}
+
 def DocOpenCLAddressSpaces : DocumentationCategory<"OpenCL Address Spaces"> {
   let Content = [{
 The address space qualifier may be used to specify the region of memory that is
 used to allocate the object. OpenCL supports the following address spaces:
 __generic(generic), __global(global), __local(local), __private(private),
 __constant(constant).
 
   .. code-block:: c

cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td

def err_pragma_pointers_to_members_unknown_kind : Error<
   "'single_inheritance', 'multiple_inheritance', or 'virtual_inheritance'">;
 // - #pragma clang optimize on/off
 def err_pragma_optimize_invalid_argument : Error<
   "unexpected argument '%0' to '#pragma clang optimize'; "
   "expected 'on' or 'off'">;
 def err_pragma_optimize_extra_argument : Error<
   "unexpected extra argument '%0' to '#pragma clang optimize'">;
 
+def err_opencl_unroll_hint_on_non_loop : Error<
+  "OpenCL only supports 'opencl_unroll_hint' attribute on for, while, and do statements">;
+
 // OpenCL EXTENSION pragma (OpenCL 1.1 [9.1])
 def warn_pragma_expected_colon : Warning<
   "missing ':' after %0 - ignoring">, InGroup<IgnoredPragmas>;
 def warn_pragma_expected_enable_disable : Warning<
   "expected 'enable' or 'disable' - ignoring">, InGroup<IgnoredPragmas>;
 def warn_pragma_unknown_extension : Warning<
   "unknown OpenCL extension %0 - ignoring">, InGroup<IgnoredPragmas>;
 

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def err_attribute_wrong_number_arguments : Error<
   ":requires exactly %1 arguments}1">;
 def err_attribute_too_many_arguments : Error<
   "%0 attribute takes no more than %1 argument%s1">;
 def err_attribute_too_few_arguments : Error<
   "%0 attribute takes at least %1 argument%s1">;
 def err_attribute_invalid_vector_type : Error<"invalid vector element type %0">;
 def err_attribute_bad_neon_vector_size : Error<
   "Neon vector size must be 64 or 128 bits">;
+def err_attribute_requires_positive_integer : Error<
+  "%0 attribute requires a positive integral compile time constant expression">;
+def err_attribute_requires_opencl_version : Error<
+  "%0 attribute requires OpenCL version %1 or above">;
 def warn_unsupported_target_attribute
     : Warning<"Ignoring unsupported '%0' in the target attribute string">,
     InGroup<IgnoredAttributes>;
 def err_attribute_unsupported
     : Error<"%0 attribute is not supported for this target">;
 // The err_*_attribute_argument_not_int are seperate because they're used by
 // VerifyIntegerConstantExpression.
 def err_aligned_attribute_argument_not_int : Error<

cfe/trunk/include/clang/Parse/Parser.h

private:
   bool ParseMicrosoftDeclSpecArgs(IdentifierInfo *AttrName,
                                   SourceLocation AttrNameLoc,
                                   ParsedAttributes &Attrs);
   void ParseMicrosoftTypeAttributes(ParsedAttributes &attrs);
   void DiagnoseAndSkipExtendedMicrosoftTypeAttributes();
   SourceLocation SkipExtendedMicrosoftTypeAttributes();
   void ParseMicrosoftInheritanceClassAttributes(ParsedAttributes &attrs);
   void ParseBorlandTypeAttributes(ParsedAttributes &attrs);
-  void ParseOpenCLAttributes(ParsedAttributes &attrs);
+  void ParseOpenCLKernelAttributes(ParsedAttributes &attrs);
   void ParseOpenCLQualifiers(ParsedAttributes &Attrs);
+  /// \brief Parses opencl_unroll_hint attribute if language is OpenCL v2.0
+  /// or higher.
+  /// \return false if error happens.
+  bool MaybeParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs) {
+    if (getLangOpts().OpenCL)
+      return ParseOpenCLUnrollHintAttribute(Attrs);
+    return true;
+  }
+  /// \brief Parses opencl_unroll_hint attribute.
+  /// \return false if error happens.
+  bool ParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs);
   void ParseNullabilityTypeSpecifiers(ParsedAttributes &attrs);
 
   VersionTuple ParseVersionTuple(SourceRange &Range);
   void ParseAvailabilityAttribute(IdentifierInfo &Availability,
                                   SourceLocation AvailabilityLoc,
                                   ParsedAttributes &attrs,
                                   SourceLocation *endLoc,
                                   IdentifierInfo *ScopeName,

cfe/trunk/lib/CodeGen/CGLoopInfo.cpp

 }
 
 void LoopInfoStack::push(BasicBlock *Header, clang::ASTContext &Ctx,
                          ArrayRef<const clang::Attr *> Attrs) {
 
   // Identify loop hint attributes from Attrs.
   for (const auto *Attr : Attrs) {
     const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(Attr);
+    const OpenCLUnrollHintAttr *OpenCLHint =
+        dyn_cast<OpenCLUnrollHintAttr>(Attr);
 
     // Skip non loop hint attributes
-    if (!LH)
+    if (!LH && !OpenCLHint) {
       continue;
+    }
 
-    auto *ValueExpr = LH->getValue();
+    LoopHintAttr::OptionType Option = LoopHintAttr::Unroll;
+    LoopHintAttr::LoopHintState State = LoopHintAttr::Disable;
     unsigned ValueInt = 1;
+    // Translate opencl_unroll_hint attribute argument to
+    // equivalent LoopHintAttr enums.
+    // OpenCL v2.0 s6.11.5:  
+    // 0 - full unroll (no argument).
+    // 1 - disable unroll.
+    // other positive integer n - unroll by n.
+    if (OpenCLHint) {
+      ValueInt = OpenCLHint->getUnrollHint();
+      if (ValueInt == 0) {
+        State = LoopHintAttr::Full;
+      } else if (ValueInt != 1) {
+        Option = LoopHintAttr::UnrollCount;
+        State = LoopHintAttr::Numeric;
+      }
+    } else if (LH) {
+      auto *ValueExpr = LH->getValue();
       if (ValueExpr) {
         llvm::APSInt ValueAPS = ValueExpr->EvaluateKnownConstInt(Ctx);
         ValueInt = ValueAPS.getSExtValue();
       }
 
-    LoopHintAttr::OptionType Option = LH->getOption();
-    LoopHintAttr::LoopHintState State = LH->getState();
+      Option = LH->getOption();
+      State = LH->getState();
+    }
     switch (State) {
     case LoopHintAttr::Disable:
       switch (Option) {
       case LoopHintAttr::Vectorize:
         // Disable vectorization by specifying a width of 1.
         setVectorizeWidth(1);
         break;
       case LoopHintAttr::Interleave:

cfe/trunk/lib/Parse/ParseDecl.cpp

void Parser::ParseBorlandTypeAttributes(ParsedAttributes &attrs) {
   while (Tok.is(tok::kw___pascal)) {
     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
     SourceLocation AttrNameLoc = ConsumeToken();
     attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
                  AttributeList::AS_Keyword);
   }
 }
 
-void Parser::ParseOpenCLAttributes(ParsedAttributes &attrs) {
+void Parser::ParseOpenCLKernelAttributes(ParsedAttributes &attrs) {
   // Treat these like attributes
   while (Tok.is(tok::kw___kernel)) {
     IdentifierInfo *AttrName = Tok.getIdentifierInfo();
     SourceLocation AttrNameLoc = ConsumeToken();
     attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
                  AttributeList::AS_Keyword);
   }
 }
while (1) {
 
     // Borland single token adornments.
     case tok::kw___pascal:
       ParseBorlandTypeAttributes(DS.getAttributes());
       continue;
 
     // OpenCL single token adornments.
     case tok::kw___kernel:
-      ParseOpenCLAttributes(DS.getAttributes());
+      ParseOpenCLKernelAttributes(DS.getAttributes());
       continue;
 
     // Nullability type specifiers.
     case tok::kw__Nonnull:
     case tok::kw__Nullable:
     case tok::kw__Null_unspecified:
       ParseNullabilityTypeSpecifiers(DS.getAttributes());
       continue;

cfe/trunk/lib/Parse/ParseStmt.cpp

 Parser::ParseStatementOrDeclaration(StmtVector &Stmts,
                                     AllowedContsructsKind Allowed,
                                     SourceLocation *TrailingElseLoc) {
 
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
 
   ParsedAttributesWithRange Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs, nullptr, /*MightBeObjCMessageSend*/ true);
+  if (!MaybeParseOpenCLUnrollHintAttribute(Attrs))
+    return StmtError();
 
   StmtResult Res = ParseStatementOrDeclarationAfterAttributes(
       Stmts, Allowed, TrailingElseLoc, Attrs);
 
   assert((Attrs.empty() || Res.isInvalid() || Res.isUsable()) &&
          "attributes on empty statement");
 
   if (Attrs.empty() || Res.isInvalid())
void Parser::ParseMicrosoftIfExistsStatement(StmtVector &Stmts) {
   // Condition is true, parse the statements.
   while (Tok.isNot(tok::r_brace)) {
     StmtResult R = ParseStatementOrDeclaration(Stmts, ACK_Any);
     if (R.isUsable())
       Stmts.push_back(R.get());
   }
   Braces.consumeClose();
 }
+
+bool Parser::ParseOpenCLUnrollHintAttribute(ParsedAttributes &Attrs) {
+  MaybeParseGNUAttributes(Attrs);
+
+  if (Attrs.empty())
+    return true;
+
+  if (Attrs.getList()->getKind() != AttributeList::AT_OpenCLUnrollHint)
+    return true;
+
+  if (!(Tok.is(tok::kw_for) || Tok.is(tok::kw_while) || Tok.is(tok::kw_do))) {
+    Diag(Tok, diag::err_opencl_unroll_hint_on_non_loop);
+    return false;
+  }
+  return true;
+}

cfe/trunk/lib/Sema/SemaStmtAttr.cpp

if (CategoryState.StateAttr && CategoryState.NumericAttr &&
       S.Diag(OptionLoc, diag::err_pragma_loop_compatibility)
           << /*Duplicate=*/false
           << CategoryState.StateAttr->getDiagnosticName(Policy)
           << CategoryState.NumericAttr->getDiagnosticName(Policy);
     }
   }
 }
 
+static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const AttributeList &A,
+                                    SourceRange Range) {
+  // OpenCL v2.0 s6.11.5 - opencl_unroll_hint can have 0 arguments (compiler
+  // determines unrolling factor) or 1 argument (the unroll factor provided
+  // by the user).
+
+  if (S.getLangOpts().OpenCLVersion < 200) {
+    S.Diag(A.getLoc(), diag::err_attribute_requires_opencl_version)
+        << A.getName() << "2.0";
+    return nullptr;
+  }
+
+  unsigned NumArgs = A.getNumArgs();
+
+  if (NumArgs > 1) {
+    S.Diag(A.getLoc(), diag::err_attribute_too_many_arguments) << A.getName()
+                                                               << 1;
+    return nullptr;
+  }
+
+  unsigned UnrollFactor = 0;
+
+  if (NumArgs == 1) {
+    Expr *E = A.getArgAsExpr(0);
+    llvm::APSInt ArgVal(32);
+
+    if (!E->isIntegerConstantExpr(ArgVal, S.Context)) {
+      S.Diag(A.getLoc(), diag::err_attribute_argument_type)
+          << A.getName() << AANT_ArgumentIntegerConstant << E->getSourceRange();
+      return nullptr;
+    }
+
+    int Val = ArgVal.getSExtValue();
+
+    if (Val <= 0) {
+      S.Diag(A.getRange().getBegin(),
+             diag::err_attribute_requires_positive_integer)
+          << A.getName();
+      return nullptr;
+    }
+    UnrollFactor = Val;
+  }
+
+  return OpenCLUnrollHintAttr::CreateImplicit(S.Context, UnrollFactor);
+}
+
 static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const AttributeList &A,
                                   SourceRange Range) {
   switch (A.getKind()) {
   case AttributeList::UnknownAttribute:
     S.Diag(A.getLoc(), A.isDeclspecAttribute() ?
            diag::warn_unhandled_ms_attribute_ignored :
            diag::warn_unknown_attribute_ignored) << A.getName();
     return nullptr;
   case AttributeList::AT_FallThrough:
     return handleFallThroughAttr(S, St, A, Range);
   case AttributeList::AT_LoopHint:
     return handleLoopHintAttr(S, St, A, Range);
+  case AttributeList::AT_OpenCLUnrollHint:
+    return handleOpenCLUnrollHint(S, St, A, Range);
   default:
     // if we're here, then we parsed a known attribute, but didn't recognize
     // it as a statement attribute => it is declaration attribute
     S.Diag(A.getRange().getBegin(), diag::err_attribute_invalid_on_stmt)
         << A.getName() << St->getLocStart();
     return nullptr;
   }
 }

cfe/trunk/test/CodeGenOpenCL/unroll-hint.cl

+// RUN: %clang_cc1 -emit-llvm -O0 -cl-std=CL2.0 -o - %s | FileCheck %s
+
+/*** for ***/
+void for_count()
+{
+// CHECK-LABEL: for_count
+    __attribute__((opencl_unroll_hint(8)))
+    for( int i = 0; i < 1000; ++i);
+// CHECK: br label %{{.*}}, !llvm.loop ![[FOR_COUNT:.*]]
+}
+
+void for_disable()
+{
+// CHECK-LABEL: for_disable
+    __attribute__((opencl_unroll_hint(1)))
+    for( int i = 0; i < 1000; ++i);
+// CHECK: br label %{{.*}}, !llvm.loop ![[FOR_DISABLE:.*]]
+}
+
+void for_full()
+{
+// CHECK-LABEL: for_full
+    __attribute__((opencl_unroll_hint))
+    for( int i = 0; i < 1000; ++i);
+// CHECK: br label %{{.*}}, !llvm.loop ![[FOR_FULL:.*]]
+}
+
+/*** while ***/
+void while_count()
+{
+// CHECK-LABEL: while_count
+    int i = 1000;
+    __attribute__((opencl_unroll_hint(8)))
+    while(i-->0);
+// CHECK: br label %{{.*}}, !llvm.loop ![[WHILE_COUNT:.*]]
+}
+
+void while_disable()
+{
+// CHECK-LABEL: while_disable
+    int i = 1000;
+    __attribute__((opencl_unroll_hint(1)))
+    while(i-->0);
+// CHECK: br label %{{.*}}, !llvm.loop ![[WHILE_DISABLE:.*]]
+}
+
+void while_full()
+{
+// CHECK-LABEL: while_full
+    int i = 1000;
+    __attribute__((opencl_unroll_hint))
+    while(i-->0);
+// CHECK: br label %{{.*}}, !llvm.loop ![[WHILE_FULL:.*]]
+}
+
+/*** do ***/
+void do_count()
+{
+// CHECK-LABEL: do_count
+    int i = 1000;
+    __attribute__((opencl_unroll_hint(8)))
+    do {} while(i--> 0);
+// CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !llvm.loop ![[DO_COUNT:.*]]
+}
+
+void do_disable()
+{
+// CHECK-LABEL: do_disable
+    int i = 1000;
+    __attribute__((opencl_unroll_hint(1)))
+    do {} while(i--> 0);
+// CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !llvm.loop ![[DO_DISABLE:.*]]
+}
+
+void do_full()
+{
+// CHECK-LABEL: do_full
+    int i = 1000;
+    __attribute__((opencl_unroll_hint))
+    do {} while(i--> 0);
+// CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}}, !llvm.loop ![[DO_FULL:.*]]
+}
+
+
+// CHECK: ![[FOR_COUNT]]     =  distinct !{![[FOR_COUNT]],  ![[COUNT:.*]]}
+// CHECK: ![[COUNT]]         =  !{!"llvm.loop.unroll.count", i32 8}
+// CHECK: ![[FOR_DISABLE]]   =  distinct !{![[FOR_DISABLE]],  ![[DISABLE:.*]]}
+// CHECK: ![[DISABLE]]       =  !{!"llvm.loop.unroll.disable"}
+// CHECK: ![[FOR_FULL]]      =  distinct !{![[FOR_FULL]],  ![[FULL:.*]]}
+// CHECK: ![[FULL]]          =  !{!"llvm.loop.unroll.full"}
+// CHECK: ![[WHILE_COUNT]]   =  distinct !{![[WHILE_COUNT]],    ![[COUNT]]}
+// CHECK: ![[WHILE_DISABLE]] =  distinct !{![[WHILE_DISABLE]],  ![[DISABLE]]}
+// CHECK: ![[WHILE_FULL]]    =  distinct !{![[WHILE_FULL]],     ![[FULL]]}
+// CHECK: ![[DO_COUNT]]      =  distinct !{![[DO_COUNT]],       ![[COUNT]]}
+// CHECK: ![[DO_DISABLE]]    =  distinct !{![[DO_DISABLE]],     ![[DISABLE]]}
+// CHECK: ![[DO_FULL]]       =  distinct !{![[DO_FULL]],        ![[FULL]]}

cfe/trunk/test/Parser/opencl-unroll-hint.cl

+//RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify %s
+
+kernel void B (global int *x) {
+  __attribute__((opencl_unroll_hint(42)))
+  if (x[0])                             // expected-error {{OpenCL only supports 'opencl_unroll_hint' attribute on for, while, and do statements}}
+    x[0] = 15;
+}
+

cfe/trunk/test/SemaOpenCL/unroll-hint.cl

+//RUN: %clang_cc1 -O0 -fsyntax-only -verify %s
+//RUN: %clang_cc1 -O0 -cl-std=CL2.0 -fsyntax-only -verify -DCL20 %s
+
+kernel void D (global int *x) {
+  int i = 10;
+#ifndef CL20
+  // expected-error@+2 {{'opencl_unroll_hint' attribute requires OpenCL version 2.0 or above}}
+#endif
+  __attribute__((opencl_unroll_hint))
+  do {
+  } while(i--);
+}
+
+#ifdef CL20
+kernel void C (global int *x) {
+  int I = 3;
+  __attribute__((opencl_unroll_hint(I))) // expected-error {{'opencl_unroll_hint' attribute requires an integer constant}}
+  while (I--);
+}
+
+kernel void E() {
+  __attribute__((opencl_unroll_hint(2,4))) // expected-error {{'opencl_unroll_hint' attribute takes no more than 1 argument}}
+  for(int i=0; i<100; i++);
+}
+
+kernel void F() {
+  __attribute__((opencl_unroll_hint(-1))) // expected-error {{'opencl_unroll_hint' attribute requires a positive integral compile time constant expression}}
+  for(int i=0; i<100; i++);
+}
+#endif