Index: include/clang/AST/Stmt.h =================================================================== --- include/clang/AST/Stmt.h (revision 207464) +++ include/clang/AST/Stmt.h (working copy) @@ -20,6 +20,7 @@ #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" +#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/Support/Compiler.h" Index: include/clang/Basic/Attr.td =================================================================== --- include/clang/Basic/Attr.td (revision 207464) +++ include/clang/Basic/Attr.td (working copy) @@ -1744,3 +1744,15 @@ def Unaligned : IgnoredAttr { let Spellings = [Keyword<"__unaligned">]; } + +def LoopHint : Attr { + // This attribute has no spellings. It is + // created when pragma loop is specified. + let Spellings = [Keyword<"vectorize">, + Keyword<"interleave">]; + + let Args = [UnsignedArgument<"state">, + UnsignedArgument<"value">]; + + let Documentation = [Undocumented]; +} Index: include/clang/Basic/LoopHint.h =================================================================== --- include/clang/Basic/LoopHint.h (revision 0) +++ include/clang/Basic/LoopHint.h (working copy) @@ -0,0 +1,44 @@ +//===--- 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_BASIC_LOOPHINT_H +#define LLVM_CLANG_BASIC_LOOPHINT_H + +#include "clang/Sema/AttributeList.h" +#include "clang/Basic/IdentifierTable.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Sema/Ownership.h" + +namespace clang { + +/// \brief Loop hint specified by a pragma loop directive +/// and used by codegen to attach metadata to the IR. +struct LoopHint { + enum State { + Unknown = 0x0, + Enable = 0x1, + Disable = 0x2, + Value = 0x4 + }; + + static bool isCompatible(unsigned State) { + return (State & (Enable | Value)) && !(State & Disable); + } + + SourceRange Range; + ExprResult ValueExpr; + IdentifierLoc *ValueLoc; + IdentifierLoc *OptionLoc; +}; + + +} // end namespace clang + +#endif // LLVM_CLANG_BASIC_LOOPHINT_H Index: include/clang/Basic/TokenKinds.def =================================================================== --- include/clang/Basic/TokenKinds.def (revision 207464) +++ include/clang/Basic/TokenKinds.def (working copy) @@ -701,6 +701,11 @@ ANNOTATION(pragma_openmp) ANNOTATION(pragma_openmp_end) +// Annotations for loop pragma directives #pragma 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 207464) +++ include/clang/Parse/Parser.h (working copy) @@ -17,6 +17,7 @@ #include "clang/Basic/OpenMPKinds.h" #include "clang/Basic/OperatorPrecedence.h" #include "clang/Basic/Specifiers.h" +#include "clang/Basic/LoopHint.h" #include "clang/Lex/CodeCompletionHandler.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/DeclSpec.h" @@ -160,6 +161,7 @@ std::unique_ptr MSConstSeg; std::unique_ptr MSCodeSeg; std::unique_ptr MSSection; + std::unique_ptr LoopHintHandler; std::unique_ptr CommentSemaHandler; @@ -517,6 +519,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. @@ -1598,6 +1604,10 @@ 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: lib/CodeGen/CGStmt.cpp =================================================================== --- lib/CodeGen/CGStmt.cpp (revision 207464) +++ 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/Basic/LoopHint.h" #include "clang/Sema/SemaDiagnostic.h" #include "llvm/ADT/StringExtras.h" #include "llvm/IR/CallSite.h" @@ -394,7 +395,23 @@ } void CodeGenFunction::EmitAttributedStmt(const AttributedStmt &S) { - EmitStmt(S.getSubStmt()); + const Stmt *SubStmt = S.getSubStmt(); + switch (SubStmt->getStmtClass()) { + case Stmt::DoStmtClass: + EmitDoStmt(cast(*SubStmt), S.getAttrs()); + break; + case Stmt::ForStmtClass: + EmitForStmt(cast(*SubStmt), S.getAttrs()); + break; + case Stmt::WhileStmtClass: + EmitWhileStmt(cast(*SubStmt), S.getAttrs()); + break; + case Stmt::CXXForRangeStmtClass: + EmitCXXForRangeStmt(cast(*SubStmt), S.getAttrs()); + break; + default: + EmitStmt(SubStmt); + } } void CodeGenFunction::EmitGotoStmt(const GotoStmt &S) { @@ -500,7 +517,90 @@ EmitBlock(ContBlock, true); } -void CodeGenFunction::EmitWhileStmt(const WhileStmt &S) { +void CodeGenFunction::EmitCondBrHints(llvm::LLVMContext &Context, + llvm::BranchInst *CondBr, + ArrayRef &Attrs) { + llvm::IntegerType *BoolTy = llvm::Type::getInt1Ty(Context); + llvm::IntegerType *IntTy = llvm::Type::getInt32Ty(Context); + + // Do not continue if there are not hints. + if (Attrs.empty()) + return; + + unsigned int VectorizeState = LoopHint::Unknown; + unsigned int InterleaveState = LoopHint::Unknown; + + // If there are any vectorize hints on this loop + // add them as metadata on the conditional branch. + SmallVector Metadata(1); + ArrayRef::const_iterator I; + for (I = Attrs.begin(); I != Attrs.end(); ++I) { + const LoopHintAttr *LH = cast(*I); + + llvm::Value *Value; + llvm::MDString *Name; + LoopHintAttr::Spelling S = LH->getSemanticSpelling(); + + if (S == LoopHintAttr::Keyword_vectorize) { + VectorizeState |= LH->getState(); + switch(LH->getState()) { + case LoopHint::Enable: + Name = llvm::MDString::get(Context, "llvm.vectorizer.enable"); + Value = llvm::ConstantInt::get(BoolTy, true); + break; + case LoopHint::Disable: + Name = llvm::MDString::get(Context, "llvm.vectorizer.width"); + Value = llvm::ConstantInt::get(IntTy, 1); + break; + case LoopHint::Value: + Name = llvm::MDString::get(Context, "llvm.vectorizer.width"); + Value = llvm::ConstantInt::get(IntTy, LH->getValue()); + break; + } + } else if (S == LoopHintAttr::Keyword_interleave) { + InterleaveState |= LH->getState(); + switch(LH->getState()) { + case LoopHint::Enable: + Name = llvm::MDString::get(Context, "llvm.vectorizer.enable"); + Value = llvm::ConstantInt::get(BoolTy, true); + break; + case LoopHint::Disable: + Name = llvm::MDString::get(Context, "llvm.vectorizer.unroll"); + Value = llvm::ConstantInt::get(IntTy, 1); + break; + case LoopHint::Value: + Name = llvm::MDString::get(Context, "llvm.vectorizer.unroll"); + Value = llvm::ConstantInt::get(IntTy, LH->getValue()); + break; + default: + continue; + } + } + + if (!LoopHint::isCompatible(VectorizeState) || + !LoopHint::isCompatible(InterleaveState)) { + CGM.getDiags().Report(LH->getLocation(), diag::err_attributes_are_not_compatible) << + "{enable, integer value}" << "disable"; + continue; + } + + SmallVector OpValues; + OpValues.push_back(Name); + OpValues.push_back(Value); + + // Set or overwrite metadata indicated by Name. + Metadata.push_back(llvm::MDNode::get(Context, OpValues)); + } + + // 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, + ArrayRef WhileAttrs) { RegionCounter Cnt = getPGORegionCounter(&S); // Emit the header for the loop, which will also become @@ -545,13 +645,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 @@ -580,7 +684,8 @@ SimplifyForwardingBlocks(LoopHeader.getBlock()); } -void CodeGenFunction::EmitDoStmt(const DoStmt &S) { +void CodeGenFunction::EmitDoStmt(const DoStmt &S, + ArrayRef DoAttrs) { JumpDest LoopExit = getJumpDestInCurrentScope("do.end"); JumpDest LoopCond = getJumpDestInCurrentScope("do.cond"); @@ -617,10 +722,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); + } + // Emit the exit block. EmitBlock(LoopExit.getBlock()); @@ -630,7 +740,8 @@ SimplifyForwardingBlocks(LoopCond.getBlock()); } -void CodeGenFunction::EmitForStmt(const ForStmt &S) { +void CodeGenFunction::EmitForStmt(const ForStmt &S, + ArrayRef ForAttrs) { JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); RunCleanupsScope ForScope(*this); @@ -684,9 +795,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); @@ -726,7 +841,8 @@ EmitBlock(LoopExit.getBlock(), true); } -void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S) { +void CodeGenFunction::EmitCXXForRangeStmt(const CXXForRangeStmt &S, + ArrayRef ForAttrs) { JumpDest LoopExit = getJumpDestInCurrentScope("for.end"); RunCleanupsScope ForScope(*this); @@ -759,9 +875,13 @@ // 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 207464) +++ lib/CodeGen/CodeGenFunction.h (working copy) @@ -1846,9 +1846,16 @@ 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, + ArrayRef &Attrs); + void EmitWhileStmt(const WhileStmt &S, + ArrayRef Attrs = ArrayRef()); + void EmitDoStmt(const DoStmt &S, + ArrayRef Attrs = ArrayRef()); + void EmitForStmt(const ForStmt &S, + ArrayRef Attrs = ArrayRef()); void EmitReturnStmt(const ReturnStmt &S); void EmitDeclStmt(const DeclStmt &S); void EmitBreakStmt(const BreakStmt &S); @@ -1872,7 +1879,8 @@ void EmitCXXTryStmt(const CXXTryStmt &S); void EmitSEHTryStmt(const SEHTryStmt &S); - void EmitCXXForRangeStmt(const CXXForRangeStmt &S); + void EmitCXXForRangeStmt(const CXXForRangeStmt &S, + ArrayRef Attrs = ArrayRef()); llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K); llvm::Function *GenerateCapturedStmtFunction(const CapturedDecl *CD, Index: lib/Parse/ParsePragma.cpp =================================================================== --- lib/Parse/ParsePragma.cpp (revision 207464) +++ lib/Parse/ParsePragma.cpp (working copy) @@ -16,6 +16,7 @@ #include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/Parser.h" #include "clang/Sema/Scope.h" +#include "clang/Basic/LoopHint.h" #include "llvm/ADT/StringSwitch.h" using namespace clang; @@ -131,6 +132,12 @@ Token &FirstToken) override; }; +struct PragmaLoopHintHandler : public PragmaHandler { + PragmaLoopHintHandler() : PragmaHandler("loop") {} + void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, + Token &FirstToken) override; +}; + } // end namespace void Parser::initializePragmaHandlers() { @@ -195,6 +202,9 @@ MSSection.reset(new PragmaMSPragma("section")); PP.AddPragmaHandler(MSSection.get()); } + + LoopHintHandler.reset(new PragmaLoopHintHandler()); + PP.AddPragmaHandler(LoopHintHandler.get()); } void Parser::resetPragmaHandlers() { @@ -249,6 +259,10 @@ PP.RemovePragmaHandler("STDC", FPContractHandler.get()); FPContractHandler.reset(); + + PP.RemovePragmaHandler(LoopHintHandler.get()); + LoopHintHandler.reset(); + } /// \brief Handle the annotation token produced for #pragma unused(...) @@ -570,6 +584,32 @@ DiagnosticsEngine::Error, "'#pragma %0' not implemented."); } +struct PragmaLoopHintInfo { + Token Value; + Token Option; + SourceRange Range; +}; + +LoopHint Parser::HandlePragmaLoopHint() { + assert(Tok.is(tok::annot_pragma_loop_hint)); + PragmaLoopHintInfo *Info = + static_cast(Tok.getAnnotationValue()); + + LoopHint Hint; + Hint.ValueLoc = IdentifierLoc::create(Actions.Context, + Info->Value.getLocation(), + Info->Value.getIdentifierInfo()); + Hint.OptionLoc = IdentifierLoc::create(Actions.Context, + Info->Option.getLocation(), + Info->Option.getIdentifierInfo()); + Hint.Range = Info->Range; + + if (Info->Value.is(tok::numeric_constant)) + Hint.ValueExpr = Actions.ActOnNumericConstant(Info->Value); + + return Hint; +} + // #pragma GCC visibility comes in two variants: // 'push' '(' [visibility] ')' // 'pop' @@ -1531,3 +1571,103 @@ Actions.ActOnPragmaMSComment(Kind, ArgumentString); } + +/// \brief Handle the \#pragma vectorize hint +/// +/// The syntax is: +/// \code +/// #pragma loop vectorize(enable/disable/_value_) +/// #pragma loop interleave(enable/disable/_value_) +/// #pragma loop vectorize(...) interleave(...) ... +/// \endcode +/// Specifying vectorize(enable) or vectorize(_value_) instructs llvm to +/// try vectorizing the subsequent loop. Specifying interleave(enable) or +/// interleave(_value_) instructs llvm to tru interleaving the subsequent loop +/// Giving a _value_ of 1 or "disable" prevents the optimization, even if it +/// is possible or profitable. The loop vectorizer currently only works on +/// inner loops. +void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP, + PragmaIntroducerKind Introducer, + Token &Tok) { + SourceLocation LoopHintLoc = Tok.getLocation(); + + SmallVector 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_expected) << + "vectorize or interleave"; + return; + } + + while(Tok.is(tok::identifier)) { + // Read the optimization option identifier. + PragmaLoopHintInfo *Info = + (PragmaLoopHintInfo*) PP.getPreprocessorAllocator().Allocate( + sizeof(PragmaLoopHintInfo), llvm::alignOf()); + + Info->Option = Tok; + StringRef Option = Tok.getIdentifierInfo()->getName(); + + if (Option != "vectorize" && Option != "interleave") { + PP.Diag(Tok.getLocation(), diag::err_expected) << + "vectorize or interleave"; + return; + } + + // Read '(' + PP.Lex(Tok); + if (Tok.isNot(tok::l_paren)) { + PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren; + return; + } + + // Read the optimization value identifier. + PP.Lex(Tok); + if (Tok.isNot(tok::identifier) && Tok.isNot(tok::numeric_constant)) { + PP.Diag(Tok.getLocation(), diag::err_expected) << + "enable, disable or integer value"; + return; + } + + Info->Value = Tok; + + // Read ')' + PP.Lex(Tok); + if (Tok.isNot(tok::r_paren)) { + PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; + return; + } + + Info->Range = SourceRange(LoopHintLoc, Tok.getLocation()); + + // Get next optimization option. + PP.Lex(Tok); + + // Generate the vectorization hint token. + Token LoopHintTok; + LoopHintTok.startToken(); + LoopHintTok.setKind(tok::annot_pragma_loop_hint); + LoopHintTok.setLocation(LoopHintLoc); + LoopHintTok.setAnnotationValue(static_cast(Info)); + TokenList.push_back(LoopHintTok); + } + + // Consume all remaining token in the pragam loop directive. + if (Tok.isNot(tok::eod)) { + PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << + "loop"; + return; + } + + Token *TokenArray = new Token[TokenList.size()]; + for(unsigned long i = 0; i < TokenList.size(); i++) { + TokenArray[i] = TokenList[i]; + } + + PP.EnterTokenStream(TokenArray, TokenList.size(), + /*DisableMacroExpansion=*/false, + /*OwnsTokens=*/true); + TokenList.clear(); +} Index: lib/Parse/ParseStmt.cpp =================================================================== --- lib/Parse/ParseStmt.cpp (revision 207464) +++ lib/Parse/ParseStmt.cpp (working copy) @@ -19,6 +19,8 @@ #include "clang/Basic/PrettyStackTrace.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/TargetInfo.h" +#include "clang/Basic/LoopHint.h" +#include "clang/Basic/Attributes.h" #include "clang/Sema/DeclSpec.h" #include "clang/Sema/PrettyDeclStackTrace.h" #include "clang/Sema/Scope.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. @@ -1753,6 +1759,49 @@ return Actions.ActOnReturnStmt(ReturnLoc, R.take()); } +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.ValueLoc || !Hint.OptionLoc) + continue; + + ArgsUnion ArgHints[] = {Hint.ValueLoc, + ArgsUnion(Hint.ValueExpr.get())}; + TempAttrs.addNew(Hint.OptionLoc->Ident, Hint.Range, + 0, Hint.OptionLoc->Loc, + ArgHints, 2, + AttributeList::AS_Keyword); + } + + SourceLocation Loc = Tok.getLocation(); + StmtResult S = StmtEmpty(); + + // Get the next statement's attributes, if any. + MaybeParseCXX11Attributes(Attrs, 0, /*MightBeObjCMessageSend*/ true); + + if (Tok.is(tok::kw_for) || Tok.is(tok::kw_while) || Tok.is(tok::kw_do)) { + // Get the next statement. + S = ParseStatementOrDeclarationAfterAttributes(Stmts, + /*OnlyStatement*/ true, 0, Attrs); + Attrs.takeAllFrom(TempAttrs); + return S; + } + + Diag(Loc, diag::err_expected) << + "for, while, or do-while loop to immediately follow #pragma loop ..."; + + return S; +} + namespace { class ClangAsmParserCallback : public llvm::MCAsmParserSemaCallback { Parser &TheParser; Index: lib/Sema/SemaStmtAttr.cpp =================================================================== --- lib/Sema/SemaStmtAttr.cpp (revision 207464) +++ lib/Sema/SemaStmtAttr.cpp (working copy) @@ -14,6 +14,8 @@ #include "clang/Sema/SemaInternal.h" #include "clang/AST/ASTContext.h" #include "clang/Basic/SourceManager.h" +#include "clang/Basic/LoopHint.h" +#include "clang/Parse/ParseDiagnostic.h" #include "clang/Lex/Lexer.h" #include "clang/Sema/DelayedDiagnostic.h" #include "clang/Sema/Lookup.h" @@ -44,7 +46,64 @@ A.getAttributeSpellingListIndex()); } +static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const AttributeList &A, + SourceRange Range) { + if (St->getStmtClass() != Stmt::DoStmtClass && + St->getStmtClass() != Stmt::ForStmtClass && + St->getStmtClass() != Stmt::CXXForRangeStmtClass && + St->getStmtClass() != Stmt::WhileStmtClass) { + S.Diag(A.getLoc(), diag::err_expected) << + "for, while, or do-while loop to immediately follow #pragma loop ..."; + return 0; + } + IdentifierLoc *ValueLoc = A.getArgAsIdent(0); + IdentifierInfo *ValueInfo = ValueLoc->Ident; + Expr *ValueExpr = A.getArgAsExpr(1); + + llvm::APSInt Val; + int Value = 0; + LoopHint::State State = LoopHint::Unknown; + if (ValueExpr && + ValueExpr->EvaluateAsInt(Val, S.Context)) { + Value = Val.getSExtValue(); + State = LoopHint::Value; + } else if (ValueInfo) { + State = llvm::StringSwitch(ValueInfo->getName()) + .Case("enable", LoopHint::Enable) + .Case("disable", LoopHint::Disable) + .Default(LoopHint::Unknown); + } + + if (State == LoopHint::Unknown) { + S.Diag(ValueLoc->Loc, diag::err_expected) << + "enable, disable or integer value"; + return 0; + } + + if (State == LoopHint::Value && Value < 1) { + S.Diag(ValueLoc->Loc, diag::err_expected) << + "integer value greater than one"; + return 0; + } + + StringRef Option = A.getName()->getName(); + if (Option == "vectorize") { + return LoopHintAttr::CreateImplicit(S.Context, + LoopHintAttr::Keyword_vectorize, + State, Value, A.getRange()); + } else if (Option == "interleave") { + return LoopHintAttr::CreateImplicit(S.Context, + LoopHintAttr::Keyword_interleave, + State, Value, A.getRange()); + } + + S.Diag(A.getLoc(), diag::err_expected) << "vectorize or interleave"; + + return 0; +} + + static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const AttributeList &A, SourceRange Range) { switch (A.getKind()) { @@ -55,6 +114,8 @@ return 0; 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 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 -std=c++11 -emit-llvm -S -o - %s | FileCheck %s + +// CHECK: br i1 %cmp, label %while.body, label %while.end, !llvm.loop !1 +// CHECK: br i1 %cmp, label %do.body, label %do.end, !llvm.loop !5 +// CHECK: br i1 %cmp, label %for.body, label %for.end, !llvm.loop !7 +// CHECK: br i1 %cmp, label %for.body, label %for.end, !llvm.loop !8 +// CHECK: br i1 %cmp, label %for.body, label %for.end, !llvm.loop !11 +// CHECK: br i1 %cmp, label %for.body, label %for.end, !llvm.loop !13 +// CHECK: br i1 %cmp, label %for.body, label %for.end, !llvm.loop !14 +// CHECK: br i1 %cmp, label %for.body, label %for.end, !llvm.loop !16 + +// CHECK: !1 = metadata !{metadata !1, metadata !2, metadata !3, metadata !4} +// CHECK: !2 = metadata !{metadata !"llvm.vectorizer.width", i32 4} +// CHECK: !3 = metadata !{metadata !"llvm.vectorizer.unroll", i32 4} +// CHECK: !4 = metadata !{metadata !"llvm.vectorizer.enable", i1 true} +// CHECK: !5 = metadata !{metadata !5, metadata !3, metadata !6} +// CHECK: !6 = metadata !{metadata !"llvm.vectorizer.width", i32 8} +// CHECK: !7 = metadata !{metadata !7, metadata !3, metadata !4} +// CHECK: !8 = metadata !{metadata !8, metadata !9, metadata !10} +// CHECK: !9 = metadata !{metadata !"llvm.vectorizer.unroll", i32 2} +// CHECK: !10 = metadata !{metadata !"llvm.vectorizer.width", i32 2} +// CHECK: !11 = metadata !{metadata !11, metadata !12} +// CHECK: !12 = metadata !{metadata !"llvm.vectorizer.width", i32 1} +// CHECK: !13 = metadata !{metadata !13, metadata !9, metadata !10} +// CHECK: !14 = metadata !{metadata !14, metadata !15, metadata !6} +// CHECK: !15 = metadata !{metadata !"llvm.vectorizer.unroll", i32 8} +// CHECK: !16 = metadata !{metadata !16, metadata !9, metadata !10} + +// Verify while loop is recognized after sequence of pragma loop directives. +void while_test(int *List, int Length) { + int i = 0; + + #pragma loop vectorize(enable) + #pragma loop interleave(4) + #pragma loop vectorize(4) + while(i < Length) { + List[i] = i*2; + i++; + } +} + +// Verify do loop is recognized after multi-option pragma loop directive. +void do_test(int *List, int Length) { + int i = 0; + + #pragma loop vectorize(8) interleave(4) + do { + List[i] = i*2; + i++; + } while (i < Length); +} + +// Verify for loop is recognized after sequence of pragma loop directives. +void for_test(int *List, int Length) { + #pragma loop interleave(enable) + #pragma loop interleave(4) + for(int i = 0; i < Length; i++) { + List[i] = i*2; + } +} + +// Verify c++11 for range loop is recognized after +// sequence of pragma loop directives. +void for_range_test() { + double List[100]; + + #pragma loop vectorize(2) interleave(2) + for (int i : List) { + List[i] = i; + } +} + +// Verify disable pragma loop directive generates correct metadata +void disable_test(int *List, int Length) { + #pragma loop vectorize(disable) + for(int i = 0; i < Length; i++) { + List[i] = i*2; + } +} + +#define VECWIDTH 2 +#define INTERLEAVE 2 + +// Verify defines are correctly resolved in pragma loop directive +void for_define_test(int *List, int Length, int Value) { + #pragma loop vectorize(VECWIDTH) interleave(INTERLEAVE) + for(int i = 0; i < Length; i++) { + List[i] = i*Value; + } +} + +// Verify metadata is generated when template is used. +template +void for_template_test(A *List, int Length, A Value) { + + #pragma loop vectorize(8) interleave(8) + for(int i = 0; i < Length; i++) { + List[i] = i*Value; + } +} + +// Verify define is resolved correctly when template is used. +template +void for_template_define_test(A *List, int Length, A Value) { + #pragma loop vectorize(VECWIDTH) interleave(INTERLEAVE) + for(int i = 0; i < Length; i++) { + List[i] = i*Value; + } +} + +#undef VECWIDTH +#undef INTERLEAVE + +// Use templates defined above. Test verifies metadata is generated correctly. +void template_test(double *List, int Length) { + double Value = 10; + + for_template_test(List, Length, Value); + for_template_define_test(List, Length, Value); +} Index: test/Parser/pragma-loop.cpp =================================================================== --- test/Parser/pragma-loop.cpp (revision 0) +++ test/Parser/pragma-loop.cpp (working copy) @@ -0,0 +1,70 @@ +// RUN: %clang_cc1 -fsyntax-only -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 loop vectorize(4) + #pragma loop vectorize(enable) + #pragma loop vectorize(disable) + #pragma loop interleave(8) + #pragma loop interleave(enable) + #pragma loop interleave(disable) + while (i-1 < Length) { + List[i] = i; + } + + #pragma loop vectorize(4) interleave(8) + while (i-2 < Length) { + List[i] = i; + } + + #pragma loop interleave(16) + while (i-3 < Length) { + List[i] = i; + } + + int VList[Length]; + #pragma loop vectorize(disable) interleave(disable) + for (int j : VList) { + VList[j] = List[j]; + } + +/* expected-error {{expected '('}} */ #pragma loop vectorize +/* expected-error {{expected '('}} */ #pragma loop interleave + +/* expected-error {{expected ')'}} */ #pragma loop vectorize(4 +/* expected-error {{expected ')'}} */ #pragma loop interleave(4 + +/* expected-error {{expected integer value greater than one}} */ #pragma loop vectorize(0) +/* expected-error {{expected integer value greater than one}} */ #pragma loop interleave(0) + +/* expected-error {{expected integer value greater than one}} */ #pragma loop vectorize(3000000000) +/* expected-error {{expected integer value greater than one}} */ #pragma loop interleave(3000000000) + +/* expected-error {{expected enable, disable or integer value}} */ #pragma loop vectorize(badvalue) +/* expected-error {{expected enable, disable or integer value}} */ #pragma loop interleave(badvalue) + +/* expected-error {{expected vectorize or interleave}} */ #pragma loop +/* expected-error {{expected vectorize or interleave}} */ #pragma loop badkeyword +/* expected-error {{expected vectorize or interleave}} */ #pragma loop badkeyword(2) +/* expected-error {{expected vectorize or interleave}} */ #pragma loop vectorize(4) badkeyword(4) +/* expected-warning {{extra tokens at end of '#pragma loop' - ignored}} */ #pragma loop vectorize(4) , + + while (i-4 < Length) { + List[i] = i; + } + +#pragma loop vectorize(enable) +/* expected-error {{expected for, while, or do-while loop to immediately follow #pragma loop ...}} */ int j = Length; + List[0] = List[1]; + + while (j-5 < Length) { + List[j] = j; + } + +#pragma loop interleave(enable) +/* expected-error {{expected for, while, or do-while loop to immediately follow #pragma loop ...}} */ }