[PATCH] #pragma vectorize
Aaron Ballman
aaron at aaronballman.com
Tue Jun 3 06:35:21 PDT 2014
Minor nits below, but otherwise LGTM! Thank you for all of your hard
work on this!
> Index: include/clang/Basic/Attr.td
> ===================================================================
> --- include/clang/Basic/Attr.td (revision 210052)
> +++ include/clang/Basic/Attr.td (working copy)
> @@ -1760,3 +1760,50 @@
> def Unaligned : IgnoredAttr {
> let Spellings = [Keyword<"__unaligned">];
> }
> +
> +def LoopHint : Attr {
> + /// vectorize: vectorizes loop operations if 'value != 0'.
> + /// vectorize_width: vectorize loop operations with width 'value'.
> + /// interleave: interleave multiple loop iterations if 'value != 0'.
> + /// interleave_count: interleaves 'value' loop interations.
> +
> + /// FIXME: Add Pragma spelling to tablegen and
> + /// use it here.
> + let Spellings = [Keyword<"loop">];
> +
> + /// State of the loop optimization specified by the spelling.
> + let Args = [EnumArgument<"Option", "OptionType",
> + ["vectorize", "vectorize_width", "interleave", "interleave_count"],
> + ["Vectorize", "VectorizeWidth", "Interleave", "InterleaveCount"]>,
> + DefaultIntArgument<"Value", 1>];
> +
> + let AdditionalMembers = [{
> + static StringRef getOptionName(int Option) {
> + switch(Option) {
> + case Vectorize: return "vectorize";
> + case VectorizeWidth: return "vectorize_width";
> + case Interleave: return "interleave";
> + case InterleaveCount: return "interleave_count";
> + }
> + llvm_unreachable("Unhandled LoopHint option.");
> + }
> +
> + static StringRef getValueName(int Value) {
> + if (Value)
> + return "enable";
> + return "disable";
> + }
> +
> + // 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)
> + OS << value;
> + else
> + OS << getValueName(value);
> + OS << ")\n";
> + }
> + }];
> +
> + let Documentation = [Undocumented];
> +}
> Index: include/clang/Basic/DiagnosticParseKinds.td
> ===================================================================
> --- include/clang/Basic/DiagnosticParseKinds.td (revision 210052)
> +++ include/clang/Basic/DiagnosticParseKinds.td (working copy)
> @@ -892,6 +892,10 @@
> "unexpected OpenMP clause '%0' in directive '#pragma omp %1'">;
> def err_omp_more_one_clause : Error<
> "directive '#pragma omp %0' cannot contain more than one '%1' clause">;
> +
> +// Pragma loop support.
> +def err_pragma_loop_invalid_option : Error<
> + "%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, vectorize_width, interleave, or interleave_count">;
> } // end of Parse Issue category.
>
> let CategoryName = "Modules Issue" in {
> Index: include/clang/Basic/DiagnosticSemaKinds.td
> ===================================================================
> --- include/clang/Basic/DiagnosticSemaKinds.td (revision 210052)
> +++ include/clang/Basic/DiagnosticSemaKinds.td (working copy)
> @@ -542,6 +542,15 @@
> "#pragma visibility pop with no matching #pragma visibility push">;
> def note_surrounding_namespace_starts_here : Note<
> "surrounding namespace with visibility attribute starts here">;
> +def err_pragma_loop_invalid_value : Error<
> + "%select{invalid|missing}0 value%select{ %1|}0; expected a positive integer value">;
> +def err_pragma_loop_invalid_keyword : Error<
> + "%select{invalid|missing}0 keyword%select{ %1|}0; expected 'enable' or 'disable'">;
> +def err_pragma_loop_compatibility : Error<
> + "%select{incompatible|duplicate}0 directives '%1(%2)' and '%3(%4)'">;
> +def err_pragma_loop_precedes_nonloop : Error<
> + "expected a for, while, or do-while loop to follow the '#pragma clang loop' "
> + "directive">;
>
> /// Objective-C parser diagnostics
> def err_duplicate_class_def : Error<
> Index: include/clang/Basic/TokenKinds.def
> ===================================================================
> --- include/clang/Basic/TokenKinds.def (revision 210052)
> +++ include/clang/Basic/TokenKinds.def (working copy)
> @@ -701,6 +701,11 @@
> ANNOTATION(pragma_openmp)
> ANNOTATION(pragma_openmp_end)
>
> +// Annotations for loop pragma directives #pragma clang loop ...
> +// The lexer produces these so that they only take effect when the parser
> +// handles #pragma loop ... directives.
> +ANNOTATION(pragma_loop_hint)
> +
> // Annotations for module import translated from #include etc.
> ANNOTATION(module_include)
> ANNOTATION(module_begin)
> Index: include/clang/Parse/Parser.h
> ===================================================================
> --- include/clang/Parse/Parser.h (revision 210052)
> +++ include/clang/Parse/Parser.h (working copy)
> @@ -20,6 +20,7 @@
> #include "clang/Lex/CodeCompletionHandler.h"
> #include "clang/Lex/Preprocessor.h"
> #include "clang/Sema/DeclSpec.h"
> +#include "clang/Sema/LoopHint.h"
> #include "clang/Sema/Sema.h"
> #include "llvm/ADT/SmallVector.h"
> #include "llvm/Support/Compiler.h"
> @@ -161,6 +162,7 @@
> std::unique_ptr<PragmaHandler> MSCodeSeg;
> std::unique_ptr<PragmaHandler> MSSection;
> std::unique_ptr<PragmaHandler> OptimizeHandler;
> + std::unique_ptr<PragmaHandler> LoopHintHandler;
>
> std::unique_ptr<CommentHandler> CommentSemaHandler;
>
> @@ -519,6 +521,10 @@
> /// #pragma clang __debug captured
> StmtResult HandlePragmaCaptured();
>
> + /// \brief Handle the annotation token produced for
> + /// #pragma vectorize...
> + LoopHint HandlePragmaLoopHint();
> +
> /// GetLookAheadToken - This peeks ahead N tokens and returns that token
> /// without consuming any tokens. LookAhead(0) returns 'Tok', LookAhead(1)
> /// returns the token after Tok, etc.
> @@ -1601,6 +1607,9 @@
> StmtResult ParseReturnStatement();
> StmtResult ParseAsmStatement(bool &msAsm);
> StmtResult ParseMicrosoftAsmStatement(SourceLocation AsmLoc);
> + StmtResult ParsePragmaLoopHint(StmtVector &Stmts, bool OnlyStatement,
> + SourceLocation *TrailingElseLoc,
> + ParsedAttributesWithRange &Attrs);
>
> /// \brief Describes the behavior that should be taken for an __if_exists
> /// block.
> Index: include/clang/Sema/LoopHint.h
> ===================================================================
> --- include/clang/Sema/LoopHint.h (revision 0)
> +++ include/clang/Sema/LoopHint.h (working copy)
> @@ -0,0 +1,31 @@
> +//===--- LoopHint.h - Types for LoopHint ------------------------*- C++ -*-===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_CLANG_SEMA_LOOPHINT_H
> +#define LLVM_CLANG_SEMA_LOOPHINT_H
> +
> +#include "clang/Basic/IdentifierTable.h"
> +#include "clang/Basic/SourceLocation.h"
> +#include "clang/Sema/AttributeList.h"
> +#include "clang/Sema/Ownership.h"
> +
> +namespace clang {
> +
> +/// \brief Loop hint specified by a pragma loop directive.
> +struct LoopHint {
> + SourceRange Range;
> + Expr *ValueExpr;
> + IdentifierLoc *LoopLoc;
> + IdentifierLoc *ValueLoc;
> + IdentifierLoc *OptionLoc;
> +};
> +
> +} // end namespace clang
> +
> +#endif // LLVM_CLANG_SEMA_LOOPHINT_H
> Index: lib/AST/StmtPrinter.cpp
> ===================================================================
> --- lib/AST/StmtPrinter.cpp (revision 210052)
> +++ lib/AST/StmtPrinter.cpp (working copy)
> @@ -168,8 +168,22 @@
> }
>
> void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
> - for (const auto *Attr : Node->getAttrs())
> - Attr->printPretty(OS, Policy);
> + std::string raw_attr_os;
> + llvm::raw_string_ostream AttrOS(raw_attr_os);
> + for (const auto *Attr : Node->getAttrs()) {
> + // FIXME: This hack will be removed when printPretty
> + // has been modified to print pretty pragmas
> + if (const LoopHintAttr *LHA = dyn_cast<LoopHintAttr>(Attr)) {
> + LHA->print(OS, Policy);
> + } else
> + Attr->printPretty(AttrOS, Policy);
> + }
> +
> + // Print attributes after pragmas.
> + StringRef AttrStr = AttrOS.str();
> + if (!AttrStr.empty())
> + OS << AttrStr;
> +
> PrintStmt(Node->getSubStmt(), 0);
> }
>
> Index: lib/CodeGen/CGStmt.cpp
> ===================================================================
> --- lib/CodeGen/CGStmt.cpp (revision 210052)
> +++ lib/CodeGen/CGStmt.cpp (working copy)
> @@ -18,6 +18,7 @@
> #include "clang/AST/StmtVisitor.h"
> #include "clang/Basic/PrettyStackTrace.h"
> #include "clang/Basic/TargetInfo.h"
> +#include "clang/Sema/LoopHint.h"
> #include "clang/Sema/SemaDiagnostic.h"
> #include "llvm/ADT/StringExtras.h"
> #include "llvm/IR/CallSite.h"
> @@ -398,7 +399,23 @@
> }
>
> void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) {
> - EmitStmt(S.getSubStmt());
> + const Stmt *SubStmt = S.getSubStmt();
> + switch (SubStmt->getStmtClass()) {
> + case Stmt::DoStmtClass:
> + EmitDoStmt(cast<DoStmt>(*SubStmt), S.getAttrs());
> + break;
> + case Stmt::ForStmtClass:
> + EmitForStmt(cast<ForStmt>(*SubStmt), S.getAttrs());
> + break;
> + case Stmt::WhileStmtClass:
> + EmitWhileStmt(cast<WhileStmt>(*SubStmt), S.getAttrs());
> + break;
> + case Stmt::CXXForRangeStmtClass:
> + EmitCXXForRangeStmt(cast<CXXForRangeStmt>(*SubStmt), S.getAttrs());
> + break;
> + default:
> + EmitStmt(SubStmt);
> + }
> }
>
> void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) {
> @@ -504,7 +521,70 @@
> EmitBlock(ContBlock, true);
> }
>
> -void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) {
> +void CodeGenFunction::EmitCondBrHints(llvm::LLVMContext &Context,
> + llvm::BranchInst *CondBr,
> + const ArrayRef<const Attr *> &Attrs) {
> + // Return if there are no hints.
> + if (Attrs.empty())
> + return;
> +
> + // Add vectorize hints to the metadata on the conditional branch.
> + SmallVector<llvm::Value *, 2> Metadata(1);
> + for (auto Attr : Attrs) {
const auto *Attr instead of just auto.
> + const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(Attr);
> +
> + // Skip non loop hint attributes
> + if (!LH)
> + continue;
> +
> + LoopHintAttr::OptionType Option = LH->getOption();
> + int ValueInt = LH->getValue();
> +
> + // FIXME: In the future I will modifiy the behavior of the metadata
> + // so we can enable/disable vectorization and interleaving separately.
> + llvm::Value *Value;
> + llvm::MDString *Name;
> + const char *MetadataNames[] = {
> + "llvm.vectorizer.width", "llvm.vectorizer.width",
> + "llvm.vectorizer.unroll", "llvm.vectorizer.unroll"};
> +
> + switch (Option) {
> + case LoopHintAttr::Vectorize:
> + case LoopHintAttr::Interleave:
> + if (ValueInt == 1) {
> + Name = llvm::MDString::get(Context, "llvm.vectorizer.enable");
> + Value = Builder.getTrue();
> + break;
> + }
> + // Vectorization/interleaving is disabled, set width/count to 1.
> + ValueInt = 1;
> + // Fallthrough.
We should add [[clang::fallthrough]] to Compiler.h and use it here. :-)
> + case LoopHintAttr::VectorizeWidth:
> + case LoopHintAttr::InterleaveCount:
> + Name = llvm::MDString::get(Context, MetadataNames[Option]);
> + Value = llvm::ConstantInt::get(Int32Ty, ValueInt);
> + break;
> + }
> +
> + SmallVector<llvm::Value *, 2> OpValues;
> + OpValues.push_back(Name);
> + OpValues.push_back(Value);
> +
> + // Set or overwrite metadata indicated by Name.
> + Metadata.push_back(llvm::MDNode::get(Context, OpValues));
> + }
> +
> + if (!Metadata.empty()) {
> + // Add llvm.loop MDNode to CondBr.
> + llvm::MDNode *LoopID = llvm::MDNode::get(Context, Metadata);
> + LoopID->replaceOperandWith(0, LoopID); // First op points to itself.
> +
> + CondBr->setMetadata("llvm.loop", LoopID);
> + }
> +}
> +
> +void CodeGenFunction::EmitWhileStmt(const WhileStmt &S,
> + const ArrayRef<const Attr *> &WhileAttrs) {
> RegionCounter Cnt = getPGORegionCounter(&S);
>
> // Emit the header for the loop, which will also become
> @@ -551,13 +631,17 @@
> llvm::BasicBlock *ExitBlock = LoopExit.getBlock();
> if (ConditionScope.requiresCleanups())
> ExitBlock = createBasicBlock("while.exit");
> - Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock,
> - PGO.createLoopWeights(S.getCond(), Cnt));
> + llvm::BranchInst *CondBr =
> + Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock,
> + PGO.createLoopWeights(S.getCond(), Cnt));
>
> if (ExitBlock != LoopExit.getBlock()) {
> EmitBlock(ExitBlock);
> EmitBranchThroughCleanup(LoopExit);
> }
> +
> + // Attach metadata to loop body conditional branch.
> + EmitCondBrHints(LoopBody->getContext(), CondBr, WhileAttrs);
> }
>
> // Emit the loop body. We have to emit this in a cleanup scope
> @@ -588,7 +672,8 @@
> SimplifyForwardingBlocks(LoopHeader.getBlock());
> }
>
> -void CodeGenFunction::EmitDoStmt(const DoStmt &S) {
> +void CodeGenFunction::EmitDoStmt(const DoStmt &S,
> + const ArrayRef<const Attr *> &DoAttrs) {
> JumpDest LoopExit = getJumpDestInCurrentScope("do.end");
> JumpDest LoopCond = getJumpDestInCurrentScope("do.cond");
>
> @@ -628,10 +713,15 @@
> EmitBoolCondBranch = false;
>
> // As long as the condition is true, iterate the loop.
> - if (EmitBoolCondBranch)
> - Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock(),
> - PGO.createLoopWeights(S.getCond(), Cnt));
> + if (EmitBoolCondBranch) {
> + llvm::BranchInst *CondBr =
> + Builder.CreateCondBr(BoolCondVal, LoopBody, LoopExit.getBlock(),
> + PGO.createLoopWeights(S.getCond(), Cnt));
>
> + // Attach metadata to loop body conditional branch.
> + EmitCondBrHints(LoopBody->getContext(), CondBr, DoAttrs);
> + }
> +
> LoopStack.pop();
>
> // Emit the exit block.
> @@ -643,7 +733,8 @@
> SimplifyForwardingBlocks(LoopCond.getBlock());
> }
>
> -void CodeGenFunction::EmitForStmt(const ForStmt &S) {
> +void CodeGenFunction::EmitForStmt(const ForStmt &S,
> + const ArrayRef<const Attr *> &ForAttrs) {
> JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
>
> RunCleanupsScope ForScope(*this);
> @@ -699,9 +790,13 @@
> // C99 6.8.5p2/p4: The first substatement is executed if the expression
> // compares unequal to 0. The condition must be a scalar type.
> llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
> - Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock,
> - PGO.createLoopWeights(S.getCond(), Cnt));
> + llvm::BranchInst *CondBr =
> + Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock,
> + PGO.createLoopWeights(S.getCond(), Cnt));
>
> + // Attach metadata to loop body conditional branch.
> + EmitCondBrHints(ForBody->getContext(), CondBr, ForAttrs);
> +
> if (ExitBlock != LoopExit.getBlock()) {
> EmitBlock(ExitBlock);
> EmitBranchThroughCleanup(LoopExit);
> @@ -743,7 +838,9 @@
> EmitBlock(LoopExit.getBlock(), true);
> }
>
> -void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) {
> +void
> +CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S,
> + const ArrayRef<const Attr *> &ForAttrs) {
> JumpDest LoopExit = getJumpDestInCurrentScope("for.end");
>
> RunCleanupsScope ForScope(*this);
> @@ -778,9 +875,12 @@
> // The body is executed if the expression, contextually converted
> // to bool, is true.
> llvm::Value *BoolCondVal = EvaluateExprAsBool(S.getCond());
> - Builder.CreateCondBr(BoolCondVal, ForBody, ExitBlock,
> - PGO.createLoopWeights(S.getCond(), Cnt));
> + llvm::BranchInst *CondBr = Builder.CreateCondBr(
> + BoolCondVal, ForBody, ExitBlock, PGO.createLoopWeights(S.getCond(), Cnt));
>
> + // Attach metadata to loop body conditional branch.
> + EmitCondBrHints(ForBody->getContext(), CondBr, ForAttrs);
> +
> if (ExitBlock != LoopExit.getBlock()) {
> EmitBlock(ExitBlock);
> EmitBranchThroughCleanup(LoopExit);
> Index: lib/CodeGen/CodeGenFunction.h
> ===================================================================
> --- lib/CodeGen/CodeGenFunction.h (revision 210052)
> +++ lib/CodeGen/CodeGenFunction.h (working copy)
> @@ -1856,9 +1856,14 @@
> void EmitGotoStmt(const GotoStmt &S);
> void EmitIndirectGotoStmt(const IndirectGotoStmt &S);
> void EmitIfStmt(const IfStmt &S);
> - void EmitWhileStmt(const WhileStmt &S);
> - void EmitDoStmt(const DoStmt &S);
> - void EmitForStmt(const ForStmt &S);
> +
> + void EmitCondBrHints(llvm::LLVMContext &Context, llvm::BranchInst *CondBr,
> + const ArrayRef<const Attr *> &Attrs);
> + void EmitWhileStmt(const WhileStmt &S,
> + const ArrayRef<const Attr *> &Attrs = None);
> + void EmitDoStmt(const DoStmt &S, const ArrayRef<const Attr *> &Attrs = None);
> + void EmitForStmt(const ForStmt &S,
> + const ArrayRef<const Attr *> &Attrs = None);
> void EmitReturnStmt(const ReturnStmt &S);
> void EmitDeclStmt(const DeclStmt &S);
> void EmitBreakStmt(const BreakStmt &S);
> @@ -1882,7 +1887,8 @@
>
> void EmitCXXTryStmt(const CXXTryStmt &S);
> void EmitSEHTryStmt(const SEHTryStmt &S);
> - void EmitCXXForRangeStmt(const CXXForRangeStmt &S);
> + void EmitCXXForRangeStmt(const CXXForRangeStmt &S,
> + const ArrayRef<const Attr *> &Attrs = None);
>
> llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K);
> llvm::Function *GenerateCapturedStmtFunction(const CapturedDecl *CD,
> Index: lib/Parse/ParsePragma.cpp
> ===================================================================
> --- lib/Parse/ParsePragma.cpp (revision 210052)
> +++ lib/Parse/ParsePragma.cpp (working copy)
> @@ -15,6 +15,7 @@
> #include "clang/Lex/Preprocessor.h"
> #include "clang/Parse/ParseDiagnostic.h"
> #include "clang/Parse/Parser.h"
> +#include "clang/Sema/LoopHint.h"
> #include "clang/Sema/Scope.h"
> #include "llvm/ADT/StringSwitch.h"
> using namespace clang;
> @@ -141,6 +142,12 @@
> Sema &Actions;
> };
>
> +struct PragmaLoopHintHandler : public PragmaHandler {
> + PragmaLoopHintHandler() : PragmaHandler("loop") {}
> + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
> + Token &FirstToken) override;
> +};
> +
> } // end namespace
>
> void Parser::initializePragmaHandlers() {
> @@ -208,6 +215,9 @@
>
> OptimizeHandler.reset(new PragmaOptimizeHandler(Actions));
> PP.AddPragmaHandler("clang", OptimizeHandler.get());
> +
> + LoopHintHandler.reset(new PragmaLoopHintHandler());
> + PP.AddPragmaHandler("clang", LoopHintHandler.get());
> }
>
> void Parser::resetPragmaHandlers() {
> @@ -265,6 +275,9 @@
>
> PP.RemovePragmaHandler("clang", OptimizeHandler.get());
> OptimizeHandler.reset();
> +
> + PP.RemovePragmaHandler("clang", LoopHintHandler.get());
> + LoopHintHandler.reset();
> }
>
> /// \brief Handle the annotation token produced for #pragma unused(...)
> @@ -586,6 +599,40 @@
> DiagnosticsEngine::Error, "'#pragma %0' not implemented.");
> }
>
> +struct PragmaLoopHintInfo {
> + Token Loop;
> + Token Value;
> + Token Option;
> +};
> +
> +LoopHint Parser::HandlePragmaLoopHint() {
> + assert(Tok.is(tok::annot_pragma_loop_hint));
> + PragmaLoopHintInfo *Info =
> + static_cast<PragmaLoopHintInfo *>(Tok.getAnnotationValue());
> +
> + LoopHint Hint;
> + Hint.LoopLoc =
> + IdentifierLoc::create(Actions.Context, Info->Loop.getLocation(),
> + Info->Loop.getIdentifierInfo());
> + Hint.OptionLoc =
> + IdentifierLoc::create(Actions.Context, Info->Option.getLocation(),
> + Info->Option.getIdentifierInfo());
> + Hint.ValueLoc =
> + IdentifierLoc::create(Actions.Context, Info->Value.getLocation(),
> + Info->Value.getIdentifierInfo());
> + Hint.Range =
> + SourceRange(Info->Option.getLocation(), Info->Value.getLocation());
> +
> + // FIXME: We should support template parameters for the loop hint value.
> + // See bug report #19610
> + if (Info->Value.is(tok::numeric_constant))
> + Hint.ValueExpr = Actions.ActOnNumericConstant(Info->Value).get();
> + else
> + Hint.ValueExpr = nullptr;
> +
> + return Hint;
> +}
> +
> // #pragma GCC visibility comes in two variants:
> // 'push' '(' [visibility] ')'
> // 'pop'
> @@ -1584,3 +1631,110 @@
>
> Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
> }
> +
> +/// \brief Handle the \#pragma clang loop directive.
> +/// #pragma clang 'loop' loop-hints
> +///
> +/// loop-hints:
> +/// loop-hint loop-hints[opt]
> +///
> +/// loop-hint:
> +/// 'vectorize' '(' loop-hint-keyword ')'
> +/// 'interleave' '(' loop-hint-keyword ')'
> +/// 'vectorize_width' '(' loop-hint-value ')'
> +/// 'interleave_count' '(' loop-hint-value ')'
> +///
> +/// loop-hint-keyword:
> +/// 'enable'
> +/// 'disable'
> +///
> +/// loop-hint-value:
> +/// constant-expression
> +///
> +/// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to
> +/// try vectorizing the instructions of the loop it precedes. Specifying
> +/// interleave(enable) or interleave_count(_value_) instructs llvm to try
> +/// interleaving multiple iterations of the loop it precedes. The width of the
> +/// vector instructions is specified by vectorize_width() and the number of
> +/// interleaved loop iterations is specified by interleave_count(). Specifying a
> +/// value of 1 effectively disables vectorization/interleaving, even if it is
> +/// possible and profitable, and 0 is invalid. The loop vectorizer currently
> +/// only works on inner loops.
> +///
> +void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP,
> + PragmaIntroducerKind Introducer,
> + Token &Tok) {
> + Token Loop = Tok;
> + SmallVector<Token, 1> TokenList;
> +
> + // Lex the optimization option and verify it is an identifier.
> + PP.Lex(Tok);
> + if (Tok.isNot(tok::identifier)) {
> + PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
> + << /*MissingOption=*/true << "";
> + return;
> + }
> +
> + while (Tok.is(tok::identifier)) {
> + Token Option = Tok;
> + IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();
> +
> + if (!OptionInfo->isStr("vectorize") && !OptionInfo->isStr("interleave") &&
> + !OptionInfo->isStr("vectorize_width") &&
> + !OptionInfo->isStr("interleave_count")) {
> + PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
> + << /*MissingOption=*/false << OptionInfo;
> + return;
> + }
> +
> + // Read '('
> + PP.Lex(Tok);
> + if (Tok.isNot(tok::l_paren)) {
> + PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
> + return;
> + }
> +
> + // FIXME: All tokens between '(' and ')' should be stored and parsed as a
> + // constant expression.
> + PP.Lex(Tok);
> + Token Value;
> + if (Tok.is(tok::identifier) || Tok.is(tok::numeric_constant))
> + Value = Tok;
> +
> + // Read ')'
> + PP.Lex(Tok);
> + if (Tok.isNot(tok::r_paren)) {
> + PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
> + return;
> + }
> +
> + // Get next optimization option.
> + PP.Lex(Tok);
> +
> + auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
> + Info->Loop = Loop;
> + Info->Option = Option;
> + Info->Value = Value;
> +
> + // Generate the vectorization hint token.
> + Token LoopHintTok;
> + LoopHintTok.startToken();
> + LoopHintTok.setKind(tok::annot_pragma_loop_hint);
> + LoopHintTok.setLocation(Loop.getLocation());
> + LoopHintTok.setAnnotationValue(static_cast<void *>(Info));
> + TokenList.push_back(LoopHintTok);
> + }
> +
> + if (Tok.isNot(tok::eod)) {
> + PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
> + << "clang loop";
> + return;
> + }
> +
> + Token *TokenArray = new Token[TokenList.size()];
> + std::copy(TokenList.begin(), TokenList.end(), TokenArray);
> +
> + PP.EnterTokenStream(TokenArray, TokenList.size(),
> + /*DisableMacroExpansion=*/false,
> + /*OwnsTokens=*/true);
> +}
> Index: lib/Parse/ParseStmt.cpp
> ===================================================================
> --- lib/Parse/ParseStmt.cpp (revision 210052)
> +++ lib/Parse/ParseStmt.cpp (working copy)
> @@ -15,11 +15,13 @@
> #include "clang/Parse/Parser.h"
> #include "RAIIObjectsForParser.h"
> #include "clang/AST/ASTContext.h"
> +#include "clang/Basic/Attributes.h"
> #include "clang/Basic/Diagnostic.h"
> #include "clang/Basic/PrettyStackTrace.h"
> #include "clang/Basic/SourceManager.h"
> #include "clang/Basic/TargetInfo.h"
> #include "clang/Sema/DeclSpec.h"
> +#include "clang/Sema/LoopHint.h"
> #include "clang/Sema/PrettyDeclStackTrace.h"
> #include "clang/Sema/Scope.h"
> #include "clang/Sema/TypoCorrection.h"
> @@ -357,6 +359,10 @@
> ProhibitAttributes(Attrs);
> HandlePragmaMSPragma();
> return StmtEmpty();
> +
> + case tok::annot_pragma_loop_hint:
> + ProhibitAttributes(Attrs);
> + return ParsePragmaLoopHint(Stmts, OnlyStatement, TrailingElseLoc, Attrs);
> }
>
> // If we reached this code, the statement must end in a semicolon.
> @@ -1759,6 +1765,37 @@
> return Actions.ActOnReturnStmt(ReturnLoc, R.get(), getCurScope());
> }
>
> +StmtResult Parser::ParsePragmaLoopHint(StmtVector &Stmts, bool OnlyStatement,
> + SourceLocation *TrailingElseLoc,
> + ParsedAttributesWithRange &Attrs) {
> + // Create temporary attribute list.
> + ParsedAttributesWithRange TempAttrs(AttrFactory);
> +
> + // Get vectorize hints and consume annotated token.
> + while (Tok.is(tok::annot_pragma_loop_hint)) {
> + LoopHint Hint = HandlePragmaLoopHint();
> + ConsumeToken();
> +
> + if (!Hint.LoopLoc || !Hint.OptionLoc || !Hint.ValueLoc)
> + continue;
> +
> + ArgsUnion ArgHints[] = {Hint.OptionLoc, Hint.ValueLoc,
> + ArgsUnion(Hint.ValueExpr)};
> + // FIXME: Replace AS_Keyword with Pragma spelling AS_Pragma.
> + TempAttrs.addNew(Hint.LoopLoc->Ident, Hint.Range, 0, Hint.LoopLoc->Loc,
> + ArgHints, 3, AttributeList::AS_Keyword);
> + }
> +
> + // Get the next statement.
> + MaybeParseCXX11Attributes(Attrs);
> +
> + StmtResult S = ParseStatementOrDeclarationAfterAttributes(
> + Stmts, OnlyStatement, TrailingElseLoc, Attrs);
> +
> + Attrs.takeAllFrom(TempAttrs);
> + return S;
> +}
> +
> namespace {
> class ClangAsmParserCallback : public llvm::MCAsmParserSemaCallback {
> Parser &TheParser;
> Index: lib/Sema/SemaStmtAttr.cpp
> ===================================================================
> --- lib/Sema/SemaStmtAttr.cpp (revision 210052)
> +++ lib/Sema/SemaStmtAttr.cpp (working copy)
> @@ -16,6 +16,7 @@
> #include "clang/Basic/SourceManager.h"
> #include "clang/Sema/DelayedDiagnostic.h"
> #include "clang/Sema/Lookup.h"
> +#include "clang/Sema/LoopHint.h"
> #include "clang/Sema/ScopeInfo.h"
> #include "llvm/ADT/StringExtras.h"
>
> @@ -42,7 +43,161 @@
> A.getAttributeSpellingListIndex());
> }
>
> +static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const AttributeList &A,
> + SourceRange) {
> + if (St->getStmtClass() != Stmt::DoStmtClass &&
> + St->getStmtClass() != Stmt::ForStmtClass &&
> + St->getStmtClass() != Stmt::CXXForRangeStmtClass &&
> + St->getStmtClass() != Stmt::WhileStmtClass) {
> + S.Diag(St->getLocStart(), diag::err_pragma_loop_precedes_nonloop);
> + return nullptr;
> + }
>
> + IdentifierLoc *OptionLoc = A.getArgAsIdent(0);
> + IdentifierInfo *OptionInfo = OptionLoc->Ident;
> + IdentifierLoc *ValueLoc = A.getArgAsIdent(1);
> + IdentifierInfo *ValueInfo = ValueLoc->Ident;
> + Expr *ValueExpr = A.getArgAsExpr(2);
> +
> + assert(OptionInfo && "Attribute must have valid option info.");
> +
> + LoopHintAttr::OptionType Option = LoopHintAttr::Vectorize;
> + if (OptionInfo->isStr("vectorize"))
> + Option = LoopHintAttr::Vectorize;
> + else if (OptionInfo->isStr("vectorize_width"))
> + Option = LoopHintAttr::VectorizeWidth;
> + else if (OptionInfo->isStr("interleave"))
> + Option = LoopHintAttr::Interleave;
> + else if (OptionInfo->isStr("interleave_count"))
> + Option = LoopHintAttr::InterleaveCount;
This looks like it could use a StringSwitch and be a bit more clear.
Not horribly important.
> +
> + int ValueInt;
> + if (Option == LoopHintAttr::Vectorize || Option == LoopHintAttr::Interleave) {
> + if (!ValueInfo) {
> + S.Diag(ValueLoc->Loc, diag::err_pragma_loop_invalid_keyword)
> + << /*MissingKeyword=*/true << "";
> + return nullptr;
> + }
> +
> + if (ValueInfo->isStr("disable"))
> + ValueInt = 0;
> + else if (ValueInfo->isStr("enable"))
> + ValueInt = 1;
> + else {
> + S.Diag(ValueLoc->Loc, diag::err_pragma_loop_invalid_keyword)
> + << /*MissingKeyword=*/false << ValueInfo;
> + return nullptr;
> + }
> + }
> +
> + // FIXME: We should support template parameters for the loop hint value.
> + // See bug report #19610.
> + else if (Option == LoopHintAttr::VectorizeWidth ||
> + Option == LoopHintAttr::InterleaveCount) {
The large amount of spacing between the closing curly brace and the
else if is a bit weird. I think the comment should go inside of the
else if, and the statement can move up to the closing curly brace of
the if statement, for clarity.
> + llvm::APSInt ValueAPS;
> + if (!ValueExpr || !ValueExpr->isIntegerConstantExpr(ValueAPS, S.Context)) {
> + S.Diag(ValueLoc->Loc, diag::err_pragma_loop_invalid_value)
> + << /*MissingValue=*/true << "";
> + return nullptr;
> + }
> +
> + if ((ValueInt = ValueAPS.getSExtValue()) < 1) {
> + S.Diag(ValueLoc->Loc, diag::err_pragma_loop_invalid_value)
> + << /*MissingValue=*/false << ValueInt;
> + return nullptr;
> + }
> + }
> +
> + return LoopHintAttr::CreateImplicit(S.Context, Option, ValueInt,
> + A.getRange());
> +}
> +
> +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};
> +
> + for (auto I = Attrs.begin(), E = Attrs.end(); I != E; ++I) {
Range-based for loop (using const auto *)?
> + const LoopHintAttr *LH = dyn_cast<LoopHintAttr>(*I);
> +
> + // Skip non loop hint attributes
> + if (!LH)
> + continue;
> +
> + int State, Value;
> + int Option = LH->getOption();
> + int ValueInt = LH->getValue();
> +
> + switch (Option) {
> + case LoopHintAttr::Vectorize:
> + case LoopHintAttr::VectorizeWidth:
> + State = 0;
> + Value = 1;
> + break;
> + case LoopHintAttr::Interleave:
> + case LoopHintAttr::InterleaveCount:
> + State = 2;
> + Value = 3;
> + break;
> + }
> +
> + 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];
> + S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
> + << /*Duplicate=*/true << LoopHintAttr::getOptionName(Option)
> + << LoopHintAttr::getValueName(PrevValue)
> + << 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);
> + }
> + } 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];
> + S.Diag(ValueLoc, diag::err_pragma_loop_compatibility)
> + << /*Duplicate=*/true << LoopHintAttr::getOptionName(Option)
> + << PrevValueInt << LoopHintAttr::getOptionName(Option) << ValueInt;
> + }
> + }
> +
> + PrevOptionValue[Option] = ValueInt;
> + }
> +}
> +
> static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const AttributeList &A,
> SourceRange Range) {
> switch (A.getKind()) {
> @@ -53,6 +208,8 @@
> return nullptr;
> case AttributeList::AT_FallThrough:
> return handleFallThroughAttr(S, St, A, Range);
> + case AttributeList::AT_LoopHint:
> + return handleLoopHintAttr(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
> @@ -70,6 +227,8 @@
> Attrs.push_back(a);
> }
>
> + CheckForIncompatibleAttributes(*this, Attrs);
> +
> if (Attrs.empty())
> return S;
>
> Index: test/CodeGen/pragma-loop.cpp
> ===================================================================
> --- test/CodeGen/pragma-loop.cpp (revision 0)
> +++ test/CodeGen/pragma-loop.cpp (working copy)
> @@ -0,0 +1,120 @@
> +// RUN: %clang_cc1 -std=c++11 -emit-llvm -o - %s | FileCheck %s
This test needs a target triple because of the mangling used (it fails
for me currently on Windows with an MSVC build).
> +
> +// Verify while loop is recognized after sequence of pragma clang loop directives.
> +void while_test(int *List, int Length) {
> + // CHECK: define {{.*}} @_Z10while_test
> + int i = 0;
> +
> +#pragma clang loop vectorize(enable)
> +#pragma clang loop interleave_count(4)
> +#pragma clang loop vectorize_width(4)
> + while (i < Length) {
> + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_1:.*]]
> + List[i] = i * 2;
> + i++;
> + }
> +}
> +
> +// Verify do loop is recognized after multi-option pragma clang loop directive.
> +void do_test(int *List, int Length) {
> + int i = 0;
> +
> +#pragma clang loop vectorize_width(8) interleave_count(4)
> + do {
> + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_2:.*]]
> + List[i] = i * 2;
> + i++;
> + } while (i < Length);
> +}
> +
> +// Verify for loop is recognized after sequence of pragma clang loop directives.
> +void for_test(int *List, int Length) {
> +#pragma clang loop interleave(enable)
> +#pragma clang loop interleave_count(4)
> + for (int i = 0; i < Length; i++) {
> + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_3:.*]]
> + List[i] = i * 2;
> + }
> +}
> +
> +// Verify c++11 for range loop is recognized after
> +// sequence of pragma clang loop directives.
> +void for_range_test() {
> + double List[100];
> +
> +#pragma clang loop vectorize_width(2) interleave_count(2)
> + for (int i : List) {
> + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_4:.*]]
> + List[i] = i;
> + }
> +}
> +
> +// Verify disable pragma clang loop directive generates correct metadata
> +void disable_test(int *List, int Length) {
> +#pragma clang loop vectorize(disable)
> + for (int i = 0; i < Length; i++) {
> + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_5:.*]]
> + List[i] = i * 2;
> + }
> +}
> +
> +#define VECWIDTH 2
> +#define INTCOUNT 2
> +
> +// 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)
> + for (int i = 0; i < Length; i++) {
> + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_6:.*]]
> + List[i] = i * Value;
> + }
> +}
> +
> +// Verify metadata is generated when template is used.
> +template <typename A>
> +void for_template_test(A *List, int Length, A Value) {
> +
> +#pragma clang loop vectorize_width(8) interleave_count(8)
> + for (int i = 0; i < Length; i++) {
> + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_7:.*]]
> + List[i] = i * Value;
> + }
> +}
> +
> +// Verify define is resolved correctly when template is used.
> +template <typename A>
> +void for_template_define_test(A *List, int Length, A Value) {
> +#pragma clang loop vectorize_width(VECWIDTH) interleave_count(INTCOUNT)
> + for (int i = 0; i < Length; i++) {
> + // CHECK: br i1 {{.*}}, label {{.*}}, label {{.*}}, !llvm.loop ![[LOOP_8:.*]]
> + List[i] = i * Value;
> + }
> +}
> +
> +#undef VECWIDTH
> +#undef INTCOUNT
> +
> +// Use templates defined above. Test verifies metadata is generated correctly.
> +void template_test(double *List, int Length) {
> + double Value = 10;
> +
> + for_template_test<double>(List, Length, Value);
> + for_template_define_test<double>(List, Length, Value);
> +}
> +
> +// CHECK: ![[LOOP_1]] = metadata !{metadata ![[LOOP_1]], metadata ![[WIDTH_4:.*]], metadata ![[UNROLL_4:.*]], metadata ![[ENABLE_1:.*]]}
> +// 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: ![[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: ![[WIDTH_2]] = metadata !{metadata !"llvm.vectorizer.width", i32 2}
> +// CHECK: ![[LOOP_5]] = metadata !{metadata ![[LOOP_5]], 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:.*]]}
> Index: test/PCH/pragma-loop.cpp
> ===================================================================
> --- test/PCH/pragma-loop.cpp (revision 0)
> +++ test/PCH/pragma-loop.cpp (working copy)
> @@ -0,0 +1,62 @@
> +// RUN: %clang_cc1 -emit-pch -o %t.a %s
> +// RUN: %clang_cc1 -include-pch %t.a %s -ast-print -o - | FileCheck %s
> +
> +// FIXME: A bug in ParsedAttributes causes the order of the attributes to be
> +// reversed. The checks are consequently in the reverse order below.
> +
> +// CHECK: #pragma clang loop interleave_count(8)
> +// CHECK: #pragma clang loop vectorize_width(4)
> +// CHECK: #pragma clang loop interleave(disable)
> +// CHECK: #pragma clang loop vectorize(enable)
> +// CHECK: #pragma clang loop interleave(enable)
> +// CHECK: #pragma clang loop vectorize(disable)
> +
> +#ifndef HEADER
> +#define HEADER
> +
> +class pragma_test {
> +public:
> + inline void run1(int *List, int Length) {
> + int i = 0;
> +#pragma clang loop vectorize_width(4)
> +#pragma clang loop interleave_count(8)
> + while (i < Length) {
> + List[i] = i;
> + i++;
> + }
> + }
> +
> + inline void run2(int *List, int Length) {
> + int i = 0;
> +#pragma clang loop vectorize(enable)
> +#pragma clang loop interleave(disable)
> + while (i - 1 < Length) {
> + List[i] = i;
> + i++;
> + }
> + }
> +
> + inline void run3(int *List, int Length) {
> + int i = 0;
> +#pragma clang loop vectorize(disable)
> +#pragma clang loop interleave(enable)
> + while (i - 3 < Length) {
> + List[i] = i;
> + i++;
> + }
> + }
> +};
> +
> +#else
> +
> +void test() {
> + int List[100];
> +
> + pragma_test pt;
> +
> + pt.run1(List, 100);
> + pt.run2(List, 100);
> + pt.run3(List, 100);
> +}
> +
> +#endif
> Index: test/Parser/pragma-loop-ast.cpp
> ===================================================================
> --- test/Parser/pragma-loop-ast.cpp (revision 0)
> +++ test/Parser/pragma-loop-ast.cpp (working copy)
> @@ -0,0 +1,35 @@
> +// RUN: %clang_cc1 -ast-print %s | FileCheck %s
> +
> +// FIXME: A bug in ParsedAttributes causes the order of the attributes to be
> +// reversed. The checks are consequently in the reverse order below.
> +
> +// CHECK: #pragma clang loop interleave_count(8)
> +// CHECK: #pragma clang loop vectorize_width(4)
> +// CHECK: #pragma clang loop interleave(disable)
> +// CHECK: #pragma clang loop vectorize(enable)
> +// CHECK: #pragma clang loop interleave(enable)
> +// CHECK: #pragma clang loop vectorize(disable)
> +
> +void test(int *List, int Length) {
> + int i = 0;
> +#pragma clang loop vectorize_width(4)
> +#pragma clang loop interleave_count(8)
> + while (i < Length) {
> + List[i] = i * 2;
> + i++;
> + }
> +
> +#pragma clang loop vectorize(enable)
> +#pragma clang loop interleave(disable)
> + while (i - 1 < Length) {
> + List[i] = i * 2;
> + i++;
> + }
> +
> +#pragma clang loop vectorize(disable)
> +#pragma clang loop interleave(enable)
> + while (i - 2 < Length) {
> + List[i] = i * 2;
> + i++;
> + }
> +}
> Index: test/Parser/pragma-loop.cpp
> ===================================================================
> --- test/Parser/pragma-loop.cpp (revision 0)
> +++ test/Parser/pragma-loop.cpp (working copy)
> @@ -0,0 +1,132 @@
> +// RUN: %clang_cc1 -std=c++11 -verify %s
> +
> +// Note that this puts the expected lines before the directives to work around
> +// limitations in the -verify mode.
> +
> +void test(int *List, int Length) {
> + int i = 0;
> +
> +#pragma clang loop vectorize(enable)
> +#pragma clang loop interleave(enable)
> + while (i + 1 < Length) {
> + List[i] = i;
> + }
> +
> +#pragma clang loop vectorize_width(4)
> +#pragma clang loop interleave_count(8)
> + while (i < Length) {
> + List[i] = i;
> + }
> +
> +#pragma clang loop vectorize(disable)
> +#pragma clang loop interleave(disable)
> + while (i - 1 < Length) {
> + List[i] = i;
> + }
> +
> +#pragma clang loop vectorize_width(4) interleave_count(8)
> + while (i - 2 < Length) {
> + List[i] = i;
> + }
> +
> +#pragma clang loop interleave_count(16)
> + while (i - 3 < Length) {
> + List[i] = i;
> + }
> +
> + int VList[Length];
> +#pragma clang loop vectorize(disable) interleave(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 vectorize(enable
> +/* expected-error {{expected ')'}} */ #pragma clang loop interleave(enable
> +
> +/* expected-error {{expected ')'}} */ #pragma clang loop vectorize_width(4
> +/* expected-error {{expected ')'}} */ #pragma clang loop interleave_count(4
> +
> +/* expected-error {{missing option}} */ #pragma clang loop
> +/* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop badkeyword
> +/* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop badkeyword(enable)
> +/* expected-error {{invalid option 'badkeyword'}} */ #pragma clang loop vectorize(enable) badkeyword(4)
> +/* expected-warning {{extra tokens at end of '#pragma clang loop'}} */ #pragma clang loop vectorize(enable) ,
> +
> + while (i-4 < Length) {
> + List[i] = i;
> + }
> +
> +/* 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)
> + 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)
> + 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)
> + 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)
> + while (i-7 < Length) {
> + List[i] = i;
> + }
> +
> +#pragma clang loop vectorize(enable)
> +/* expected-error {{expected a for, while, or do-while loop to follow the '#pragma clang loop' directive}} */ int j = Length;
> + List[0] = List[1];
> +
> + while (j-1 < Length) {
> + List[j] = j;
> + }
> +
> +// FIXME: A bug in ParsedAttributes causes the order of the attributes to be
> +// processed in reverse. Consequently, the errors occur on the first of pragma
> +// of the next three tests rather than the last, and the order of the kinds
> +// is also reversed.
> +
> +/* expected-error {{incompatible directives 'vectorize(disable)' and 'vectorize_width(4)'}} */ #pragma clang loop vectorize_width(4)
> +#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)
> + while (i-8 < Length) {
> + List[i] = i;
> + }
> +
> +/* expected-error {{duplicate directives 'vectorize(disable)' and 'vectorize(enable)'}} */ #pragma clang loop vectorize(enable)
> +#pragma clang loop vectorize(disable)
> +/* expected-error {{duplicate directives 'interleave(disable)' and 'interleave(enable)'}} */ #pragma clang loop interleave(enable)
> +#pragma clang loop interleave(disable)
> + while (i-9 < Length) {
> + List[i] = i;
> + }
> +
> +/* expected-error {{incompatible directives 'vectorize_width(4)' and 'vectorize(disable)'}} */ #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)
> +#pragma clang loop interleave_count(4)
> + while (i-10 < Length) {
> + List[i] = i;
> + }
> +
> +/* expected-error {{duplicate directives 'vectorize_width(4)' and 'vectorize_width(8)'}} */ #pragma clang loop vectorize_width(8)
> +#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)
> + while (i-11 < Length) {
> + List[i] = i;
> + }
> +
> +#pragma clang loop interleave(enable)
> +/* expected-error {{expected statement}} */ }
>
~Aaron
On Mon, Jun 2, 2014 at 7:18 PM, Tyler Nowicki <tnowicki at apple.com> wrote:
> Hi Richard,
>
> Thanks again for the review. I’m glad to hear its getting closer. I’ve applied your suggestions. Here is the updated patch.
>
>> Once you move to supporting arbitrary constant expressions as the argument, I think you may want to split this into two separate Attrs (one for vectorize and interleave, that have a BoolArgument, and one for vectorize_width and interleave_count, that have an ExprArgument).
>>
>> I also think we should have different spellings for these different enum values, once we have proper pragma spelling support:
>>
>> let Spellings = [Pragma<"clang", "loop", "vectorize_width">,
>> Pragma<"clang", "loop", "interleave_count">];
>> let Args = [ExprArgument<"Value">];
>>
>> ... but that can all be deferred for a later patch.
>
> I like the idea of separating the LoopHintAttrs that may make it easier to support c++11 spellings as well.
>
> Tyler
>
More information about the cfe-commits
mailing list