r272699 should do it. > On Jun 14, 2016, at 9:32 PM, Adam Nemet via cfe-commits > <cfe-commits@lists.llvm.org> wrote: > > On it, sorry about it. > >> On Jun 14, 2016, at 4:51 PM, Rafael Espíndola <rafael.espind...@gmail.com> >> wrote: >> >> Looks like this broke the docs: >> http://lab.llvm.org:8011/builders/clang-sphinx-docs/builds/14690/steps/docs-clang-html/logs/stdio >> >> Cheers, >> Rafael >> >> >> On 14 June 2016 at 08:04, Adam Nemet via cfe-commits >> <cfe-commits@lists.llvm.org> wrote: >>> Author: anemet >>> Date: Tue Jun 14 07:04:26 2016 >>> New Revision: 272656 >>> >>> URL: http://llvm.org/viewvc/llvm-project?rev=272656&view=rev >>> Log: >>> Add loop pragma for Loop Distribution >>> >>> Summary: >>> This is similar to other loop pragmas like 'vectorize'. Currently it >>> only has state values: distribute(enable) and distribute(disable). When >>> one of these is specified the corresponding loop metadata is generated: >>> >>> !{!"llvm.loop.distribute.enable", i1 true/false} >>> >>> As a result, loop distribution will be attempted on the loop even if >>> Loop Distribution in not enabled globally. Analogously, with 'disable' >>> distribution can be turned off for an individual loop even when the pass >>> is otherwise enabled. >>> >>> There are some slight differences compared to the existing loop pragmas. >>> >>> 1. There is no 'assume_safety' variant which makes its handling slightly >>> different from 'vectorize'/'interleave'. >>> >>> 2. Unlike the existing loop pragmas, it does not have a corresponding >>> numeric pragma like 'vectorize' -> 'vectorize_width'. So for the >>> consistency checks in CheckForIncompatibleAttributes we don't need to >>> check it against other pragmas. We just need to check for duplicates of >>> the same pragma. >>> >>> Reviewers: rsmith, dexonsmith, aaron.ballman >>> >>> Subscribers: bob.wilson, cfe-commits, hfinkel >>> >>> Differential Revision: http://reviews.llvm.org/D19403 >>> >>> Modified: >>> cfe/trunk/docs/LanguageExtensions.rst >>> cfe/trunk/include/clang/Basic/Attr.td >>> cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td >>> cfe/trunk/lib/CodeGen/CGLoopInfo.cpp >>> cfe/trunk/lib/CodeGen/CGLoopInfo.h >>> cfe/trunk/lib/Parse/ParsePragma.cpp >>> cfe/trunk/lib/Sema/SemaStmtAttr.cpp >>> cfe/trunk/test/CodeGenCXX/pragma-loop.cpp >>> cfe/trunk/test/Misc/ast-print-pragmas.cpp >>> cfe/trunk/test/PCH/pragma-loop.cpp >>> cfe/trunk/test/Parser/pragma-loop-safety.cpp >>> cfe/trunk/test/Parser/pragma-loop.cpp >>> >>> Modified: cfe/trunk/docs/LanguageExtensions.rst >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/docs/LanguageExtensions.rst?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/docs/LanguageExtensions.rst (original) >>> +++ cfe/trunk/docs/LanguageExtensions.rst Tue Jun 14 07:04:26 2016 >>> @@ -2050,9 +2050,9 @@ Extensions for loop hint optimizations >>> >>> The ``#pragma clang loop`` directive is used to specify hints for >>> optimizing the >>> subsequent for, while, do-while, or c++11 range-based for loop. The >>> directive >>> -provides options for vectorization, interleaving, and unrolling. Loop >>> hints can >>> -be specified before any loop and will be ignored if the optimization is >>> not safe >>> -to apply. >>> +provides options for vectorization, interleaving, unrolling and >>> +distribution. Loop hints can be specified before any loop and will be >>> ignored if >>> +the optimization is not safe to apply. >>> >>> Vectorization and Interleaving >>> ------------------------------ >>> @@ -2147,6 +2147,38 @@ to the same code size limit as with ``un >>> >>> Unrolling of a loop can be prevented by specifying ``unroll(disable)``. >>> >>> +Loop Distribution >>> +----------------- >>> + >>> +Loop Distribution allows splitting a loop into multiple loops. This is >>> +beneficial for example when the entire loop cannot be vectorized but some >>> of the >>> +resulting loops can. >>> + >>> +If ``distribute(enable))'' is specified and the loop has memory >>> dependencies >>> +that inhibit vectorization, the compiler will attempt to isolate the >>> offending >>> +operations into a new loop. This optimization is not enabled by default, >>> only >>> +loops marked with the pragma are considered. >>> + >>> +.. code-block:: c++ >>> + >>> + #pragma clang loop distribute(enable) >>> + for (i = 0; i < N; ++i) { >>> + S1: A[i + 1] = A[i] + B[i]; >>> + S2: C[i] = D[i] * E[i]; >>> + } >>> + >>> +This loop will be split into two loops between statements S1 and S2. The >>> +second loop containing S2 will be vectorized. >>> + >>> +Loop Distribution is currently not enabled by default in the optimizer >>> because >>> +it can hurt performance in some cases. For example, instruction-level >>> +parallelism could be reduced by sequentializing the execution of the >>> +statements S1 and S2 above. >>> + >>> +If Loop Distribution is turned on globally with >>> +``-mllvm -enable-loop-distribution``, specifying ``distribute(disable)`` >>> can >>> +be used the disable it on a per-loop basis. >>> + >>> Additional Information >>> ---------------------- >>> >>> >>> Modified: cfe/trunk/include/clang/Basic/Attr.td >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/Attr.td?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/include/clang/Basic/Attr.td (original) >>> +++ cfe/trunk/include/clang/Basic/Attr.td Tue Jun 14 07:04:26 2016 >>> @@ -2186,6 +2186,7 @@ def LoopHint : Attr { >>> /// interleave_count: interleaves 'Value' loop interations. >>> /// unroll: fully unroll loop if State == Enable. >>> /// unroll_count: unrolls loop 'Value' times. >>> + /// distribute: attempt to distribute loop if State == Enable >>> >>> /// #pragma unroll <argument> directive >>> /// <no arg>: fully unrolls loop. >>> @@ -2198,9 +2199,9 @@ def LoopHint : Attr { >>> /// State of the loop optimization specified by the spelling. >>> let Args = [EnumArgument<"Option", "OptionType", >>> ["vectorize", "vectorize_width", "interleave", >>> "interleave_count", >>> - "unroll", "unroll_count"], >>> + "unroll", "unroll_count", "distribute"], >>> ["Vectorize", "VectorizeWidth", "Interleave", >>> "InterleaveCount", >>> - "Unroll", "UnrollCount"]>, >>> + "Unroll", "UnrollCount", "Distribute"]>, >>> EnumArgument<"State", "LoopHintState", >>> ["enable", "disable", "numeric", "assume_safety", >>> "full"], >>> ["Enable", "Disable", "Numeric", "AssumeSafety", >>> "Full"]>, >>> @@ -2215,6 +2216,7 @@ def LoopHint : Attr { >>> case InterleaveCount: return "interleave_count"; >>> case Unroll: return "unroll"; >>> case UnrollCount: return "unroll_count"; >>> + case Distribute: return "distribute"; >>> } >>> llvm_unreachable("Unhandled LoopHint option."); >>> } >>> >>> Modified: cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td (original) >>> +++ cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td Tue Jun 14 >>> 07:04:26 2016 >>> @@ -977,12 +977,12 @@ def err_omp_declare_target_unexpected_cl >>> // Pragma loop support. >>> def err_pragma_loop_missing_argument : Error< >>> "missing argument; expected %select{an integer value|" >>> - "'enable', %select{'assume_safety'|'full'}1 or 'disable'}0">; >>> + "'enable'%select{|, 'full'}1%select{|, 'assume_safety'}2 or >>> 'disable'}0">; >>> 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">; >>> + "vectorize_width, interleave, interleave_count, unroll, unroll_count, or >>> distribute">; >>> def err_pragma_invalid_keyword : Error< >>> - "invalid argument; expected 'enable', %select{'assume_safety'|'full'}0 >>> or 'disable'">; >>> + "invalid argument; expected 'enable'%select{|, 'full'}0%select{|, >>> 'assume_safety'}1 or 'disable'">; >>> >>> // Pragma unroll support. >>> def warn_pragma_unroll_cuda_value_in_parens : Warning< >>> >>> Modified: cfe/trunk/lib/CodeGen/CGLoopInfo.cpp >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGLoopInfo.cpp?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/lib/CodeGen/CGLoopInfo.cpp (original) >>> +++ cfe/trunk/lib/CodeGen/CGLoopInfo.cpp Tue Jun 14 07:04:26 2016 >>> @@ -26,6 +26,7 @@ static MDNode *createMetadata(LLVMContex >>> Attrs.InterleaveCount == 0 && Attrs.UnrollCount == 0 && >>> Attrs.VectorizeEnable == LoopAttributes::Unspecified && >>> Attrs.UnrollEnable == LoopAttributes::Unspecified && >>> + Attrs.DistributeEnable == LoopAttributes::Unspecified && >>> !Location) >>> return nullptr; >>> >>> @@ -84,6 +85,14 @@ static MDNode *createMetadata(LLVMContex >>> Args.push_back(MDNode::get(Ctx, Vals)); >>> } >>> >>> + if (Attrs.DistributeEnable != LoopAttributes::Unspecified) { >>> + Metadata *Vals[] = {MDString::get(Ctx, "llvm.loop.distribute.enable"), >>> + ConstantAsMetadata::get(ConstantInt::get( >>> + Type::getInt1Ty(Ctx), (Attrs.DistributeEnable >>> == >>> + >>> LoopAttributes::Enable)))}; >>> + Args.push_back(MDNode::get(Ctx, Vals)); >>> + } >>> + >>> // Set the first operand to itself. >>> MDNode *LoopID = MDNode::get(Ctx, Args); >>> LoopID->replaceOperandWith(0, LoopID); >>> @@ -93,7 +102,8 @@ static MDNode *createMetadata(LLVMContex >>> LoopAttributes::LoopAttributes(bool IsParallel) >>> : IsParallel(IsParallel), VectorizeEnable(LoopAttributes::Unspecified), >>> UnrollEnable(LoopAttributes::Unspecified), VectorizeWidth(0), >>> - InterleaveCount(0), UnrollCount(0) {} >>> + InterleaveCount(0), UnrollCount(0), >>> + DistributeEnable(LoopAttributes::Unspecified) {} >>> >>> void LoopAttributes::clear() { >>> IsParallel = false; >>> @@ -172,6 +182,9 @@ void LoopInfoStack::push(BasicBlock *Hea >>> case LoopHintAttr::Unroll: >>> setUnrollState(LoopAttributes::Disable); >>> break; >>> + case LoopHintAttr::Distribute: >>> + setDistributeState(false); >>> + break; >>> case LoopHintAttr::UnrollCount: >>> case LoopHintAttr::VectorizeWidth: >>> case LoopHintAttr::InterleaveCount: >>> @@ -188,6 +201,9 @@ void LoopInfoStack::push(BasicBlock *Hea >>> case LoopHintAttr::Unroll: >>> setUnrollState(LoopAttributes::Enable); >>> break; >>> + case LoopHintAttr::Distribute: >>> + setDistributeState(true); >>> + break; >>> case LoopHintAttr::UnrollCount: >>> case LoopHintAttr::VectorizeWidth: >>> case LoopHintAttr::InterleaveCount: >>> @@ -207,6 +223,7 @@ void LoopInfoStack::push(BasicBlock *Hea >>> case LoopHintAttr::UnrollCount: >>> case LoopHintAttr::VectorizeWidth: >>> case LoopHintAttr::InterleaveCount: >>> + case LoopHintAttr::Distribute: >>> llvm_unreachable("Options cannot be used to assume mem safety."); >>> break; >>> } >>> @@ -221,6 +238,7 @@ void LoopInfoStack::push(BasicBlock *Hea >>> case LoopHintAttr::UnrollCount: >>> case LoopHintAttr::VectorizeWidth: >>> case LoopHintAttr::InterleaveCount: >>> + case LoopHintAttr::Distribute: >>> llvm_unreachable("Options cannot be used with 'full' hint."); >>> break; >>> } >>> @@ -239,6 +257,7 @@ void LoopInfoStack::push(BasicBlock *Hea >>> case LoopHintAttr::Unroll: >>> case LoopHintAttr::Vectorize: >>> case LoopHintAttr::Interleave: >>> + case LoopHintAttr::Distribute: >>> llvm_unreachable("Options cannot be assigned a value."); >>> break; >>> } >>> >>> Modified: cfe/trunk/lib/CodeGen/CGLoopInfo.h >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGLoopInfo.h?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/lib/CodeGen/CGLoopInfo.h (original) >>> +++ cfe/trunk/lib/CodeGen/CGLoopInfo.h Tue Jun 14 07:04:26 2016 >>> @@ -58,6 +58,9 @@ struct LoopAttributes { >>> >>> /// \brief llvm.unroll. >>> unsigned UnrollCount; >>> + >>> + /// \brief Value for llvm.loop.distribute.enable metadata. >>> + LVEnableState DistributeEnable; >>> }; >>> >>> /// \brief Information used when generating a structured loop. >>> @@ -130,6 +133,12 @@ public: >>> Enable ? LoopAttributes::Enable : LoopAttributes::Disable; >>> } >>> >>> + /// \brief Set the next pushed loop as a distribution candidate. >>> + void setDistributeState(bool Enable = true) { >>> + StagedAttrs.DistributeEnable = >>> + Enable ? LoopAttributes::Enable : LoopAttributes::Disable; >>> + } >>> + >>> /// \brief Set the next pushed loop unroll state. >>> void setUnrollState(const LoopAttributes::LVEnableState &State) { >>> StagedAttrs.UnrollEnable = State; >>> >>> Modified: cfe/trunk/lib/Parse/ParsePragma.cpp >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Parse/ParsePragma.cpp?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/lib/Parse/ParsePragma.cpp (original) >>> +++ cfe/trunk/lib/Parse/ParsePragma.cpp Tue Jun 14 07:04:26 2016 >>> @@ -826,20 +826,25 @@ bool Parser::HandlePragmaLoopHint(LoopHi >>> >>> // If no option is specified the argument is assumed to be a constant expr. >>> bool OptionUnroll = false; >>> + bool OptionDistribute = false; >>> bool StateOption = false; >>> if (OptionInfo) { // Pragma Unroll does not specify an option. >>> OptionUnroll = OptionInfo->isStr("unroll"); >>> + OptionDistribute = OptionInfo->isStr("distribute"); >>> StateOption = llvm::StringSwitch<bool>(OptionInfo->getName()) >>> .Case("vectorize", true) >>> .Case("interleave", true) >>> - .Default(false) || OptionUnroll; >>> + .Default(false) || >>> + OptionUnroll || OptionDistribute; >>> } >>> >>> + bool AssumeSafetyArg = !OptionUnroll && !OptionDistribute; >>> // Verify loop hint has an argument. >>> if (Toks[0].is(tok::eof)) { >>> ConsumeToken(); // The annotation token. >>> Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument) >>> - << /*StateArgument=*/StateOption << /*FullKeyword=*/OptionUnroll; >>> + << /*StateArgument=*/StateOption << /*FullKeyword=*/OptionUnroll >>> + << /*AssumeSafetyKeyword=*/AssumeSafetyArg; >>> return false; >>> } >>> >>> @@ -853,11 +858,12 @@ bool Parser::HandlePragmaLoopHint(LoopHi >>> llvm::StringSwitch<bool>(StateInfo->getName()) >>> .Cases("enable", "disable", true) >>> .Case("full", OptionUnroll) >>> - .Case("assume_safety", !OptionUnroll) >>> + .Case("assume_safety", AssumeSafetyArg) >>> .Default(false); >>> if (!Valid) { >>> Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword) >>> - << /*FullKeyword=*/OptionUnroll; >>> + << /*FullKeyword=*/OptionUnroll >>> + << /*AssumeSafetyKeyword=*/AssumeSafetyArg; >>> return false; >>> } >>> if (Toks.size() > 2) >>> @@ -2005,6 +2011,7 @@ void PragmaLoopHintHandler::HandlePragma >>> .Case("vectorize", true) >>> .Case("interleave", true) >>> .Case("unroll", true) >>> + .Case("distribute", true) >>> .Case("vectorize_width", true) >>> .Case("interleave_count", true) >>> .Case("unroll_count", true) >>> >>> Modified: cfe/trunk/lib/Sema/SemaStmtAttr.cpp >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Sema/SemaStmtAttr.cpp?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/lib/Sema/SemaStmtAttr.cpp (original) >>> +++ cfe/trunk/lib/Sema/SemaStmtAttr.cpp Tue Jun 14 07:04:26 2016 >>> @@ -107,6 +107,7 @@ static Attr *handleLoopHintAttr(Sema &S, >>> .Case("interleave_count", LoopHintAttr::InterleaveCount) >>> .Case("unroll", LoopHintAttr::Unroll) >>> .Case("unroll_count", LoopHintAttr::UnrollCount) >>> + .Case("distribute", LoopHintAttr::Distribute) >>> .Default(LoopHintAttr::Vectorize); >>> if (Option == LoopHintAttr::VectorizeWidth || >>> Option == LoopHintAttr::InterleaveCount || >>> @@ -117,7 +118,8 @@ static Attr *handleLoopHintAttr(Sema &S, >>> State = LoopHintAttr::Numeric; >>> } else if (Option == LoopHintAttr::Vectorize || >>> Option == LoopHintAttr::Interleave || >>> - Option == LoopHintAttr::Unroll) { >>> + Option == LoopHintAttr::Unroll || >>> + Option == LoopHintAttr::Distribute) { >>> assert(StateLoc && StateLoc->Ident && "Loop hint must have an >>> argument"); >>> if (StateLoc->Ident->isStr("disable")) >>> State = LoopHintAttr::Disable; >>> @@ -140,18 +142,21 @@ static Attr *handleLoopHintAttr(Sema &S, >>> static void >>> CheckForIncompatibleAttributes(Sema &S, >>> const SmallVectorImpl<const Attr *> &Attrs) { >>> - // There are 3 categories of loop hints attributes: vectorize, >>> interleave, >>> - // and unroll. Each comes in two variants: a state form and a numeric >>> form. >>> - // The state form selectively defaults/enables/disables the >>> transformation >>> - // for the loop (for unroll, default indicates full unrolling rather than >>> - // enabling the transformation). The numeric form form provides an >>> integer >>> - // hint (for example, unroll count) to the transformer. The following >>> array >>> - // accumulates the hints encountered while iterating through the >>> attributes >>> - // to check for compatibility. >>> + // There are 4 categories of loop hints attributes: vectorize, >>> interleave, >>> + // unroll and distribute. Except for distribute they come in two >>> variants: a >>> + // state form and a numeric form. The state form selectively >>> + // defaults/enables/disables the transformation for the loop (for unroll, >>> + // default indicates full unrolling rather than enabling the >>> transformation). >>> + // The numeric form form provides an integer hint (for example, unroll >>> count) >>> + // to the transformer. The following array accumulates the hints >>> encountered >>> + // while iterating through the attributes to check for compatibility. >>> struct { >>> const LoopHintAttr *StateAttr; >>> const LoopHintAttr *NumericAttr; >>> - } HintAttrs[] = {{nullptr, nullptr}, {nullptr, nullptr}, {nullptr, >>> nullptr}}; >>> + } HintAttrs[] = {{nullptr, nullptr}, >>> + {nullptr, nullptr}, >>> + {nullptr, nullptr}, >>> + {nullptr, nullptr}}; >>> >>> for (const auto *I : Attrs) { >>> const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(I); >>> @@ -161,7 +166,7 @@ CheckForIncompatibleAttributes(Sema &S, >>> continue; >>> >>> LoopHintAttr::OptionType Option = LH->getOption(); >>> - enum { Vectorize, Interleave, Unroll } Category; >>> + enum { Vectorize, Interleave, Unroll, Distribute } Category; >>> switch (Option) { >>> case LoopHintAttr::Vectorize: >>> case LoopHintAttr::VectorizeWidth: >>> @@ -175,12 +180,17 @@ CheckForIncompatibleAttributes(Sema &S, >>> case LoopHintAttr::UnrollCount: >>> Category = Unroll; >>> break; >>> + case LoopHintAttr::Distribute: >>> + // Perform the check for duplicated 'distribute' hints. >>> + Category = Distribute; >>> + break; >>> }; >>> >>> auto &CategoryState = HintAttrs[Category]; >>> const LoopHintAttr *PrevAttr; >>> if (Option == LoopHintAttr::Vectorize || >>> - Option == LoopHintAttr::Interleave || Option == >>> LoopHintAttr::Unroll) { >>> + Option == LoopHintAttr::Interleave || Option == >>> LoopHintAttr::Unroll || >>> + Option == LoopHintAttr::Distribute) { >>> // Enable|Disable|AssumeSafety hint. For example, vectorize(enable). >>> PrevAttr = CategoryState.StateAttr; >>> CategoryState.StateAttr = LH; >>> >>> Modified: cfe/trunk/test/CodeGenCXX/pragma-loop.cpp >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/pragma-loop.cpp?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/test/CodeGenCXX/pragma-loop.cpp (original) >>> +++ cfe/trunk/test/CodeGenCXX/pragma-loop.cpp Tue Jun 14 07:04:26 2016 >>> @@ -9,6 +9,7 @@ void while_test(int *List, int Length) { >>> #pragma clang loop interleave_count(4) >>> #pragma clang loop vectorize_width(4) >>> #pragma clang loop unroll(full) >>> +#pragma clang loop distribute(enable) >>> while (i < Length) { >>> // CHECK: br label {{.*}}, !llvm.loop ![[LOOP_1:.*]] >>> List[i] = i * 2; >>> @@ -20,7 +21,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) unroll(disable) >>> +#pragma clang loop vectorize_width(8) interleave_count(4) unroll(disable) >>> distribute(disable) >>> do { >>> // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop >>> ![[LOOP_2:.*]] >>> List[i] = i * 2; >>> @@ -55,7 +56,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) unroll(disable) >>> +#pragma clang loop vectorize(disable) unroll(disable) distribute(disable) >>> for (int i = 0; i < Length; i++) { >>> // CHECK: br label {{.*}}, !llvm.loop ![[LOOP_5:.*]] >>> List[i] = i * 2; >>> @@ -157,20 +158,22 @@ void template_test(double *List, int Len >>> for_template_constant_expression_test<double, 2, 4, 8>(List, Length); >>> } >>> >>> -// CHECK: ![[LOOP_1]] = distinct !{![[LOOP_1]], ![[WIDTH_4:.*]], >>> ![[INTERLEAVE_4:.*]], ![[INTENABLE_1:.*]], ![[UNROLL_FULL:.*]]} >>> +// CHECK: ![[LOOP_1]] = distinct !{![[LOOP_1]], ![[WIDTH_4:.*]], >>> ![[INTERLEAVE_4:.*]], ![[INTENABLE_1:.*]], ![[UNROLL_FULL:.*]], >>> ![[DISTRIBUTE_ENABLE:.*]]} >>> // CHECK: ![[WIDTH_4]] = !{!"llvm.loop.vectorize.width", i32 4} >>> // CHECK: ![[INTERLEAVE_4]] = !{!"llvm.loop.interleave.count", i32 4} >>> // CHECK: ![[INTENABLE_1]] = !{!"llvm.loop.vectorize.enable", i1 true} >>> // CHECK: ![[UNROLL_FULL]] = !{!"llvm.loop.unroll.full"} >>> -// CHECK: ![[LOOP_2]] = distinct !{![[LOOP_2:.*]], ![[WIDTH_8:.*]], >>> ![[INTERLEAVE_4:.*]], ![[UNROLL_DISABLE:.*]]} >>> +// CHECK: ![[DISTRIBUTE_ENABLE]] = !{!"llvm.loop.distribute.enable", i1 >>> true} >>> +// CHECK: ![[LOOP_2]] = distinct !{![[LOOP_2:.*]], ![[WIDTH_8:.*]], >>> ![[INTERLEAVE_4:.*]], ![[UNROLL_DISABLE:.*]], ![[DISTRIBUTE_DISABLE:.*]]} >>> // CHECK: ![[WIDTH_8]] = !{!"llvm.loop.vectorize.width", i32 8} >>> // CHECK: ![[UNROLL_DISABLE]] = !{!"llvm.loop.unroll.disable"} >>> +// CHECK: ![[DISTRIBUTE_DISABLE]] = !{!"llvm.loop.distribute.enable", i1 >>> false} >>> // CHECK: ![[LOOP_3]] = distinct !{![[LOOP_3]], ![[INTERLEAVE_4:.*]], >>> ![[UNROLL_8:.*]], ![[INTENABLE_1:.*]]} >>> // CHECK: ![[UNROLL_8]] = !{!"llvm.loop.unroll.count", i32 8} >>> // CHECK: ![[LOOP_4]] = distinct !{![[LOOP_4]], ![[WIDTH_2:.*]], >>> ![[INTERLEAVE_2:.*]]} >>> // CHECK: ![[WIDTH_2]] = !{!"llvm.loop.vectorize.width", i32 2} >>> // CHECK: ![[INTERLEAVE_2]] = !{!"llvm.loop.interleave.count", i32 2} >>> -// CHECK: ![[LOOP_5]] = distinct !{![[LOOP_5]], ![[WIDTH_1:.*]], >>> ![[UNROLL_DISABLE:.*]]} >>> +// CHECK: ![[LOOP_5]] = distinct !{![[LOOP_5]], ![[WIDTH_1:.*]], >>> ![[UNROLL_DISABLE:.*]], ![[DISTRIBUTE_DISABLE:.*]]} >>> // CHECK: ![[WIDTH_1]] = !{!"llvm.loop.vectorize.width", i32 1} >>> // CHECK: ![[LOOP_6]] = distinct !{![[LOOP_6]], ![[WIDTH_2:.*]], >>> ![[INTERLEAVE_2:.*]], ![[UNROLL_8:.*]]} >>> // CHECK: ![[LOOP_7]] = distinct !{![[LOOP_7]], ![[WIDTH_5:.*]]} >>> >>> Modified: cfe/trunk/test/Misc/ast-print-pragmas.cpp >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Misc/ast-print-pragmas.cpp?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/test/Misc/ast-print-pragmas.cpp (original) >>> +++ cfe/trunk/test/Misc/ast-print-pragmas.cpp Tue Jun 14 07:04:26 2016 >>> @@ -19,7 +19,9 @@ void test(int *List, int Length) { >>> >>> // CHECK: #pragma clang loop interleave(disable) >>> // CHECK-NEXT: #pragma clang loop vectorize(enable) >>> +// CHECK-NEXT: #pragma clang loop distribute(disable) >>> >>> +#pragma clang loop distribute(disable) >>> #pragma clang loop vectorize(enable) >>> #pragma clang loop interleave(disable) >>> // CHECK-NEXT: while (i - 1 < Length) >>> @@ -30,7 +32,9 @@ void test(int *List, int Length) { >>> >>> // CHECK: #pragma clang loop interleave(enable) >>> // CHECK-NEXT: #pragma clang loop vectorize(disable) >>> +// CHECK-NEXT: #pragma clang loop distribute(enable) >>> >>> +#pragma clang loop distribute(enable) >>> #pragma clang loop vectorize(disable) >>> #pragma clang loop interleave(enable) >>> // CHECK-NEXT: while (i - 2 < Length) >>> >>> Modified: cfe/trunk/test/PCH/pragma-loop.cpp >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/PCH/pragma-loop.cpp?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/test/PCH/pragma-loop.cpp (original) >>> +++ cfe/trunk/test/PCH/pragma-loop.cpp Tue Jun 14 07:04:26 2016 >>> @@ -7,9 +7,11 @@ >>> // 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 distribute(enable) >>> // CHECK: #pragma clang loop unroll(disable) >>> // CHECK: #pragma clang loop interleave(disable) >>> // CHECK: #pragma clang loop vectorize(enable) >>> +// CHECK: #pragma clang loop distribute(disable) >>> // CHECK: #pragma clang loop unroll(full) >>> // CHECK: #pragma clang loop interleave(enable) >>> // CHECK: #pragma clang loop vectorize(disable) >>> @@ -40,6 +42,7 @@ public: >>> #pragma clang loop vectorize(enable) >>> #pragma clang loop interleave(disable) >>> #pragma clang loop unroll(disable) >>> +#pragma clang loop distribute(enable) >>> while (i - 1 < Length) { >>> List[i] = i; >>> i++; >>> @@ -51,6 +54,7 @@ public: >>> #pragma clang loop vectorize(disable) >>> #pragma clang loop interleave(enable) >>> #pragma clang loop unroll(full) >>> +#pragma clang loop distribute(disable) >>> while (i - 3 < Length) { >>> List[i] = i; >>> i++; >>> >>> Modified: cfe/trunk/test/Parser/pragma-loop-safety.cpp >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Parser/pragma-loop-safety.cpp?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/test/Parser/pragma-loop-safety.cpp (original) >>> +++ cfe/trunk/test/Parser/pragma-loop-safety.cpp Tue Jun 14 07:04:26 2016 >>> @@ -16,6 +16,7 @@ void test(int *List, int Length) { >>> /* expected-error {{expected ')'}} */ #pragma clang loop >>> interleave(assume_safety >>> >>> /* expected-error {{invalid argument; expected 'enable', 'full' or >>> 'disable'}} */ #pragma clang loop unroll(assume_safety) >>> +/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ >>> #pragma clang loop distribute(assume_safety) >>> >>> /* expected-error {{invalid argument; expected 'enable', 'assume_safety' or >>> 'disable'}} */ #pragma clang loop vectorize(badidentifier) >>> /* expected-error {{invalid argument; expected 'enable', 'assume_safety' or >>> 'disable'}} */ #pragma clang loop interleave(badidentifier) >>> >>> Modified: cfe/trunk/test/Parser/pragma-loop.cpp >>> URL: >>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/Parser/pragma-loop.cpp?rev=272656&r1=272655&r2=272656&view=diff >>> ============================================================================== >>> --- cfe/trunk/test/Parser/pragma-loop.cpp (original) >>> +++ cfe/trunk/test/Parser/pragma-loop.cpp Tue Jun 14 07:04:26 2016 >>> @@ -116,15 +116,27 @@ void test(int *List, int Length) { >>> VList[j] = List[j]; >>> } >>> >>> +#pragma clang loop distribute(enable) >>> + for (int j : VList) { >>> + VList[j] = List[j]; >>> + } >>> + >>> +#pragma clang loop distribute(disable) >>> + for (int j : VList) { >>> + VList[j] = List[j]; >>> + } >>> + >>> test_nontype_template_param<4, 8>(List, Length); >>> >>> /* 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 distribute >>> >>> /* expected-error {{expected ')'}} */ #pragma clang loop vectorize(enable >>> /* expected-error {{expected ')'}} */ #pragma clang loop interleave(enable >>> /* expected-error {{expected ')'}} */ #pragma clang loop unroll(full >>> +/* expected-error {{expected ')'}} */ #pragma clang loop distribute(enable >>> >>> /* expected-error {{expected ')'}} */ #pragma clang loop vectorize_width(4 >>> /* expected-error {{expected ')'}} */ #pragma clang loop interleave_count(4 >>> @@ -133,8 +145,9 @@ void test(int *List, int Length) { >>> /* expected-error {{missing argument; expected 'enable', 'assume_safety' or >>> 'disable'}} */ #pragma clang loop vectorize() >>> /* expected-error {{missing argument; expected an integer value}} */ >>> #pragma clang loop interleave_count() >>> /* expected-error {{missing argument; expected 'enable', 'full' or >>> 'disable'}} */ #pragma clang loop unroll() >>> +/* expected-error {{missing argument; expected 'enable' or 'disable'}} */ >>> #pragma clang loop distribute() >>> >>> -/* expected-error {{missing option; expected vectorize, vectorize_width, >>> interleave, interleave_count, unroll, or unroll_count}} */ #pragma clang >>> loop >>> +/* expected-error {{missing option; expected vectorize, vectorize_width, >>> interleave, interleave_count, unroll, unroll_count, or distribute}} */ >>> #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) >>> @@ -187,6 +200,7 @@ const int VV = 4; >>> /* expected-error {{invalid argument; expected 'enable', 'assume_safety' or >>> 'disable'}} */ #pragma clang loop vectorize(badidentifier) >>> /* expected-error {{invalid argument; expected 'enable', 'assume_safety' or >>> 'disable'}} */ #pragma clang loop interleave(badidentifier) >>> /* expected-error {{invalid argument; expected 'enable', 'full' or >>> 'disable'}} */ #pragma clang loop unroll(badidentifier) >>> +/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ >>> #pragma clang loop distribute(badidentifier) >>> while (i-7 < Length) { >>> List[i] = i; >>> } >>> @@ -196,6 +210,7 @@ const int VV = 4; >>> /* expected-error {{expected ')'}} */ #pragma clang loop vectorize(() >>> /* expected-error {{invalid argument; expected 'enable', 'assume_safety' or >>> 'disable'}} */ #pragma clang loop interleave(*) >>> /* expected-error {{invalid argument; expected 'enable', 'full' or >>> 'disable'}} */ #pragma clang loop unroll(=) >>> +/* expected-error {{invalid argument; expected 'enable' or 'disable'}} */ >>> #pragma clang loop distribute(+) >>> /* expected-error {{type name requires a specifier or qualifier}} >>> expected-error {{expected expression}} */ #pragma clang loop >>> vectorize_width(^) >>> /* expected-error {{expected expression}} expected-error {{expected >>> expression}} */ #pragma clang loop interleave_count(/) >>> /* expected-error {{expected expression}} expected-error {{expected >>> expression}} */ #pragma clang loop unroll_count(==) >>> @@ -232,6 +247,8 @@ const int VV = 4; >>> #pragma clang loop interleave(disable) >>> /* expected-error {{duplicate directives 'unroll(disable)' and >>> 'unroll(full)'}} */ #pragma clang loop unroll(full) >>> #pragma clang loop unroll(disable) >>> +/* expected-error {{duplicate directives 'distribute(disable)' and >>> 'distribute(enable)'}} */ #pragma clang loop distribute(enable) >>> +#pragma clang loop distribute(disable) >>> while (i-9 < Length) { >>> List[i] = i; >>> } >>> >>> >>> _______________________________________________ >>> cfe-commits mailing list >>> cfe-commits@lists.llvm.org >>> http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits > > _______________________________________________ > cfe-commits mailing list > cfe-commits@lists.llvm.org > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
