r210667 - Add loop unroll pragma support
Chandler Carruth
chandlerc at google.com
Thu Jun 12 11:46:38 PDT 2014
Ostensibly to keep finding new test failures with shorter blame lists. Not
a huge fan of this, but it seems legit.
On Thu, Jun 12, 2014 at 7:23 PM, Craig Topper <craig.topper at gmail.com>
wrote:
> Why do none of the bots build clang with clang with Werror?
>
>
> On Thu, Jun 12, 2014 at 10:32 AM, David Blaikie <dblaikie at gmail.com>
> wrote:
>
>> On Thu, Jun 12, 2014 at 9:22 AM, Eli Bendersky <eliben at google.com> wrote:
>> >
>> >
>> >
>> > On Thu, Jun 12, 2014 at 9:19 AM, Craig Topper <craig.topper at gmail.com>
>> > wrote:
>> >>
>> >> I believe -Wmissing-field-initializers is part of the -Wextra in clang.
>> >> Which looks to be on by default in our cmake files. Tough it also
>> looks to
>> >> be explicitly enabled for clang too
>> >>
>> >>
>> >> if (LLVM_ENABLE_WARNINGS)
>> >> append("-Wall -W -Wno-unused-parameter -Wwrite-strings"
>> CMAKE_C_FLAGS
>> >> CMAKE_CXX_FLAGS)
>> >>
>> >> # Turn off missing field initializer warnings for gcc to avoid
>> noise
>> >> from
>> >> # false positives with empty {}. Turn them on otherwise (they're
>> off
>> >> by
>> >> # default for clang).
>> >> check_cxx_compiler_flag("-Wmissing-field-initializers"
>> >> CXX_SUPPORTS_MISSING_FIELD_INITIALIZERS_FLAG)
>> >> if (CXX_SUPPORTS_MISSING_FIELD_INITIALIZERS_FLAG)
>> >> if (CMAKE_COMPILER_IS_GNUCXX)
>> >> append("-Wno-missing-field-initializers" CMAKE_C_FLAGS
>> >> CMAKE_CXX_FLAGS)
>> >> else()
>> >> append("-Wmissing-field-initializers" CMAKE_C_FLAGS
>> >> CMAKE_CXX_FLAGS)
>> >> endif()
>> >> endif()
>> >
>> >
>> > Ah, OK. I'm usually building with gcc 4.8.2 so I go through the GNUCXX
>> > branch, and have teh -Wno-missing-field-initializers flag tacked on
>> (which
>> > overrides -Wextra)
>>
>> Yep - if you don't use a near-ToT Clang you'll get both false
>> positives (warnings we don't clean up and possibly have no intention
>> of doing so) and negatives (code that doesn't warn for you, but you'll
>> find people quick to fix (or just complain at you) because it breaks
>> the clang -Werror build).
>>
>> Also we only tend to care about the performance of clang/LLVM when
>> build with itself.
>>
>> In short, it's generally recommended/encouraged that you dev Clang with
>> Clang.
>>
>> - David
>>
>> >
>> > Eli
>> >
>> >
>> >
>> >
>> >>
>> >>
>> >>
>> >> On Thu, Jun 12, 2014 at 8:57 AM, Eli Bendersky <eliben at google.com>
>> wrote:
>> >>>
>> >>>
>> >>>
>> >>>
>> >>> On Thu, Jun 12, 2014 at 8:35 AM, Eli Bendersky <eliben at google.com>
>> wrote:
>> >>>>
>> >>>> Looking into it...
>> >>>>
>> >>>>
>> >>>> On Wed, Jun 11, 2014 at 8:40 PM, Craig Topper <
>> craig.topper at gmail.com>
>> >>>> wrote:
>> >>>>>
>> >>>>> I seem to be getting this build failure after this commit with
>> -Werror
>> >>>>> enabled
>> >>>>>
>> >>>>> lib/Sema/SemaStmtAttr.cpp:132:59: error: missing field
>> 'EnabledIsSet'
>> >>>>> initializer [-Werror,-Wmissing-field-initializers]
>> >>>>>
>> >>>>> {LoopHintAttr::Vectorize, LoopHintAttr::VectorizeWidth},
>> >>>>>
>> >>>>> ^
>> >>>>>
>> >>>>> lib/Sema/SemaStmtAttr.cpp:133:61: error: missing field
>> 'EnabledIsSet'
>> >>>>> initializer [-Werror,-Wmissing-field-initializers]
>> >>>>>
>> >>>>> {LoopHintAttr::Interleave, LoopHintAttr::InterleaveCount},
>> >>>>>
>> >>>>> ^
>> >>>>>
>> >>>>> lib/Sema/SemaStmtAttr.cpp:134:53: error: missing field
>> 'EnabledIsSet'
>> >>>>> initializer [-Werror,-Wmissing-field-initializers]
>> >>>>>
>> >>>>> {LoopHintAttr::Unroll, LoopHintAttr::UnrollCount}
>> >>>
>> >>> Fixed in r210791.
>> >>>
>> >>> Out of curiosity - our standard makefiles/ninja don't seem to turn
>> this
>> >>> warning on (-Wmissing-field-initializers); is this a build you
>> configure
>> >>> specially?
>> >>> Also, how do you manage to build all of clang with -Werror? I always
>> get
>> >>> a bunch of warnings with gcc 4.8.2, e.g. -Wstrict-aliasing on
>> APValue.h
>> >>>
>> >>> Eli
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>
>> >>>>>>
>> >>>>>>
>> >>>>>>
>> >>>>>> Modified: cfe/trunk/include/clang/Basic/Attr.td
>> >>>>>> URL:
>> >>>>>>
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/Attr.td?rev=210667&r1=210666&r2=210667&view=diff
>> >>>>>>
>> >>>>>>
>> ==============================================================================
>> >>>>>> --- cfe/trunk/include/clang/Basic/Attr.td (original)
>> >>>>>> +++ cfe/trunk/include/clang/Basic/Attr.td Wed Jun 11 12:56:26 2014
>> >>>>>> @@ -1766,6 +1766,8 @@ def LoopHint : Attr {
>> >>>>>> /// 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.
>> >>>>>>
>> >>>>>> /// FIXME: Add Pragma spelling to tablegen and
>> >>>>>> /// use it here.
>> >>>>>> @@ -1773,8 +1775,10 @@ def LoopHint : Attr {
>> >>>>>>
>> >>>>>> /// State of the loop optimization specified by the spelling.
>> >>>>>> let Args = [EnumArgument<"Option", "OptionType",
>> >>>>>> - ["vectorize", "vectorize_width",
>> >>>>>> "interleave", "interleave_count"],
>> >>>>>> - ["Vectorize", "VectorizeWidth",
>> >>>>>> "Interleave", "InterleaveCount"]>,
>> >>>>>> + ["vectorize", "vectorize_width",
>> >>>>>> "interleave", "interleave_count",
>> >>>>>> + "unroll", "unroll_count"],
>> >>>>>> + ["Vectorize", "VectorizeWidth",
>> >>>>>> "Interleave", "InterleaveCount",
>> >>>>>> + "Unroll", "UnrollCount"]>,
>> >>>>>> DefaultIntArgument<"Value", 1>];
>> >>>>>>
>> >>>>>> let AdditionalMembers = [{
>> >>>>>> @@ -1784,6 +1788,8 @@ def LoopHint : Attr {
>> >>>>>> 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.");
>> >>>>>> }
>> >>>>>> @@ -1797,7 +1803,8 @@ def LoopHint : Attr {
>> >>>>>> // FIXME: Modify pretty printer to print this pragma.
>> >>>>>> void print(raw_ostream &OS, const PrintingPolicy &Policy) const
>> {
>> >>>>>> OS << "#pragma clang loop " << getOptionName(option) << "(";
>> >>>>>> - if (option == VectorizeWidth || option == InterleaveCount)
>> >>>>>> + if (option == VectorizeWidth || option == InterleaveCount ||
>> >>>>>> + option == UnrollCount)
>> >>>>>> OS << value;
>> >>>>>> else
>> >>>>>> OS << getValueName(value);
>> >>>>>>
>> >>>>>> Modified: cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td
>> >>>>>> URL:
>> >>>>>>
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td?rev=210667&r1=210666&r2=210667&view=diff
>> >>>>>>
>> >>>>>>
>> ==============================================================================
>> >>>>>> --- cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td
>> (original)
>> >>>>>> +++ cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td Wed Jun
>> 11
>> >>>>>> 12:56:26 2014
>> >>>>>> @@ -895,7 +895,8 @@ def err_omp_more_one_clause : Error<
>> >>>>>>
>> >>>>>> // Pragma loop support.
>> >>>>>> def err_pragma_loop_invalid_option : Error<
>> >>>>>> - "%select{invalid|missing}0 option%select{ %1|}0; expected
>> >>>>>> vectorize, vectorize_width, interleave, or interleave_count">;
>> >>>>>> + "%select{invalid|missing}0 option%select{ %1|}0; expected
>> >>>>>> vectorize, "
>> >>>>>> + "vectorize_width, interleave, interleave_count, unroll, or
>> >>>>>> unroll_count">;
>> >>>>>> } // end of Parse Issue category.
>> >>>>>>
>> >>>>>> let CategoryName = "Modules Issue" in {
>> >>>>>>
>> >>>>>> Modified: cfe/trunk/lib/CodeGen/CGStmt.cpp
>> >>>>>> URL:
>> >>>>>>
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGStmt.cpp?rev=210667&r1=210666&r2=210667&view=diff
>> >>>>>>
>> >>>>>>
>> ==============================================================================
>> >>>>>> --- cfe/trunk/lib/CodeGen/CGStmt.cpp (original)
>> >>>>>> +++ cfe/trunk/lib/CodeGen/CGStmt.cpp Wed Jun 11 12:56:26 2014
>> >>>>>> @@ -550,6 +550,12 @@ void CodeGenFunction::EmitCondBrHints(ll
>> >>>>>> case LoopHintAttr::InterleaveCount:
>> >>>>>> MetadataName = "llvm.vectorizer.unroll";
>> >>>>>> break;
>> >>>>>> + case LoopHintAttr::Unroll:
>> >>>>>> + MetadataName = "llvm.loopunroll.enable";
>> >>>>>> + break;
>> >>>>>> + case LoopHintAttr::UnrollCount:
>> >>>>>> + MetadataName = "llvm.loopunroll.count";
>> >>>>>> + break;
>> >>>>>> }
>> >>>>>>
>> >>>>>> llvm::Value *Value;
>> >>>>>> @@ -572,6 +578,14 @@ void CodeGenFunction::EmitCondBrHints(ll
>> >>>>>> Name = llvm::MDString::get(Context, MetadataName);
>> >>>>>> Value = llvm::ConstantInt::get(Int32Ty, ValueInt);
>> >>>>>> break;
>> >>>>>> + case LoopHintAttr::Unroll:
>> >>>>>> + Name = llvm::MDString::get(Context, MetadataName);
>> >>>>>> + Value = (ValueInt == 0) ? Builder.getFalse() :
>> >>>>>> Builder.getTrue();
>> >>>>>> + break;
>> >>>>>> + case LoopHintAttr::UnrollCount:
>> >>>>>> + Name = llvm::MDString::get(Context, MetadataName);
>> >>>>>> + Value = llvm::ConstantInt::get(Int32Ty, ValueInt);
>> >>>>>> + break;
>> >>>>>> }
>> >>>>>>
>> >>>>>> SmallVector<llvm::Value *, 2> OpValues;
>> >>>>>>
>> >>>>>> Modified: cfe/trunk/lib/Parse/ParsePragma.cpp
>> >>>>>> URL:
>> >>>>>>
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParsePragma.cpp?rev=210667&r1=210666&r2=210667&view=diff
>> >>>>>>
>> >>>>>>
>> ==============================================================================
>> >>>>>> --- cfe/trunk/lib/Parse/ParsePragma.cpp (original)
>> >>>>>> +++ cfe/trunk/lib/Parse/ParsePragma.cpp Wed Jun 11 12:56:26 2014
>> >>>>>> @@ -1641,8 +1641,10 @@ void PragmaOptimizeHandler::HandlePragma
>> >>>>>> /// loop-hint:
>> >>>>>> /// 'vectorize' '(' loop-hint-keyword ')'
>> >>>>>> /// 'interleave' '(' loop-hint-keyword ')'
>> >>>>>> +/// 'unroll' '(' loop-hint-keyword ')'
>> >>>>>> /// 'vectorize_width' '(' loop-hint-value ')'
>> >>>>>> /// 'interleave_count' '(' loop-hint-value ')'
>> >>>>>> +/// 'unroll_count' '(' loop-hint-value ')'
>> >>>>>> ///
>> >>>>>> /// loop-hint-keyword:
>> >>>>>> /// 'enable'
>> >>>>>> @@ -1661,6 +1663,13 @@ void PragmaOptimizeHandler::HandlePragma
>> >>>>>> /// possible and profitable, and 0 is invalid. The loop vectorizer
>> >>>>>> currently
>> >>>>>> /// only works on inner loops.
>> >>>>>> ///
>> >>>>>> +/// 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) {
>> >>>>>> @@ -1679,9 +1688,15 @@ void PragmaLoopHintHandler::HandlePragma
>> >>>>>> Token Option = Tok;
>> >>>>>> IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
>> >>>>>>
>> >>>>>> - if (!OptionInfo->isStr("vectorize") &&
>> >>>>>> !OptionInfo->isStr("interleave") &&
>> >>>>>> - !OptionInfo->isStr("vectorize_width") &&
>> >>>>>> - !OptionInfo->isStr("interleave_count")) {
>> >>>>>> + 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;
>> >>>>>>
>> >>>>>> Modified: cfe/trunk/lib/Sema/SemaStmtAttr.cpp
>> >>>>>> URL:
>> >>>>>>
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaStmtAttr.cpp?rev=210667&r1=210666&r2=210667&view=diff
>> >>>>>>
>> >>>>>>
>> ==============================================================================
>> >>>>>> --- cfe/trunk/lib/Sema/SemaStmtAttr.cpp (original)
>> >>>>>> +++ cfe/trunk/lib/Sema/SemaStmtAttr.cpp Wed Jun 11 12:56:26 2014
>> >>>>>> @@ -67,10 +67,13 @@ static Attr *handleLoopHintAttr(Sema &S,
>> >>>>>> .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);
>> >>>>>>
>> >>>>>> int ValueInt;
>> >>>>>> - if (Option == LoopHintAttr::Vectorize || Option ==
>> >>>>>> LoopHintAttr::Interleave) {
>> >>>>>> + if (Option == LoopHintAttr::Vectorize || Option ==
>> >>>>>> LoopHintAttr::Interleave ||
>> >>>>>> + Option == LoopHintAttr::Unroll) {
>> >>>>>> if (!ValueInfo) {
>> >>>>>> S.Diag(ValueLoc->Loc, diag::err_pragma_loop_invalid_keyword)
>> >>>>>> << /*MissingKeyword=*/true << "";
>> >>>>>> @@ -87,7 +90,8 @@ static Attr *handleLoopHintAttr(Sema &S,
>> >>>>>> return nullptr;
>> >>>>>> }
>> >>>>>> } else if (Option == LoopHintAttr::VectorizeWidth ||
>> >>>>>> - Option == LoopHintAttr::InterleaveCount) {
>> >>>>>> + Option == LoopHintAttr::InterleaveCount ||
>> >>>>>> + Option == LoopHintAttr::UnrollCount) {
>> >>>>>> // FIXME: We should support template parameters for the loop
>> hint
>> >>>>>> value.
>> >>>>>> // See bug report #19610.
>> >>>>>> llvm::APSInt ValueAPS;
>> >>>>>> @@ -111,9 +115,24 @@ static Attr *handleLoopHintAttr(Sema &S,
>> >>>>>>
>> >>>>>> static void
>> >>>>>> CheckForIncompatibleAttributes(Sema &S, SmallVectorImpl<const
>> Attr *>
>> >>>>>> &Attrs) {
>> >>>>>> - int PrevOptionValue[4] = {-1, -1, -1, -1};
>> >>>>>> - int OptionId[4] = {LoopHintAttr::Vectorize,
>> >>>>>> LoopHintAttr::VectorizeWidth,
>> >>>>>> - LoopHintAttr::Interleave,
>> >>>>>> LoopHintAttr::InterleaveCount};
>> >>>>>> + // 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},
>> >>>>>> + {LoopHintAttr::Interleave, LoopHintAttr::InterleaveCount},
>> >>>>>> + {LoopHintAttr::Unroll, LoopHintAttr::UnrollCount}
>> >>>>>> + };
>> >>>>>>
>> >>>>>> for (const auto *I : Attrs) {
>> >>>>>> const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(I);
>> >>>>>> @@ -122,76 +141,64 @@ CheckForIncompatibleAttributes(Sema &S,
>> >>>>>> if (!LH)
>> >>>>>> continue;
>> >>>>>>
>> >>>>>> - int State, Value;
>> >>>>>> int Option = LH->getOption();
>> >>>>>> int ValueInt = LH->getValue();
>> >>>>>>
>> >>>>>> + int Category;
>> >>>>>> switch (Option) {
>> >>>>>> case LoopHintAttr::Vectorize:
>> >>>>>> case LoopHintAttr::VectorizeWidth:
>> >>>>>> - State = 0;
>> >>>>>> - Value = 1;
>> >>>>>> + Category = 0;
>> >>>>>> break;
>> >>>>>> case LoopHintAttr::Interleave:
>> >>>>>> case LoopHintAttr::InterleaveCount:
>> >>>>>> - State = 2;
>> >>>>>> - Value = 3;
>> >>>>>> + Category = 1;
>> >>>>>> break;
>> >>>>>> - }
>> >>>>>> + case LoopHintAttr::Unroll:
>> >>>>>> + case LoopHintAttr::UnrollCount:
>> >>>>>> + Category = 2;
>> >>>>>> + break;
>> >>>>>> + };
>> >>>>>>
>> >>>>>> + auto &CategoryState = Options[Category];
>> >>>>>> SourceLocation ValueLoc = LH->getRange().getEnd();
>> >>>>>> -
>> >>>>>> - // Compatibility testing is split into two cases.
>> >>>>>> - // 1. if the current loop hint sets state (enable/disable) -
>> >>>>>> check against
>> >>>>>> - // previous state and value.
>> >>>>>> - // 2. if the current loop hint sets a value - check against
>> >>>>>> previous state
>> >>>>>> - // and value.
>> >>>>>> -
>> >>>>>> - if (Option == State) {
>> >>>>>> - if (PrevOptionValue[State] != -1) {
>> >>>>>> - // Cannot specify state twice.
>> >>>>>> - int PrevValue = PrevOptionValue[State];
>> >>>>>> + if (Option == LoopHintAttr::Vectorize ||
>> >>>>>> + Option == LoopHintAttr::Interleave || Option ==
>> >>>>>> LoopHintAttr::Unroll) {
>> >>>>>> + // Enable|disable hint. For example, vectorize(enable).
>> >>>>>> + if (CategoryState.EnabledIsSet) {
>> >>>>>> + // Cannot specify enable/disable state twice.
>> >>>>>> S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
>> >>>>>> << /*Duplicate=*/true <<
>> >>>>>> LoopHintAttr::getOptionName(Option)
>> >>>>>> - << LoopHintAttr::getValueName(PrevValue)
>> >>>>>> + << LoopHintAttr::getValueName(CategoryState.Enabled)
>> >>>>>> << LoopHintAttr::getOptionName(Option)
>> >>>>>> - << LoopHintAttr::getValueName(Value);
>> >>>>>> - }
>> >>>>>> -
>> >>>>>> - if (PrevOptionValue[Value] != -1) {
>> >>>>>> - // Compare state with previous width/count.
>> >>>>>> - int PrevOption = OptionId[Value];
>> >>>>>> - int PrevValueInt = PrevOptionValue[Value];
>> >>>>>> - if ((ValueInt == 0 && PrevValueInt > 1) ||
>> >>>>>> - (ValueInt == 1 && PrevValueInt <= 1))
>> >>>>>> - S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
>> >>>>>> - << /*Duplicate=*/false <<
>> >>>>>> LoopHintAttr::getOptionName(PrevOption)
>> >>>>>> - << PrevValueInt <<
>> LoopHintAttr::getOptionName(Option)
>> >>>>>> - << LoopHintAttr::getValueName(ValueInt);
>> >>>>>> + << LoopHintAttr::getValueName(ValueInt);
>> >>>>>> }
>> >>>>>> + CategoryState.EnabledIsSet = true;
>> >>>>>> + CategoryState.Enabled = ValueInt;
>> >>>>>> } else {
>> >>>>>> - if (PrevOptionValue[State] != -1) {
>> >>>>>> - // Compare width/count value with previous state.
>> >>>>>> - int PrevOption = OptionId[State];
>> >>>>>> - int PrevValueInt = PrevOptionValue[State];
>> >>>>>> - if ((ValueInt > 1 && PrevValueInt == 0) ||
>> >>>>>> - (ValueInt <= 1 && PrevValueInt == 1))
>> >>>>>> - S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
>> >>>>>> - << /*Duplicate=*/false <<
>> >>>>>> LoopHintAttr::getOptionName(PrevOption)
>> >>>>>> - << LoopHintAttr::getValueName(PrevValueInt)
>> >>>>>> - << LoopHintAttr::getOptionName(Option) << ValueInt;
>> >>>>>> - }
>> >>>>>> -
>> >>>>>> - if (PrevOptionValue[Value] != -1) {
>> >>>>>> - // Cannot specify a width/count twice.
>> >>>>>> - int PrevValueInt = PrevOptionValue[Value];
>> >>>>>> + // Numeric hint. For example, unroll_count(8).
>> >>>>>> + if (CategoryState.ValueIsSet) {
>> >>>>>> + // Cannot specify numeric hint twice.
>> >>>>>> S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
>> >>>>>> << /*Duplicate=*/true <<
>> >>>>>> LoopHintAttr::getOptionName(Option)
>> >>>>>> - << PrevValueInt <<
>> LoopHintAttr::getOptionName(Option) <<
>> >>>>>> ValueInt;
>> >>>>>> + << CategoryState.Value <<
>> >>>>>> LoopHintAttr::getOptionName(Option)
>> >>>>>> + << ValueInt;
>> >>>>>> }
>> >>>>>> + CategoryState.ValueIsSet = true;
>> >>>>>> + CategoryState.Value = ValueInt;
>> >>>>>> }
>> >>>>>>
>> >>>>>> - PrevOptionValue[Option] = ValueInt;
>> >>>>>> + if (CategoryState.EnabledIsSet && !CategoryState.Enabled &&
>> >>>>>> + CategoryState.ValueIsSet) {
>> >>>>>> + // Disable hints are not compatible with numeric hints of
>> the
>> >>>>>> + // same category.
>> >>>>>> + S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
>> >>>>>> + << /*Duplicate=*/false
>> >>>>>> + <<
>> >>>>>> LoopHintAttr::getOptionName(CategoryState.EnableOptionId)
>> >>>>>> + << LoopHintAttr::getValueName(CategoryState.Enabled)
>> >>>>>> + <<
>> >>>>>> LoopHintAttr::getOptionName(CategoryState.NumericOptionId)
>> >>>>>> + << CategoryState.Value;
>> >>>>>> + }
>> >>>>>> }
>> >>>>>> }
>> >>>>>>
>> >>>>>>
>> >>>>>> Modified: cfe/trunk/test/CodeGen/pragma-loop.cpp
>> >>>>>> URL:
>> >>>>>>
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGen/pragma-loop.cpp?rev=210667&r1=210666&r2=210667&view=diff
>> >>>>>>
>> >>>>>>
>> ==============================================================================
>> >>>>>> --- cfe/trunk/test/CodeGen/pragma-loop.cpp (original)
>> >>>>>> +++ cfe/trunk/test/CodeGen/pragma-loop.cpp Wed Jun 11 12:56:26 2014
>> >>>>>> @@ -8,6 +8,7 @@ void while_test(int *List, int Length) {
>> >>>>>> #pragma clang loop vectorize(enable)
>> >>>>>> #pragma clang loop interleave_count(4)
>> >>>>>> #pragma clang loop vectorize_width(4)
>> >>>>>> +#pragma clang loop unroll(enable)
>> >>>>>> while (i < Length) {
>> >>>>>> // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop
>> >>>>>> ![[LOOP_1:.*]]
>> >>>>>> List[i] = i * 2;
>> >>>>>> @@ -19,7 +20,7 @@ void while_test(int *List, int Length) {
>> >>>>>> void do_test(int *List, int Length) {
>> >>>>>> int i = 0;
>> >>>>>>
>> >>>>>> -#pragma clang loop vectorize_width(8) interleave_count(4)
>> >>>>>> +#pragma clang loop vectorize_width(8) interleave_count(4)
>> >>>>>> unroll(disable)
>> >>>>>> do {
>> >>>>>> // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop
>> >>>>>> ![[LOOP_2:.*]]
>> >>>>>> List[i] = i * 2;
>> >>>>>> @@ -31,6 +32,7 @@ void do_test(int *List, int Length) {
>> >>>>>> void for_test(int *List, int Length) {
>> >>>>>> #pragma clang loop interleave(enable)
>> >>>>>> #pragma clang loop interleave_count(4)
>> >>>>>> +#pragma clang loop unroll_count(8)
>> >>>>>> for (int i = 0; i < Length; i++) {
>> >>>>>> // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop
>> >>>>>> ![[LOOP_3:.*]]
>> >>>>>> List[i] = i * 2;
>> >>>>>> @@ -51,7 +53,7 @@ void for_range_test() {
>> >>>>>>
>> >>>>>> // Verify disable pragma clang loop directive generates correct
>> >>>>>> metadata
>> >>>>>> void disable_test(int *List, int Length) {
>> >>>>>> -#pragma clang loop vectorize(disable)
>> >>>>>> +#pragma clang loop vectorize(disable) unroll(disable)
>> >>>>>> for (int i = 0; i < Length; i++) {
>> >>>>>> // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop
>> >>>>>> ![[LOOP_5:.*]]
>> >>>>>> List[i] = i * 2;
>> >>>>>> @@ -60,10 +62,12 @@ void disable_test(int *List, int Length)
>> >>>>>>
>> >>>>>> #define VECWIDTH 2
>> >>>>>> #define INTCOUNT 2
>> >>>>>> +#define UNROLLCOUNT 8
>> >>>>>>
>> >>>>>> // Verify defines are correctly resolved in pragma clang loop
>> >>>>>> directive
>> >>>>>> void for_define_test(int *List, int Length, int Value) {
>> >>>>>> #pragma clang loop vectorize_width(VECWIDTH)
>> >>>>>> interleave_count(INTCOUNT)
>> >>>>>> +#pragma clang loop unroll_count(UNROLLCOUNT)
>> >>>>>> for (int i = 0; i < Length; i++) {
>> >>>>>> // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop
>> >>>>>> ![[LOOP_6:.*]]
>> >>>>>> List[i] = i * Value;
>> >>>>>> @@ -74,7 +78,7 @@ void for_define_test(int *List, int Leng
>> >>>>>> template <typename A>
>> >>>>>> void for_template_test(A *List, int Length, A Value) {
>> >>>>>>
>> >>>>>> -#pragma clang loop vectorize_width(8) interleave_count(8)
>> >>>>>> +#pragma clang loop vectorize_width(8) interleave_count(8)
>> >>>>>> unroll_count(8)
>> >>>>>> for (int i = 0; i < Length; i++) {
>> >>>>>> // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop
>> >>>>>> ![[LOOP_7:.*]]
>> >>>>>> List[i] = i * Value;
>> >>>>>> @@ -85,6 +89,7 @@ void for_template_test(A *List, int Leng
>> >>>>>> template <typename A>
>> >>>>>> void for_template_define_test(A *List, int Length, A Value) {
>> >>>>>> #pragma clang loop vectorize_width(VECWIDTH)
>> >>>>>> interleave_count(INTCOUNT)
>> >>>>>> +#pragma clang loop unroll_count(UNROLLCOUNT)
>> >>>>>> for (int i = 0; i < Length; i++) {
>> >>>>>> // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop
>> >>>>>> ![[LOOP_8:.*]]
>> >>>>>> List[i] = i * Value;
>> >>>>>> @@ -93,6 +98,7 @@ void for_template_define_test(A *List, i
>> >>>>>>
>> >>>>>> #undef VECWIDTH
>> >>>>>> #undef INTCOUNT
>> >>>>>> +#undef UNROLLCOUNT
>> >>>>>>
>> >>>>>> // Use templates defined above. Test verifies metadata is
>> generated
>> >>>>>> correctly.
>> >>>>>> void template_test(double *List, int Length) {
>> >>>>>> @@ -102,19 +108,22 @@ void template_test(double *List, int Len
>> >>>>>> for_template_define_test<double>(List, Length, Value);
>> >>>>>> }
>> >>>>>>
>> >>>>>> -// CHECK: ![[LOOP_1]] = metadata !{metadata ![[LOOP_1]], metadata
>> >>>>>> ![[WIDTH_4:.*]], metadata ![[UNROLL_4:.*]], metadata
>> ![[ENABLE_1:.*]]}
>> >>>>>> +// CHECK: ![[LOOP_1]] = metadata !{metadata ![[LOOP_1]], metadata
>> >>>>>> ![[UNROLLENABLE_1:.*]], metadata ![[WIDTH_4:.*]], metadata
>> >>>>>> ![[INTERLEAVE_4:.*]], metadata ![[INTENABLE_1:.*]]}
>> >>>>>> +// CHECK: ![[UNROLLENABLE_1]] = metadata !{metadata
>> >>>>>> !"llvm.loopunroll.enable", i1 true}
>> >>>>>> // CHECK: ![[WIDTH_4]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.width", i32 4}
>> >>>>>> -// CHECK: ![[UNROLL_4]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.unroll", i32 4}
>> >>>>>> -// CHECK: ![[ENABLE_1]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.enable", i1 true}
>> >>>>>> -// CHECK: ![[LOOP_2]] = metadata !{metadata ![[LOOP_2:.*]],
>> metadata
>> >>>>>> ![[UNROLL_4:.*]], metadata ![[WIDTH_8:.*]]}
>> >>>>>> +// CHECK: ![[INTERLEAVE_4]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.unroll", i32 4}
>> >>>>>> +// CHECK: ![[INTENABLE_1]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.enable", i1 true}
>> >>>>>> +// CHECK: ![[LOOP_2]] = metadata !{metadata ![[LOOP_2:.*]],
>> metadata
>> >>>>>> ![[UNROLLENABLE_0:.*]], metadata ![[INTERLEAVE_4:.*]], metadata
>> >>>>>> ![[WIDTH_8:.*]]}
>> >>>>>> +// CHECK: ![[UNROLLENABLE_0]] = metadata !{metadata
>> >>>>>> !"llvm.loopunroll.enable", i1 false}
>> >>>>>> // CHECK: ![[WIDTH_8]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.width", i32 8}
>> >>>>>> -// CHECK: ![[LOOP_3]] = metadata !{metadata ![[LOOP_3]], metadata
>> >>>>>> ![[UNROLL_4:.*]], metadata ![[ENABLE_1:.*]]}
>> >>>>>> -// CHECK: ![[LOOP_4]] = metadata !{metadata ![[LOOP_4]], metadata
>> >>>>>> ![[UNROLL_2:.*]], metadata ![[WIDTH_2:.*]]}
>> >>>>>> -// CHECK: ![[UNROLL_2]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.unroll", i32 2}
>> >>>>>> +// CHECK: ![[LOOP_3]] = metadata !{metadata ![[LOOP_3]], metadata
>> >>>>>> ![[UNROLL_8:.*]], metadata ![[INTERLEAVE_4:.*]], metadata
>> ![[ENABLE_1:.*]]}
>> >>>>>> +// CHECK: ![[UNROLL_8]] = metadata !{metadata
>> >>>>>> !"llvm.loopunroll.count", i32 8}
>> >>>>>> +// CHECK: ![[LOOP_4]] = metadata !{metadata ![[LOOP_4]], metadata
>> >>>>>> ![[INTERLEAVE_2:.*]], metadata ![[WIDTH_2:.*]]}
>> >>>>>> +// CHECK: ![[INTERLEAVE_2]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.unroll", i32 2}
>> >>>>>> // CHECK: ![[WIDTH_2]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.width", i32 2}
>> >>>>>> -// CHECK: ![[LOOP_5]] = metadata !{metadata ![[LOOP_5]], metadata
>> >>>>>> ![[WIDTH_1:.*]]}
>> >>>>>> +// CHECK: ![[LOOP_5]] = metadata !{metadata ![[LOOP_5]], metadata
>> >>>>>> ![[UNROLLENABLE_0:.*]], metadata ![[WIDTH_1:.*]]}
>> >>>>>> // CHECK: ![[WIDTH_1]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.width", i32 1}
>> >>>>>> -// CHECK: ![[LOOP_6]] = metadata !{metadata ![[LOOP_6]], metadata
>> >>>>>> ![[UNROLL_2:.*]], metadata ![[WIDTH_2:.*]]}
>> >>>>>> -// CHECK: ![[LOOP_7]] = metadata !{metadata ![[LOOP_7]], metadata
>> >>>>>> ![[UNROLL_8:.*]], metadata ![[WIDTH_8:.*]]}
>> >>>>>> -// CHECK: ![[UNROLL_8]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.unroll", i32 8}
>> >>>>>> -// CHECK: ![[LOOP_8]] = metadata !{metadata ![[LOOP_8]], metadata
>> >>>>>> ![[UNROLL_2:.*]], metadata ![[WIDTH_2:.*]]}
>> >>>>>> +// CHECK: ![[LOOP_6]] = metadata !{metadata ![[LOOP_6]], metadata
>> >>>>>> ![[UNROLL_8:.*]], metadata ![[INTERLEAVE_2:.*]], metadata
>> ![[WIDTH_2:.*]]}
>> >>>>>> +// CHECK: ![[LOOP_7]] = metadata !{metadata ![[LOOP_7]], metadata
>> >>>>>> ![[UNROLL_8:.*]], metadata ![[INTERLEAVE_8:.*]], metadata
>> ![[WIDTH_8:.*]]}
>> >>>>>> +// CHECK: ![[INTERLEAVE_8]] = metadata !{metadata
>> >>>>>> !"llvm.vectorizer.unroll", i32 8}
>> >>>>>> +// CHECK: ![[LOOP_8]] = metadata !{metadata ![[LOOP_8]], metadata
>> >>>>>> ![[UNROLL_8:.*]], metadata ![[INTERLEAVE_2:.*]], metadata
>> ![[WIDTH_2:.*]]}
>> >>>>>>
>> >>>>>> Modified: cfe/trunk/test/PCH/pragma-loop.cpp
>> >>>>>> URL:
>> >>>>>>
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/PCH/pragma-loop.cpp?rev=210667&r1=210666&r2=210667&view=diff
>> >>>>>>
>> >>>>>>
>> ==============================================================================
>> >>>>>> --- cfe/trunk/test/PCH/pragma-loop.cpp (original)
>> >>>>>> +++ cfe/trunk/test/PCH/pragma-loop.cpp Wed Jun 11 12:56:26 2014
>> >>>>>> @@ -4,10 +4,13 @@
>> >>>>>> // 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)
>> >>>>>>
>> >>>>>> @@ -20,6 +23,7 @@ public:
>> >>>>>> int i = 0;
>> >>>>>> #pragma clang loop vectorize_width(4)
>> >>>>>> #pragma clang loop interleave_count(8)
>> >>>>>> +#pragma clang loop unroll_count(16)
>> >>>>>> while (i < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> i++;
>> >>>>>> @@ -30,6 +34,7 @@ public:
>> >>>>>> int i = 0;
>> >>>>>> #pragma clang loop vectorize(enable)
>> >>>>>> #pragma clang loop interleave(disable)
>> >>>>>> +#pragma clang loop unroll(disable)
>> >>>>>> while (i - 1 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> i++;
>> >>>>>> @@ -40,6 +45,7 @@ public:
>> >>>>>> 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++;
>> >>>>>>
>> >>>>>> Modified: cfe/trunk/test/Parser/pragma-loop.cpp
>> >>>>>> URL:
>> >>>>>>
>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Parser/pragma-loop.cpp?rev=210667&r1=210666&r2=210667&view=diff
>> >>>>>>
>> >>>>>>
>> ==============================================================================
>> >>>>>> --- cfe/trunk/test/Parser/pragma-loop.cpp (original)
>> >>>>>> +++ cfe/trunk/test/Parser/pragma-loop.cpp Wed Jun 11 12:56:26 2014
>> >>>>>> @@ -8,23 +8,26 @@ void test(int *List, int Length) {
>> >>>>>>
>> >>>>>> #pragma clang loop vectorize(enable)
>> >>>>>> #pragma clang loop interleave(enable)
>> >>>>>> +#pragma clang loop unroll(enable)
>> >>>>>> while (i + 1 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>>
>> >>>>>> #pragma clang loop vectorize_width(4)
>> >>>>>> #pragma clang loop interleave_count(8)
>> >>>>>> +#pragma clang loop unroll_count(16)
>> >>>>>> while (i < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>>
>> >>>>>> #pragma clang loop vectorize(disable)
>> >>>>>> #pragma clang loop interleave(disable)
>> >>>>>> +#pragma clang loop unroll(disable)
>> >>>>>> while (i - 1 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>>
>> >>>>>> -#pragma clang loop vectorize_width(4) interleave_count(8)
>> >>>>>> +#pragma clang loop vectorize_width(4) interleave_count(8)
>> >>>>>> unroll_count(16)
>> >>>>>> while (i - 2 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>> @@ -35,19 +38,22 @@ void test(int *List, int Length) {
>> >>>>>> }
>> >>>>>>
>> >>>>>> int VList[Length];
>> >>>>>> -#pragma clang loop vectorize(disable) interleave(disable)
>> >>>>>> +#pragma clang loop vectorize(disable) interleave(disable)
>> >>>>>> unroll(disable)
>> >>>>>> for (int j : VList) {
>> >>>>>> VList[j] = List[j];
>> >>>>>> }
>> >>>>>>
>> >>>>>> /* expected-error {{expected '('}} */ #pragma clang loop vectorize
>> >>>>>> /* expected-error {{expected '('}} */ #pragma clang loop
>> interleave
>> >>>>>> +/* expected-error {{expected '('}} */ #pragma clang loop unroll
>> >>>>>>
>> >>>>>> /* 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 option}} */ #pragma clang loop
>> >>>>>> /* expected-error {{invalid option 'badkeyword'}} */ #pragma clang
>> >>>>>> loop badkeyword
>> >>>>>> @@ -61,24 +67,28 @@ void test(int *List, int Length) {
>> >>>>>>
>> >>>>>> /* expected-error {{invalid value 0; expected a positive integer
>> >>>>>> value}} */ #pragma clang loop vectorize_width(0)
>> >>>>>> /* expected-error {{invalid value 0; expected a positive integer
>> >>>>>> value}} */ #pragma clang loop interleave_count(0)
>> >>>>>> +/* expected-error {{invalid value 0; expected a positive integer
>> >>>>>> value}} */ #pragma clang loop unroll_count(0)
>> >>>>>> while (i-5 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>>
>> >>>>>> /* expected-error {{invalid value -1294967296; expected a positive
>> >>>>>> integer value}} */ #pragma clang loop vectorize_width(3000000000)
>> >>>>>> /* expected-error {{invalid value -1294967296; expected a positive
>> >>>>>> integer value}} */ #pragma clang loop interleave_count(3000000000)
>> >>>>>> +/* expected-error {{invalid value -1294967296; expected a positive
>> >>>>>> integer value}} */ #pragma clang loop unroll_count(3000000000)
>> >>>>>> while (i-6 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>>
>> >>>>>> /* expected-error {{missing value; expected a positive integer
>> >>>>>> value}} */ #pragma clang loop vectorize_width(badvalue)
>> >>>>>> /* expected-error {{missing value; expected a positive integer
>> >>>>>> value}} */ #pragma clang loop interleave_count(badvalue)
>> >>>>>> +/* expected-error {{missing value; expected a positive integer
>> >>>>>> value}} */ #pragma clang loop unroll_count(badvalue)
>> >>>>>> while (i-6 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>>
>> >>>>>> /* expected-error {{invalid keyword 'badidentifier'; expected
>> >>>>>> 'enable' or 'disable'}} */ #pragma clang loop
>> vectorize(badidentifier)
>> >>>>>> /* expected-error {{invalid keyword 'badidentifier'; expected
>> >>>>>> 'enable' or 'disable'}} */ #pragma clang loop
>> interleave(badidentifier)
>> >>>>>> +/* expected-error {{invalid keyword 'badidentifier'; expected
>> >>>>>> 'enable' or 'disable'}} */ #pragma clang loop unroll(badidentifier)
>> >>>>>> while (i-7 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>> @@ -100,6 +110,8 @@ void test(int *List, int Length) {
>> >>>>>> #pragma clang loop vectorize(disable)
>> >>>>>> /* expected-error {{incompatible directives 'interleave(disable)'
>> and
>> >>>>>> 'interleave_count(4)'}} */ #pragma clang loop interleave_count(4)
>> >>>>>> #pragma clang loop interleave(disable)
>> >>>>>> +/* expected-error {{incompatible directives 'unroll(disable)' and
>> >>>>>> 'unroll_count(4)'}} */ #pragma clang loop unroll_count(4)
>> >>>>>> +#pragma clang loop unroll(disable)
>> >>>>>> while (i-8 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>> @@ -108,14 +120,18 @@ void test(int *List, int Length) {
>> >>>>>> #pragma clang loop vectorize(disable)
>> >>>>>> /* expected-error {{duplicate directives 'interleave(disable)' and
>> >>>>>> 'interleave(enable)'}} */ #pragma clang loop interleave(enable)
>> >>>>>> #pragma clang loop interleave(disable)
>> >>>>>> +/* expected-error {{duplicate directives 'unroll(disable)' and
>> >>>>>> 'unroll(enable)'}} */ #pragma clang loop unroll(enable)
>> >>>>>> +#pragma clang loop unroll(disable)
>> >>>>>> while (i-9 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>>
>> >>>>>> -/* expected-error {{incompatible directives 'vectorize_width(4)'
>> and
>> >>>>>> 'vectorize(disable)'}} */ #pragma clang loop vectorize(disable)
>> >>>>>> +/* expected-error {{incompatible directives 'vectorize(disable)'
>> and
>> >>>>>> 'vectorize_width(4)'}} */ #pragma clang loop vectorize(disable)
>> >>>>>> #pragma clang loop vectorize_width(4)
>> >>>>>> -/* expected-error {{incompatible directives 'interleave_count(4)'
>> and
>> >>>>>> 'interleave(disable)'}} */ #pragma clang loop interleave(disable)
>> >>>>>> +/* expected-error {{incompatible directives 'interleave(disable)'
>> and
>> >>>>>> 'interleave_count(4)'}} */ #pragma clang loop interleave(disable)
>> >>>>>> #pragma clang loop interleave_count(4)
>> >>>>>> +/* expected-error {{incompatible directives 'unroll(disable)' and
>> >>>>>> 'unroll_count(4)'}} */ #pragma clang loop unroll(disable)
>> >>>>>> +#pragma clang loop unroll_count(4)
>> >>>>>> while (i-10 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>> @@ -124,6 +140,8 @@ void test(int *List, int Length) {
>> >>>>>> #pragma clang loop vectorize_width(4)
>> >>>>>> /* expected-error {{duplicate directives 'interleave_count(4)' and
>> >>>>>> 'interleave_count(8)'}} */ #pragma clang loop interleave_count(8)
>> >>>>>> #pragma clang loop interleave_count(4)
>> >>>>>> +/* expected-error {{duplicate directives 'unroll_count(4)' and
>> >>>>>> 'unroll_count(8)'}} */ #pragma clang loop unroll_count(8)
>> >>>>>> +#pragma clang loop unroll_count(4)
>> >>>>>> while (i-11 < Length) {
>> >>>>>> List[i] = i;
>> >>>>>> }
>> >>>>>>
>> >>>>>>
>> >>>>>> _______________________________________________
>> >>>>>> cfe-commits mailing list
>> >>>>>> cfe-commits at cs.uiuc.edu
>> >>>>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>> >>>>>
>> >>>>>
>> >>>>>
>> >>>>>
>> >>>>> --
>> >>>>> ~Craig
>> >>>>
>> >>>>
>> >>>
>> >>
>> >>
>> >>
>> >> --
>> >> ~Craig
>> >
>> >
>> >
>> > _______________________________________________
>> > cfe-commits mailing list
>> > cfe-commits at cs.uiuc.edu
>> > http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>> >
>>
>
>
>
> --
> ~Craig
>
> _______________________________________________
> cfe-commits mailing list
> cfe-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20140612/acdec91c/attachment.html>
More information about the cfe-commits
mailing list