head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.12 netbsd-11-0-RC3:1.1.1.12 netbsd-11-0-RC2:1.1.1.12 netbsd-11-0-RC1:1.1.1.12 perseant-exfatfs-base-20250801:1.1.1.12 netbsd-11:1.1.1.12.0.10 netbsd-11-base:1.1.1.12 netbsd-10-1-RELEASE:1.1.1.12 perseant-exfatfs-base-20240630:1.1.1.12 perseant-exfatfs:1.1.1.12.0.8 perseant-exfatfs-base:1.1.1.12 netbsd-8-3-RELEASE:1.1.1.9 netbsd-9-4-RELEASE:1.1.1.11 netbsd-10-0-RELEASE:1.1.1.12 netbsd-10-0-RC6:1.1.1.12 netbsd-10-0-RC5:1.1.1.12 netbsd-10-0-RC4:1.1.1.12 netbsd-10-0-RC3:1.1.1.12 netbsd-10-0-RC2:1.1.1.12 netbsd-10-0-RC1:1.1.1.12 netbsd-10:1.1.1.12.0.6 netbsd-10-base:1.1.1.12 netbsd-9-3-RELEASE:1.1.1.11 cjep_sun2x:1.1.1.12.0.4 cjep_sun2x-base:1.1.1.12 cjep_staticlib_x-base1:1.1.1.12 netbsd-9-2-RELEASE:1.1.1.11 cjep_staticlib_x:1.1.1.12.0.2 cjep_staticlib_x-base:1.1.1.12 netbsd-9-1-RELEASE:1.1.1.11 phil-wifi-20200421:1.1.1.12 phil-wifi-20200411:1.1.1.12 phil-wifi-20200406:1.1.1.12 netbsd-8-2-RELEASE:1.1.1.9 netbsd-9-0-RELEASE:1.1.1.11 netbsd-9-0-RC2:1.1.1.11 netbsd-9-0-RC1:1.1.1.11 netbsd-9:1.1.1.11.0.2 netbsd-9-base:1.1.1.11 phil-wifi-20190609:1.1.1.11 netbsd-8-1-RELEASE:1.1.1.9 netbsd-8-1-RC1:1.1.1.9 pgoyette-compat-merge-20190127:1.1.1.10.2.1 pgoyette-compat-20190127:1.1.1.11 pgoyette-compat-20190118:1.1.1.11 pgoyette-compat-1226:1.1.1.11 pgoyette-compat-1126:1.1.1.11 pgoyette-compat-1020:1.1.1.11 pgoyette-compat-0930:1.1.1.11 pgoyette-compat-0906:1.1.1.11 netbsd-7-2-RELEASE:1.1.1.6.2.1 pgoyette-compat-0728:1.1.1.11 clang-337282:1.1.1.11 netbsd-8-0-RELEASE:1.1.1.9 phil-wifi:1.1.1.10.0.4 phil-wifi-base:1.1.1.10 pgoyette-compat-0625:1.1.1.10 netbsd-8-0-RC2:1.1.1.9 pgoyette-compat-0521:1.1.1.10 pgoyette-compat-0502:1.1.1.10 pgoyette-compat-0422:1.1.1.10 netbsd-8-0-RC1:1.1.1.9 pgoyette-compat-0415:1.1.1.10 pgoyette-compat-0407:1.1.1.10 pgoyette-compat-0330:1.1.1.10 pgoyette-compat-0322:1.1.1.10 pgoyette-compat-0315:1.1.1.10 netbsd-7-1-2-RELEASE:1.1.1.6.2.1 pgoyette-compat:1.1.1.10.0.2 pgoyette-compat-base:1.1.1.10 netbsd-7-1-1-RELEASE:1.1.1.6.2.1 clang-319952:1.1.1.10 matt-nb8-mediatek:1.1.1.9.0.10 matt-nb8-mediatek-base:1.1.1.9 clang-309604:1.1.1.10 perseant-stdc-iso10646:1.1.1.9.0.8 perseant-stdc-iso10646-base:1.1.1.9 netbsd-8:1.1.1.9.0.6 netbsd-8-base:1.1.1.9 prg-localcount2-base3:1.1.1.9 prg-localcount2-base2:1.1.1.9 prg-localcount2-base1:1.1.1.9 prg-localcount2:1.1.1.9.0.4 prg-localcount2-base:1.1.1.9 pgoyette-localcount-20170426:1.1.1.9 bouyer-socketcan-base1:1.1.1.9 pgoyette-localcount-20170320:1.1.1.9 netbsd-7-1:1.1.1.6.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.6.2.1 netbsd-7-1-RC2:1.1.1.6.2.1 clang-294123:1.1.1.9 netbsd-7-nhusb-base-20170116:1.1.1.6.2.1 bouyer-socketcan:1.1.1.9.0.2 bouyer-socketcan-base:1.1.1.9 clang-291444:1.1.1.9 pgoyette-localcount-20170107:1.1.1.8 netbsd-7-1-RC1:1.1.1.6.2.1 pgoyette-localcount-20161104:1.1.1.8 netbsd-7-0-2-RELEASE:1.1.1.6.2.1 localcount-20160914:1.1.1.8 netbsd-7-nhusb:1.1.1.6.2.1.0.4 netbsd-7-nhusb-base:1.1.1.6.2.1 clang-280599:1.1.1.8 pgoyette-localcount-20160806:1.1.1.8 pgoyette-localcount-20160726:1.1.1.8 pgoyette-localcount:1.1.1.8.0.2 pgoyette-localcount-base:1.1.1.8 netbsd-7-0-1-RELEASE:1.1.1.6.2.1 clang-261930:1.1.1.8 netbsd-7-0:1.1.1.6.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.6.2.1 netbsd-7-0-RC3:1.1.1.6.2.1 netbsd-7-0-RC2:1.1.1.6.2.1 netbsd-7-0-RC1:1.1.1.6.2.1 clang-237755:1.1.1.7 clang-232565:1.1.1.7 clang-227398:1.1.1.7 tls-maxphys-base:1.1.1.6 tls-maxphys:1.1.1.6.0.4 netbsd-7:1.1.1.6.0.2 netbsd-7-base:1.1.1.6 clang-215315:1.1.1.6 clang-209886:1.1.1.5 yamt-pagecache:1.1.1.4.0.4 yamt-pagecache-base9:1.1.1.4 tls-earlyentropy:1.1.1.4.0.2 tls-earlyentropy-base:1.1.1.5 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.4 riastradh-drm2-base3:1.1.1.4 clang-202566:1.1.1.4 clang-201163:1.1.1.3 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.54; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.54; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.38.17; author joerg; state Exp; branches; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.02.14.20.07.04; author joerg; state Exp; branches; next 1.1.1.4; commitid annVkZ1sc17rF6px; 1.1.1.4 date 2014.03.04.19.53.29; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid 29z1hJonZISIXprx; 1.1.1.5 date 2014.05.30.18.14.42; author joerg; state Exp; branches; next 1.1.1.6; commitid 8q0kdlBlCn09GACx; 1.1.1.6 date 2014.08.10.17.08.25; author joerg; state Exp; branches 1.1.1.6.2.1 1.1.1.6.4.1; next 1.1.1.7; commitid N85tXAN6Ex9VZPLx; 1.1.1.7 date 2015.01.29.19.57.31; author joerg; state Exp; branches; next 1.1.1.8; commitid mlISSizlPKvepX7y; 1.1.1.8 date 2016.02.27.22.11.49; author joerg; state Exp; branches 1.1.1.8.2.1; next 1.1.1.9; commitid tIimz3oDlh1NpBWy; 1.1.1.9 date 2017.01.11.10.33.45; author joerg; state Exp; branches; next 1.1.1.10; commitid CNnUNfII1jgNmxBz; 1.1.1.10 date 2017.08.01.19.34.58; author joerg; state Exp; branches 1.1.1.10.2.1 1.1.1.10.4.1; next 1.1.1.11; commitid pMuDy65V0VicSx1A; 1.1.1.11 date 2018.07.17.18.30.57; author joerg; state Exp; branches; next 1.1.1.12; commitid wDzL46ALjrCZgwKA; 1.1.1.12 date 2019.11.13.22.19.26; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.4.2.1 date 2014.08.10.07.08.08; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.4.4.1 date 2014.03.04.19.53.29; author yamt; state dead; branches; next 1.1.1.4.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.4.2 date 2014.05.22.16.18.29; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.6.2.1 date 2015.06.04.20.04.29; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.6.4.1 date 2014.08.10.17.08.25; author tls; state dead; branches; next 1.1.1.6.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.4.2 date 2014.08.19.23.47.29; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.8.2.1 date 2017.03.20.06.52.39; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.10.2.1 date 2018.07.28.04.33.21; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.10.4.1 date 2019.06.10.21.45.26; author christos; state Exp; branches; next 1.1.1.10.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.10.4.2 date 2020.04.13.07.46.36; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//===--- ParsePragma.cpp - Language specific pragma parsing ---------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the language specific #pragma handlers. // //===----------------------------------------------------------------------===// #include "ParsePragma.h" #include "clang/Lex/Preprocessor.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/Parser.h" #include "clang/Sema/Scope.h" #include "llvm/ADT/StringSwitch.h" using namespace clang; /// \brief Handle the annotation token produced for #pragma unused(...) /// /// Each annot_pragma_unused is followed by the argument token so e.g. /// "#pragma unused(x,y)" becomes: /// annot_pragma_unused 'x' annot_pragma_unused 'y' void Parser::HandlePragmaUnused() { assert(Tok.is(tok::annot_pragma_unused)); SourceLocation UnusedLoc = ConsumeToken(); Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc); ConsumeToken(); // The argument token. } void Parser::HandlePragmaVisibility() { assert(Tok.is(tok::annot_pragma_vis)); const IdentifierInfo *VisType = static_cast(Tok.getAnnotationValue()); SourceLocation VisLoc = ConsumeToken(); Actions.ActOnPragmaVisibility(VisType, VisLoc); } struct PragmaPackInfo { Sema::PragmaPackKind Kind; IdentifierInfo *Name; Token Alignment; SourceLocation LParenLoc; SourceLocation RParenLoc; }; void Parser::HandlePragmaPack() { assert(Tok.is(tok::annot_pragma_pack)); PragmaPackInfo *Info = static_cast(Tok.getAnnotationValue()); SourceLocation PragmaLoc = ConsumeToken(); ExprResult Alignment; if (Info->Alignment.is(tok::numeric_constant)) { Alignment = Actions.ActOnNumericConstant(Info->Alignment); if (Alignment.isInvalid()) return; } Actions.ActOnPragmaPack(Info->Kind, Info->Name, Alignment.get(), PragmaLoc, Info->LParenLoc, Info->RParenLoc); } void Parser::HandlePragmaMSStruct() { assert(Tok.is(tok::annot_pragma_msstruct)); Sema::PragmaMSStructKind Kind = static_cast( reinterpret_cast(Tok.getAnnotationValue())); Actions.ActOnPragmaMSStruct(Kind); ConsumeToken(); // The annotation token. } void Parser::HandlePragmaAlign() { assert(Tok.is(tok::annot_pragma_align)); Sema::PragmaOptionsAlignKind Kind = static_cast( reinterpret_cast(Tok.getAnnotationValue())); SourceLocation PragmaLoc = ConsumeToken(); Actions.ActOnPragmaOptionsAlign(Kind, PragmaLoc); } void Parser::HandlePragmaWeak() { assert(Tok.is(tok::annot_pragma_weak)); SourceLocation PragmaLoc = ConsumeToken(); Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc, Tok.getLocation()); ConsumeToken(); // The weak name. } void Parser::HandlePragmaWeakAlias() { assert(Tok.is(tok::annot_pragma_weakalias)); SourceLocation PragmaLoc = ConsumeToken(); IdentifierInfo *WeakName = Tok.getIdentifierInfo(); SourceLocation WeakNameLoc = Tok.getLocation(); ConsumeToken(); IdentifierInfo *AliasName = Tok.getIdentifierInfo(); SourceLocation AliasNameLoc = Tok.getLocation(); ConsumeToken(); Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc, WeakNameLoc, AliasNameLoc); } void Parser::HandlePragmaRedefineExtname() { assert(Tok.is(tok::annot_pragma_redefine_extname)); SourceLocation RedefLoc = ConsumeToken(); IdentifierInfo *RedefName = Tok.getIdentifierInfo(); SourceLocation RedefNameLoc = Tok.getLocation(); ConsumeToken(); IdentifierInfo *AliasName = Tok.getIdentifierInfo(); SourceLocation AliasNameLoc = Tok.getLocation(); ConsumeToken(); Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc, RedefNameLoc, AliasNameLoc); } void Parser::HandlePragmaFPContract() { assert(Tok.is(tok::annot_pragma_fp_contract)); tok::OnOffSwitch OOS = static_cast( reinterpret_cast(Tok.getAnnotationValue())); Actions.ActOnPragmaFPContract(OOS); ConsumeToken(); // The annotation token. } StmtResult Parser::HandlePragmaCaptured() { assert(Tok.is(tok::annot_pragma_captured)); ConsumeToken(); if (Tok.isNot(tok::l_brace)) { PP.Diag(Tok, diag::err_expected_lbrace); return StmtError(); } SourceLocation Loc = Tok.getLocation(); ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope); Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default, /*NumParams=*/1); StmtResult R = ParseCompoundStatement(); CapturedRegionScope.Exit(); if (R.isInvalid()) { Actions.ActOnCapturedRegionError(); return StmtError(); } return Actions.ActOnCapturedRegionEnd(R.get()); } namespace { typedef llvm::PointerIntPair OpenCLExtData; } void Parser::HandlePragmaOpenCLExtension() { assert(Tok.is(tok::annot_pragma_opencl_extension)); OpenCLExtData data = OpenCLExtData::getFromOpaqueValue(Tok.getAnnotationValue()); unsigned state = data.getInt(); IdentifierInfo *ename = data.getPointer(); SourceLocation NameLoc = Tok.getLocation(); ConsumeToken(); // The annotation token. OpenCLOptions &f = Actions.getOpenCLOptions(); // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions, // overriding all previously issued extension directives, but only if the // behavior is set to disable." if (state == 0 && ename->isStr("all")) { #define OPENCLEXT(nm) f.nm = 0; #include "clang/Basic/OpenCLExtensions.def" } #define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; } #include "clang/Basic/OpenCLExtensions.def" else { PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename; return; } } // #pragma GCC visibility comes in two variants: // 'push' '(' [visibility] ')' // 'pop' void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &VisTok) { SourceLocation VisLoc = VisTok.getLocation(); Token Tok; PP.LexUnexpandedToken(Tok); const IdentifierInfo *PushPop = Tok.getIdentifierInfo(); const IdentifierInfo *VisType; if (PushPop && PushPop->isStr("pop")) { VisType = 0; } else if (PushPop && PushPop->isStr("push")) { PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "visibility"; return; } PP.LexUnexpandedToken(Tok); VisType = Tok.getIdentifierInfo(); if (!VisType) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "visibility"; return; } PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "visibility"; return; } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "visibility"; return; } PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "visibility"; return; } Token *Toks = new Token[1]; Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_vis); Toks[0].setLocation(VisLoc); Toks[0].setAnnotationValue( const_cast(static_cast(VisType))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true); } // #pragma pack(...) comes in the following delicious flavors: // pack '(' [integer] ')' // pack '(' 'show' ')' // pack '(' ('push' | 'pop') [',' identifier] [, integer] ')' void PragmaPackHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PackTok) { SourceLocation PackLoc = PackTok.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack"; return; } Sema::PragmaPackKind Kind = Sema::PPK_Default; IdentifierInfo *Name = 0; Token Alignment; Alignment.startToken(); SourceLocation LParenLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.is(tok::numeric_constant)) { Alignment = Tok; PP.Lex(Tok); // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting // the push/pop stack. // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4) if (PP.getLangOpts().ApplePragmaPack) Kind = Sema::PPK_Push; } else if (Tok.is(tok::identifier)) { const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("show")) { Kind = Sema::PPK_Show; PP.Lex(Tok); } else { if (II->isStr("push")) { Kind = Sema::PPK_Push; } else if (II->isStr("pop")) { Kind = Sema::PPK_Pop; } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_invalid_action); return; } PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); if (Tok.is(tok::numeric_constant)) { Alignment = Tok; PP.Lex(Tok); } else if (Tok.is(tok::identifier)) { Name = Tok.getIdentifierInfo(); PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); if (Tok.isNot(tok::numeric_constant)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed); return; } Alignment = Tok; PP.Lex(Tok); } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed); return; } } } } else if (PP.getLangOpts().ApplePragmaPack) { // In MSVC/gcc, #pragma pack() resets the alignment without affecting // the push/pop stack. // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop). Kind = Sema::PPK_Pop; } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack"; return; } SourceLocation RParenLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack"; return; } PragmaPackInfo *Info = (PragmaPackInfo*) PP.getPreprocessorAllocator().Allocate( sizeof(PragmaPackInfo), llvm::alignOf()); new (Info) PragmaPackInfo(); Info->Kind = Kind; Info->Name = Name; Info->Alignment = Alignment; Info->LParenLoc = LParenLoc; Info->RParenLoc = RParenLoc; Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_pack); Toks[0].setLocation(PackLoc); Toks[0].setAnnotationValue(static_cast(Info)); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma ms_struct on // #pragma ms_struct off void PragmaMSStructHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MSStructTok) { Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF; Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct); return; } const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("on")) { Kind = Sema::PMSST_ON; PP.Lex(Tok); } else if (II->isStr("off") || II->isStr("reset")) PP.Lex(Tok); else { PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct); return; } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "ms_struct"; return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_msstruct); Toks[0].setLocation(MSStructTok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(Kind))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma 'align' '=' {'native','natural','mac68k','power','reset'} // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'} static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok, bool IsOptions) { Token Tok; if (IsOptions) { PP.Lex(Tok); if (Tok.isNot(tok::identifier) || !Tok.getIdentifierInfo()->isStr("align")) { PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align); return; } } PP.Lex(Tok); if (Tok.isNot(tok::equal)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal) << IsOptions; return; } PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << (IsOptions ? "options" : "align"); return; } Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural; const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("native")) Kind = Sema::POAK_Native; else if (II->isStr("natural")) Kind = Sema::POAK_Natural; else if (II->isStr("packed")) Kind = Sema::POAK_Packed; else if (II->isStr("power")) Kind = Sema::POAK_Power; else if (II->isStr("mac68k")) Kind = Sema::POAK_Mac68k; else if (II->isStr("reset")) Kind = Sema::POAK_Reset; else { PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option) << IsOptions; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << (IsOptions ? "options" : "align"); return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_align); Toks[0].setLocation(FirstTok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(Kind))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaAlignHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &AlignTok) { ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false); } void PragmaOptionsHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &OptionsTok) { ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true); } // #pragma unused(identifier) void PragmaUnusedHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnusedTok) { // FIXME: Should we be expanding macros here? My guess is no. SourceLocation UnusedLoc = UnusedTok.getLocation(); // Lex the left '('. Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused"; return; } // Lex the declaration reference(s). SmallVector Identifiers; SourceLocation RParenLoc; bool LexID = true; while (true) { PP.Lex(Tok); if (LexID) { if (Tok.is(tok::identifier)) { Identifiers.push_back(Tok); LexID = false; continue; } // Illegal token! PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var); return; } // We are execting a ')' or a ','. if (Tok.is(tok::comma)) { LexID = true; continue; } if (Tok.is(tok::r_paren)) { RParenLoc = Tok.getLocation(); break; } // Illegal token! PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_punc); return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "unused"; return; } // Verify that we have a location for the right parenthesis. assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'"); assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments"); // For each identifier token, insert into the token stream a // annot_pragma_unused token followed by the identifier token. // This allows us to cache a "#pragma unused" that occurs inside an inline // C++ member function. Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 2 * Identifiers.size(), llvm::alignOf()); for (unsigned i=0; i != Identifiers.size(); i++) { Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_unused); pragmaUnusedTok.setLocation(UnusedLoc); idTok = Identifiers[i]; } PP.EnterTokenStream(Toks, 2*Identifiers.size(), /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma weak identifier // #pragma weak identifier '=' identifier void PragmaWeakHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &WeakTok) { SourceLocation WeakLoc = WeakTok.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak"; return; } Token WeakName = Tok; bool HasAlias = false; Token AliasName; PP.Lex(Tok); if (Tok.is(tok::equal)) { HasAlias = true; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak"; return; } AliasName = Tok; PP.Lex(Tok); } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak"; return; } if (HasAlias) { Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 3, llvm::alignOf()); Token &pragmaUnusedTok = Toks[0]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_weakalias); pragmaUnusedTok.setLocation(WeakLoc); Toks[1] = WeakName; Toks[2] = AliasName; PP.EnterTokenStream(Toks, 3, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } else { Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 2, llvm::alignOf()); Token &pragmaUnusedTok = Toks[0]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_weak); pragmaUnusedTok.setLocation(WeakLoc); Toks[1] = WeakName; PP.EnterTokenStream(Toks, 2, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } } // #pragma redefine_extname identifier identifier void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &RedefToken) { SourceLocation RedefLoc = RedefToken.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "redefine_extname"; return; } Token RedefName = Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "redefine_extname"; return; } Token AliasName = Tok; PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "redefine_extname"; return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 3, llvm::alignOf()); Token &pragmaRedefTok = Toks[0]; pragmaRedefTok.startToken(); pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname); pragmaRedefTok.setLocation(RedefLoc); Toks[1] = RedefName; Toks[2] = AliasName; PP.EnterTokenStream(Toks, 3, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaFPContractHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_fp_contract); Toks[0].setLocation(Tok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(OOS))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "OPENCL"; return; } IdentifierInfo *ename = Tok.getIdentifierInfo(); SourceLocation NameLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::colon)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename; return; } PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable); return; } IdentifierInfo *op = Tok.getIdentifierInfo(); unsigned state; if (op->isStr("enable")) { state = 1; } else if (op->isStr("disable")) { state = 0; } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable); return; } SourceLocation StateLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "OPENCL EXTENSION"; return; } OpenCLExtData data(ename, state); Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_opencl_extension); Toks[0].setLocation(NameLoc); Toks[0].setAnnotationValue(data.getOpaqueValue()); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, ename, StateLoc, state); } /// \brief Handle '#pragma omp ...' when OpenMP is disabled. /// void PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstTok) { if (PP.getDiagnostics().getDiagnosticLevel(diag::warn_pragma_omp_ignored, FirstTok.getLocation()) != DiagnosticsEngine::Ignored) { PP.Diag(FirstTok, diag::warn_pragma_omp_ignored); PP.getDiagnostics().setDiagnosticMapping(diag::warn_pragma_omp_ignored, diag::MAP_IGNORE, SourceLocation()); } PP.DiscardUntilEndOfDirective(); } /// \brief Handle '#pragma omp ...' when OpenMP is enabled. /// void PragmaOpenMPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstTok) { SmallVector Pragma; Token Tok; Tok.startToken(); Tok.setKind(tok::annot_pragma_openmp); Tok.setLocation(FirstTok.getLocation()); while (Tok.isNot(tok::eod)) { Pragma.push_back(Tok); PP.Lex(Tok); } SourceLocation EodLoc = Tok.getLocation(); Tok.startToken(); Tok.setKind(tok::annot_pragma_openmp_end); Tok.setLocation(EodLoc); Pragma.push_back(Tok); Token *Toks = new Token[Pragma.size()]; std::copy(Pragma.begin(), Pragma.end(), Toks); PP.EnterTokenStream(Toks, Pragma.size(), /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true); } /// \brief Handle the Microsoft \#pragma detect_mismatch extension. /// /// The syntax is: /// \code /// #pragma detect_mismatch("name", "value") /// \endcode /// Where 'name' and 'value' are quoted strings. The values are embedded in /// the object file and passed along to the linker. If the linker detects a /// mismatch in the object file's values for the given name, a LNK2038 error /// is emitted. See MSDN for more details. void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation CommentLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(CommentLoc, diag::err_expected_lparen); return; } // Read the name to embed, which must be a string literal. std::string NameString; if (!PP.LexStringLiteral(Tok, NameString, "pragma detect_mismatch", /*MacroExpansion=*/true)) return; // Read the comma followed by a second string literal. std::string ValueString; if (Tok.isNot(tok::comma)) { PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed); return; } if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch", /*MacroExpansion=*/true)) return; if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected_rparen); return; } PP.Lex(Tok); // Eat the r_paren. if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed); return; } // If the pragma is lexically sound, notify any interested PPCallbacks. if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaDetectMismatch(CommentLoc, NameString, ValueString); Actions.ActOnPragmaDetectMismatch(NameString, ValueString); } /// \brief Handle the microsoft \#pragma comment extension. /// /// The syntax is: /// \code /// #pragma comment(linker, "foo") /// \endcode /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user. /// "foo" is a string, which is fully macro expanded, and permits string /// concatenation, embedded escape characters etc. See MSDN for more details. void PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation CommentLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(CommentLoc, diag::err_pragma_comment_malformed); return; } // Read the identifier. PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(CommentLoc, diag::err_pragma_comment_malformed); return; } // Verify that this is one of the 5 whitelisted options. IdentifierInfo *II = Tok.getIdentifierInfo(); Sema::PragmaMSCommentKind Kind = llvm::StringSwitch(II->getName()) .Case("linker", Sema::PCK_Linker) .Case("lib", Sema::PCK_Lib) .Case("compiler", Sema::PCK_Compiler) .Case("exestr", Sema::PCK_ExeStr) .Case("user", Sema::PCK_User) .Default(Sema::PCK_Unknown); if (Kind == Sema::PCK_Unknown) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind); return; } // Read the optional string if present. PP.Lex(Tok); std::string ArgumentString; if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString, "pragma comment", /*MacroExpansion=*/true)) return; // FIXME: warn that 'exestr' is deprecated. // FIXME: If the kind is "compiler" warn if the string is present (it is // ignored). // The MSDN docs say that "lib" and "linker" require a string and have a short // whitelist of linker options they support, but in practice MSVC doesn't // issue a diagnostic. Therefore neither does clang. if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); return; } PP.Lex(Tok); // eat the r_paren. if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); return; } // If the pragma is lexically sound, notify any interested PPCallbacks. if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString); Actions.ActOnPragmaMSComment(Kind, ArgumentString); } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d133 1 a133 1 PP.Diag(Tok, diag::err_expected) << tok::l_brace; d818 1 a818 1 PP.Diag(CommentLoc, diag::err_expected) << tok::l_paren; d841 1 a841 1 PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; @ 1.1.1.3 log @Import Clang 3.5svn r201163. @ text @a182 8 void Parser::HandlePragmaMSPointersToMembers() { assert(Tok.is(tok::annot_pragma_ms_pointers_to_members)); Sema::PragmaMSPointersToMembersKind RepresentationMethod = static_cast( reinterpret_cast(Tok.getAnnotationValue())); SourceLocation PragmaLoc = ConsumeToken(); // The annotation token. Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc); } d533 1 a533 1 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused"; a801 93 /// \brief Handle '#pragma pointers_to_members' // The grammar for this pragma is as follows: // // ::= ('single' | 'multiple' | 'virtual') '_inheritance' // // #pragma pointers_to_members '(' 'best_case' ')' // #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')' // #pragma pointers_to_members '(' inheritance-model ')' void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation PointersToMembersLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen) << "pointers_to_members"; return; } PP.Lex(Tok); const IdentifierInfo *Arg = Tok.getIdentifierInfo(); if (!Arg) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "pointers_to_members"; return; } PP.Lex(Tok); Sema::PragmaMSPointersToMembersKind RepresentationMethod; if (Arg->isStr("best_case")) { RepresentationMethod = Sema::PPTMK_BestCase; } else { if (Arg->isStr("full_generality")) { if (Tok.is(tok::comma)) { PP.Lex(Tok); Arg = Tok.getIdentifierInfo(); if (!Arg) { PP.Diag(Tok.getLocation(), diag::err_pragma_pointers_to_members_unknown_kind) << Tok.getKind() << /*OnlyInheritanceModels*/ 0; return; } PP.Lex(Tok); } else if (Tok.is(tok::r_paren)) { // #pragma pointers_to_members(full_generality) implicitly specifies // virtual_inheritance. Arg = 0; RepresentationMethod = Sema::PPTMK_FullGeneralityVirtualInheritance; } else { PP.Diag(Tok.getLocation(), diag::err_expected_punc) << "full_generality"; return; } } if (Arg) { if (Arg->isStr("single_inheritance")) { RepresentationMethod = Sema::PPTMK_FullGeneralitySingleInheritance; } else if (Arg->isStr("multiple_inheritance")) { RepresentationMethod = Sema::PPTMK_FullGeneralityMultipleInheritance; } else if (Arg->isStr("virtual_inheritance")) { RepresentationMethod = Sema::PPTMK_FullGeneralityVirtualInheritance; } else { PP.Diag(Tok.getLocation(), diag::err_pragma_pointers_to_members_unknown_kind) << Arg << /*HasPointerDeclaration*/ 1; return; } } } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected_rparen_after) << (Arg ? Arg->getName() : "full_generality"); return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pointers_to_members"; return; } Token AnnotTok; AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_pointers_to_members); AnnotTok.setLocation(PointersToMembersLoc); AnnotTok.setAnnotationValue( reinterpret_cast(static_cast(RepresentationMethod))); PP.EnterToken(AnnotTok); } @ 1.1.1.4 log @Import Clang 3.5svn r202566. @ text @d14 1 a21 202 namespace { struct PragmaAlignHandler : public PragmaHandler { explicit PragmaAlignHandler() : PragmaHandler("align") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaGCCVisibilityHandler : public PragmaHandler { explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaOptionsHandler : public PragmaHandler { explicit PragmaOptionsHandler() : PragmaHandler("options") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaPackHandler : public PragmaHandler { explicit PragmaPackHandler() : PragmaHandler("pack") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaMSStructHandler : public PragmaHandler { explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaUnusedHandler : public PragmaHandler { PragmaUnusedHandler() : PragmaHandler("unused") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaWeakHandler : public PragmaHandler { explicit PragmaWeakHandler() : PragmaHandler("weak") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaRedefineExtnameHandler : public PragmaHandler { explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaOpenCLExtensionHandler : public PragmaHandler { PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaFPContractHandler : public PragmaHandler { PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaNoOpenMPHandler : public PragmaHandler { PragmaNoOpenMPHandler() : PragmaHandler("omp") { } virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaOpenMPHandler : public PragmaHandler { PragmaOpenMPHandler() : PragmaHandler("omp") { } virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; /// PragmaCommentHandler - "\#pragma comment ...". struct PragmaCommentHandler : public PragmaHandler { PragmaCommentHandler(Sema &Actions) : PragmaHandler("comment"), Actions(Actions) {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); private: Sema &Actions; }; struct PragmaDetectMismatchHandler : public PragmaHandler { PragmaDetectMismatchHandler(Sema &Actions) : PragmaHandler("detect_mismatch"), Actions(Actions) {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); private: Sema &Actions; }; struct PragmaMSPointersToMembers : public PragmaHandler { explicit PragmaMSPointersToMembers() : PragmaHandler("pointers_to_members") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaMSVtorDisp : public PragmaHandler { explicit PragmaMSVtorDisp() : PragmaHandler("vtordisp") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; } // end namespace void Parser::initializePragmaHandlers() { AlignHandler.reset(new PragmaAlignHandler()); PP.AddPragmaHandler(AlignHandler.get()); GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler()); PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get()); OptionsHandler.reset(new PragmaOptionsHandler()); PP.AddPragmaHandler(OptionsHandler.get()); PackHandler.reset(new PragmaPackHandler()); PP.AddPragmaHandler(PackHandler.get()); MSStructHandler.reset(new PragmaMSStructHandler()); PP.AddPragmaHandler(MSStructHandler.get()); UnusedHandler.reset(new PragmaUnusedHandler()); PP.AddPragmaHandler(UnusedHandler.get()); WeakHandler.reset(new PragmaWeakHandler()); PP.AddPragmaHandler(WeakHandler.get()); RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler()); PP.AddPragmaHandler(RedefineExtnameHandler.get()); FPContractHandler.reset(new PragmaFPContractHandler()); PP.AddPragmaHandler("STDC", FPContractHandler.get()); if (getLangOpts().OpenCL) { OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler()); PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get()); PP.AddPragmaHandler("OPENCL", FPContractHandler.get()); } if (getLangOpts().OpenMP) OpenMPHandler.reset(new PragmaOpenMPHandler()); else OpenMPHandler.reset(new PragmaNoOpenMPHandler()); PP.AddPragmaHandler(OpenMPHandler.get()); if (getLangOpts().MicrosoftExt) { MSCommentHandler.reset(new PragmaCommentHandler(Actions)); PP.AddPragmaHandler(MSCommentHandler.get()); MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(Actions)); PP.AddPragmaHandler(MSDetectMismatchHandler.get()); MSPointersToMembers.reset(new PragmaMSPointersToMembers()); PP.AddPragmaHandler(MSPointersToMembers.get()); MSVtorDisp.reset(new PragmaMSVtorDisp()); PP.AddPragmaHandler(MSVtorDisp.get()); } } void Parser::resetPragmaHandlers() { // Remove the pragma handlers we installed. PP.RemovePragmaHandler(AlignHandler.get()); AlignHandler.reset(); PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get()); GCCVisibilityHandler.reset(); PP.RemovePragmaHandler(OptionsHandler.get()); OptionsHandler.reset(); PP.RemovePragmaHandler(PackHandler.get()); PackHandler.reset(); PP.RemovePragmaHandler(MSStructHandler.get()); MSStructHandler.reset(); PP.RemovePragmaHandler(UnusedHandler.get()); UnusedHandler.reset(); PP.RemovePragmaHandler(WeakHandler.get()); WeakHandler.reset(); PP.RemovePragmaHandler(RedefineExtnameHandler.get()); RedefineExtnameHandler.reset(); if (getLangOpts().OpenCL) { PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get()); OpenCLExtensionHandler.reset(); PP.RemovePragmaHandler("OPENCL", FPContractHandler.get()); } PP.RemovePragmaHandler(OpenMPHandler.get()); OpenMPHandler.reset(); if (getLangOpts().MicrosoftExt) { PP.RemovePragmaHandler(MSCommentHandler.get()); MSCommentHandler.reset(); PP.RemovePragmaHandler(MSDetectMismatchHandler.get()); MSDetectMismatchHandler.reset(); PP.RemovePragmaHandler(MSPointersToMembers.get()); MSPointersToMembers.reset(); PP.RemovePragmaHandler(MSVtorDisp.get()); MSVtorDisp.reset(); } PP.RemovePragmaHandler("STDC", FPContractHandler.get()); FPContractHandler.reset(); } d185 2 a186 2 LangOptions::PragmaMSPointersToMembersKind RepresentationMethod = static_cast( a191 9 void Parser::HandlePragmaMSVtorDisp() { assert(Tok.is(tok::annot_pragma_ms_vtordisp)); uintptr_t Value = reinterpret_cast(Tok.getAnnotationValue()); Sema::PragmaVtorDispKind Kind = static_cast((Value >> 16) & 0xFFFF); MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF); SourceLocation PragmaLoc = ConsumeToken(); // The annotation token. Actions.ActOnPragmaMSVtorDisp(Kind, PragmaLoc, Mode); } d294 1 a294 1 PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "pack"; d837 1 a837 1 LangOptions::PragmaMSPointersToMembersKind RepresentationMethod; d839 1 a839 1 RepresentationMethod = LangOptions::PPTMK_BestCase; d857 1 a857 1 RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance; d867 1 a867 2 RepresentationMethod = LangOptions::PPTMK_FullGeneralitySingleInheritance; d869 1 a869 2 RepresentationMethod = LangOptions::PPTMK_FullGeneralityMultipleInheritance; d871 1 a871 2 RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance; a902 91 /// \brief Handle '#pragma vtordisp' // The grammar for this pragma is as follows: // // ::= ('off' | 'on' | '0' | '1' | '2' ) // // #pragma vtordisp '(' ['push' ','] vtordisp-mode ')' // #pragma vtordisp '(' 'pop' ')' // #pragma vtordisp '(' ')' void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation VtorDispLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) << "vtordisp"; return; } PP.Lex(Tok); Sema::PragmaVtorDispKind Kind = Sema::PVDK_Set; const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II) { if (II->isStr("push")) { // #pragma vtordisp(push, mode) PP.Lex(Tok); if (Tok.isNot(tok::comma)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_punc) << "vtordisp"; return; } PP.Lex(Tok); Kind = Sema::PVDK_Push; // not push, could be on/off } else if (II->isStr("pop")) { // #pragma vtordisp(pop) PP.Lex(Tok); Kind = Sema::PVDK_Pop; } // not push or pop, could be on/off } else { if (Tok.is(tok::r_paren)) { // #pragma vtordisp() Kind = Sema::PVDK_Reset; } } uint64_t Value = 0; if (Kind == Sema::PVDK_Push || Kind == Sema::PVDK_Set) { const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II && II->isStr("off")) { PP.Lex(Tok); Value = 0; } else if (II && II->isStr("on")) { PP.Lex(Tok); Value = 1; } else if (Tok.is(tok::numeric_constant) && PP.parseSimpleIntegerLiteral(Tok, Value)) { if (Value > 2) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_integer) << 0 << 2 << "vtordisp"; return; } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "vtordisp"; return; } } // Finish the pragma: ')' $ if (Tok.isNot(tok::r_paren)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) << "vtordisp"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "vtordisp"; return; } // Enter the annotation. Token AnnotTok; AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_vtordisp); AnnotTok.setLocation(VtorDispLoc); AnnotTok.setAnnotationValue(reinterpret_cast( static_cast((Kind << 16) | (Value & 0xFFFF)))); PP.EnterToken(AnnotTok); } @ 1.1.1.4.2.1 log @Rebase. @ text @a13 1 #include "RAIIObjectsForParser.h" d25 2 a26 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d31 2 a32 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d37 2 a38 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d43 2 a44 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d49 2 a50 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d55 2 a56 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d61 2 a62 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d67 2 a68 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d73 2 a74 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d80 2 a81 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d86 2 a87 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d92 2 a93 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d100 2 a101 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d109 2 a110 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d117 2 a118 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d123 2 a124 18 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaMSPragma : public PragmaHandler { explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; /// PragmaOptimizeHandler - "\#pragma clang optimize on/off". struct PragmaOptimizeHandler : public PragmaHandler { PragmaOptimizeHandler(Sema &S) : PragmaHandler("optimize"), Actions(S) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; private: Sema &Actions; a177 12 MSInitSeg.reset(new PragmaMSPragma("init_seg")); PP.AddPragmaHandler(MSInitSeg.get()); MSDataSeg.reset(new PragmaMSPragma("data_seg")); PP.AddPragmaHandler(MSDataSeg.get()); MSBSSSeg.reset(new PragmaMSPragma("bss_seg")); PP.AddPragmaHandler(MSBSSSeg.get()); MSConstSeg.reset(new PragmaMSPragma("const_seg")); PP.AddPragmaHandler(MSConstSeg.get()); MSCodeSeg.reset(new PragmaMSPragma("code_seg")); PP.AddPragmaHandler(MSCodeSeg.get()); MSSection.reset(new PragmaMSPragma("section")); PP.AddPragmaHandler(MSSection.get()); a178 3 OptimizeHandler.reset(new PragmaOptimizeHandler(Actions)); PP.AddPragmaHandler("clang", OptimizeHandler.get()); a216 12 PP.RemovePragmaHandler(MSInitSeg.get()); MSInitSeg.reset(); PP.RemovePragmaHandler(MSDataSeg.get()); MSDataSeg.reset(); PP.RemovePragmaHandler(MSBSSSeg.get()); MSBSSSeg.reset(); PP.RemovePragmaHandler(MSConstSeg.get()); MSConstSeg.reset(); PP.RemovePragmaHandler(MSCodeSeg.get()); MSCodeSeg.reset(); PP.RemovePragmaHandler(MSSection.get()); MSSection.reset(); a220 3 PP.RemovePragmaHandler("clang", OptimizeHandler.get()); OptimizeHandler.reset(); a402 139 void Parser::HandlePragmaMSPragma() { assert(Tok.is(tok::annot_pragma_ms_pragma)); // Grab the tokens out of the annotation and enter them into the stream. auto TheTokens = (std::pair *)Tok.getAnnotationValue(); PP.EnterTokenStream(TheTokens->first, TheTokens->second, true, true); SourceLocation PragmaLocation = ConsumeToken(); // The annotation token. assert(Tok.isAnyIdentifier()); llvm::StringRef PragmaName = Tok.getIdentifierInfo()->getName(); PP.Lex(Tok); // pragma kind // Figure out which #pragma we're dealing with. The switch has no default // because lex shouldn't emit the annotation token for unrecognized pragmas. typedef unsigned (Parser::*PragmaHandler)(llvm::StringRef, SourceLocation); PragmaHandler Handler = llvm::StringSwitch(PragmaName) .Case("data_seg", &Parser::HandlePragmaMSSegment) .Case("bss_seg", &Parser::HandlePragmaMSSegment) .Case("const_seg", &Parser::HandlePragmaMSSegment) .Case("code_seg", &Parser::HandlePragmaMSSegment) .Case("section", &Parser::HandlePragmaMSSection) .Case("init_seg", &Parser::HandlePragmaMSInitSeg); if (auto DiagID = (this->*Handler)(PragmaName, PragmaLocation)) { PP.Diag(PragmaLocation, DiagID) << PragmaName; while (Tok.isNot(tok::eof)) PP.Lex(Tok); PP.Lex(Tok); } } unsigned Parser::HandlePragmaMSSection(llvm::StringRef PragmaName, SourceLocation PragmaLocation) { if (Tok.isNot(tok::l_paren)) return diag::warn_pragma_expected_lparen; PP.Lex(Tok); // ( // Parsing code for pragma section if (Tok.isNot(tok::string_literal)) return diag::warn_pragma_expected_section_name; StringLiteral *SegmentName = cast(ParseStringLiteralExpression().get()); int SectionFlags = 0; while (Tok.is(tok::comma)) { PP.Lex(Tok); // , if (!Tok.isAnyIdentifier()) return diag::warn_pragma_expected_action_or_r_paren; Sema::PragmaSectionFlag Flag = llvm::StringSwitch( Tok.getIdentifierInfo()->getName()) .Case("read", Sema::PSF_Read) .Case("write", Sema::PSF_Write) .Case("execute", Sema::PSF_Execute) .Case("shared", Sema::PSF_Invalid) .Case("nopage", Sema::PSF_Invalid) .Case("nocache", Sema::PSF_Invalid) .Case("discard", Sema::PSF_Invalid) .Case("remove", Sema::PSF_Invalid) .Default(Sema::PSF_None); if (Flag == Sema::PSF_None || Flag == Sema::PSF_Invalid) { PP.Diag(PragmaLocation, Flag == Sema::PSF_None ? diag::warn_pragma_invalid_specific_action : diag::warn_pragma_unsupported_action) << PragmaName << Tok.getIdentifierInfo()->getName(); while (Tok.isNot(tok::eof)) PP.Lex(Tok); PP.Lex(Tok); return 0; } SectionFlags |= Flag; PP.Lex(Tok); // Identifier } if (Tok.isNot(tok::r_paren)) return diag::warn_pragma_expected_rparen; PP.Lex(Tok); // ) if (Tok.isNot(tok::eof)) return diag::warn_pragma_extra_tokens_at_eol; PP.Lex(Tok); // eof Actions.ActOnPragmaMSSection(PragmaLocation, SectionFlags, SegmentName); return 0; } unsigned Parser::HandlePragmaMSSegment(llvm::StringRef PragmaName, SourceLocation PragmaLocation) { if (Tok.isNot(tok::l_paren)) return diag::warn_pragma_expected_lparen; PP.Lex(Tok); // ( Sema::PragmaMsStackAction Action = Sema::PSK_Reset; llvm::StringRef SlotLabel; if (Tok.isAnyIdentifier()) { llvm::StringRef PushPop = Tok.getIdentifierInfo()->getName(); if (PushPop == "push") Action = Sema::PSK_Push; else if (PushPop == "pop") Action = Sema::PSK_Pop; else return diag::warn_pragma_expected_section_push_pop_or_name; if (Action != Sema::PSK_Reset) { PP.Lex(Tok); // push | pop if (Tok.is(tok::comma)) { PP.Lex(Tok); // , // If we've got a comma, we either need a label or a string. if (Tok.isAnyIdentifier()) { SlotLabel = Tok.getIdentifierInfo()->getName(); PP.Lex(Tok); // identifier if (Tok.is(tok::comma)) PP.Lex(Tok); else if (Tok.isNot(tok::r_paren)) return diag::warn_pragma_expected_punc; } } else if (Tok.isNot(tok::r_paren)) return diag::warn_pragma_expected_punc; } } // Grab the string literal for our section name. StringLiteral *SegmentName = nullptr; if (Tok.isNot(tok::r_paren)) { if (Tok.isNot(tok::string_literal)) return Action != Sema::PSK_Reset ? !SlotLabel.empty() ? diag::warn_pragma_expected_section_name : diag::warn_pragma_expected_section_label_or_name : diag::warn_pragma_expected_section_push_pop_or_name; SegmentName = cast(ParseStringLiteralExpression().get()); // Setting section "" has no effect if (SegmentName->getLength()) Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set); } if (Tok.isNot(tok::r_paren)) return diag::warn_pragma_expected_rparen; PP.Lex(Tok); // ) if (Tok.isNot(tok::eof)) return diag::warn_pragma_extra_tokens_at_eol; PP.Lex(Tok); // eof Actions.ActOnPragmaMSSeg(PragmaLocation, Action, SlotLabel, SegmentName, PragmaName); return 0; } unsigned Parser::HandlePragmaMSInitSeg(llvm::StringRef PragmaName, SourceLocation PragmaLocation) { return PP.getDiagnostics().getCustomDiagID( DiagnosticsEngine::Error, "'#pragma %0' not implemented."); } d418 1 a418 1 VisType = nullptr; d478 1 a478 1 IdentifierInfo *Name = nullptr; d1066 1 a1066 1 Arg = nullptr; a1206 27 /// \brief Handle all MS pragmas. Simply forwards the tokens after inserting /// an annotation token. void PragmaMSPragma::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { Token EoF, AnnotTok; EoF.startToken(); EoF.setKind(tok::eof); AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_pragma); AnnotTok.setLocation(Tok.getLocation()); SmallVector TokenVector; // Suck up all of the tokens before the eod. for (; Tok.isNot(tok::eod); PP.Lex(Tok)) TokenVector.push_back(Tok); // Add a sentinal EoF token to the end of the list. TokenVector.push_back(EoF); // We must allocate this array with new because EnterTokenStream is going to // delete it later. Token *TokenArray = new Token[TokenVector.size()]; std::copy(TokenVector.begin(), TokenVector.end(), TokenArray); auto Value = new (PP.getPreprocessorAllocator()) std::pair(std::make_pair(TokenArray, TokenVector.size())); AnnotTok.setAnnotationValue(Value); PP.EnterToken(AnnotTok); } a1336 37 // #pragma clang optimize off // #pragma clang optimize on void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) { Token Tok; PP.Lex(Tok); if (Tok.is(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_missing_argument); return; } if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) << PP.getSpelling(Tok); return; } const IdentifierInfo *II = Tok.getIdentifierInfo(); // The only accepted values are 'on' or 'off'. bool IsOn = false; if (II->isStr("on")) { IsOn = true; } else if (!II->isStr("off")) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) << PP.getSpelling(Tok); return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument) << PP.getSpelling(Tok); return; } Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation()); } @ 1.1.1.5 log @Import Clang 3.5svn r209886. @ text @a13 1 #include "RAIIObjectsForParser.h" d25 2 a26 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d31 2 a32 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d37 2 a38 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d43 2 a44 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d49 2 a50 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d55 2 a56 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d61 2 a62 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d67 2 a68 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d73 2 a74 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d80 2 a81 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d86 2 a87 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d92 2 a93 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d100 2 a101 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d109 2 a110 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d117 2 a118 2 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; d123 2 a124 18 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaMSPragma : public PragmaHandler { explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; /// PragmaOptimizeHandler - "\#pragma clang optimize on/off". struct PragmaOptimizeHandler : public PragmaHandler { PragmaOptimizeHandler(Sema &S) : PragmaHandler("optimize"), Actions(S) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; private: Sema &Actions; a177 12 MSInitSeg.reset(new PragmaMSPragma("init_seg")); PP.AddPragmaHandler(MSInitSeg.get()); MSDataSeg.reset(new PragmaMSPragma("data_seg")); PP.AddPragmaHandler(MSDataSeg.get()); MSBSSSeg.reset(new PragmaMSPragma("bss_seg")); PP.AddPragmaHandler(MSBSSSeg.get()); MSConstSeg.reset(new PragmaMSPragma("const_seg")); PP.AddPragmaHandler(MSConstSeg.get()); MSCodeSeg.reset(new PragmaMSPragma("code_seg")); PP.AddPragmaHandler(MSCodeSeg.get()); MSSection.reset(new PragmaMSPragma("section")); PP.AddPragmaHandler(MSSection.get()); a178 3 OptimizeHandler.reset(new PragmaOptimizeHandler(Actions)); PP.AddPragmaHandler("clang", OptimizeHandler.get()); a216 12 PP.RemovePragmaHandler(MSInitSeg.get()); MSInitSeg.reset(); PP.RemovePragmaHandler(MSDataSeg.get()); MSDataSeg.reset(); PP.RemovePragmaHandler(MSBSSSeg.get()); MSBSSSeg.reset(); PP.RemovePragmaHandler(MSConstSeg.get()); MSConstSeg.reset(); PP.RemovePragmaHandler(MSCodeSeg.get()); MSCodeSeg.reset(); PP.RemovePragmaHandler(MSSection.get()); MSSection.reset(); a220 3 PP.RemovePragmaHandler("clang", OptimizeHandler.get()); OptimizeHandler.reset(); a402 139 void Parser::HandlePragmaMSPragma() { assert(Tok.is(tok::annot_pragma_ms_pragma)); // Grab the tokens out of the annotation and enter them into the stream. auto TheTokens = (std::pair *)Tok.getAnnotationValue(); PP.EnterTokenStream(TheTokens->first, TheTokens->second, true, true); SourceLocation PragmaLocation = ConsumeToken(); // The annotation token. assert(Tok.isAnyIdentifier()); llvm::StringRef PragmaName = Tok.getIdentifierInfo()->getName(); PP.Lex(Tok); // pragma kind // Figure out which #pragma we're dealing with. The switch has no default // because lex shouldn't emit the annotation token for unrecognized pragmas. typedef unsigned (Parser::*PragmaHandler)(llvm::StringRef, SourceLocation); PragmaHandler Handler = llvm::StringSwitch(PragmaName) .Case("data_seg", &Parser::HandlePragmaMSSegment) .Case("bss_seg", &Parser::HandlePragmaMSSegment) .Case("const_seg", &Parser::HandlePragmaMSSegment) .Case("code_seg", &Parser::HandlePragmaMSSegment) .Case("section", &Parser::HandlePragmaMSSection) .Case("init_seg", &Parser::HandlePragmaMSInitSeg); if (auto DiagID = (this->*Handler)(PragmaName, PragmaLocation)) { PP.Diag(PragmaLocation, DiagID) << PragmaName; while (Tok.isNot(tok::eof)) PP.Lex(Tok); PP.Lex(Tok); } } unsigned Parser::HandlePragmaMSSection(llvm::StringRef PragmaName, SourceLocation PragmaLocation) { if (Tok.isNot(tok::l_paren)) return diag::warn_pragma_expected_lparen; PP.Lex(Tok); // ( // Parsing code for pragma section if (Tok.isNot(tok::string_literal)) return diag::warn_pragma_expected_section_name; StringLiteral *SegmentName = cast(ParseStringLiteralExpression().get()); int SectionFlags = 0; while (Tok.is(tok::comma)) { PP.Lex(Tok); // , if (!Tok.isAnyIdentifier()) return diag::warn_pragma_expected_action_or_r_paren; Sema::PragmaSectionFlag Flag = llvm::StringSwitch( Tok.getIdentifierInfo()->getName()) .Case("read", Sema::PSF_Read) .Case("write", Sema::PSF_Write) .Case("execute", Sema::PSF_Execute) .Case("shared", Sema::PSF_Invalid) .Case("nopage", Sema::PSF_Invalid) .Case("nocache", Sema::PSF_Invalid) .Case("discard", Sema::PSF_Invalid) .Case("remove", Sema::PSF_Invalid) .Default(Sema::PSF_None); if (Flag == Sema::PSF_None || Flag == Sema::PSF_Invalid) { PP.Diag(PragmaLocation, Flag == Sema::PSF_None ? diag::warn_pragma_invalid_specific_action : diag::warn_pragma_unsupported_action) << PragmaName << Tok.getIdentifierInfo()->getName(); while (Tok.isNot(tok::eof)) PP.Lex(Tok); PP.Lex(Tok); return 0; } SectionFlags |= Flag; PP.Lex(Tok); // Identifier } if (Tok.isNot(tok::r_paren)) return diag::warn_pragma_expected_rparen; PP.Lex(Tok); // ) if (Tok.isNot(tok::eof)) return diag::warn_pragma_extra_tokens_at_eol; PP.Lex(Tok); // eof Actions.ActOnPragmaMSSection(PragmaLocation, SectionFlags, SegmentName); return 0; } unsigned Parser::HandlePragmaMSSegment(llvm::StringRef PragmaName, SourceLocation PragmaLocation) { if (Tok.isNot(tok::l_paren)) return diag::warn_pragma_expected_lparen; PP.Lex(Tok); // ( Sema::PragmaMsStackAction Action = Sema::PSK_Reset; llvm::StringRef SlotLabel; if (Tok.isAnyIdentifier()) { llvm::StringRef PushPop = Tok.getIdentifierInfo()->getName(); if (PushPop == "push") Action = Sema::PSK_Push; else if (PushPop == "pop") Action = Sema::PSK_Pop; else return diag::warn_pragma_expected_section_push_pop_or_name; if (Action != Sema::PSK_Reset) { PP.Lex(Tok); // push | pop if (Tok.is(tok::comma)) { PP.Lex(Tok); // , // If we've got a comma, we either need a label or a string. if (Tok.isAnyIdentifier()) { SlotLabel = Tok.getIdentifierInfo()->getName(); PP.Lex(Tok); // identifier if (Tok.is(tok::comma)) PP.Lex(Tok); else if (Tok.isNot(tok::r_paren)) return diag::warn_pragma_expected_punc; } } else if (Tok.isNot(tok::r_paren)) return diag::warn_pragma_expected_punc; } } // Grab the string literal for our section name. StringLiteral *SegmentName = nullptr; if (Tok.isNot(tok::r_paren)) { if (Tok.isNot(tok::string_literal)) return Action != Sema::PSK_Reset ? !SlotLabel.empty() ? diag::warn_pragma_expected_section_name : diag::warn_pragma_expected_section_label_or_name : diag::warn_pragma_expected_section_push_pop_or_name; SegmentName = cast(ParseStringLiteralExpression().get()); // Setting section "" has no effect if (SegmentName->getLength()) Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set); } if (Tok.isNot(tok::r_paren)) return diag::warn_pragma_expected_rparen; PP.Lex(Tok); // ) if (Tok.isNot(tok::eof)) return diag::warn_pragma_extra_tokens_at_eol; PP.Lex(Tok); // eof Actions.ActOnPragmaMSSeg(PragmaLocation, Action, SlotLabel, SegmentName, PragmaName); return 0; } unsigned Parser::HandlePragmaMSInitSeg(llvm::StringRef PragmaName, SourceLocation PragmaLocation) { return PP.getDiagnostics().getCustomDiagID( DiagnosticsEngine::Error, "'#pragma %0' not implemented."); } d418 1 a418 1 VisType = nullptr; d478 1 a478 1 IdentifierInfo *Name = nullptr; d1066 1 a1066 1 Arg = nullptr; a1206 27 /// \brief Handle all MS pragmas. Simply forwards the tokens after inserting /// an annotation token. void PragmaMSPragma::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { Token EoF, AnnotTok; EoF.startToken(); EoF.setKind(tok::eof); AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_pragma); AnnotTok.setLocation(Tok.getLocation()); SmallVector TokenVector; // Suck up all of the tokens before the eod. for (; Tok.isNot(tok::eod); PP.Lex(Tok)) TokenVector.push_back(Tok); // Add a sentinal EoF token to the end of the list. TokenVector.push_back(EoF); // We must allocate this array with new because EnterTokenStream is going to // delete it later. Token *TokenArray = new Token[TokenVector.size()]; std::copy(TokenVector.begin(), TokenVector.end(), TokenArray); auto Value = new (PP.getPreprocessorAllocator()) std::pair(std::make_pair(TokenArray, TokenVector.size())); AnnotTok.setAnnotationValue(Value); PP.EnterToken(AnnotTok); } a1336 37 // #pragma clang optimize off // #pragma clang optimize on void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) { Token Tok; PP.Lex(Tok); if (Tok.is(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_missing_argument); return; } if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) << PP.getSpelling(Tok); return; } const IdentifierInfo *II = Tok.getIdentifierInfo(); // The only accepted values are 'on' or 'off'. bool IsOn = false; if (II->isStr("on")) { IsOn = true; } else if (!II->isStr("off")) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) << PP.getSpelling(Tok); return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument) << PP.getSpelling(Tok); return; } Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation()); } @ 1.1.1.6 log @Import clang 3.6svn r215315. @ text @a17 1 #include "clang/Sema/LoopHint.h" a143 12 struct PragmaLoopHintHandler : public PragmaHandler { PragmaLoopHintHandler() : PragmaHandler("loop") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaUnrollHintHandler : public PragmaHandler { PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; a210 9 LoopHintHandler.reset(new PragmaLoopHintHandler()); PP.AddPragmaHandler("clang", LoopHintHandler.get()); UnrollHintHandler.reset(new PragmaUnrollHintHandler("unroll")); PP.AddPragmaHandler(UnrollHintHandler.get()); NoUnrollHintHandler.reset(new PragmaUnrollHintHandler("nounroll")); PP.AddPragmaHandler(NoUnrollHintHandler.get()); a267 9 PP.RemovePragmaHandler("clang", LoopHintHandler.get()); LoopHintHandler.reset(); PP.RemovePragmaHandler(UnrollHintHandler.get()); UnrollHintHandler.reset(); PP.RemovePragmaHandler(NoUnrollHintHandler.get()); NoUnrollHintHandler.reset(); d457 1 a457 1 StringRef PragmaName = Tok.getIdentifierInfo()->getName(); a458 1 d461 1 a461 1 typedef bool (Parser::*PragmaHandler)(StringRef, SourceLocation); d469 2 a470 4 if (!(this->*Handler)(PragmaName, PragmaLocation)) { // Pragma handling failed, and has been diagnosed. Slurp up the tokens // until eof (really end of line) to prevent follow-on errors. d477 4 a480 6 bool Parser::HandlePragmaMSSection(StringRef PragmaName, SourceLocation PragmaLocation) { if (Tok.isNot(tok::l_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName; return false; } d483 4 a486 14 if (Tok.isNot(tok::string_literal)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_name) << PragmaName; return false; } ExprResult StringResult = ParseStringLiteralExpression(); if (StringResult.isInvalid()) return false; // Already diagnosed. StringLiteral *SegmentName = cast(StringResult.get()); if (SegmentName->getCharByteWidth() != 1) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) << PragmaName; return false; } d490 2 a491 5 if (!Tok.isAnyIdentifier()) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren) << PragmaName; return false; } d505 3 a507 3 PP.Diag(PragmaLocation, Flag == Sema::PSF_None ? diag::warn_pragma_invalid_specific_action : diag::warn_pragma_unsupported_action) d509 4 a512 1 return false; d517 2 a518 4 if (Tok.isNot(tok::r_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName; return false; } d520 2 a521 5 if (Tok.isNot(tok::eof)) { PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol) << PragmaName; return false; } d524 1 a524 1 return true; d527 4 a530 6 bool Parser::HandlePragmaMSSegment(StringRef PragmaName, SourceLocation PragmaLocation) { if (Tok.isNot(tok::l_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName; return false; } d533 1 a533 1 StringRef SlotLabel; d535 1 a535 1 StringRef PushPop = Tok.getIdentifierInfo()->getName(); d540 2 a541 6 else { PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_push_pop_or_name) << PragmaName; return false; } d552 2 a553 5 else if (Tok.isNot(tok::r_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName; return false; } d555 2 a556 4 } else if (Tok.isNot(tok::r_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName; return false; } d562 2 a563 2 if (Tok.isNot(tok::string_literal)) { unsigned DiagID = Action != Sema::PSK_Reset ? !SlotLabel.empty() ? d567 1 a567 12 PP.Diag(PragmaLocation, DiagID) << PragmaName; return false; } ExprResult StringResult = ParseStringLiteralExpression(); if (StringResult.isInvalid()) return false; // Already diagnosed. SegmentName = cast(StringResult.get()); if (SegmentName->getCharByteWidth() != 1) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) << PragmaName; return false; } d572 2 a573 4 if (Tok.isNot(tok::r_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName; return false; } d575 2 a576 5 if (Tok.isNot(tok::eof)) { PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol) << PragmaName; return false; } d580 1 a580 58 return true; } // #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} ) bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName, SourceLocation PragmaLocation) { if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen, PragmaName)) return false; // Parse either the known section names or the string section name. StringLiteral *SegmentName = nullptr; if (Tok.isAnyIdentifier()) { auto *II = Tok.getIdentifierInfo(); StringRef Section = llvm::StringSwitch(II->getName()) .Case("compiler", "\".CRT$XCC\"") .Case("lib", "\".CRT$XCL\"") .Case("user", "\".CRT$XCU\"") .Default(""); if (!Section.empty()) { // Pretend the user wrote the appropriate string literal here. Token Toks[1]; Toks[0].startToken(); Toks[0].setKind(tok::string_literal); Toks[0].setLocation(Tok.getLocation()); Toks[0].setLiteralData(Section.data()); Toks[0].setLength(Section.size()); SegmentName = cast(Actions.ActOnStringLiteral(Toks, nullptr).get()); PP.Lex(Tok); } } else if (Tok.is(tok::string_literal)) { ExprResult StringResult = ParseStringLiteralExpression(); if (StringResult.isInvalid()) return false; SegmentName = cast(StringResult.get()); if (SegmentName->getCharByteWidth() != 1) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) << PragmaName; return false; } // FIXME: Add support for the '[, func-name]' part of the pragma. } if (!SegmentName) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName; return false; } if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen, PragmaName) || ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol, PragmaName)) return false; Actions.ActOnPragmaMSInitSeg(PragmaLocation, SegmentName); return true; d583 4 a586 71 struct PragmaLoopHintInfo { Token PragmaName; Token Option; Token Value; bool HasValue; PragmaLoopHintInfo() : HasValue(false) {} }; bool Parser::HandlePragmaLoopHint(LoopHint &Hint) { assert(Tok.is(tok::annot_pragma_loop_hint)); PragmaLoopHintInfo *Info = static_cast(Tok.getAnnotationValue()); ConsumeToken(); // The annotation token. IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo(); Hint.PragmaNameLoc = IdentifierLoc::create( Actions.Context, Info->PragmaName.getLocation(), PragmaNameInfo); // It is possible that the loop hint has no option identifier, such as // #pragma unroll(4). IdentifierInfo *OptionInfo = Info->Option.is(tok::identifier) ? Info->Option.getIdentifierInfo() : nullptr; Hint.OptionLoc = IdentifierLoc::create( Actions.Context, Info->Option.getLocation(), OptionInfo); // Return a valid hint if pragma unroll or nounroll were specified // without an argument. bool PragmaUnroll = PragmaNameInfo->getName() == "unroll"; bool PragmaNoUnroll = PragmaNameInfo->getName() == "nounroll"; if (!Info->HasValue && (PragmaUnroll || PragmaNoUnroll)) { Hint.Range = Info->PragmaName.getLocation(); return true; } // If no option is specified the argument is assumed to be numeric. bool StateOption = false; if (OptionInfo) StateOption = llvm::StringSwitch(OptionInfo->getName()) .Case("vectorize", true) .Case("interleave", true) .Case("unroll", true) .Default(false); // Validate the argument. if (StateOption) { bool OptionUnroll = OptionInfo->isStr("unroll"); SourceLocation StateLoc = Info->Value.getLocation(); IdentifierInfo *StateInfo = Info->Value.getIdentifierInfo(); if (!StateInfo || ((OptionUnroll ? !StateInfo->isStr("full") : !StateInfo->isStr("enable")) && !StateInfo->isStr("disable"))) { Diag(StateLoc, diag::err_pragma_invalid_keyword) << /*MissingArgument=*/false << /*FullKeyword=*/OptionUnroll; return false; } Hint.StateLoc = IdentifierLoc::create(Actions.Context, StateLoc, StateInfo); } else { // FIXME: We should allow non-type 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 { Diag(Info->Value.getLocation(), diag::err_pragma_loop_numeric_value); return false; } } Hint.Range = SourceRange(Info->PragmaName.getLocation(), Info->Value.getLocation()); return true; d1167 3 a1169 2 if (!PP.getDiagnostics().isIgnored(diag::warn_pragma_omp_ignored, FirstTok.getLocation())) { d1171 3 a1173 2 PP.getDiagnostics().setSeverity(diag::warn_pragma_omp_ignored, diag::Severity::Ignored, SourceLocation()); d1559 1 a1559 2 PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument) << "clang optimize" << /*Expected=*/true << "'on' or 'off'"; a1586 225 /// \brief Parses loop or unroll pragma hint value and fills in Info. static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName, Token Option, bool ValueInParens, PragmaLoopHintInfo &Info) { if (ValueInParens) { if (Tok.is(tok::r_paren)) { // Nothing between the parentheses. std::string PragmaString; if (PragmaName.getIdentifierInfo()->getName() == "loop") { PragmaString = "clang loop "; PragmaString += Option.getIdentifierInfo()->getName(); } else { assert(PragmaName.getIdentifierInfo()->getName() == "unroll" && "Unexpected pragma name"); PragmaString = "unroll"; } // Don't try to emit what the pragma is expecting with the diagnostic // because the logic is non-trivial and we give expected values in sema // diagnostics if an invalid argument is given. Here, just note that the // pragma is missing an argument. PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument) << PragmaString << /*Expected=*/false; return true; } } // FIXME: Value should be stored and parsed as a constant expression. Token Value = Tok; PP.Lex(Tok); if (ValueInParens) { // Read ')' if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; return true; } PP.Lex(Tok); } Info.PragmaName = PragmaName; Info.Option = Option; Info.Value = Value; Info.HasValue = true; return false; } /// \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 ')' /// 'unroll' '(' unroll-hint-keyword ')' /// 'vectorize_width' '(' loop-hint-value ')' /// 'interleave_count' '(' loop-hint-value ')' /// 'unroll_count' '(' loop-hint-value ')' /// /// loop-hint-keyword: /// 'enable' /// 'disable' /// /// unroll-hint-keyword: /// 'full' /// '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. /// /// The unroll and unroll_count directives control the concatenation /// unroller. Specifying unroll(full) instructs llvm to try to /// unroll the loop completely, and unroll(disable) disables unrolling /// for the loop. Specifying unroll_count(_value_) instructs llvm to /// try to unroll the loop the number of times indicated by the value. void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Incoming token is "loop" from "#pragma clang loop". Token PragmaName = Tok; 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_pragma_loop_invalid_option) << /*MissingOption=*/true << ""; return; } while (Tok.is(tok::identifier)) { Token Option = Tok; IdentifierInfo *OptionInfo = Tok.getIdentifierInfo(); bool OptionValid = llvm::StringSwitch(OptionInfo->getName()) .Case("vectorize", true) .Case("interleave", true) .Case("unroll", true) .Case("vectorize_width", true) .Case("interleave_count", true) .Case("unroll_count", true) .Default(false); if (!OptionValid) { PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option) << /*MissingOption=*/false << OptionInfo; return; } PP.Lex(Tok); // Read '(' if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren; return; } PP.Lex(Tok); auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo; if (ParseLoopHintValue(PP, Tok, PragmaName, Option, /*ValueInParens=*/true, *Info)) return; // Generate the loop hint token. Token LoopHintTok; LoopHintTok.startToken(); LoopHintTok.setKind(tok::annot_pragma_loop_hint); LoopHintTok.setLocation(PragmaName.getLocation()); LoopHintTok.setAnnotationValue(static_cast(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); } /// \brief Handle the loop unroll optimization pragmas. /// #pragma unroll /// #pragma unroll unroll-hint-value /// #pragma unroll '(' unroll-hint-value ')' /// #pragma nounroll /// /// unroll-hint-value: /// constant-expression /// /// Loop unrolling hints can be specified with '#pragma unroll' or /// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally /// contained in parentheses. With no argument the directive instructs llvm to /// try to unroll the loop completely. A positive integer argument can be /// specified to indicate the number of times the loop should be unrolled. To /// maximize compatibility with other compilers the unroll count argument can be /// specified with or without parentheses. Specifying, '#pragma nounroll' /// disables unrolling of the loop. void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Incoming token is "unroll" for "#pragma unroll", or "nounroll" for // "#pragma nounroll". Token PragmaName = Tok; PP.Lex(Tok); auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo; if (Tok.is(tok::eod)) { // nounroll or unroll pragma without an argument. Info->PragmaName = PragmaName; Info->HasValue = false; Info->Option.startToken(); } else if (PragmaName.getIdentifierInfo()->getName() == "nounroll") { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "nounroll"; return; } else { // Unroll pragma with an argument: "#pragma unroll N" or // "#pragma unroll(N)". // Read '(' if it exists. bool ValueInParens = Tok.is(tok::l_paren); if (ValueInParens) PP.Lex(Tok); Token Option; Option.startToken(); if (ParseLoopHintValue(PP, Tok, PragmaName, Option, ValueInParens, *Info)) return; // In CUDA, the argument to '#pragma unroll' should not be contained in // parentheses. if (PP.getLangOpts().CUDA && ValueInParens) PP.Diag(Info->Value.getLocation(), diag::warn_pragma_unroll_cuda_value_in_parens); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "unroll"; return; } } // Generate the hint token. Token *TokenArray = new Token[1]; TokenArray[0].startToken(); TokenArray[0].setKind(tok::annot_pragma_loop_hint); TokenArray[0].setLocation(PragmaName.getLocation()); TokenArray[0].setAnnotationValue(static_cast(Info)); PP.EnterTokenStream(TokenArray, 1, /*DisableMacroExpansion=*/false, /*OwnsTokens=*/true); } @ 1.1.1.6.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @a14 2 #include "clang/AST/ASTContext.h" #include "clang/Basic/TargetInfo.h" d533 1 a533 2 int SectionFlags = ASTContext::PSF_Read; bool SectionFlagsAreDefault = true; a535 8 // Ignore "long" and "short". // They are undocumented, but widely used, section attributes which appear // to do nothing. if (Tok.is(tok::kw_long) || Tok.is(tok::kw_short)) { PP.Lex(Tok); // long/short continue; } d541 2 a542 2 ASTContext::PragmaSectionFlag Flag = llvm::StringSwitch( d544 11 a554 11 .Case("read", ASTContext::PSF_Read) .Case("write", ASTContext::PSF_Write) .Case("execute", ASTContext::PSF_Execute) .Case("shared", ASTContext::PSF_Invalid) .Case("nopage", ASTContext::PSF_Invalid) .Case("nocache", ASTContext::PSF_Invalid) .Case("discard", ASTContext::PSF_Invalid) .Case("remove", ASTContext::PSF_Invalid) .Default(ASTContext::PSF_None); if (Flag == ASTContext::PSF_None || Flag == ASTContext::PSF_Invalid) { PP.Diag(PragmaLocation, Flag == ASTContext::PSF_None a560 1 SectionFlagsAreDefault = false; a562 4 // If no section attributes are specified, the section will be marked as // read/write. if (SectionFlagsAreDefault) SectionFlags |= ASTContext::PSF_Write; a663 5 if (getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) { PP.Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target); return false; } d721 3 a723 3 Token *Toks; size_t TokSize; PragmaLoopHintInfo() : Toks(nullptr), TokSize(0) {} a725 13 static std::string PragmaLoopHintString(Token PragmaName, Token Option) { std::string PragmaString; if (PragmaName.getIdentifierInfo()->getName() == "loop") { PragmaString = "clang loop "; PragmaString += Option.getIdentifierInfo()->getName(); } else { assert(PragmaName.getIdentifierInfo()->getName() == "unroll" && "Unexpected pragma name"); PragmaString = "unroll"; } return PragmaString; } d730 1 a743 3 Token *Toks = Info->Toks; size_t TokSize = Info->TokSize; d748 1 a748 2 if (TokSize == 0 && (PragmaUnroll || PragmaNoUnroll)) { ConsumeToken(); // The annotation token. d753 1 a753 6 // The constant expression is always followed by an eof token, which increases // the TokSize by 1. assert(TokSize > 0 && "PragmaLoopHintInfo::Toks must contain at least one token."); // If no option is specified the argument is assumed to be a constant expr. d755 1 a755 1 if (OptionInfo) { // Pragma unroll does not specify an option. a760 9 } // 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=*/PragmaUnroll; return false; } a763 1 ConsumeToken(); // The annotation token. d765 2 a766 2 SourceLocation StateLoc = Toks[0].getLocation(); IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo(); d770 2 a771 2 Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword) << /*FullKeyword=*/OptionUnroll; a773 3 if (TokSize > 2) Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << PragmaLoopHintString(Info->PragmaName, Info->Option); d776 7 a782 14 // Enter constant expression including eof terminator into token stream. PP.EnterTokenStream(Toks, TokSize, /*DisableMacroExpansion=*/false, /*OwnsTokens=*/false); ConsumeToken(); // The annotation token. ExprResult R = ParseConstantExpression(); // Tokens following an error in an ill-formed constant expression will // remain in the token stream and must be removed. if (Tok.isNot(tok::eof)) { Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << PragmaLoopHintString(Info->PragmaName, Info->Option); while (Tok.isNot(tok::eof)) ConsumeAnyToken(); a783 9 ConsumeToken(); // Consume the constant expression eof terminator. if (R.isInvalid() || Actions.CheckLoopHintExpr(R.get(), Toks[0].getLocation())) return false; // Argument is a constant expression with an integer type. Hint.ValueExpr = R.get(); d786 2 a787 2 Hint.Range = SourceRange(Info->PragmaName.getLocation(), Info->Toks[TokSize - 1].getLocation()); d1793 19 a1811 10 SmallVector ValueList; int OpenParens = ValueInParens ? 1 : 0; // Read constant expression. while (Tok.isNot(tok::eod)) { if (Tok.is(tok::l_paren)) OpenParens++; else if (Tok.is(tok::r_paren)) { OpenParens--; if (OpenParens == 0 && ValueInParens) break; d1813 1 d1815 3 a1817 3 ValueList.push_back(Tok); PP.Lex(Tok); } a1827 12 Token EOFTok; EOFTok.startToken(); EOFTok.setKind(tok::eof); EOFTok.setLocation(Tok.getLocation()); ValueList.push_back(EOFTok); // Terminates expression for parsing. Token *TokenArray = (Token *)PP.getPreprocessorAllocator().Allocate( ValueList.size() * sizeof(Token), llvm::alignOf()); std::copy(ValueList.begin(), ValueList.end(), TokenArray); Info.Toks = TokenArray; Info.TokSize = ValueList.size(); d1830 2 d1972 1 d1994 1 a1994 1 PP.Diag(Info->Toks[0].getLocation(), @ 1.1.1.7 log @Import Clang 3.6RC1 r227398. @ text @a14 2 #include "clang/AST/ASTContext.h" #include "clang/Basic/TargetInfo.h" d533 1 a533 2 int SectionFlags = ASTContext::PSF_Read; bool SectionFlagsAreDefault = true; a535 8 // Ignore "long" and "short". // They are undocumented, but widely used, section attributes which appear // to do nothing. if (Tok.is(tok::kw_long) || Tok.is(tok::kw_short)) { PP.Lex(Tok); // long/short continue; } d541 2 a542 2 ASTContext::PragmaSectionFlag Flag = llvm::StringSwitch( d544 11 a554 11 .Case("read", ASTContext::PSF_Read) .Case("write", ASTContext::PSF_Write) .Case("execute", ASTContext::PSF_Execute) .Case("shared", ASTContext::PSF_Invalid) .Case("nopage", ASTContext::PSF_Invalid) .Case("nocache", ASTContext::PSF_Invalid) .Case("discard", ASTContext::PSF_Invalid) .Case("remove", ASTContext::PSF_Invalid) .Default(ASTContext::PSF_None); if (Flag == ASTContext::PSF_None || Flag == ASTContext::PSF_Invalid) { PP.Diag(PragmaLocation, Flag == ASTContext::PSF_None a560 1 SectionFlagsAreDefault = false; a562 4 // If no section attributes are specified, the section will be marked as // read/write. if (SectionFlagsAreDefault) SectionFlags |= ASTContext::PSF_Write; a663 5 if (getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) { PP.Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target); return false; } d721 3 a723 3 Token *Toks; size_t TokSize; PragmaLoopHintInfo() : Toks(nullptr), TokSize(0) {} a725 13 static std::string PragmaLoopHintString(Token PragmaName, Token Option) { std::string PragmaString; if (PragmaName.getIdentifierInfo()->getName() == "loop") { PragmaString = "clang loop "; PragmaString += Option.getIdentifierInfo()->getName(); } else { assert(PragmaName.getIdentifierInfo()->getName() == "unroll" && "Unexpected pragma name"); PragmaString = "unroll"; } return PragmaString; } d730 1 a743 3 Token *Toks = Info->Toks; size_t TokSize = Info->TokSize; d748 1 a748 2 if (TokSize == 0 && (PragmaUnroll || PragmaNoUnroll)) { ConsumeToken(); // The annotation token. d753 1 a753 6 // The constant expression is always followed by an eof token, which increases // the TokSize by 1. assert(TokSize > 0 && "PragmaLoopHintInfo::Toks must contain at least one token."); // If no option is specified the argument is assumed to be a constant expr. d755 1 a755 1 if (OptionInfo) { // Pragma unroll does not specify an option. a760 9 } // 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=*/PragmaUnroll; return false; } a763 1 ConsumeToken(); // The annotation token. d765 2 a766 2 SourceLocation StateLoc = Toks[0].getLocation(); IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo(); d770 2 a771 2 Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword) << /*FullKeyword=*/OptionUnroll; a773 3 if (TokSize > 2) Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << PragmaLoopHintString(Info->PragmaName, Info->Option); d776 7 a782 14 // Enter constant expression including eof terminator into token stream. PP.EnterTokenStream(Toks, TokSize, /*DisableMacroExpansion=*/false, /*OwnsTokens=*/false); ConsumeToken(); // The annotation token. ExprResult R = ParseConstantExpression(); // Tokens following an error in an ill-formed constant expression will // remain in the token stream and must be removed. if (Tok.isNot(tok::eof)) { Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << PragmaLoopHintString(Info->PragmaName, Info->Option); while (Tok.isNot(tok::eof)) ConsumeAnyToken(); a783 9 ConsumeToken(); // Consume the constant expression eof terminator. if (R.isInvalid() || Actions.CheckLoopHintExpr(R.get(), Toks[0].getLocation())) return false; // Argument is a constant expression with an integer type. Hint.ValueExpr = R.get(); d786 2 a787 2 Hint.Range = SourceRange(Info->PragmaName.getLocation(), Info->Toks[TokSize - 1].getLocation()); d1793 19 a1811 10 SmallVector ValueList; int OpenParens = ValueInParens ? 1 : 0; // Read constant expression. while (Tok.isNot(tok::eod)) { if (Tok.is(tok::l_paren)) OpenParens++; else if (Tok.is(tok::r_paren)) { OpenParens--; if (OpenParens == 0 && ValueInParens) break; d1813 1 d1815 3 a1817 3 ValueList.push_back(Tok); PP.Lex(Tok); } a1827 12 Token EOFTok; EOFTok.startToken(); EOFTok.setKind(tok::eof); EOFTok.setLocation(Tok.getLocation()); ValueList.push_back(EOFTok); // Terminates expression for parsing. Token *TokenArray = (Token *)PP.getPreprocessorAllocator().Allocate( ValueList.size() * sizeof(Token), llvm::alignOf()); std::copy(ValueList.begin(), ValueList.end(), TokenArray); Info.Toks = TokenArray; Info.TokSize = ValueList.size(); d1830 2 d1972 1 d1994 1 a1994 1 PP.Diag(Info->Toks[0].getLocation(), @ 1.1.1.8 log @Import Clang 3.8.0rc3 r261930. @ text @a158 4 struct PragmaMSRuntimeChecksHandler : public EmptyPragmaHandler { PragmaMSRuntimeChecksHandler() : EmptyPragmaHandler("runtime_checks") {} }; d201 1 a201 1 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) { a203 3 } if (getLangOpts().MicrosoftExt) { a221 2 MSRuntimeChecks.reset(new PragmaMSRuntimeChecksHandler()); PP.AddPragmaHandler(MSRuntimeChecks.get()); d264 1 a264 1 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) { a266 3 } if (getLangOpts().MicrosoftExt) { a284 2 PP.RemovePragmaHandler(MSRuntimeChecks.get()); MSRuntimeChecks.reset(); a322 1 namespace { a329 1 } // end anonymous namespace a363 8 void Parser::HandlePragmaDump() { assert(Tok.is(tok::annot_pragma_dump)); IdentifierInfo *II = reinterpret_cast(Tok.getAnnotationValue()); Actions.ActOnPragmaDump(getCurScope(), Tok.getLocation(), II); ConsumeToken(); } a738 1 namespace { d742 3 a744 1 ArrayRef Toks; a745 1 } // end anonymous namespace d777 2 a778 2 const Token *Toks = Info->Toks.data(); size_t TokSize = Info->Toks.size(); a795 1 bool OptionUnroll = false; d797 1 a797 2 if (OptionInfo) { // Pragma Unroll does not specify an option. OptionUnroll = OptionInfo->isStr("unroll"); d809 1 a809 1 << /*StateArgument=*/StateOption << /*FullKeyword=*/OptionUnroll; d816 1 d819 3 a821 4 if (!StateInfo || (!StateInfo->isStr("enable") && !StateInfo->isStr("disable") && ((OptionUnroll && !StateInfo->isStr("full")) || (!OptionUnroll && !StateInfo->isStr("assume_safety"))))) { a902 1 SourceLocation EndLoc = Tok.getLocation(); a913 1 Toks[0].setAnnotationEndLoc(EndLoc); a1032 1 Toks[0].setAnnotationEndLoc(RParenLoc); a1050 1 SourceLocation EndLoc = Tok.getLocation(); a1075 1 Toks[0].setAnnotationEndLoc(EndLoc); a1130 1 SourceLocation EndLoc = Tok.getLocation(); a1144 1 Toks[0].setAnnotationEndLoc(EndLoc); a1287 1 pragmaUnusedTok.setAnnotationEndLoc(AliasName.getLocation()); a1299 1 pragmaUnusedTok.setAnnotationEndLoc(WeakLoc); a1344 1 pragmaRedefTok.setAnnotationEndLoc(AliasName.getLocation()); a1366 1 Toks[0].setAnnotationEndLoc(Tok.getLocation()); a1425 1 Toks[0].setAnnotationEndLoc(StateLoc); d1474 1 a1474 1 /*DisableMacroExpansion=*/false, /*OwnsTokens=*/true); a1556 1 SourceLocation EndLoc = Tok.getLocation(); a1567 1 AnnotTok.setAnnotationEndLoc(EndLoc); a1646 1 SourceLocation EndLoc = Tok.getLocation(); a1658 1 AnnotTok.setAnnotationEndLoc(EndLoc); a1674 1 AnnotTok.setAnnotationEndLoc(Tok.getLocation()); d1677 1 a1677 1 for (; Tok.isNot(tok::eod); PP.Lex(Tok)) { a1678 2 AnnotTok.setAnnotationEndLoc(Tok.getLocation()); } a1788 8 // On PS4, issue a warning about any pragma comments other than // #pragma comment lib. if (PP.getTargetInfo().getTriple().isPS4() && Kind != Sema::PCK_Lib) { PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored) << II->getName(); return; } d1895 5 a1899 1 Info.Toks = llvm::makeArrayRef(ValueList).copy(PP.getPreprocessorAllocator()); a1922 1 /// 'assume_safety' d1925 1 a1925 1 /// 'enable' a1926 1 /// 'full' d1942 4 a1945 7 /// unroller. Specifying unroll(enable) instructs llvm to unroll the loop /// completely if the trip count is known at compile time and unroll partially /// if the trip count is not known. Specifying unroll(full) is similar to /// unroll(enable) but will unroll the loop only if the trip count is known at /// compile time. Specifying unroll(disable) disables unrolling for the /// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the /// loop the number of times indicated by the value. a1996 1 LoopHintTok.setAnnotationEndLoc(PragmaName.getLocation()); a2078 1 TokenArray[0].setAnnotationEndLoc(PragmaName.getLocation()); @ 1.1.1.8.2.1 log @Sync with HEAD @ text @a15 1 #include "clang/Basic/PragmaKinds.h" a162 16 struct PragmaMSIntrinsicHandler : public PragmaHandler { PragmaMSIntrinsicHandler() : PragmaHandler("intrinsic") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaForceCUDAHostDeviceHandler : public PragmaHandler { PragmaForceCUDAHostDeviceHandler(Sema &Actions) : PragmaHandler("force_cuda_host_device"), Actions(Actions) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; private: Sema &Actions; }; a230 8 MSIntrinsic.reset(new PragmaMSIntrinsicHandler()); PP.AddPragmaHandler(MSIntrinsic.get()); } if (getLangOpts().CUDA) { CUDAForceHostDeviceHandler.reset( new PragmaForceCUDAHostDeviceHandler(Actions)); PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get()); a298 7 PP.RemovePragmaHandler(MSIntrinsic.get()); MSIntrinsic.reset(); } if (getLangOpts().CUDA) { PP.RemovePragmaHandler("clang", CUDAForceHostDeviceHandler.get()); CUDAForceHostDeviceHandler.reset(); d339 2 a340 2 Sema::PragmaMsStackAction Action; StringRef SlotLabel; d342 2 d358 2 a359 2 Actions.ActOnPragmaPack(PragmaLoc, Info->Action, Info->SlotLabel, Alignment.get()); d364 3 a366 2 PragmaMSStructKind Kind = static_cast( reinterpret_cast(Tok.getAnnotationValue())); d460 1 a460 4 enum OpenCLExtState : char { Disable, Enable, Begin, End }; typedef std::pair OpenCLExtData; d465 4 a468 3 OpenCLExtData *Data = static_cast(Tok.getAnnotationValue()); auto State = Data->second; auto Ident = Data->first; d472 1 a472 2 auto &Opt = Actions.getOpenCLOptions(); auto Name = Ident->getName(); d476 10 a485 25 if (Name == "all") { if (State == Disable) { Opt.disableAll(); Opt.enableSupportedCore(getLangOpts().OpenCLVersion); } else { PP.Diag(NameLoc, diag::warn_pragma_expected_predicate) << 1; } } else if (State == Begin) { if (!Opt.isKnown(Name) || !Opt.isSupported(Name, getLangOpts().OpenCLVersion)) { Opt.support(Name); } Actions.setCurrentOpenCLExtension(Name); } else if (State == End) { if (Name != Actions.getCurrentOpenCLExtension()) PP.Diag(NameLoc, diag::warn_pragma_begin_end_mismatch); Actions.setCurrentOpenCLExtension(""); } else if (!Opt.isKnown(Name)) PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << Ident; else if (Opt.isSupportedExtension(Name, getLangOpts().OpenCLVersion)) Opt.enable(Name, State == Enable); else if (Opt.isSupportedCore(Name, getLangOpts().OpenCLVersion)) PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << Ident; else PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << Ident; d500 2 a501 2 Sema::PragmaMsStackAction Action = static_cast((Value >> 16) & 0xFFFF); d504 1 a504 1 Actions.ActOnPragmaMSVtorDisp(Action, PragmaLoc, Mode); d510 2 a511 3 auto TheTokens = (std::pair, size_t> *)Tok.getAnnotationValue(); PP.EnterTokenStream(std::move(TheTokens->first), TheTokens->second, true); d801 2 a802 1 llvm::ArrayRef Toks = Info->Toks; d808 1 a808 1 if (Toks.empty() && (PragmaUnroll || PragmaNoUnroll)) { d816 1 a816 1 assert(!Toks.empty() && a820 1 bool OptionDistribute = false; a823 1 OptionDistribute = OptionInfo->isStr("distribute"); d827 2 a828 2 .Default(false) || OptionUnroll || OptionDistribute; a830 1 bool AssumeSafetyArg = !OptionUnroll && !OptionDistribute; d835 1 a835 2 << /*StateArgument=*/StateOption << /*FullKeyword=*/OptionUnroll << /*AssumeSafetyKeyword=*/AssumeSafetyArg; d844 4 a847 8 bool Valid = StateInfo && llvm::StringSwitch(StateInfo->getName()) .Cases("enable", "disable", true) .Case("full", OptionUnroll) .Case("assume_safety", AssumeSafetyArg) .Default(false); if (!Valid) { d849 1 a849 2 << /*FullKeyword=*/OptionUnroll << /*AssumeSafetyKeyword=*/AssumeSafetyArg; d852 1 a852 1 if (Toks.size() > 2) d858 2 a859 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/false); d884 1 a884 1 Info->Toks.back().getLocation()); d937 1 a937 1 auto Toks = llvm::make_unique(1); d944 2 a945 1 PP.EnterTokenStream(std::move(Toks), 1, /*DisableMacroExpansion=*/true); d964 2 a965 2 Sema::PragmaMsStackAction Action = Sema::PSK_Reset; StringRef SlotLabel; d968 1 d978 2 a979 2 Action = PP.getLangOpts().ApplePragmaPack ? Sema::PSK_Push_Set : Sema::PSK_Set; d983 1 a983 1 Action = Sema::PSK_Show; d987 1 a987 1 Action = Sema::PSK_Push; d989 1 a989 1 Action = Sema::PSK_Pop; a999 1 Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set); d1004 1 a1004 1 SlotLabel = Tok.getIdentifierInfo()->getName(); a1014 1 Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set); d1029 1 a1029 1 Action = Sema::PSK_Pop; d1044 6 a1049 4 PragmaPackInfo *Info = PP.getPreprocessorAllocator().Allocate(1); Info->Action = Action; Info->SlotLabel = SlotLabel; d1051 2 d1054 4 a1057 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1063 2 a1064 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1072 2 a1073 2 PragmaMSStructKind Kind = PMSST_OFF; d1083 1 a1083 1 Kind = PMSST_ON; d1099 4 a1102 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1109 2 a1110 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1170 4 a1173 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1180 2 a1181 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1263 3 a1265 3 MutableArrayRef Toks( PP.getPreprocessorAllocator().Allocate(2 * Identifiers.size()), 2 * Identifiers.size()); d1273 2 a1274 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1314 3 a1316 2 MutableArrayRef Toks( PP.getPreprocessorAllocator().Allocate(3), 3); d1324 2 a1325 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1327 3 a1329 2 MutableArrayRef Toks( PP.getPreprocessorAllocator().Allocate(2), 2); d1336 2 a1337 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1373 3 a1375 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(3), 3); d1383 2 a1384 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1396 4 a1399 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1406 2 a1407 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1420 1 a1420 1 IdentifierInfo *Ext = Tok.getIdentifierInfo(); d1425 1 a1425 1 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << Ext; d1431 1 a1431 1 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate) << 0; d1434 1 a1434 1 IdentifierInfo *Pred = Tok.getIdentifierInfo(); d1436 7 a1442 12 OpenCLExtState State; if (Pred->isStr("enable")) { State = Enable; } else if (Pred->isStr("disable")) { State = Disable; } else if (Pred->isStr("begin")) State = Begin; else if (Pred->isStr("end")) State = End; else { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate) << Ext->isStr("all"); d1454 5 a1458 5 auto Info = PP.getPreprocessorAllocator().Allocate(1); Info->first = Ext; Info->second = State; MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1462 1 a1462 1 Toks[0].setAnnotationValue(static_cast(Info)); d1464 2 a1465 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1468 2 a1469 2 PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, Ext, StateLoc, State); d1509 4 a1512 4 auto Toks = llvm::make_unique(Pragma.size()); std::copy(Pragma.begin(), Pragma.end(), Toks.get()); PP.EnterTokenStream(std::move(Toks), Pragma.size(), /*DisableMacroExpansion=*/false); d1632 1 a1632 1 Sema::PragmaMsStackAction Action = Sema::PSK_Set; d1643 1 a1643 1 Action = Sema::PSK_Push_Set; d1648 1 a1648 1 Action = Sema::PSK_Pop; d1654 1 a1654 1 Action = Sema::PSK_Reset; d1660 1 a1660 1 if (Action & Sema::PSK_Push || Action & Sema::PSK_Set) { d1702 1 a1702 1 static_cast((Action << 16) | (Value & 0xFFFF)))); d1728 2 a1729 2 auto TokenArray = llvm::make_unique(TokenVector.size()); std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get()); d1731 1 a1731 2 std::pair, size_t>(std::move(TokenArray), TokenVector.size()); d1749 1 a1749 1 SourceLocation DetectMismatchLoc = Tok.getLocation(); d1752 1 a1752 1 PP.Diag(DetectMismatchLoc, diag::err_expected) << tok::l_paren; d1787 1 a1787 1 PP.getPPCallbacks()->PragmaDetectMismatch(DetectMismatchLoc, NameString, d1790 1 a1790 1 Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString); d1821 9 a1829 9 PragmaMSCommentKind Kind = llvm::StringSwitch(II->getName()) .Case("linker", PCK_Linker) .Case("lib", PCK_Lib) .Case("compiler", PCK_Compiler) .Case("exestr", PCK_ExeStr) .Case("user", PCK_User) .Default(PCK_Unknown); if (Kind == PCK_Unknown) { d1836 1 a1836 1 if (PP.getTargetInfo().getTriple().isPS4() && Kind != PCK_Lib) { d1872 1 a1872 1 Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString); a2022 1 .Case("distribute", true) d2062 2 a2063 2 auto TokenArray = llvm::make_unique(TokenList.size()); std::copy(TokenList.begin(), TokenList.end(), TokenArray.get()); d2065 3 a2067 2 PP.EnterTokenStream(std::move(TokenArray), TokenList.size(), /*DisableMacroExpansion=*/false); d2130 1 a2130 1 auto TokenArray = llvm::make_unique(1); d2136 2 a2137 75 PP.EnterTokenStream(std::move(TokenArray), 1, /*DisableMacroExpansion=*/false); } /// \brief Handle the Microsoft \#pragma intrinsic extension. /// /// The syntax is: /// \code /// #pragma intrinsic(memset) /// #pragma intrinsic(strlen, memcpy) /// \endcode /// /// Pragma intrisic tells the compiler to use a builtin version of the /// function. Clang does it anyway, so the pragma doesn't really do anything. /// Anyway, we emit a warning if the function specified in \#pragma intrinsic /// isn't an intrinsic in clang and suggest to include intrin.h. void PragmaMSIntrinsicHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "intrinsic"; return; } PP.Lex(Tok); bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H"); while (Tok.is(tok::identifier)) { IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II->getBuiltinID()) PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin) << II << SuggestIntrinH; PP.Lex(Tok); if (Tok.isNot(tok::comma)) break; PP.Lex(Tok); } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "intrinsic"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "intrinsic"; } void PragmaForceCUDAHostDeviceHandler::HandlePragma( Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { Token FirstTok = Tok; PP.Lex(Tok); IdentifierInfo *Info = Tok.getIdentifierInfo(); if (!Info || (!Info->isStr("begin") && !Info->isStr("end"))) { PP.Diag(FirstTok.getLocation(), diag::warn_pragma_force_cuda_host_device_bad_arg); return; } if (Info->isStr("begin")) Actions.PushForceCUDAHostDevice(); else if (!Actions.PopForceCUDAHostDevice()) PP.Diag(FirstTok.getLocation(), diag::err_pragma_cannot_end_force_cuda_host_device); PP.Lex(Tok); if (!Tok.is(tok::eod)) PP.Diag(FirstTok.getLocation(), diag::warn_pragma_force_cuda_host_device_bad_arg); @ 1.1.1.9 log @Import Clang pre-4.0.0 r291444. @ text @a15 1 #include "clang/Basic/PragmaKinds.h" a162 16 struct PragmaMSIntrinsicHandler : public PragmaHandler { PragmaMSIntrinsicHandler() : PragmaHandler("intrinsic") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaForceCUDAHostDeviceHandler : public PragmaHandler { PragmaForceCUDAHostDeviceHandler(Sema &Actions) : PragmaHandler("force_cuda_host_device"), Actions(Actions) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; private: Sema &Actions; }; a230 8 MSIntrinsic.reset(new PragmaMSIntrinsicHandler()); PP.AddPragmaHandler(MSIntrinsic.get()); } if (getLangOpts().CUDA) { CUDAForceHostDeviceHandler.reset( new PragmaForceCUDAHostDeviceHandler(Actions)); PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get()); a298 7 PP.RemovePragmaHandler(MSIntrinsic.get()); MSIntrinsic.reset(); } if (getLangOpts().CUDA) { PP.RemovePragmaHandler("clang", CUDAForceHostDeviceHandler.get()); CUDAForceHostDeviceHandler.reset(); d339 2 a340 2 Sema::PragmaMsStackAction Action; StringRef SlotLabel; d342 2 d358 2 a359 2 Actions.ActOnPragmaPack(PragmaLoc, Info->Action, Info->SlotLabel, Alignment.get()); d364 3 a366 2 PragmaMSStructKind Kind = static_cast( reinterpret_cast(Tok.getAnnotationValue())); d460 1 a460 4 enum OpenCLExtState : char { Disable, Enable, Begin, End }; typedef std::pair OpenCLExtData; d465 4 a468 3 OpenCLExtData *Data = static_cast(Tok.getAnnotationValue()); auto State = Data->second; auto Ident = Data->first; d472 1 a472 2 auto &Opt = Actions.getOpenCLOptions(); auto Name = Ident->getName(); d476 10 a485 25 if (Name == "all") { if (State == Disable) { Opt.disableAll(); Opt.enableSupportedCore(getLangOpts().OpenCLVersion); } else { PP.Diag(NameLoc, diag::warn_pragma_expected_predicate) << 1; } } else if (State == Begin) { if (!Opt.isKnown(Name) || !Opt.isSupported(Name, getLangOpts().OpenCLVersion)) { Opt.support(Name); } Actions.setCurrentOpenCLExtension(Name); } else if (State == End) { if (Name != Actions.getCurrentOpenCLExtension()) PP.Diag(NameLoc, diag::warn_pragma_begin_end_mismatch); Actions.setCurrentOpenCLExtension(""); } else if (!Opt.isKnown(Name)) PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << Ident; else if (Opt.isSupportedExtension(Name, getLangOpts().OpenCLVersion)) Opt.enable(Name, State == Enable); else if (Opt.isSupportedCore(Name, getLangOpts().OpenCLVersion)) PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << Ident; else PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << Ident; d500 2 a501 2 Sema::PragmaMsStackAction Action = static_cast((Value >> 16) & 0xFFFF); d504 1 a504 1 Actions.ActOnPragmaMSVtorDisp(Action, PragmaLoc, Mode); d510 2 a511 3 auto TheTokens = (std::pair, size_t> *)Tok.getAnnotationValue(); PP.EnterTokenStream(std::move(TheTokens->first), TheTokens->second, true); d801 2 a802 1 llvm::ArrayRef Toks = Info->Toks; d808 1 a808 1 if (Toks.empty() && (PragmaUnroll || PragmaNoUnroll)) { d816 1 a816 1 assert(!Toks.empty() && a820 1 bool OptionDistribute = false; a823 1 OptionDistribute = OptionInfo->isStr("distribute"); d827 2 a828 2 .Default(false) || OptionUnroll || OptionDistribute; a830 1 bool AssumeSafetyArg = !OptionUnroll && !OptionDistribute; d835 1 a835 2 << /*StateArgument=*/StateOption << /*FullKeyword=*/OptionUnroll << /*AssumeSafetyKeyword=*/AssumeSafetyArg; d844 4 a847 8 bool Valid = StateInfo && llvm::StringSwitch(StateInfo->getName()) .Cases("enable", "disable", true) .Case("full", OptionUnroll) .Case("assume_safety", AssumeSafetyArg) .Default(false); if (!Valid) { d849 1 a849 2 << /*FullKeyword=*/OptionUnroll << /*AssumeSafetyKeyword=*/AssumeSafetyArg; d852 1 a852 1 if (Toks.size() > 2) d858 2 a859 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/false); d884 1 a884 1 Info->Toks.back().getLocation()); d937 1 a937 1 auto Toks = llvm::make_unique(1); d944 2 a945 1 PP.EnterTokenStream(std::move(Toks), 1, /*DisableMacroExpansion=*/true); d964 2 a965 2 Sema::PragmaMsStackAction Action = Sema::PSK_Reset; StringRef SlotLabel; d968 1 d978 2 a979 2 Action = PP.getLangOpts().ApplePragmaPack ? Sema::PSK_Push_Set : Sema::PSK_Set; d983 1 a983 1 Action = Sema::PSK_Show; d987 1 a987 1 Action = Sema::PSK_Push; d989 1 a989 1 Action = Sema::PSK_Pop; a999 1 Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set); d1004 1 a1004 1 SlotLabel = Tok.getIdentifierInfo()->getName(); a1014 1 Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set); d1029 1 a1029 1 Action = Sema::PSK_Pop; d1044 6 a1049 4 PragmaPackInfo *Info = PP.getPreprocessorAllocator().Allocate(1); Info->Action = Action; Info->SlotLabel = SlotLabel; d1051 2 d1054 4 a1057 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1063 2 a1064 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1072 2 a1073 2 PragmaMSStructKind Kind = PMSST_OFF; d1083 1 a1083 1 Kind = PMSST_ON; d1099 4 a1102 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1109 2 a1110 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1170 4 a1173 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1180 2 a1181 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1263 3 a1265 3 MutableArrayRef Toks( PP.getPreprocessorAllocator().Allocate(2 * Identifiers.size()), 2 * Identifiers.size()); d1273 2 a1274 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1314 3 a1316 2 MutableArrayRef Toks( PP.getPreprocessorAllocator().Allocate(3), 3); d1324 2 a1325 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1327 3 a1329 2 MutableArrayRef Toks( PP.getPreprocessorAllocator().Allocate(2), 2); d1336 2 a1337 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1373 3 a1375 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(3), 3); d1383 2 a1384 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1396 4 a1399 2 MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1406 2 a1407 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1420 1 a1420 1 IdentifierInfo *Ext = Tok.getIdentifierInfo(); d1425 1 a1425 1 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << Ext; d1431 1 a1431 1 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate) << 0; d1434 1 a1434 1 IdentifierInfo *Pred = Tok.getIdentifierInfo(); d1436 7 a1442 12 OpenCLExtState State; if (Pred->isStr("enable")) { State = Enable; } else if (Pred->isStr("disable")) { State = Disable; } else if (Pred->isStr("begin")) State = Begin; else if (Pred->isStr("end")) State = End; else { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate) << Ext->isStr("all"); d1454 5 a1458 5 auto Info = PP.getPreprocessorAllocator().Allocate(1); Info->first = Ext; Info->second = State; MutableArrayRef Toks(PP.getPreprocessorAllocator().Allocate(1), 1); d1462 1 a1462 1 Toks[0].setAnnotationValue(static_cast(Info)); d1464 2 a1465 1 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); d1468 2 a1469 2 PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, Ext, StateLoc, State); d1509 4 a1512 4 auto Toks = llvm::make_unique(Pragma.size()); std::copy(Pragma.begin(), Pragma.end(), Toks.get()); PP.EnterTokenStream(std::move(Toks), Pragma.size(), /*DisableMacroExpansion=*/false); d1632 1 a1632 1 Sema::PragmaMsStackAction Action = Sema::PSK_Set; d1643 1 a1643 1 Action = Sema::PSK_Push_Set; d1648 1 a1648 1 Action = Sema::PSK_Pop; d1654 1 a1654 1 Action = Sema::PSK_Reset; d1660 1 a1660 1 if (Action & Sema::PSK_Push || Action & Sema::PSK_Set) { d1702 1 a1702 1 static_cast((Action << 16) | (Value & 0xFFFF)))); d1728 2 a1729 2 auto TokenArray = llvm::make_unique(TokenVector.size()); std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get()); d1731 1 a1731 2 std::pair, size_t>(std::move(TokenArray), TokenVector.size()); d1749 1 a1749 1 SourceLocation DetectMismatchLoc = Tok.getLocation(); d1752 1 a1752 1 PP.Diag(DetectMismatchLoc, diag::err_expected) << tok::l_paren; d1787 1 a1787 1 PP.getPPCallbacks()->PragmaDetectMismatch(DetectMismatchLoc, NameString, d1790 1 a1790 1 Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString); d1821 9 a1829 9 PragmaMSCommentKind Kind = llvm::StringSwitch(II->getName()) .Case("linker", PCK_Linker) .Case("lib", PCK_Lib) .Case("compiler", PCK_Compiler) .Case("exestr", PCK_ExeStr) .Case("user", PCK_User) .Default(PCK_Unknown); if (Kind == PCK_Unknown) { d1836 1 a1836 1 if (PP.getTargetInfo().getTriple().isPS4() && Kind != PCK_Lib) { d1872 1 a1872 1 Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString); a2022 1 .Case("distribute", true) d2062 2 a2063 2 auto TokenArray = llvm::make_unique(TokenList.size()); std::copy(TokenList.begin(), TokenList.end(), TokenArray.get()); d2065 3 a2067 2 PP.EnterTokenStream(std::move(TokenArray), TokenList.size(), /*DisableMacroExpansion=*/false); d2130 1 a2130 1 auto TokenArray = llvm::make_unique(1); d2136 2 a2137 75 PP.EnterTokenStream(std::move(TokenArray), 1, /*DisableMacroExpansion=*/false); } /// \brief Handle the Microsoft \#pragma intrinsic extension. /// /// The syntax is: /// \code /// #pragma intrinsic(memset) /// #pragma intrinsic(strlen, memcpy) /// \endcode /// /// Pragma intrisic tells the compiler to use a builtin version of the /// function. Clang does it anyway, so the pragma doesn't really do anything. /// Anyway, we emit a warning if the function specified in \#pragma intrinsic /// isn't an intrinsic in clang and suggest to include intrin.h. void PragmaMSIntrinsicHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "intrinsic"; return; } PP.Lex(Tok); bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H"); while (Tok.is(tok::identifier)) { IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II->getBuiltinID()) PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin) << II << SuggestIntrinH; PP.Lex(Tok); if (Tok.isNot(tok::comma)) break; PP.Lex(Tok); } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "intrinsic"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "intrinsic"; } void PragmaForceCUDAHostDeviceHandler::HandlePragma( Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { Token FirstTok = Tok; PP.Lex(Tok); IdentifierInfo *Info = Tok.getIdentifierInfo(); if (!Info || (!Info->isStr("begin") && !Info->isStr("end"))) { PP.Diag(FirstTok.getLocation(), diag::warn_pragma_force_cuda_host_device_bad_arg); return; } if (Info->isStr("begin")) Actions.PushForceCUDAHostDevice(); else if (!Actions.PopForceCUDAHostDevice()) PP.Diag(FirstTok.getLocation(), diag::err_pragma_cannot_end_force_cuda_host_device); PP.Lex(Tok); if (!Tok.is(tok::eod)) PP.Diag(FirstTok.getLocation(), diag::warn_pragma_force_cuda_host_device_bad_arg); @ 1.1.1.10 log @Import clang r309604 from branches/release_50 @ text @d14 1 a20 1 #include "clang/Parse/RAIIObjectsForParser.h" a51 9 struct PragmaClangSectionHandler : public PragmaHandler { explicit PragmaClangSectionHandler(Sema &S) : PragmaHandler("section"), Actions(S) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; private: Sema &Actions; }; a88 6 struct PragmaFPHandler : public PragmaHandler { PragmaFPHandler() : PragmaHandler("fp") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; a179 11 /// PragmaAttributeHandler - "\#pragma clang attribute ...". struct PragmaAttributeHandler : public PragmaHandler { PragmaAttributeHandler(AttributeFactory &AttrFactory) : PragmaHandler("attribute"), AttributesForPragmaAttribute(AttrFactory) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; /// A pool of attributes that were parsed in \#pragma clang attribute. ParsedAttributes AttributesForPragmaAttribute; }; a209 3 PCSectionHandler.reset(new PragmaClangSectionHandler(Actions)); PP.AddPragmaHandler("clang", PCSectionHandler.get()); a268 6 FPHandler.reset(new PragmaFPHandler()); PP.AddPragmaHandler("clang", FPHandler.get()); AttributePragmaHandler.reset(new PragmaAttributeHandler(AttrFactory)); PP.AddPragmaHandler("clang", AttributePragmaHandler.get()); a302 3 PP.RemovePragmaHandler("clang", PCSectionHandler.get()); PCSectionHandler.reset(); a346 6 PP.RemovePragmaHandler("clang", FPHandler.get()); FPHandler.reset(); PP.RemovePragmaHandler("clang", AttributePragmaHandler.get()); AttributePragmaHandler.reset(); d356 1 a356 1 SourceLocation UnusedLoc = ConsumeAnnotationToken(); d365 1 a365 1 SourceLocation VisLoc = ConsumeAnnotationToken(); d381 1 a381 1 SourceLocation PragmaLoc = ConsumeAnnotationToken(); d397 1 a397 1 ConsumeAnnotationToken(); d405 1 a405 1 SourceLocation PragmaLoc = ConsumeAnnotationToken(); d414 1 a414 1 ConsumeAnnotationToken(); d419 1 a419 1 SourceLocation PragmaLoc = ConsumeAnnotationToken(); d427 1 a427 1 SourceLocation PragmaLoc = ConsumeAnnotationToken(); d441 1 a441 1 SourceLocation RedefLoc = ConsumeAnnotationToken(); d457 2 a458 16 LangOptions::FPContractModeKind FPC; switch (OOS) { case tok::OOS_ON: FPC = LangOptions::FPC_On; break; case tok::OOS_OFF: FPC = LangOptions::FPC_Off; break; case tok::OOS_DEFAULT: FPC = getLangOpts().getDefaultFPContractMode(); break; } Actions.ActOnPragmaFPContract(FPC); ConsumeAnnotationToken(); d464 1 a464 1 ConsumeAnnotationToken(); d501 1 a501 1 ConsumeAnnotationToken(); d540 1 a540 1 SourceLocation PragmaLoc = ConsumeAnnotationToken(); d550 1 a550 1 SourceLocation PragmaLoc = ConsumeAnnotationToken(); d560 1 a560 1 SourceLocation PragmaLocation = ConsumeAnnotationToken(); d856 1 a856 1 ConsumeAnnotationToken(); d883 1 a883 1 ConsumeAnnotationToken(); d892 1 a892 1 ConsumeAnnotationToken(); d915 1 a915 1 ConsumeAnnotationToken(); a942 416 namespace { struct PragmaAttributeInfo { enum ActionType { Push, Pop }; ParsedAttributes &Attributes; ActionType Action; ArrayRef Tokens; PragmaAttributeInfo(ParsedAttributes &Attributes) : Attributes(Attributes) {} }; #include "clang/Parse/AttrSubMatchRulesParserStringSwitches.inc" } // end anonymous namespace static StringRef getIdentifier(const Token &Tok) { if (Tok.is(tok::identifier)) return Tok.getIdentifierInfo()->getName(); const char *S = tok::getKeywordSpelling(Tok.getKind()); if (!S) return ""; return S; } static bool isAbstractAttrMatcherRule(attr::SubjectMatchRule Rule) { using namespace attr; switch (Rule) { #define ATTR_MATCH_RULE(Value, Spelling, IsAbstract) \ case Value: \ return IsAbstract; #include "clang/Basic/AttrSubMatchRulesList.inc" } llvm_unreachable("Invalid attribute subject match rule"); return false; } static void diagnoseExpectedAttributeSubjectSubRule( Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName, SourceLocation SubRuleLoc) { auto Diagnostic = PRef.Diag(SubRuleLoc, diag::err_pragma_attribute_expected_subject_sub_identifier) << PrimaryRuleName; if (const char *SubRules = validAttributeSubjectMatchSubRules(PrimaryRule)) Diagnostic << /*SubRulesSupported=*/1 << SubRules; else Diagnostic << /*SubRulesSupported=*/0; } static void diagnoseUnknownAttributeSubjectSubRule( Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName, StringRef SubRuleName, SourceLocation SubRuleLoc) { auto Diagnostic = PRef.Diag(SubRuleLoc, diag::err_pragma_attribute_unknown_subject_sub_rule) << SubRuleName << PrimaryRuleName; if (const char *SubRules = validAttributeSubjectMatchSubRules(PrimaryRule)) Diagnostic << /*SubRulesSupported=*/1 << SubRules; else Diagnostic << /*SubRulesSupported=*/0; } bool Parser::ParsePragmaAttributeSubjectMatchRuleSet( attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc) { bool IsAny = false; BalancedDelimiterTracker AnyParens(*this, tok::l_paren); if (getIdentifier(Tok) == "any") { AnyLoc = ConsumeToken(); IsAny = true; if (AnyParens.expectAndConsume()) return true; } do { // Parse the subject matcher rule. StringRef Name = getIdentifier(Tok); if (Name.empty()) { Diag(Tok, diag::err_pragma_attribute_expected_subject_identifier); return true; } std::pair, Optional (*)(StringRef, bool)> Rule = isAttributeSubjectMatchRule(Name); if (!Rule.first) { Diag(Tok, diag::err_pragma_attribute_unknown_subject_rule) << Name; return true; } attr::SubjectMatchRule PrimaryRule = *Rule.first; SourceLocation RuleLoc = ConsumeToken(); BalancedDelimiterTracker Parens(*this, tok::l_paren); if (isAbstractAttrMatcherRule(PrimaryRule)) { if (Parens.expectAndConsume()) return true; } else if (Parens.consumeOpen()) { if (!SubjectMatchRules .insert( std::make_pair(PrimaryRule, SourceRange(RuleLoc, RuleLoc))) .second) Diag(RuleLoc, diag::err_pragma_attribute_duplicate_subject) << Name << FixItHint::CreateRemoval(SourceRange( RuleLoc, Tok.is(tok::comma) ? Tok.getLocation() : RuleLoc)); LastMatchRuleEndLoc = RuleLoc; continue; } // Parse the sub-rules. StringRef SubRuleName = getIdentifier(Tok); if (SubRuleName.empty()) { diagnoseExpectedAttributeSubjectSubRule(*this, PrimaryRule, Name, Tok.getLocation()); return true; } attr::SubjectMatchRule SubRule; if (SubRuleName == "unless") { SourceLocation SubRuleLoc = ConsumeToken(); BalancedDelimiterTracker Parens(*this, tok::l_paren); if (Parens.expectAndConsume()) return true; SubRuleName = getIdentifier(Tok); if (SubRuleName.empty()) { diagnoseExpectedAttributeSubjectSubRule(*this, PrimaryRule, Name, SubRuleLoc); return true; } auto SubRuleOrNone = Rule.second(SubRuleName, /*IsUnless=*/true); if (!SubRuleOrNone) { std::string SubRuleUnlessName = "unless(" + SubRuleName.str() + ")"; diagnoseUnknownAttributeSubjectSubRule(*this, PrimaryRule, Name, SubRuleUnlessName, SubRuleLoc); return true; } SubRule = *SubRuleOrNone; ConsumeToken(); if (Parens.consumeClose()) return true; } else { auto SubRuleOrNone = Rule.second(SubRuleName, /*IsUnless=*/false); if (!SubRuleOrNone) { diagnoseUnknownAttributeSubjectSubRule(*this, PrimaryRule, Name, SubRuleName, Tok.getLocation()); return true; } SubRule = *SubRuleOrNone; ConsumeToken(); } SourceLocation RuleEndLoc = Tok.getLocation(); LastMatchRuleEndLoc = RuleEndLoc; if (Parens.consumeClose()) return true; if (!SubjectMatchRules .insert(std::make_pair(SubRule, SourceRange(RuleLoc, RuleEndLoc))) .second) { Diag(RuleLoc, diag::err_pragma_attribute_duplicate_subject) << attr::getSubjectMatchRuleSpelling(SubRule) << FixItHint::CreateRemoval(SourceRange( RuleLoc, Tok.is(tok::comma) ? Tok.getLocation() : RuleEndLoc)); continue; } } while (IsAny && TryConsumeToken(tok::comma)); if (IsAny) if (AnyParens.consumeClose()) return true; return false; } namespace { /// Describes the stage at which attribute subject rule parsing was interruped. enum class MissingAttributeSubjectRulesRecoveryPoint { Comma, ApplyTo, Equals, Any, None, }; MissingAttributeSubjectRulesRecoveryPoint getAttributeSubjectRulesRecoveryPointForToken(const Token &Tok) { if (const auto *II = Tok.getIdentifierInfo()) { if (II->isStr("apply_to")) return MissingAttributeSubjectRulesRecoveryPoint::ApplyTo; if (II->isStr("any")) return MissingAttributeSubjectRulesRecoveryPoint::Any; } if (Tok.is(tok::equal)) return MissingAttributeSubjectRulesRecoveryPoint::Equals; return MissingAttributeSubjectRulesRecoveryPoint::None; } /// Creates a diagnostic for the attribute subject rule parsing diagnostic that /// suggests the possible attribute subject rules in a fix-it together with /// any other missing tokens. DiagnosticBuilder createExpectedAttributeSubjectRulesTokenDiagnostic( unsigned DiagID, AttributeList &Attribute, MissingAttributeSubjectRulesRecoveryPoint Point, Parser &PRef) { SourceLocation Loc = PRef.getEndOfPreviousToken(); if (Loc.isInvalid()) Loc = PRef.getCurToken().getLocation(); auto Diagnostic = PRef.Diag(Loc, DiagID); std::string FixIt; MissingAttributeSubjectRulesRecoveryPoint EndPoint = getAttributeSubjectRulesRecoveryPointForToken(PRef.getCurToken()); if (Point == MissingAttributeSubjectRulesRecoveryPoint::Comma) FixIt = ", "; if (Point <= MissingAttributeSubjectRulesRecoveryPoint::ApplyTo && EndPoint > MissingAttributeSubjectRulesRecoveryPoint::ApplyTo) FixIt += "apply_to"; if (Point <= MissingAttributeSubjectRulesRecoveryPoint::Equals && EndPoint > MissingAttributeSubjectRulesRecoveryPoint::Equals) FixIt += " = "; SourceRange FixItRange(Loc); if (EndPoint == MissingAttributeSubjectRulesRecoveryPoint::None) { // Gather the subject match rules that are supported by the attribute. SmallVector, 4> SubjectMatchRuleSet; Attribute.getMatchRules(PRef.getLangOpts(), SubjectMatchRuleSet); if (SubjectMatchRuleSet.empty()) { // FIXME: We can emit a "fix-it" with a subject list placeholder when // placeholders will be supported by the fix-its. return Diagnostic; } FixIt += "any("; bool NeedsComma = false; for (const auto &I : SubjectMatchRuleSet) { // Ensure that the missing rule is reported in the fix-it only when it's // supported in the current language mode. if (!I.second) continue; if (NeedsComma) FixIt += ", "; else NeedsComma = true; FixIt += attr::getSubjectMatchRuleSpelling(I.first); } FixIt += ")"; // Check if we need to remove the range PRef.SkipUntil(tok::eof, Parser::StopBeforeMatch); FixItRange.setEnd(PRef.getCurToken().getLocation()); } if (FixItRange.getBegin() == FixItRange.getEnd()) Diagnostic << FixItHint::CreateInsertion(FixItRange.getBegin(), FixIt); else Diagnostic << FixItHint::CreateReplacement( CharSourceRange::getCharRange(FixItRange), FixIt); return Diagnostic; } } // end anonymous namespace void Parser::HandlePragmaAttribute() { assert(Tok.is(tok::annot_pragma_attribute) && "Expected #pragma attribute annotation token"); SourceLocation PragmaLoc = Tok.getLocation(); auto *Info = static_cast(Tok.getAnnotationValue()); if (Info->Action == PragmaAttributeInfo::Pop) { ConsumeAnnotationToken(); Actions.ActOnPragmaAttributePop(PragmaLoc); return; } // Parse the actual attribute with its arguments. assert(Info->Action == PragmaAttributeInfo::Push && "Unexpected #pragma attribute command"); PP.EnterTokenStream(Info->Tokens, /*DisableMacroExpansion=*/false); ConsumeAnnotationToken(); ParsedAttributes &Attrs = Info->Attributes; Attrs.clearListOnly(); auto SkipToEnd = [this]() { SkipUntil(tok::eof, StopBeforeMatch); ConsumeToken(); }; if (Tok.is(tok::l_square) && NextToken().is(tok::l_square)) { // Parse the CXX11 style attribute. ParseCXX11AttributeSpecifier(Attrs); } else if (Tok.is(tok::kw___attribute)) { ConsumeToken(); if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "attribute")) return SkipToEnd(); if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "(")) return SkipToEnd(); if (Tok.isNot(tok::identifier)) { Diag(Tok, diag::err_pragma_attribute_expected_attribute_name); SkipToEnd(); return; } IdentifierInfo *AttrName = Tok.getIdentifierInfo(); SourceLocation AttrNameLoc = ConsumeToken(); if (Tok.isNot(tok::l_paren)) Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0, AttributeList::AS_GNU); else ParseGNUAttributeArgs(AttrName, AttrNameLoc, Attrs, /*EndLoc=*/nullptr, /*ScopeName=*/nullptr, /*ScopeLoc=*/SourceLocation(), AttributeList::AS_GNU, /*Declarator=*/nullptr); if (ExpectAndConsume(tok::r_paren)) return SkipToEnd(); if (ExpectAndConsume(tok::r_paren)) return SkipToEnd(); } else if (Tok.is(tok::kw___declspec)) { ParseMicrosoftDeclSpecs(Attrs); } else { Diag(Tok, diag::err_pragma_attribute_expected_attribute_syntax); if (Tok.getIdentifierInfo()) { // If we suspect that this is an attribute suggest the use of // '__attribute__'. if (AttributeList::getKind(Tok.getIdentifierInfo(), /*ScopeName=*/nullptr, AttributeList::AS_GNU) != AttributeList::UnknownAttribute) { SourceLocation InsertStartLoc = Tok.getLocation(); ConsumeToken(); if (Tok.is(tok::l_paren)) { ConsumeAnyToken(); SkipUntil(tok::r_paren, StopBeforeMatch); if (Tok.isNot(tok::r_paren)) return SkipToEnd(); } Diag(Tok, diag::note_pragma_attribute_use_attribute_kw) << FixItHint::CreateInsertion(InsertStartLoc, "__attribute__((") << FixItHint::CreateInsertion(Tok.getEndLoc(), "))"); } } SkipToEnd(); return; } if (!Attrs.getList() || Attrs.getList()->isInvalid()) { SkipToEnd(); return; } // Ensure that we don't have more than one attribute. if (Attrs.getList()->getNext()) { SourceLocation Loc = Attrs.getList()->getNext()->getLoc(); Diag(Loc, diag::err_pragma_attribute_multiple_attributes); SkipToEnd(); return; } if (!Attrs.getList()->isSupportedByPragmaAttribute()) { Diag(PragmaLoc, diag::err_pragma_attribute_unsupported_attribute) << Attrs.getList()->getName(); SkipToEnd(); return; } AttributeList &Attribute = *Attrs.getList(); // Parse the subject-list. if (!TryConsumeToken(tok::comma)) { createExpectedAttributeSubjectRulesTokenDiagnostic( diag::err_expected, Attribute, MissingAttributeSubjectRulesRecoveryPoint::Comma, *this) << tok::comma; SkipToEnd(); return; } if (Tok.isNot(tok::identifier)) { createExpectedAttributeSubjectRulesTokenDiagnostic( diag::err_pragma_attribute_invalid_subject_set_specifier, Attribute, MissingAttributeSubjectRulesRecoveryPoint::ApplyTo, *this); SkipToEnd(); return; } const IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II->isStr("apply_to")) { createExpectedAttributeSubjectRulesTokenDiagnostic( diag::err_pragma_attribute_invalid_subject_set_specifier, Attribute, MissingAttributeSubjectRulesRecoveryPoint::ApplyTo, *this); SkipToEnd(); return; } ConsumeToken(); if (!TryConsumeToken(tok::equal)) { createExpectedAttributeSubjectRulesTokenDiagnostic( diag::err_expected, Attribute, MissingAttributeSubjectRulesRecoveryPoint::Equals, *this) << tok::equal; SkipToEnd(); return; } attr::ParsedSubjectMatchRuleSet SubjectMatchRules; SourceLocation AnyLoc, LastMatchRuleEndLoc; if (ParsePragmaAttributeSubjectMatchRuleSet(SubjectMatchRules, AnyLoc, LastMatchRuleEndLoc)) { SkipToEnd(); return; } // Tokens following an ill-formed attribute will remain in the token stream // and must be removed. if (Tok.isNot(tok::eof)) { Diag(Tok, diag::err_pragma_attribute_extra_tokens_after_attribute); SkipToEnd(); return; } // Consume the eof terminator token. ConsumeToken(); Actions.ActOnPragmaAttributePush(Attribute, PragmaLoc, std::move(SubjectMatchRules)); } a1157 45 // #pragma clang section bss="abc" data="" rodata="def" text="" void PragmaClangSectionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) { Token Tok; auto SecKind = Sema::PragmaClangSectionKind::PCSK_Invalid; PP.Lex(Tok); // eat 'section' while (Tok.isNot(tok::eod)) { if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section"; return; } const IdentifierInfo *SecType = Tok.getIdentifierInfo(); if (SecType->isStr("bss")) SecKind = Sema::PragmaClangSectionKind::PCSK_BSS; else if (SecType->isStr("data")) SecKind = Sema::PragmaClangSectionKind::PCSK_Data; else if (SecType->isStr("rodata")) SecKind = Sema::PragmaClangSectionKind::PCSK_Rodata; else if (SecType->isStr("text")) SecKind = Sema::PragmaClangSectionKind::PCSK_Text; else { PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section"; return; } PP.Lex(Tok); // eat ['bss'|'data'|'rodata'|'text'] if (Tok.isNot(tok::equal)) { PP.Diag(Tok.getLocation(), diag::err_pragma_clang_section_expected_equal) << SecKind; return; } std::string SecName; if (!PP.LexStringLiteral(Tok, SecName, "pragma clang section", false)) return; Actions.ActOnPragmaClangSection(Tok.getLocation(), (SecName.size()? Sema::PragmaClangSectionAction::PCSA_Set : Sema::PragmaClangSectionAction::PCSA_Clear), SecKind, SecName); } } a1949 123 namespace { /// Used as the annotation value for tok::annot_pragma_fp. struct TokFPAnnotValue { enum FlagKinds { Contract }; enum FlagValues { On, Off, Fast }; FlagKinds FlagKind; FlagValues FlagValue; }; } // end anonymous namespace void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // fp Token PragmaName = Tok; SmallVector TokenList; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option) << /*MissingOption=*/true << ""; return; } while (Tok.is(tok::identifier)) { IdentifierInfo *OptionInfo = Tok.getIdentifierInfo(); auto FlagKind = llvm::StringSwitch>( OptionInfo->getName()) .Case("contract", TokFPAnnotValue::Contract) .Default(None); if (!FlagKind) { PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option) << /*MissingOption=*/false << OptionInfo; return; } PP.Lex(Tok); // Read '(' if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren; return; } PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument) << PP.getSpelling(Tok) << OptionInfo->getName(); return; } const IdentifierInfo *II = Tok.getIdentifierInfo(); auto FlagValue = llvm::StringSwitch>( II->getName()) .Case("on", TokFPAnnotValue::On) .Case("off", TokFPAnnotValue::Off) .Case("fast", TokFPAnnotValue::Fast) .Default(llvm::None); if (!FlagValue) { PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument) << PP.getSpelling(Tok) << OptionInfo->getName(); return; } PP.Lex(Tok); // Read ')' if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; return; } PP.Lex(Tok); auto *AnnotValue = new (PP.getPreprocessorAllocator()) TokFPAnnotValue{*FlagKind, *FlagValue}; // Generate the loop hint token. Token FPTok; FPTok.startToken(); FPTok.setKind(tok::annot_pragma_fp); FPTok.setLocation(PragmaName.getLocation()); FPTok.setAnnotationEndLoc(PragmaName.getLocation()); FPTok.setAnnotationValue(reinterpret_cast(AnnotValue)); TokenList.push_back(FPTok); } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "clang fp"; return; } auto TokenArray = llvm::make_unique(TokenList.size()); std::copy(TokenList.begin(), TokenList.end(), TokenArray.get()); PP.EnterTokenStream(std::move(TokenArray), TokenList.size(), /*DisableMacroExpansion=*/false); } void Parser::HandlePragmaFP() { assert(Tok.is(tok::annot_pragma_fp)); auto *AnnotValue = reinterpret_cast(Tok.getAnnotationValue()); LangOptions::FPContractModeKind FPC; switch (AnnotValue->FlagValue) { case TokFPAnnotValue::On: FPC = LangOptions::FPC_On; break; case TokFPAnnotValue::Fast: FPC = LangOptions::FPC_Fast; break; case TokFPAnnotValue::Off: FPC = LangOptions::FPC_Off; break; } Actions.ActOnPragmaFPContract(FPC); ConsumeAnnotationToken(); } a2248 101 /// \brief Handle the #pragma clang attribute directive. /// /// The syntax is: /// \code /// #pragma clang attribute push(attribute, subject-set) /// #pragma clang attribute pop /// \endcode /// /// The subject-set clause defines the set of declarations which receive the /// attribute. Its exact syntax is described in the LanguageExtensions document /// in Clang's documentation. /// /// This directive instructs the compiler to begin/finish applying the specified /// attribute to the set of attribute-specific declarations in the active range /// of the pragma. void PragmaAttributeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) { Token Tok; PP.Lex(Tok); auto *Info = new (PP.getPreprocessorAllocator()) PragmaAttributeInfo(AttributesForPragmaAttribute); // Parse the 'push' or 'pop'. if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_push_pop); return; } const auto *II = Tok.getIdentifierInfo(); if (II->isStr("push")) Info->Action = PragmaAttributeInfo::Push; else if (II->isStr("pop")) Info->Action = PragmaAttributeInfo::Pop; else { PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_invalid_argument) << PP.getSpelling(Tok); return; } PP.Lex(Tok); // Parse the actual attribute. if (Info->Action == PragmaAttributeInfo::Push) { if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren; return; } PP.Lex(Tok); // Lex the attribute tokens. SmallVector AttributeTokens; int OpenParens = 1; while (Tok.isNot(tok::eod)) { if (Tok.is(tok::l_paren)) OpenParens++; else if (Tok.is(tok::r_paren)) { OpenParens--; if (OpenParens == 0) break; } AttributeTokens.push_back(Tok); PP.Lex(Tok); } if (AttributeTokens.empty()) { PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_attribute); return; } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; return; } SourceLocation EndLoc = Tok.getLocation(); PP.Lex(Tok); // Terminate the attribute for parsing. Token EOFTok; EOFTok.startToken(); EOFTok.setKind(tok::eof); EOFTok.setLocation(EndLoc); AttributeTokens.push_back(EOFTok); Info->Tokens = llvm::makeArrayRef(AttributeTokens).copy(PP.getPreprocessorAllocator()); } if (Tok.isNot(tok::eod)) PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "clang attribute"; // Generate the annotated pragma token. auto TokenArray = llvm::make_unique(1); TokenArray[0].startToken(); TokenArray[0].setKind(tok::annot_pragma_attribute); TokenArray[0].setLocation(FirstToken.getLocation()); TokenArray[0].setAnnotationEndLoc(FirstToken.getLocation()); TokenArray[0].setAnnotationValue(static_cast(Info)); PP.EnterTokenStream(std::move(TokenArray), 1, /*DisableMacroExpansion=*/false); } @ 1.1.1.10.4.1 log @Sync with HEAD @ text @a97 38 // Pragma STDC implementations. /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; if (OOS == tok::OOS_ON) PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported); } }; /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...". struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; PP.LexOnOffSwitch(OOS); } }; /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { PragmaSTDC_UnknownHandler() = default; void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) override { // C99 6.10.6p2, unknown forms are not allowed. PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); } }; a184 6 struct PragmaMSOptimizeHandler : public PragmaHandler { PragmaMSOptimizeHandler() : PragmaHandler("optimize") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; a235 9 STDCFENVHandler.reset(new PragmaSTDC_FENV_ACCESSHandler()); PP.AddPragmaHandler("STDC", STDCFENVHandler.get()); STDCCXLIMITHandler.reset(new PragmaSTDC_CX_LIMITED_RANGEHandler()); PP.AddPragmaHandler("STDC", STDCCXLIMITHandler.get()); STDCUnknownHandler.reset(new PragmaSTDC_UnknownHandler()); PP.AddPragmaHandler("STDC", STDCUnknownHandler.get()); d251 1 a251 2 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isOSBinFormatELF()) { a278 2 MSOptimize.reset(new PragmaMSOptimizeHandler()); PP.AddPragmaHandler(MSOptimize.get()); d333 1 a333 2 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isOSBinFormatELF()) { a363 2 PP.RemovePragmaHandler(MSOptimize.get()); MSOptimize.reset(); a373 9 PP.RemovePragmaHandler("STDC", STDCFENVHandler.get()); STDCFENVHandler.reset(); PP.RemovePragmaHandler("STDC", STDCCXLIMITHandler.get()); STDCCXLIMITHandler.reset(); PP.RemovePragmaHandler("STDC", STDCUnknownHandler.get()); STDCUnknownHandler.reset(); d393 1 a393 1 /// Handle the annotation token produced for #pragma unused(...) d425 1 a425 1 SourceLocation PragmaLoc = Tok.getLocation(); d429 1 a429 2 if (Alignment.isInvalid()) { ConsumeAnnotationToken(); a430 1 } a433 3 // Consume the token after processing the pragma to enable pragma-specific // #include warnings. ConsumeAnnotationToken(); d449 2 a450 4 Actions.ActOnPragmaOptionsAlign(Kind, Tok.getLocation()); // Consume the token after processing the pragma to enable pragma-specific // #include warnings. ConsumeAnnotationToken(); d531 1 a531 2 ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1172 1 a1172 1 /// Describes the stage at which attribute subject rule parsing was interrupted. d1198 1 a1198 1 unsigned DiagID, ParsedAttr &Attribute, d1298 1 a1298 1 ParsedAttr::AS_GNU); d1302 2 a1303 1 /*ScopeLoc=*/SourceLocation(), ParsedAttr::AS_GNU, d1317 3 a1319 3 if (ParsedAttr::getKind(Tok.getIdentifierInfo(), /*ScopeName=*/nullptr, ParsedAttr::AS_GNU) != ParsedAttr::UnknownAttribute) { d1337 1 a1337 1 if (Attrs.empty() || Attrs.begin()->isInvalid()) { d1343 2 a1344 2 if (Attrs.size() > 1) { SourceLocation Loc = Attrs[1].getLoc(); d1350 1 a1350 2 ParsedAttr &Attribute = *Attrs.begin(); if (!Attribute.isSupportedByPragmaAttribute()) { d1352 1 a1352 1 << Attribute.getName(); d1356 1 d2027 1 a2027 1 /// Handle '#pragma omp ...' when OpenMP is disabled. d2042 1 a2042 1 /// Handle '#pragma omp ...' when OpenMP is enabled. d2054 1 a2054 1 while (Tok.isNot(tok::eod) && Tok.isNot(tok::eof)) { a2056 12 if (Tok.is(tok::annot_pragma_openmp)) { PP.Diag(Tok, diag::err_omp_unexpected_directive) << 0; unsigned InnerPragmaCnt = 1; while (InnerPragmaCnt != 0) { PP.Lex(Tok); if (Tok.is(tok::annot_pragma_openmp)) ++InnerPragmaCnt; else if (Tok.is(tok::annot_pragma_openmp_end)) --InnerPragmaCnt; } PP.Lex(Tok); } d2070 1 a2070 1 /// Handle '#pragma pointers_to_members' d2168 1 a2168 1 /// Handle '#pragma vtordisp' d2261 1 a2261 1 /// Handle all MS pragmas. Simply forwards the tokens after inserting d2279 1 a2279 1 // Add a sentinel EoF token to the end of the list. d2292 1 a2292 1 /// Handle the Microsoft \#pragma detect_mismatch extension. d2349 1 a2349 1 /// Handle the microsoft \#pragma comment extension. a2389 6 if (PP.getTargetInfo().getTriple().isOSBinFormatELF() && Kind != PCK_Lib) { PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored) << II->getName(); return; } d2592 1 a2592 1 /// Parses loop or unroll pragma hint value and fills in Info. d2634 1 a2634 1 /// Handle the \#pragma clang loop directive. d2749 1 a2749 1 /// Handle the loop unroll optimization pragmas. d2819 1 a2819 1 /// Handle the Microsoft \#pragma intrinsic extension. a2867 55 // #pragma optimize("gsty", on|off) void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation StartLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "optimize"; return; } PP.Lex(Tok); if (Tok.isNot(tok::string_literal)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_string) << "optimize"; return; } // We could syntax check the string but it's probably not worth the effort. PP.Lex(Tok); if (Tok.isNot(tok::comma)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_comma) << "optimize"; return; } PP.Lex(Tok); if (Tok.is(tok::eod) || Tok.is(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_missing_argument) << "optimize" << /*Expected=*/true << "'on' or 'off'"; return; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II || (!II->isStr("on") && !II->isStr("off"))) { PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_argument) << PP.getSpelling(Tok) << "optimize" << /*Expected=*/true << "'on' or 'off'"; return; } PP.Lex(Tok); if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "optimize"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "optimize"; return; } PP.Diag(StartLoc, diag::warn_pragma_optimize); } d2892 1 a2892 1 /// Handle the #pragma clang attribute directive. @ 1.1.1.10.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.10.2.1 log @Sync with HEAD @ text @a97 38 // Pragma STDC implementations. /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; if (OOS == tok::OOS_ON) PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported); } }; /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...". struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; PP.LexOnOffSwitch(OOS); } }; /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { PragmaSTDC_UnknownHandler() = default; void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) override { // C99 6.10.6p2, unknown forms are not allowed. PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); } }; a184 6 struct PragmaMSOptimizeHandler : public PragmaHandler { PragmaMSOptimizeHandler() : PragmaHandler("optimize") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; a235 9 STDCFENVHandler.reset(new PragmaSTDC_FENV_ACCESSHandler()); PP.AddPragmaHandler("STDC", STDCFENVHandler.get()); STDCCXLIMITHandler.reset(new PragmaSTDC_CX_LIMITED_RANGEHandler()); PP.AddPragmaHandler("STDC", STDCCXLIMITHandler.get()); STDCUnknownHandler.reset(new PragmaSTDC_UnknownHandler()); PP.AddPragmaHandler("STDC", STDCUnknownHandler.get()); d251 1 a251 2 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isOSBinFormatELF()) { a278 2 MSOptimize.reset(new PragmaMSOptimizeHandler()); PP.AddPragmaHandler(MSOptimize.get()); d333 1 a333 2 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isOSBinFormatELF()) { a363 2 PP.RemovePragmaHandler(MSOptimize.get()); MSOptimize.reset(); a373 9 PP.RemovePragmaHandler("STDC", STDCFENVHandler.get()); STDCFENVHandler.reset(); PP.RemovePragmaHandler("STDC", STDCCXLIMITHandler.get()); STDCCXLIMITHandler.reset(); PP.RemovePragmaHandler("STDC", STDCUnknownHandler.get()); STDCUnknownHandler.reset(); d393 1 a393 1 /// Handle the annotation token produced for #pragma unused(...) d425 1 a425 1 SourceLocation PragmaLoc = Tok.getLocation(); d429 1 a429 2 if (Alignment.isInvalid()) { ConsumeAnnotationToken(); a430 1 } a433 3 // Consume the token after processing the pragma to enable pragma-specific // #include warnings. ConsumeAnnotationToken(); d449 2 a450 4 Actions.ActOnPragmaOptionsAlign(Kind, Tok.getLocation()); // Consume the token after processing the pragma to enable pragma-specific // #include warnings. ConsumeAnnotationToken(); d531 1 a531 2 ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1172 1 a1172 1 /// Describes the stage at which attribute subject rule parsing was interrupted. d1198 1 a1198 1 unsigned DiagID, ParsedAttr &Attribute, d1298 1 a1298 1 ParsedAttr::AS_GNU); d1302 2 a1303 1 /*ScopeLoc=*/SourceLocation(), ParsedAttr::AS_GNU, d1317 3 a1319 3 if (ParsedAttr::getKind(Tok.getIdentifierInfo(), /*ScopeName=*/nullptr, ParsedAttr::AS_GNU) != ParsedAttr::UnknownAttribute) { d1337 1 a1337 1 if (Attrs.empty() || Attrs.begin()->isInvalid()) { d1343 2 a1344 2 if (Attrs.size() > 1) { SourceLocation Loc = Attrs[1].getLoc(); d1350 1 a1350 2 ParsedAttr &Attribute = *Attrs.begin(); if (!Attribute.isSupportedByPragmaAttribute()) { d1352 1 a1352 1 << Attribute.getName(); d1356 1 d2027 1 a2027 1 /// Handle '#pragma omp ...' when OpenMP is disabled. d2042 1 a2042 1 /// Handle '#pragma omp ...' when OpenMP is enabled. d2054 1 a2054 1 while (Tok.isNot(tok::eod) && Tok.isNot(tok::eof)) { a2056 12 if (Tok.is(tok::annot_pragma_openmp)) { PP.Diag(Tok, diag::err_omp_unexpected_directive) << 0; unsigned InnerPragmaCnt = 1; while (InnerPragmaCnt != 0) { PP.Lex(Tok); if (Tok.is(tok::annot_pragma_openmp)) ++InnerPragmaCnt; else if (Tok.is(tok::annot_pragma_openmp_end)) --InnerPragmaCnt; } PP.Lex(Tok); } d2070 1 a2070 1 /// Handle '#pragma pointers_to_members' d2168 1 a2168 1 /// Handle '#pragma vtordisp' d2261 1 a2261 1 /// Handle all MS pragmas. Simply forwards the tokens after inserting d2279 1 a2279 1 // Add a sentinel EoF token to the end of the list. d2292 1 a2292 1 /// Handle the Microsoft \#pragma detect_mismatch extension. d2349 1 a2349 1 /// Handle the microsoft \#pragma comment extension. a2389 6 if (PP.getTargetInfo().getTriple().isOSBinFormatELF() && Kind != PCK_Lib) { PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored) << II->getName(); return; } d2592 1 a2592 1 /// Parses loop or unroll pragma hint value and fills in Info. d2634 1 a2634 1 /// Handle the \#pragma clang loop directive. d2749 1 a2749 1 /// Handle the loop unroll optimization pragmas. d2819 1 a2819 1 /// Handle the Microsoft \#pragma intrinsic extension. a2867 55 // #pragma optimize("gsty", on|off) void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation StartLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "optimize"; return; } PP.Lex(Tok); if (Tok.isNot(tok::string_literal)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_string) << "optimize"; return; } // We could syntax check the string but it's probably not worth the effort. PP.Lex(Tok); if (Tok.isNot(tok::comma)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_comma) << "optimize"; return; } PP.Lex(Tok); if (Tok.is(tok::eod) || Tok.is(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_missing_argument) << "optimize" << /*Expected=*/true << "'on' or 'off'"; return; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II || (!II->isStr("on") && !II->isStr("off"))) { PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_argument) << PP.getSpelling(Tok) << "optimize" << /*Expected=*/true << "'on' or 'off'"; return; } PP.Lex(Tok); if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "optimize"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "optimize"; return; } PP.Diag(StartLoc, diag::warn_pragma_optimize); } d2892 1 a2892 1 /// Handle the #pragma clang attribute directive. @ 1.1.1.11 log @Import clang r337282 from trunk @ text @a97 38 // Pragma STDC implementations. /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...". struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler { PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; if (OOS == tok::OOS_ON) PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported); } }; /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...". struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler { PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override { tok::OnOffSwitch OOS; PP.LexOnOffSwitch(OOS); } }; /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...". struct PragmaSTDC_UnknownHandler : public PragmaHandler { PragmaSTDC_UnknownHandler() = default; void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnknownTok) override { // C99 6.10.6p2, unknown forms are not allowed. PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored); } }; a184 6 struct PragmaMSOptimizeHandler : public PragmaHandler { PragmaMSOptimizeHandler() : PragmaHandler("optimize") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; a235 9 STDCFENVHandler.reset(new PragmaSTDC_FENV_ACCESSHandler()); PP.AddPragmaHandler("STDC", STDCFENVHandler.get()); STDCCXLIMITHandler.reset(new PragmaSTDC_CX_LIMITED_RANGEHandler()); PP.AddPragmaHandler("STDC", STDCCXLIMITHandler.get()); STDCUnknownHandler.reset(new PragmaSTDC_UnknownHandler()); PP.AddPragmaHandler("STDC", STDCUnknownHandler.get()); d251 1 a251 2 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isOSBinFormatELF()) { a278 2 MSOptimize.reset(new PragmaMSOptimizeHandler()); PP.AddPragmaHandler(MSOptimize.get()); d333 1 a333 2 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isOSBinFormatELF()) { a363 2 PP.RemovePragmaHandler(MSOptimize.get()); MSOptimize.reset(); a373 9 PP.RemovePragmaHandler("STDC", STDCFENVHandler.get()); STDCFENVHandler.reset(); PP.RemovePragmaHandler("STDC", STDCCXLIMITHandler.get()); STDCCXLIMITHandler.reset(); PP.RemovePragmaHandler("STDC", STDCUnknownHandler.get()); STDCUnknownHandler.reset(); d393 1 a393 1 /// Handle the annotation token produced for #pragma unused(...) d425 1 a425 1 SourceLocation PragmaLoc = Tok.getLocation(); d429 1 a429 2 if (Alignment.isInvalid()) { ConsumeAnnotationToken(); a430 1 } a433 3 // Consume the token after processing the pragma to enable pragma-specific // #include warnings. ConsumeAnnotationToken(); d449 2 a450 4 Actions.ActOnPragmaOptionsAlign(Kind, Tok.getLocation()); // Consume the token after processing the pragma to enable pragma-specific // #include warnings. ConsumeAnnotationToken(); d531 1 a531 2 ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope); d1172 1 a1172 1 /// Describes the stage at which attribute subject rule parsing was interrupted. d1198 1 a1198 1 unsigned DiagID, ParsedAttr &Attribute, d1298 1 a1298 1 ParsedAttr::AS_GNU); d1302 2 a1303 1 /*ScopeLoc=*/SourceLocation(), ParsedAttr::AS_GNU, d1317 3 a1319 3 if (ParsedAttr::getKind(Tok.getIdentifierInfo(), /*ScopeName=*/nullptr, ParsedAttr::AS_GNU) != ParsedAttr::UnknownAttribute) { d1337 1 a1337 1 if (Attrs.empty() || Attrs.begin()->isInvalid()) { d1343 2 a1344 2 if (Attrs.size() > 1) { SourceLocation Loc = Attrs[1].getLoc(); d1350 1 a1350 2 ParsedAttr &Attribute = *Attrs.begin(); if (!Attribute.isSupportedByPragmaAttribute()) { d1352 1 a1352 1 << Attribute.getName(); d1356 1 d2027 1 a2027 1 /// Handle '#pragma omp ...' when OpenMP is disabled. d2042 1 a2042 1 /// Handle '#pragma omp ...' when OpenMP is enabled. d2054 1 a2054 1 while (Tok.isNot(tok::eod) && Tok.isNot(tok::eof)) { a2056 12 if (Tok.is(tok::annot_pragma_openmp)) { PP.Diag(Tok, diag::err_omp_unexpected_directive) << 0; unsigned InnerPragmaCnt = 1; while (InnerPragmaCnt != 0) { PP.Lex(Tok); if (Tok.is(tok::annot_pragma_openmp)) ++InnerPragmaCnt; else if (Tok.is(tok::annot_pragma_openmp_end)) --InnerPragmaCnt; } PP.Lex(Tok); } d2070 1 a2070 1 /// Handle '#pragma pointers_to_members' d2168 1 a2168 1 /// Handle '#pragma vtordisp' d2261 1 a2261 1 /// Handle all MS pragmas. Simply forwards the tokens after inserting d2279 1 a2279 1 // Add a sentinel EoF token to the end of the list. d2292 1 a2292 1 /// Handle the Microsoft \#pragma detect_mismatch extension. d2349 1 a2349 1 /// Handle the microsoft \#pragma comment extension. a2389 6 if (PP.getTargetInfo().getTriple().isOSBinFormatELF() && Kind != PCK_Lib) { PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored) << II->getName(); return; } d2592 1 a2592 1 /// Parses loop or unroll pragma hint value and fills in Info. d2634 1 a2634 1 /// Handle the \#pragma clang loop directive. d2749 1 a2749 1 /// Handle the loop unroll optimization pragmas. d2819 1 a2819 1 /// Handle the Microsoft \#pragma intrinsic extension. a2867 55 // #pragma optimize("gsty", on|off) void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation StartLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "optimize"; return; } PP.Lex(Tok); if (Tok.isNot(tok::string_literal)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_string) << "optimize"; return; } // We could syntax check the string but it's probably not worth the effort. PP.Lex(Tok); if (Tok.isNot(tok::comma)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_comma) << "optimize"; return; } PP.Lex(Tok); if (Tok.is(tok::eod) || Tok.is(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_missing_argument) << "optimize" << /*Expected=*/true << "'on' or 'off'"; return; } IdentifierInfo *II = Tok.getIdentifierInfo(); if (!II || (!II->isStr("on") && !II->isStr("off"))) { PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_argument) << PP.getSpelling(Tok) << "optimize" << /*Expected=*/true << "'on' or 'off'"; return; } PP.Lex(Tok); if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "optimize"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "optimize"; return; } PP.Diag(StartLoc, diag::warn_pragma_optimize); } d2892 1 a2892 1 /// Handle the #pragma clang attribute directive. @ 1.1.1.12 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.6.4.1 log @file ParsePragma.cpp was added on branch tls-maxphys on 2014-08-19 23:47:29 +0000 @ text @d1 2012 @ 1.1.1.6.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 2012 //===--- ParsePragma.cpp - Language specific pragma parsing ---------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the language specific #pragma handlers. // //===----------------------------------------------------------------------===// #include "RAIIObjectsForParser.h" #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; namespace { struct PragmaAlignHandler : public PragmaHandler { explicit PragmaAlignHandler() : PragmaHandler("align") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaGCCVisibilityHandler : public PragmaHandler { explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaOptionsHandler : public PragmaHandler { explicit PragmaOptionsHandler() : PragmaHandler("options") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaPackHandler : public PragmaHandler { explicit PragmaPackHandler() : PragmaHandler("pack") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaMSStructHandler : public PragmaHandler { explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaUnusedHandler : public PragmaHandler { PragmaUnusedHandler() : PragmaHandler("unused") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaWeakHandler : public PragmaHandler { explicit PragmaWeakHandler() : PragmaHandler("weak") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaRedefineExtnameHandler : public PragmaHandler { explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaOpenCLExtensionHandler : public PragmaHandler { PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaFPContractHandler : public PragmaHandler { PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaNoOpenMPHandler : public PragmaHandler { PragmaNoOpenMPHandler() : PragmaHandler("omp") { } void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaOpenMPHandler : public PragmaHandler { PragmaOpenMPHandler() : PragmaHandler("omp") { } void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; /// PragmaCommentHandler - "\#pragma comment ...". struct PragmaCommentHandler : public PragmaHandler { PragmaCommentHandler(Sema &Actions) : PragmaHandler("comment"), Actions(Actions) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; private: Sema &Actions; }; struct PragmaDetectMismatchHandler : public PragmaHandler { PragmaDetectMismatchHandler(Sema &Actions) : PragmaHandler("detect_mismatch"), Actions(Actions) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; private: Sema &Actions; }; struct PragmaMSPointersToMembers : public PragmaHandler { explicit PragmaMSPointersToMembers() : PragmaHandler("pointers_to_members") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaMSVtorDisp : public PragmaHandler { explicit PragmaMSVtorDisp() : PragmaHandler("vtordisp") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaMSPragma : public PragmaHandler { explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; /// PragmaOptimizeHandler - "\#pragma clang optimize on/off". struct PragmaOptimizeHandler : public PragmaHandler { PragmaOptimizeHandler(Sema &S) : PragmaHandler("optimize"), Actions(S) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; private: Sema &Actions; }; struct PragmaLoopHintHandler : public PragmaHandler { PragmaLoopHintHandler() : PragmaHandler("loop") {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; struct PragmaUnrollHintHandler : public PragmaHandler { PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {} void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override; }; } // end namespace void Parser::initializePragmaHandlers() { AlignHandler.reset(new PragmaAlignHandler()); PP.AddPragmaHandler(AlignHandler.get()); GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler()); PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get()); OptionsHandler.reset(new PragmaOptionsHandler()); PP.AddPragmaHandler(OptionsHandler.get()); PackHandler.reset(new PragmaPackHandler()); PP.AddPragmaHandler(PackHandler.get()); MSStructHandler.reset(new PragmaMSStructHandler()); PP.AddPragmaHandler(MSStructHandler.get()); UnusedHandler.reset(new PragmaUnusedHandler()); PP.AddPragmaHandler(UnusedHandler.get()); WeakHandler.reset(new PragmaWeakHandler()); PP.AddPragmaHandler(WeakHandler.get()); RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler()); PP.AddPragmaHandler(RedefineExtnameHandler.get()); FPContractHandler.reset(new PragmaFPContractHandler()); PP.AddPragmaHandler("STDC", FPContractHandler.get()); if (getLangOpts().OpenCL) { OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler()); PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get()); PP.AddPragmaHandler("OPENCL", FPContractHandler.get()); } if (getLangOpts().OpenMP) OpenMPHandler.reset(new PragmaOpenMPHandler()); else OpenMPHandler.reset(new PragmaNoOpenMPHandler()); PP.AddPragmaHandler(OpenMPHandler.get()); if (getLangOpts().MicrosoftExt) { MSCommentHandler.reset(new PragmaCommentHandler(Actions)); PP.AddPragmaHandler(MSCommentHandler.get()); MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(Actions)); PP.AddPragmaHandler(MSDetectMismatchHandler.get()); MSPointersToMembers.reset(new PragmaMSPointersToMembers()); PP.AddPragmaHandler(MSPointersToMembers.get()); MSVtorDisp.reset(new PragmaMSVtorDisp()); PP.AddPragmaHandler(MSVtorDisp.get()); MSInitSeg.reset(new PragmaMSPragma("init_seg")); PP.AddPragmaHandler(MSInitSeg.get()); MSDataSeg.reset(new PragmaMSPragma("data_seg")); PP.AddPragmaHandler(MSDataSeg.get()); MSBSSSeg.reset(new PragmaMSPragma("bss_seg")); PP.AddPragmaHandler(MSBSSSeg.get()); MSConstSeg.reset(new PragmaMSPragma("const_seg")); PP.AddPragmaHandler(MSConstSeg.get()); MSCodeSeg.reset(new PragmaMSPragma("code_seg")); PP.AddPragmaHandler(MSCodeSeg.get()); MSSection.reset(new PragmaMSPragma("section")); PP.AddPragmaHandler(MSSection.get()); } OptimizeHandler.reset(new PragmaOptimizeHandler(Actions)); PP.AddPragmaHandler("clang", OptimizeHandler.get()); LoopHintHandler.reset(new PragmaLoopHintHandler()); PP.AddPragmaHandler("clang", LoopHintHandler.get()); UnrollHintHandler.reset(new PragmaUnrollHintHandler("unroll")); PP.AddPragmaHandler(UnrollHintHandler.get()); NoUnrollHintHandler.reset(new PragmaUnrollHintHandler("nounroll")); PP.AddPragmaHandler(NoUnrollHintHandler.get()); } void Parser::resetPragmaHandlers() { // Remove the pragma handlers we installed. PP.RemovePragmaHandler(AlignHandler.get()); AlignHandler.reset(); PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get()); GCCVisibilityHandler.reset(); PP.RemovePragmaHandler(OptionsHandler.get()); OptionsHandler.reset(); PP.RemovePragmaHandler(PackHandler.get()); PackHandler.reset(); PP.RemovePragmaHandler(MSStructHandler.get()); MSStructHandler.reset(); PP.RemovePragmaHandler(UnusedHandler.get()); UnusedHandler.reset(); PP.RemovePragmaHandler(WeakHandler.get()); WeakHandler.reset(); PP.RemovePragmaHandler(RedefineExtnameHandler.get()); RedefineExtnameHandler.reset(); if (getLangOpts().OpenCL) { PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get()); OpenCLExtensionHandler.reset(); PP.RemovePragmaHandler("OPENCL", FPContractHandler.get()); } PP.RemovePragmaHandler(OpenMPHandler.get()); OpenMPHandler.reset(); if (getLangOpts().MicrosoftExt) { PP.RemovePragmaHandler(MSCommentHandler.get()); MSCommentHandler.reset(); PP.RemovePragmaHandler(MSDetectMismatchHandler.get()); MSDetectMismatchHandler.reset(); PP.RemovePragmaHandler(MSPointersToMembers.get()); MSPointersToMembers.reset(); PP.RemovePragmaHandler(MSVtorDisp.get()); MSVtorDisp.reset(); PP.RemovePragmaHandler(MSInitSeg.get()); MSInitSeg.reset(); PP.RemovePragmaHandler(MSDataSeg.get()); MSDataSeg.reset(); PP.RemovePragmaHandler(MSBSSSeg.get()); MSBSSSeg.reset(); PP.RemovePragmaHandler(MSConstSeg.get()); MSConstSeg.reset(); PP.RemovePragmaHandler(MSCodeSeg.get()); MSCodeSeg.reset(); PP.RemovePragmaHandler(MSSection.get()); MSSection.reset(); } PP.RemovePragmaHandler("STDC", FPContractHandler.get()); FPContractHandler.reset(); PP.RemovePragmaHandler("clang", OptimizeHandler.get()); OptimizeHandler.reset(); PP.RemovePragmaHandler("clang", LoopHintHandler.get()); LoopHintHandler.reset(); PP.RemovePragmaHandler(UnrollHintHandler.get()); UnrollHintHandler.reset(); PP.RemovePragmaHandler(NoUnrollHintHandler.get()); NoUnrollHintHandler.reset(); } /// \brief Handle the annotation token produced for #pragma unused(...) /// /// Each annot_pragma_unused is followed by the argument token so e.g. /// "#pragma unused(x,y)" becomes: /// annot_pragma_unused 'x' annot_pragma_unused 'y' void Parser::HandlePragmaUnused() { assert(Tok.is(tok::annot_pragma_unused)); SourceLocation UnusedLoc = ConsumeToken(); Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc); ConsumeToken(); // The argument token. } void Parser::HandlePragmaVisibility() { assert(Tok.is(tok::annot_pragma_vis)); const IdentifierInfo *VisType = static_cast(Tok.getAnnotationValue()); SourceLocation VisLoc = ConsumeToken(); Actions.ActOnPragmaVisibility(VisType, VisLoc); } struct PragmaPackInfo { Sema::PragmaPackKind Kind; IdentifierInfo *Name; Token Alignment; SourceLocation LParenLoc; SourceLocation RParenLoc; }; void Parser::HandlePragmaPack() { assert(Tok.is(tok::annot_pragma_pack)); PragmaPackInfo *Info = static_cast(Tok.getAnnotationValue()); SourceLocation PragmaLoc = ConsumeToken(); ExprResult Alignment; if (Info->Alignment.is(tok::numeric_constant)) { Alignment = Actions.ActOnNumericConstant(Info->Alignment); if (Alignment.isInvalid()) return; } Actions.ActOnPragmaPack(Info->Kind, Info->Name, Alignment.get(), PragmaLoc, Info->LParenLoc, Info->RParenLoc); } void Parser::HandlePragmaMSStruct() { assert(Tok.is(tok::annot_pragma_msstruct)); Sema::PragmaMSStructKind Kind = static_cast( reinterpret_cast(Tok.getAnnotationValue())); Actions.ActOnPragmaMSStruct(Kind); ConsumeToken(); // The annotation token. } void Parser::HandlePragmaAlign() { assert(Tok.is(tok::annot_pragma_align)); Sema::PragmaOptionsAlignKind Kind = static_cast( reinterpret_cast(Tok.getAnnotationValue())); SourceLocation PragmaLoc = ConsumeToken(); Actions.ActOnPragmaOptionsAlign(Kind, PragmaLoc); } void Parser::HandlePragmaWeak() { assert(Tok.is(tok::annot_pragma_weak)); SourceLocation PragmaLoc = ConsumeToken(); Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc, Tok.getLocation()); ConsumeToken(); // The weak name. } void Parser::HandlePragmaWeakAlias() { assert(Tok.is(tok::annot_pragma_weakalias)); SourceLocation PragmaLoc = ConsumeToken(); IdentifierInfo *WeakName = Tok.getIdentifierInfo(); SourceLocation WeakNameLoc = Tok.getLocation(); ConsumeToken(); IdentifierInfo *AliasName = Tok.getIdentifierInfo(); SourceLocation AliasNameLoc = Tok.getLocation(); ConsumeToken(); Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc, WeakNameLoc, AliasNameLoc); } void Parser::HandlePragmaRedefineExtname() { assert(Tok.is(tok::annot_pragma_redefine_extname)); SourceLocation RedefLoc = ConsumeToken(); IdentifierInfo *RedefName = Tok.getIdentifierInfo(); SourceLocation RedefNameLoc = Tok.getLocation(); ConsumeToken(); IdentifierInfo *AliasName = Tok.getIdentifierInfo(); SourceLocation AliasNameLoc = Tok.getLocation(); ConsumeToken(); Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc, RedefNameLoc, AliasNameLoc); } void Parser::HandlePragmaFPContract() { assert(Tok.is(tok::annot_pragma_fp_contract)); tok::OnOffSwitch OOS = static_cast( reinterpret_cast(Tok.getAnnotationValue())); Actions.ActOnPragmaFPContract(OOS); ConsumeToken(); // The annotation token. } StmtResult Parser::HandlePragmaCaptured() { assert(Tok.is(tok::annot_pragma_captured)); ConsumeToken(); if (Tok.isNot(tok::l_brace)) { PP.Diag(Tok, diag::err_expected) << tok::l_brace; return StmtError(); } SourceLocation Loc = Tok.getLocation(); ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope); Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default, /*NumParams=*/1); StmtResult R = ParseCompoundStatement(); CapturedRegionScope.Exit(); if (R.isInvalid()) { Actions.ActOnCapturedRegionError(); return StmtError(); } return Actions.ActOnCapturedRegionEnd(R.get()); } namespace { typedef llvm::PointerIntPair OpenCLExtData; } void Parser::HandlePragmaOpenCLExtension() { assert(Tok.is(tok::annot_pragma_opencl_extension)); OpenCLExtData data = OpenCLExtData::getFromOpaqueValue(Tok.getAnnotationValue()); unsigned state = data.getInt(); IdentifierInfo *ename = data.getPointer(); SourceLocation NameLoc = Tok.getLocation(); ConsumeToken(); // The annotation token. OpenCLOptions &f = Actions.getOpenCLOptions(); // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions, // overriding all previously issued extension directives, but only if the // behavior is set to disable." if (state == 0 && ename->isStr("all")) { #define OPENCLEXT(nm) f.nm = 0; #include "clang/Basic/OpenCLExtensions.def" } #define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; } #include "clang/Basic/OpenCLExtensions.def" else { PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename; return; } } void Parser::HandlePragmaMSPointersToMembers() { assert(Tok.is(tok::annot_pragma_ms_pointers_to_members)); LangOptions::PragmaMSPointersToMembersKind RepresentationMethod = static_cast( reinterpret_cast(Tok.getAnnotationValue())); SourceLocation PragmaLoc = ConsumeToken(); // The annotation token. Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc); } void Parser::HandlePragmaMSVtorDisp() { assert(Tok.is(tok::annot_pragma_ms_vtordisp)); uintptr_t Value = reinterpret_cast(Tok.getAnnotationValue()); Sema::PragmaVtorDispKind Kind = static_cast((Value >> 16) & 0xFFFF); MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF); SourceLocation PragmaLoc = ConsumeToken(); // The annotation token. Actions.ActOnPragmaMSVtorDisp(Kind, PragmaLoc, Mode); } void Parser::HandlePragmaMSPragma() { assert(Tok.is(tok::annot_pragma_ms_pragma)); // Grab the tokens out of the annotation and enter them into the stream. auto TheTokens = (std::pair *)Tok.getAnnotationValue(); PP.EnterTokenStream(TheTokens->first, TheTokens->second, true, true); SourceLocation PragmaLocation = ConsumeToken(); // The annotation token. assert(Tok.isAnyIdentifier()); StringRef PragmaName = Tok.getIdentifierInfo()->getName(); PP.Lex(Tok); // pragma kind // Figure out which #pragma we're dealing with. The switch has no default // because lex shouldn't emit the annotation token for unrecognized pragmas. typedef bool (Parser::*PragmaHandler)(StringRef, SourceLocation); PragmaHandler Handler = llvm::StringSwitch(PragmaName) .Case("data_seg", &Parser::HandlePragmaMSSegment) .Case("bss_seg", &Parser::HandlePragmaMSSegment) .Case("const_seg", &Parser::HandlePragmaMSSegment) .Case("code_seg", &Parser::HandlePragmaMSSegment) .Case("section", &Parser::HandlePragmaMSSection) .Case("init_seg", &Parser::HandlePragmaMSInitSeg); if (!(this->*Handler)(PragmaName, PragmaLocation)) { // Pragma handling failed, and has been diagnosed. Slurp up the tokens // until eof (really end of line) to prevent follow-on errors. while (Tok.isNot(tok::eof)) PP.Lex(Tok); PP.Lex(Tok); } } bool Parser::HandlePragmaMSSection(StringRef PragmaName, SourceLocation PragmaLocation) { if (Tok.isNot(tok::l_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName; return false; } PP.Lex(Tok); // ( // Parsing code for pragma section if (Tok.isNot(tok::string_literal)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_name) << PragmaName; return false; } ExprResult StringResult = ParseStringLiteralExpression(); if (StringResult.isInvalid()) return false; // Already diagnosed. StringLiteral *SegmentName = cast(StringResult.get()); if (SegmentName->getCharByteWidth() != 1) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) << PragmaName; return false; } int SectionFlags = 0; while (Tok.is(tok::comma)) { PP.Lex(Tok); // , if (!Tok.isAnyIdentifier()) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren) << PragmaName; return false; } Sema::PragmaSectionFlag Flag = llvm::StringSwitch( Tok.getIdentifierInfo()->getName()) .Case("read", Sema::PSF_Read) .Case("write", Sema::PSF_Write) .Case("execute", Sema::PSF_Execute) .Case("shared", Sema::PSF_Invalid) .Case("nopage", Sema::PSF_Invalid) .Case("nocache", Sema::PSF_Invalid) .Case("discard", Sema::PSF_Invalid) .Case("remove", Sema::PSF_Invalid) .Default(Sema::PSF_None); if (Flag == Sema::PSF_None || Flag == Sema::PSF_Invalid) { PP.Diag(PragmaLocation, Flag == Sema::PSF_None ? diag::warn_pragma_invalid_specific_action : diag::warn_pragma_unsupported_action) << PragmaName << Tok.getIdentifierInfo()->getName(); return false; } SectionFlags |= Flag; PP.Lex(Tok); // Identifier } if (Tok.isNot(tok::r_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName; return false; } PP.Lex(Tok); // ) if (Tok.isNot(tok::eof)) { PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol) << PragmaName; return false; } PP.Lex(Tok); // eof Actions.ActOnPragmaMSSection(PragmaLocation, SectionFlags, SegmentName); return true; } bool Parser::HandlePragmaMSSegment(StringRef PragmaName, SourceLocation PragmaLocation) { if (Tok.isNot(tok::l_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName; return false; } PP.Lex(Tok); // ( Sema::PragmaMsStackAction Action = Sema::PSK_Reset; StringRef SlotLabel; if (Tok.isAnyIdentifier()) { StringRef PushPop = Tok.getIdentifierInfo()->getName(); if (PushPop == "push") Action = Sema::PSK_Push; else if (PushPop == "pop") Action = Sema::PSK_Pop; else { PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_push_pop_or_name) << PragmaName; return false; } if (Action != Sema::PSK_Reset) { PP.Lex(Tok); // push | pop if (Tok.is(tok::comma)) { PP.Lex(Tok); // , // If we've got a comma, we either need a label or a string. if (Tok.isAnyIdentifier()) { SlotLabel = Tok.getIdentifierInfo()->getName(); PP.Lex(Tok); // identifier if (Tok.is(tok::comma)) PP.Lex(Tok); else if (Tok.isNot(tok::r_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName; return false; } } } else if (Tok.isNot(tok::r_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName; return false; } } } // Grab the string literal for our section name. StringLiteral *SegmentName = nullptr; if (Tok.isNot(tok::r_paren)) { if (Tok.isNot(tok::string_literal)) { unsigned DiagID = Action != Sema::PSK_Reset ? !SlotLabel.empty() ? diag::warn_pragma_expected_section_name : diag::warn_pragma_expected_section_label_or_name : diag::warn_pragma_expected_section_push_pop_or_name; PP.Diag(PragmaLocation, DiagID) << PragmaName; return false; } ExprResult StringResult = ParseStringLiteralExpression(); if (StringResult.isInvalid()) return false; // Already diagnosed. SegmentName = cast(StringResult.get()); if (SegmentName->getCharByteWidth() != 1) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) << PragmaName; return false; } // Setting section "" has no effect if (SegmentName->getLength()) Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set); } if (Tok.isNot(tok::r_paren)) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName; return false; } PP.Lex(Tok); // ) if (Tok.isNot(tok::eof)) { PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol) << PragmaName; return false; } PP.Lex(Tok); // eof Actions.ActOnPragmaMSSeg(PragmaLocation, Action, SlotLabel, SegmentName, PragmaName); return true; } // #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} ) bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName, SourceLocation PragmaLocation) { if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen, PragmaName)) return false; // Parse either the known section names or the string section name. StringLiteral *SegmentName = nullptr; if (Tok.isAnyIdentifier()) { auto *II = Tok.getIdentifierInfo(); StringRef Section = llvm::StringSwitch(II->getName()) .Case("compiler", "\".CRT$XCC\"") .Case("lib", "\".CRT$XCL\"") .Case("user", "\".CRT$XCU\"") .Default(""); if (!Section.empty()) { // Pretend the user wrote the appropriate string literal here. Token Toks[1]; Toks[0].startToken(); Toks[0].setKind(tok::string_literal); Toks[0].setLocation(Tok.getLocation()); Toks[0].setLiteralData(Section.data()); Toks[0].setLength(Section.size()); SegmentName = cast(Actions.ActOnStringLiteral(Toks, nullptr).get()); PP.Lex(Tok); } } else if (Tok.is(tok::string_literal)) { ExprResult StringResult = ParseStringLiteralExpression(); if (StringResult.isInvalid()) return false; SegmentName = cast(StringResult.get()); if (SegmentName->getCharByteWidth() != 1) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) << PragmaName; return false; } // FIXME: Add support for the '[, func-name]' part of the pragma. } if (!SegmentName) { PP.Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName; return false; } if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen, PragmaName) || ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol, PragmaName)) return false; Actions.ActOnPragmaMSInitSeg(PragmaLocation, SegmentName); return true; } struct PragmaLoopHintInfo { Token PragmaName; Token Option; Token Value; bool HasValue; PragmaLoopHintInfo() : HasValue(false) {} }; bool Parser::HandlePragmaLoopHint(LoopHint &Hint) { assert(Tok.is(tok::annot_pragma_loop_hint)); PragmaLoopHintInfo *Info = static_cast(Tok.getAnnotationValue()); ConsumeToken(); // The annotation token. IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo(); Hint.PragmaNameLoc = IdentifierLoc::create( Actions.Context, Info->PragmaName.getLocation(), PragmaNameInfo); // It is possible that the loop hint has no option identifier, such as // #pragma unroll(4). IdentifierInfo *OptionInfo = Info->Option.is(tok::identifier) ? Info->Option.getIdentifierInfo() : nullptr; Hint.OptionLoc = IdentifierLoc::create( Actions.Context, Info->Option.getLocation(), OptionInfo); // Return a valid hint if pragma unroll or nounroll were specified // without an argument. bool PragmaUnroll = PragmaNameInfo->getName() == "unroll"; bool PragmaNoUnroll = PragmaNameInfo->getName() == "nounroll"; if (!Info->HasValue && (PragmaUnroll || PragmaNoUnroll)) { Hint.Range = Info->PragmaName.getLocation(); return true; } // If no option is specified the argument is assumed to be numeric. bool StateOption = false; if (OptionInfo) StateOption = llvm::StringSwitch(OptionInfo->getName()) .Case("vectorize", true) .Case("interleave", true) .Case("unroll", true) .Default(false); // Validate the argument. if (StateOption) { bool OptionUnroll = OptionInfo->isStr("unroll"); SourceLocation StateLoc = Info->Value.getLocation(); IdentifierInfo *StateInfo = Info->Value.getIdentifierInfo(); if (!StateInfo || ((OptionUnroll ? !StateInfo->isStr("full") : !StateInfo->isStr("enable")) && !StateInfo->isStr("disable"))) { Diag(StateLoc, diag::err_pragma_invalid_keyword) << /*MissingArgument=*/false << /*FullKeyword=*/OptionUnroll; return false; } Hint.StateLoc = IdentifierLoc::create(Actions.Context, StateLoc, StateInfo); } else { // FIXME: We should allow non-type 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 { Diag(Info->Value.getLocation(), diag::err_pragma_loop_numeric_value); return false; } } Hint.Range = SourceRange(Info->PragmaName.getLocation(), Info->Value.getLocation()); return true; } // #pragma GCC visibility comes in two variants: // 'push' '(' [visibility] ')' // 'pop' void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &VisTok) { SourceLocation VisLoc = VisTok.getLocation(); Token Tok; PP.LexUnexpandedToken(Tok); const IdentifierInfo *PushPop = Tok.getIdentifierInfo(); const IdentifierInfo *VisType; if (PushPop && PushPop->isStr("pop")) { VisType = nullptr; } else if (PushPop && PushPop->isStr("push")) { PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "visibility"; return; } PP.LexUnexpandedToken(Tok); VisType = Tok.getIdentifierInfo(); if (!VisType) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "visibility"; return; } PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "visibility"; return; } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "visibility"; return; } PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "visibility"; return; } Token *Toks = new Token[1]; Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_vis); Toks[0].setLocation(VisLoc); Toks[0].setAnnotationValue( const_cast(static_cast(VisType))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true); } // #pragma pack(...) comes in the following delicious flavors: // pack '(' [integer] ')' // pack '(' 'show' ')' // pack '(' ('push' | 'pop') [',' identifier] [, integer] ')' void PragmaPackHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PackTok) { SourceLocation PackLoc = PackTok.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack"; return; } Sema::PragmaPackKind Kind = Sema::PPK_Default; IdentifierInfo *Name = nullptr; Token Alignment; Alignment.startToken(); SourceLocation LParenLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.is(tok::numeric_constant)) { Alignment = Tok; PP.Lex(Tok); // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting // the push/pop stack. // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4) if (PP.getLangOpts().ApplePragmaPack) Kind = Sema::PPK_Push; } else if (Tok.is(tok::identifier)) { const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("show")) { Kind = Sema::PPK_Show; PP.Lex(Tok); } else { if (II->isStr("push")) { Kind = Sema::PPK_Push; } else if (II->isStr("pop")) { Kind = Sema::PPK_Pop; } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "pack"; return; } PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); if (Tok.is(tok::numeric_constant)) { Alignment = Tok; PP.Lex(Tok); } else if (Tok.is(tok::identifier)) { Name = Tok.getIdentifierInfo(); PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); if (Tok.isNot(tok::numeric_constant)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed); return; } Alignment = Tok; PP.Lex(Tok); } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed); return; } } } } else if (PP.getLangOpts().ApplePragmaPack) { // In MSVC/gcc, #pragma pack() resets the alignment without affecting // the push/pop stack. // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop). Kind = Sema::PPK_Pop; } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack"; return; } SourceLocation RParenLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack"; return; } PragmaPackInfo *Info = (PragmaPackInfo*) PP.getPreprocessorAllocator().Allocate( sizeof(PragmaPackInfo), llvm::alignOf()); new (Info) PragmaPackInfo(); Info->Kind = Kind; Info->Name = Name; Info->Alignment = Alignment; Info->LParenLoc = LParenLoc; Info->RParenLoc = RParenLoc; Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_pack); Toks[0].setLocation(PackLoc); Toks[0].setAnnotationValue(static_cast(Info)); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma ms_struct on // #pragma ms_struct off void PragmaMSStructHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MSStructTok) { Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF; Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct); return; } const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("on")) { Kind = Sema::PMSST_ON; PP.Lex(Tok); } else if (II->isStr("off") || II->isStr("reset")) PP.Lex(Tok); else { PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct); return; } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "ms_struct"; return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_msstruct); Toks[0].setLocation(MSStructTok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(Kind))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma 'align' '=' {'native','natural','mac68k','power','reset'} // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'} static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok, bool IsOptions) { Token Tok; if (IsOptions) { PP.Lex(Tok); if (Tok.isNot(tok::identifier) || !Tok.getIdentifierInfo()->isStr("align")) { PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align); return; } } PP.Lex(Tok); if (Tok.isNot(tok::equal)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal) << IsOptions; return; } PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << (IsOptions ? "options" : "align"); return; } Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural; const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("native")) Kind = Sema::POAK_Native; else if (II->isStr("natural")) Kind = Sema::POAK_Natural; else if (II->isStr("packed")) Kind = Sema::POAK_Packed; else if (II->isStr("power")) Kind = Sema::POAK_Power; else if (II->isStr("mac68k")) Kind = Sema::POAK_Mac68k; else if (II->isStr("reset")) Kind = Sema::POAK_Reset; else { PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option) << IsOptions; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << (IsOptions ? "options" : "align"); return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_align); Toks[0].setLocation(FirstTok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(Kind))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaAlignHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &AlignTok) { ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false); } void PragmaOptionsHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &OptionsTok) { ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true); } // #pragma unused(identifier) void PragmaUnusedHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnusedTok) { // FIXME: Should we be expanding macros here? My guess is no. SourceLocation UnusedLoc = UnusedTok.getLocation(); // Lex the left '('. Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused"; return; } // Lex the declaration reference(s). SmallVector Identifiers; SourceLocation RParenLoc; bool LexID = true; while (true) { PP.Lex(Tok); if (LexID) { if (Tok.is(tok::identifier)) { Identifiers.push_back(Tok); LexID = false; continue; } // Illegal token! PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var); return; } // We are execting a ')' or a ','. if (Tok.is(tok::comma)) { LexID = true; continue; } if (Tok.is(tok::r_paren)) { RParenLoc = Tok.getLocation(); break; } // Illegal token! PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "unused"; return; } // Verify that we have a location for the right parenthesis. assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'"); assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments"); // For each identifier token, insert into the token stream a // annot_pragma_unused token followed by the identifier token. // This allows us to cache a "#pragma unused" that occurs inside an inline // C++ member function. Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 2 * Identifiers.size(), llvm::alignOf()); for (unsigned i=0; i != Identifiers.size(); i++) { Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_unused); pragmaUnusedTok.setLocation(UnusedLoc); idTok = Identifiers[i]; } PP.EnterTokenStream(Toks, 2*Identifiers.size(), /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma weak identifier // #pragma weak identifier '=' identifier void PragmaWeakHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &WeakTok) { SourceLocation WeakLoc = WeakTok.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak"; return; } Token WeakName = Tok; bool HasAlias = false; Token AliasName; PP.Lex(Tok); if (Tok.is(tok::equal)) { HasAlias = true; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak"; return; } AliasName = Tok; PP.Lex(Tok); } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak"; return; } if (HasAlias) { Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 3, llvm::alignOf()); Token &pragmaUnusedTok = Toks[0]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_weakalias); pragmaUnusedTok.setLocation(WeakLoc); Toks[1] = WeakName; Toks[2] = AliasName; PP.EnterTokenStream(Toks, 3, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } else { Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 2, llvm::alignOf()); Token &pragmaUnusedTok = Toks[0]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_weak); pragmaUnusedTok.setLocation(WeakLoc); Toks[1] = WeakName; PP.EnterTokenStream(Toks, 2, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } } // #pragma redefine_extname identifier identifier void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &RedefToken) { SourceLocation RedefLoc = RedefToken.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "redefine_extname"; return; } Token RedefName = Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "redefine_extname"; return; } Token AliasName = Tok; PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "redefine_extname"; return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 3, llvm::alignOf()); Token &pragmaRedefTok = Toks[0]; pragmaRedefTok.startToken(); pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname); pragmaRedefTok.setLocation(RedefLoc); Toks[1] = RedefName; Toks[2] = AliasName; PP.EnterTokenStream(Toks, 3, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaFPContractHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_fp_contract); Toks[0].setLocation(Tok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(OOS))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "OPENCL"; return; } IdentifierInfo *ename = Tok.getIdentifierInfo(); SourceLocation NameLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::colon)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename; return; } PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable); return; } IdentifierInfo *op = Tok.getIdentifierInfo(); unsigned state; if (op->isStr("enable")) { state = 1; } else if (op->isStr("disable")) { state = 0; } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable); return; } SourceLocation StateLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "OPENCL EXTENSION"; return; } OpenCLExtData data(ename, state); Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_opencl_extension); Toks[0].setLocation(NameLoc); Toks[0].setAnnotationValue(data.getOpaqueValue()); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, ename, StateLoc, state); } /// \brief Handle '#pragma omp ...' when OpenMP is disabled. /// void PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstTok) { if (!PP.getDiagnostics().isIgnored(diag::warn_pragma_omp_ignored, FirstTok.getLocation())) { PP.Diag(FirstTok, diag::warn_pragma_omp_ignored); PP.getDiagnostics().setSeverity(diag::warn_pragma_omp_ignored, diag::Severity::Ignored, SourceLocation()); } PP.DiscardUntilEndOfDirective(); } /// \brief Handle '#pragma omp ...' when OpenMP is enabled. /// void PragmaOpenMPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstTok) { SmallVector Pragma; Token Tok; Tok.startToken(); Tok.setKind(tok::annot_pragma_openmp); Tok.setLocation(FirstTok.getLocation()); while (Tok.isNot(tok::eod)) { Pragma.push_back(Tok); PP.Lex(Tok); } SourceLocation EodLoc = Tok.getLocation(); Tok.startToken(); Tok.setKind(tok::annot_pragma_openmp_end); Tok.setLocation(EodLoc); Pragma.push_back(Tok); Token *Toks = new Token[Pragma.size()]; std::copy(Pragma.begin(), Pragma.end(), Toks); PP.EnterTokenStream(Toks, Pragma.size(), /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true); } /// \brief Handle '#pragma pointers_to_members' // The grammar for this pragma is as follows: // // ::= ('single' | 'multiple' | 'virtual') '_inheritance' // // #pragma pointers_to_members '(' 'best_case' ')' // #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')' // #pragma pointers_to_members '(' inheritance-model ')' void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation PointersToMembersLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen) << "pointers_to_members"; return; } PP.Lex(Tok); const IdentifierInfo *Arg = Tok.getIdentifierInfo(); if (!Arg) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "pointers_to_members"; return; } PP.Lex(Tok); LangOptions::PragmaMSPointersToMembersKind RepresentationMethod; if (Arg->isStr("best_case")) { RepresentationMethod = LangOptions::PPTMK_BestCase; } else { if (Arg->isStr("full_generality")) { if (Tok.is(tok::comma)) { PP.Lex(Tok); Arg = Tok.getIdentifierInfo(); if (!Arg) { PP.Diag(Tok.getLocation(), diag::err_pragma_pointers_to_members_unknown_kind) << Tok.getKind() << /*OnlyInheritanceModels*/ 0; return; } PP.Lex(Tok); } else if (Tok.is(tok::r_paren)) { // #pragma pointers_to_members(full_generality) implicitly specifies // virtual_inheritance. Arg = nullptr; RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance; } else { PP.Diag(Tok.getLocation(), diag::err_expected_punc) << "full_generality"; return; } } if (Arg) { if (Arg->isStr("single_inheritance")) { RepresentationMethod = LangOptions::PPTMK_FullGeneralitySingleInheritance; } else if (Arg->isStr("multiple_inheritance")) { RepresentationMethod = LangOptions::PPTMK_FullGeneralityMultipleInheritance; } else if (Arg->isStr("virtual_inheritance")) { RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance; } else { PP.Diag(Tok.getLocation(), diag::err_pragma_pointers_to_members_unknown_kind) << Arg << /*HasPointerDeclaration*/ 1; return; } } } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected_rparen_after) << (Arg ? Arg->getName() : "full_generality"); return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pointers_to_members"; return; } Token AnnotTok; AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_pointers_to_members); AnnotTok.setLocation(PointersToMembersLoc); AnnotTok.setAnnotationValue( reinterpret_cast(static_cast(RepresentationMethod))); PP.EnterToken(AnnotTok); } /// \brief Handle '#pragma vtordisp' // The grammar for this pragma is as follows: // // ::= ('off' | 'on' | '0' | '1' | '2' ) // // #pragma vtordisp '(' ['push' ','] vtordisp-mode ')' // #pragma vtordisp '(' 'pop' ')' // #pragma vtordisp '(' ')' void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation VtorDispLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) << "vtordisp"; return; } PP.Lex(Tok); Sema::PragmaVtorDispKind Kind = Sema::PVDK_Set; const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II) { if (II->isStr("push")) { // #pragma vtordisp(push, mode) PP.Lex(Tok); if (Tok.isNot(tok::comma)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_punc) << "vtordisp"; return; } PP.Lex(Tok); Kind = Sema::PVDK_Push; // not push, could be on/off } else if (II->isStr("pop")) { // #pragma vtordisp(pop) PP.Lex(Tok); Kind = Sema::PVDK_Pop; } // not push or pop, could be on/off } else { if (Tok.is(tok::r_paren)) { // #pragma vtordisp() Kind = Sema::PVDK_Reset; } } uint64_t Value = 0; if (Kind == Sema::PVDK_Push || Kind == Sema::PVDK_Set) { const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II && II->isStr("off")) { PP.Lex(Tok); Value = 0; } else if (II && II->isStr("on")) { PP.Lex(Tok); Value = 1; } else if (Tok.is(tok::numeric_constant) && PP.parseSimpleIntegerLiteral(Tok, Value)) { if (Value > 2) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_integer) << 0 << 2 << "vtordisp"; return; } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "vtordisp"; return; } } // Finish the pragma: ')' $ if (Tok.isNot(tok::r_paren)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) << "vtordisp"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "vtordisp"; return; } // Enter the annotation. Token AnnotTok; AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_vtordisp); AnnotTok.setLocation(VtorDispLoc); AnnotTok.setAnnotationValue(reinterpret_cast( static_cast((Kind << 16) | (Value & 0xFFFF)))); PP.EnterToken(AnnotTok); } /// \brief Handle all MS pragmas. Simply forwards the tokens after inserting /// an annotation token. void PragmaMSPragma::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { Token EoF, AnnotTok; EoF.startToken(); EoF.setKind(tok::eof); AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_pragma); AnnotTok.setLocation(Tok.getLocation()); SmallVector TokenVector; // Suck up all of the tokens before the eod. for (; Tok.isNot(tok::eod); PP.Lex(Tok)) TokenVector.push_back(Tok); // Add a sentinal EoF token to the end of the list. TokenVector.push_back(EoF); // We must allocate this array with new because EnterTokenStream is going to // delete it later. Token *TokenArray = new Token[TokenVector.size()]; std::copy(TokenVector.begin(), TokenVector.end(), TokenArray); auto Value = new (PP.getPreprocessorAllocator()) std::pair(std::make_pair(TokenArray, TokenVector.size())); AnnotTok.setAnnotationValue(Value); PP.EnterToken(AnnotTok); } /// \brief Handle the Microsoft \#pragma detect_mismatch extension. /// /// The syntax is: /// \code /// #pragma detect_mismatch("name", "value") /// \endcode /// Where 'name' and 'value' are quoted strings. The values are embedded in /// the object file and passed along to the linker. If the linker detects a /// mismatch in the object file's values for the given name, a LNK2038 error /// is emitted. See MSDN for more details. void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation CommentLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(CommentLoc, diag::err_expected) << tok::l_paren; return; } // Read the name to embed, which must be a string literal. std::string NameString; if (!PP.LexStringLiteral(Tok, NameString, "pragma detect_mismatch", /*MacroExpansion=*/true)) return; // Read the comma followed by a second string literal. std::string ValueString; if (Tok.isNot(tok::comma)) { PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed); return; } if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch", /*MacroExpansion=*/true)) return; if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; return; } PP.Lex(Tok); // Eat the r_paren. if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed); return; } // If the pragma is lexically sound, notify any interested PPCallbacks. if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaDetectMismatch(CommentLoc, NameString, ValueString); Actions.ActOnPragmaDetectMismatch(NameString, ValueString); } /// \brief Handle the microsoft \#pragma comment extension. /// /// The syntax is: /// \code /// #pragma comment(linker, "foo") /// \endcode /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user. /// "foo" is a string, which is fully macro expanded, and permits string /// concatenation, embedded escape characters etc. See MSDN for more details. void PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation CommentLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(CommentLoc, diag::err_pragma_comment_malformed); return; } // Read the identifier. PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(CommentLoc, diag::err_pragma_comment_malformed); return; } // Verify that this is one of the 5 whitelisted options. IdentifierInfo *II = Tok.getIdentifierInfo(); Sema::PragmaMSCommentKind Kind = llvm::StringSwitch(II->getName()) .Case("linker", Sema::PCK_Linker) .Case("lib", Sema::PCK_Lib) .Case("compiler", Sema::PCK_Compiler) .Case("exestr", Sema::PCK_ExeStr) .Case("user", Sema::PCK_User) .Default(Sema::PCK_Unknown); if (Kind == Sema::PCK_Unknown) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind); return; } // Read the optional string if present. PP.Lex(Tok); std::string ArgumentString; if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString, "pragma comment", /*MacroExpansion=*/true)) return; // FIXME: warn that 'exestr' is deprecated. // FIXME: If the kind is "compiler" warn if the string is present (it is // ignored). // The MSDN docs say that "lib" and "linker" require a string and have a short // whitelist of linker options they support, but in practice MSVC doesn't // issue a diagnostic. Therefore neither does clang. if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); return; } PP.Lex(Tok); // eat the r_paren. if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); return; } // If the pragma is lexically sound, notify any interested PPCallbacks. if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString); Actions.ActOnPragmaMSComment(Kind, ArgumentString); } // #pragma clang optimize off // #pragma clang optimize on void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) { Token Tok; PP.Lex(Tok); if (Tok.is(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument) << "clang optimize" << /*Expected=*/true << "'on' or 'off'"; return; } if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) << PP.getSpelling(Tok); return; } const IdentifierInfo *II = Tok.getIdentifierInfo(); // The only accepted values are 'on' or 'off'. bool IsOn = false; if (II->isStr("on")) { IsOn = true; } else if (!II->isStr("off")) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) << PP.getSpelling(Tok); return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument) << PP.getSpelling(Tok); return; } Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation()); } /// \brief Parses loop or unroll pragma hint value and fills in Info. static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName, Token Option, bool ValueInParens, PragmaLoopHintInfo &Info) { if (ValueInParens) { if (Tok.is(tok::r_paren)) { // Nothing between the parentheses. std::string PragmaString; if (PragmaName.getIdentifierInfo()->getName() == "loop") { PragmaString = "clang loop "; PragmaString += Option.getIdentifierInfo()->getName(); } else { assert(PragmaName.getIdentifierInfo()->getName() == "unroll" && "Unexpected pragma name"); PragmaString = "unroll"; } // Don't try to emit what the pragma is expecting with the diagnostic // because the logic is non-trivial and we give expected values in sema // diagnostics if an invalid argument is given. Here, just note that the // pragma is missing an argument. PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument) << PragmaString << /*Expected=*/false; return true; } } // FIXME: Value should be stored and parsed as a constant expression. Token Value = Tok; PP.Lex(Tok); if (ValueInParens) { // Read ')' if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; return true; } PP.Lex(Tok); } Info.PragmaName = PragmaName; Info.Option = Option; Info.Value = Value; Info.HasValue = true; return false; } /// \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 ')' /// 'unroll' '(' unroll-hint-keyword ')' /// 'vectorize_width' '(' loop-hint-value ')' /// 'interleave_count' '(' loop-hint-value ')' /// 'unroll_count' '(' loop-hint-value ')' /// /// loop-hint-keyword: /// 'enable' /// 'disable' /// /// unroll-hint-keyword: /// 'full' /// '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. /// /// The unroll and unroll_count directives control the concatenation /// unroller. Specifying unroll(full) instructs llvm to try to /// unroll the loop completely, and unroll(disable) disables unrolling /// for the loop. Specifying unroll_count(_value_) instructs llvm to /// try to unroll the loop the number of times indicated by the value. void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Incoming token is "loop" from "#pragma clang loop". Token PragmaName = Tok; 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_pragma_loop_invalid_option) << /*MissingOption=*/true << ""; return; } while (Tok.is(tok::identifier)) { Token Option = Tok; IdentifierInfo *OptionInfo = Tok.getIdentifierInfo(); bool OptionValid = llvm::StringSwitch(OptionInfo->getName()) .Case("vectorize", true) .Case("interleave", true) .Case("unroll", true) .Case("vectorize_width", true) .Case("interleave_count", true) .Case("unroll_count", true) .Default(false); if (!OptionValid) { PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option) << /*MissingOption=*/false << OptionInfo; return; } PP.Lex(Tok); // Read '(' if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren; return; } PP.Lex(Tok); auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo; if (ParseLoopHintValue(PP, Tok, PragmaName, Option, /*ValueInParens=*/true, *Info)) return; // Generate the loop hint token. Token LoopHintTok; LoopHintTok.startToken(); LoopHintTok.setKind(tok::annot_pragma_loop_hint); LoopHintTok.setLocation(PragmaName.getLocation()); LoopHintTok.setAnnotationValue(static_cast(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); } /// \brief Handle the loop unroll optimization pragmas. /// #pragma unroll /// #pragma unroll unroll-hint-value /// #pragma unroll '(' unroll-hint-value ')' /// #pragma nounroll /// /// unroll-hint-value: /// constant-expression /// /// Loop unrolling hints can be specified with '#pragma unroll' or /// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally /// contained in parentheses. With no argument the directive instructs llvm to /// try to unroll the loop completely. A positive integer argument can be /// specified to indicate the number of times the loop should be unrolled. To /// maximize compatibility with other compilers the unroll count argument can be /// specified with or without parentheses. Specifying, '#pragma nounroll' /// disables unrolling of the loop. void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { // Incoming token is "unroll" for "#pragma unroll", or "nounroll" for // "#pragma nounroll". Token PragmaName = Tok; PP.Lex(Tok); auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo; if (Tok.is(tok::eod)) { // nounroll or unroll pragma without an argument. Info->PragmaName = PragmaName; Info->HasValue = false; Info->Option.startToken(); } else if (PragmaName.getIdentifierInfo()->getName() == "nounroll") { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "nounroll"; return; } else { // Unroll pragma with an argument: "#pragma unroll N" or // "#pragma unroll(N)". // Read '(' if it exists. bool ValueInParens = Tok.is(tok::l_paren); if (ValueInParens) PP.Lex(Tok); Token Option; Option.startToken(); if (ParseLoopHintValue(PP, Tok, PragmaName, Option, ValueInParens, *Info)) return; // In CUDA, the argument to '#pragma unroll' should not be contained in // parentheses. if (PP.getLangOpts().CUDA && ValueInParens) PP.Diag(Info->Value.getLocation(), diag::warn_pragma_unroll_cuda_value_in_parens); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "unroll"; return; } } // Generate the hint token. Token *TokenArray = new Token[1]; TokenArray[0].startToken(); TokenArray[0].setKind(tok::annot_pragma_loop_hint); TokenArray[0].setLocation(PragmaName.getLocation()); TokenArray[0].setAnnotationValue(static_cast(Info)); PP.EnterTokenStream(TokenArray, 1, /*DisableMacroExpansion=*/false, /*OwnsTokens=*/true); } @ 1.1.1.4.4.1 log @file ParsePragma.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:29 +0000 @ text @d1 1336 @ 1.1.1.4.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1336 //===--- ParsePragma.cpp - Language specific pragma parsing ---------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file implements the language specific #pragma handlers. // //===----------------------------------------------------------------------===// #include "clang/Lex/Preprocessor.h" #include "clang/Parse/ParseDiagnostic.h" #include "clang/Parse/Parser.h" #include "clang/Sema/Scope.h" #include "llvm/ADT/StringSwitch.h" using namespace clang; namespace { struct PragmaAlignHandler : public PragmaHandler { explicit PragmaAlignHandler() : PragmaHandler("align") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaGCCVisibilityHandler : public PragmaHandler { explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaOptionsHandler : public PragmaHandler { explicit PragmaOptionsHandler() : PragmaHandler("options") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaPackHandler : public PragmaHandler { explicit PragmaPackHandler() : PragmaHandler("pack") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaMSStructHandler : public PragmaHandler { explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaUnusedHandler : public PragmaHandler { PragmaUnusedHandler() : PragmaHandler("unused") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaWeakHandler : public PragmaHandler { explicit PragmaWeakHandler() : PragmaHandler("weak") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaRedefineExtnameHandler : public PragmaHandler { explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaOpenCLExtensionHandler : public PragmaHandler { PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaFPContractHandler : public PragmaHandler { PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaNoOpenMPHandler : public PragmaHandler { PragmaNoOpenMPHandler() : PragmaHandler("omp") { } virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaOpenMPHandler : public PragmaHandler { PragmaOpenMPHandler() : PragmaHandler("omp") { } virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; /// PragmaCommentHandler - "\#pragma comment ...". struct PragmaCommentHandler : public PragmaHandler { PragmaCommentHandler(Sema &Actions) : PragmaHandler("comment"), Actions(Actions) {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); private: Sema &Actions; }; struct PragmaDetectMismatchHandler : public PragmaHandler { PragmaDetectMismatchHandler(Sema &Actions) : PragmaHandler("detect_mismatch"), Actions(Actions) {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); private: Sema &Actions; }; struct PragmaMSPointersToMembers : public PragmaHandler { explicit PragmaMSPointersToMembers() : PragmaHandler("pointers_to_members") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; struct PragmaMSVtorDisp : public PragmaHandler { explicit PragmaMSVtorDisp() : PragmaHandler("vtordisp") {} virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken); }; } // end namespace void Parser::initializePragmaHandlers() { AlignHandler.reset(new PragmaAlignHandler()); PP.AddPragmaHandler(AlignHandler.get()); GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler()); PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get()); OptionsHandler.reset(new PragmaOptionsHandler()); PP.AddPragmaHandler(OptionsHandler.get()); PackHandler.reset(new PragmaPackHandler()); PP.AddPragmaHandler(PackHandler.get()); MSStructHandler.reset(new PragmaMSStructHandler()); PP.AddPragmaHandler(MSStructHandler.get()); UnusedHandler.reset(new PragmaUnusedHandler()); PP.AddPragmaHandler(UnusedHandler.get()); WeakHandler.reset(new PragmaWeakHandler()); PP.AddPragmaHandler(WeakHandler.get()); RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler()); PP.AddPragmaHandler(RedefineExtnameHandler.get()); FPContractHandler.reset(new PragmaFPContractHandler()); PP.AddPragmaHandler("STDC", FPContractHandler.get()); if (getLangOpts().OpenCL) { OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler()); PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get()); PP.AddPragmaHandler("OPENCL", FPContractHandler.get()); } if (getLangOpts().OpenMP) OpenMPHandler.reset(new PragmaOpenMPHandler()); else OpenMPHandler.reset(new PragmaNoOpenMPHandler()); PP.AddPragmaHandler(OpenMPHandler.get()); if (getLangOpts().MicrosoftExt) { MSCommentHandler.reset(new PragmaCommentHandler(Actions)); PP.AddPragmaHandler(MSCommentHandler.get()); MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(Actions)); PP.AddPragmaHandler(MSDetectMismatchHandler.get()); MSPointersToMembers.reset(new PragmaMSPointersToMembers()); PP.AddPragmaHandler(MSPointersToMembers.get()); MSVtorDisp.reset(new PragmaMSVtorDisp()); PP.AddPragmaHandler(MSVtorDisp.get()); } } void Parser::resetPragmaHandlers() { // Remove the pragma handlers we installed. PP.RemovePragmaHandler(AlignHandler.get()); AlignHandler.reset(); PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get()); GCCVisibilityHandler.reset(); PP.RemovePragmaHandler(OptionsHandler.get()); OptionsHandler.reset(); PP.RemovePragmaHandler(PackHandler.get()); PackHandler.reset(); PP.RemovePragmaHandler(MSStructHandler.get()); MSStructHandler.reset(); PP.RemovePragmaHandler(UnusedHandler.get()); UnusedHandler.reset(); PP.RemovePragmaHandler(WeakHandler.get()); WeakHandler.reset(); PP.RemovePragmaHandler(RedefineExtnameHandler.get()); RedefineExtnameHandler.reset(); if (getLangOpts().OpenCL) { PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get()); OpenCLExtensionHandler.reset(); PP.RemovePragmaHandler("OPENCL", FPContractHandler.get()); } PP.RemovePragmaHandler(OpenMPHandler.get()); OpenMPHandler.reset(); if (getLangOpts().MicrosoftExt) { PP.RemovePragmaHandler(MSCommentHandler.get()); MSCommentHandler.reset(); PP.RemovePragmaHandler(MSDetectMismatchHandler.get()); MSDetectMismatchHandler.reset(); PP.RemovePragmaHandler(MSPointersToMembers.get()); MSPointersToMembers.reset(); PP.RemovePragmaHandler(MSVtorDisp.get()); MSVtorDisp.reset(); } PP.RemovePragmaHandler("STDC", FPContractHandler.get()); FPContractHandler.reset(); } /// \brief Handle the annotation token produced for #pragma unused(...) /// /// Each annot_pragma_unused is followed by the argument token so e.g. /// "#pragma unused(x,y)" becomes: /// annot_pragma_unused 'x' annot_pragma_unused 'y' void Parser::HandlePragmaUnused() { assert(Tok.is(tok::annot_pragma_unused)); SourceLocation UnusedLoc = ConsumeToken(); Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc); ConsumeToken(); // The argument token. } void Parser::HandlePragmaVisibility() { assert(Tok.is(tok::annot_pragma_vis)); const IdentifierInfo *VisType = static_cast(Tok.getAnnotationValue()); SourceLocation VisLoc = ConsumeToken(); Actions.ActOnPragmaVisibility(VisType, VisLoc); } struct PragmaPackInfo { Sema::PragmaPackKind Kind; IdentifierInfo *Name; Token Alignment; SourceLocation LParenLoc; SourceLocation RParenLoc; }; void Parser::HandlePragmaPack() { assert(Tok.is(tok::annot_pragma_pack)); PragmaPackInfo *Info = static_cast(Tok.getAnnotationValue()); SourceLocation PragmaLoc = ConsumeToken(); ExprResult Alignment; if (Info->Alignment.is(tok::numeric_constant)) { Alignment = Actions.ActOnNumericConstant(Info->Alignment); if (Alignment.isInvalid()) return; } Actions.ActOnPragmaPack(Info->Kind, Info->Name, Alignment.get(), PragmaLoc, Info->LParenLoc, Info->RParenLoc); } void Parser::HandlePragmaMSStruct() { assert(Tok.is(tok::annot_pragma_msstruct)); Sema::PragmaMSStructKind Kind = static_cast( reinterpret_cast(Tok.getAnnotationValue())); Actions.ActOnPragmaMSStruct(Kind); ConsumeToken(); // The annotation token. } void Parser::HandlePragmaAlign() { assert(Tok.is(tok::annot_pragma_align)); Sema::PragmaOptionsAlignKind Kind = static_cast( reinterpret_cast(Tok.getAnnotationValue())); SourceLocation PragmaLoc = ConsumeToken(); Actions.ActOnPragmaOptionsAlign(Kind, PragmaLoc); } void Parser::HandlePragmaWeak() { assert(Tok.is(tok::annot_pragma_weak)); SourceLocation PragmaLoc = ConsumeToken(); Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc, Tok.getLocation()); ConsumeToken(); // The weak name. } void Parser::HandlePragmaWeakAlias() { assert(Tok.is(tok::annot_pragma_weakalias)); SourceLocation PragmaLoc = ConsumeToken(); IdentifierInfo *WeakName = Tok.getIdentifierInfo(); SourceLocation WeakNameLoc = Tok.getLocation(); ConsumeToken(); IdentifierInfo *AliasName = Tok.getIdentifierInfo(); SourceLocation AliasNameLoc = Tok.getLocation(); ConsumeToken(); Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc, WeakNameLoc, AliasNameLoc); } void Parser::HandlePragmaRedefineExtname() { assert(Tok.is(tok::annot_pragma_redefine_extname)); SourceLocation RedefLoc = ConsumeToken(); IdentifierInfo *RedefName = Tok.getIdentifierInfo(); SourceLocation RedefNameLoc = Tok.getLocation(); ConsumeToken(); IdentifierInfo *AliasName = Tok.getIdentifierInfo(); SourceLocation AliasNameLoc = Tok.getLocation(); ConsumeToken(); Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc, RedefNameLoc, AliasNameLoc); } void Parser::HandlePragmaFPContract() { assert(Tok.is(tok::annot_pragma_fp_contract)); tok::OnOffSwitch OOS = static_cast( reinterpret_cast(Tok.getAnnotationValue())); Actions.ActOnPragmaFPContract(OOS); ConsumeToken(); // The annotation token. } StmtResult Parser::HandlePragmaCaptured() { assert(Tok.is(tok::annot_pragma_captured)); ConsumeToken(); if (Tok.isNot(tok::l_brace)) { PP.Diag(Tok, diag::err_expected) << tok::l_brace; return StmtError(); } SourceLocation Loc = Tok.getLocation(); ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope); Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default, /*NumParams=*/1); StmtResult R = ParseCompoundStatement(); CapturedRegionScope.Exit(); if (R.isInvalid()) { Actions.ActOnCapturedRegionError(); return StmtError(); } return Actions.ActOnCapturedRegionEnd(R.get()); } namespace { typedef llvm::PointerIntPair OpenCLExtData; } void Parser::HandlePragmaOpenCLExtension() { assert(Tok.is(tok::annot_pragma_opencl_extension)); OpenCLExtData data = OpenCLExtData::getFromOpaqueValue(Tok.getAnnotationValue()); unsigned state = data.getInt(); IdentifierInfo *ename = data.getPointer(); SourceLocation NameLoc = Tok.getLocation(); ConsumeToken(); // The annotation token. OpenCLOptions &f = Actions.getOpenCLOptions(); // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions, // overriding all previously issued extension directives, but only if the // behavior is set to disable." if (state == 0 && ename->isStr("all")) { #define OPENCLEXT(nm) f.nm = 0; #include "clang/Basic/OpenCLExtensions.def" } #define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; } #include "clang/Basic/OpenCLExtensions.def" else { PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename; return; } } void Parser::HandlePragmaMSPointersToMembers() { assert(Tok.is(tok::annot_pragma_ms_pointers_to_members)); LangOptions::PragmaMSPointersToMembersKind RepresentationMethod = static_cast( reinterpret_cast(Tok.getAnnotationValue())); SourceLocation PragmaLoc = ConsumeToken(); // The annotation token. Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc); } void Parser::HandlePragmaMSVtorDisp() { assert(Tok.is(tok::annot_pragma_ms_vtordisp)); uintptr_t Value = reinterpret_cast(Tok.getAnnotationValue()); Sema::PragmaVtorDispKind Kind = static_cast((Value >> 16) & 0xFFFF); MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF); SourceLocation PragmaLoc = ConsumeToken(); // The annotation token. Actions.ActOnPragmaMSVtorDisp(Kind, PragmaLoc, Mode); } // #pragma GCC visibility comes in two variants: // 'push' '(' [visibility] ')' // 'pop' void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &VisTok) { SourceLocation VisLoc = VisTok.getLocation(); Token Tok; PP.LexUnexpandedToken(Tok); const IdentifierInfo *PushPop = Tok.getIdentifierInfo(); const IdentifierInfo *VisType; if (PushPop && PushPop->isStr("pop")) { VisType = 0; } else if (PushPop && PushPop->isStr("push")) { PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "visibility"; return; } PP.LexUnexpandedToken(Tok); VisType = Tok.getIdentifierInfo(); if (!VisType) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "visibility"; return; } PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "visibility"; return; } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "visibility"; return; } PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "visibility"; return; } Token *Toks = new Token[1]; Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_vis); Toks[0].setLocation(VisLoc); Toks[0].setAnnotationValue( const_cast(static_cast(VisType))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true); } // #pragma pack(...) comes in the following delicious flavors: // pack '(' [integer] ')' // pack '(' 'show' ')' // pack '(' ('push' | 'pop') [',' identifier] [, integer] ')' void PragmaPackHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &PackTok) { SourceLocation PackLoc = PackTok.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack"; return; } Sema::PragmaPackKind Kind = Sema::PPK_Default; IdentifierInfo *Name = 0; Token Alignment; Alignment.startToken(); SourceLocation LParenLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.is(tok::numeric_constant)) { Alignment = Tok; PP.Lex(Tok); // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting // the push/pop stack. // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4) if (PP.getLangOpts().ApplePragmaPack) Kind = Sema::PPK_Push; } else if (Tok.is(tok::identifier)) { const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("show")) { Kind = Sema::PPK_Show; PP.Lex(Tok); } else { if (II->isStr("push")) { Kind = Sema::PPK_Push; } else if (II->isStr("pop")) { Kind = Sema::PPK_Pop; } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "pack"; return; } PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); if (Tok.is(tok::numeric_constant)) { Alignment = Tok; PP.Lex(Tok); } else if (Tok.is(tok::identifier)) { Name = Tok.getIdentifierInfo(); PP.Lex(Tok); if (Tok.is(tok::comma)) { PP.Lex(Tok); if (Tok.isNot(tok::numeric_constant)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed); return; } Alignment = Tok; PP.Lex(Tok); } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed); return; } } } } else if (PP.getLangOpts().ApplePragmaPack) { // In MSVC/gcc, #pragma pack() resets the alignment without affecting // the push/pop stack. // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop). Kind = Sema::PPK_Pop; } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack"; return; } SourceLocation RParenLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack"; return; } PragmaPackInfo *Info = (PragmaPackInfo*) PP.getPreprocessorAllocator().Allocate( sizeof(PragmaPackInfo), llvm::alignOf()); new (Info) PragmaPackInfo(); Info->Kind = Kind; Info->Name = Name; Info->Alignment = Alignment; Info->LParenLoc = LParenLoc; Info->RParenLoc = RParenLoc; Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_pack); Toks[0].setLocation(PackLoc); Toks[0].setAnnotationValue(static_cast(Info)); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma ms_struct on // #pragma ms_struct off void PragmaMSStructHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &MSStructTok) { Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF; Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct); return; } const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("on")) { Kind = Sema::PMSST_ON; PP.Lex(Tok); } else if (II->isStr("off") || II->isStr("reset")) PP.Lex(Tok); else { PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct); return; } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "ms_struct"; return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_msstruct); Toks[0].setLocation(MSStructTok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(Kind))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma 'align' '=' {'native','natural','mac68k','power','reset'} // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'} static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok, bool IsOptions) { Token Tok; if (IsOptions) { PP.Lex(Tok); if (Tok.isNot(tok::identifier) || !Tok.getIdentifierInfo()->isStr("align")) { PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align); return; } } PP.Lex(Tok); if (Tok.isNot(tok::equal)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal) << IsOptions; return; } PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << (IsOptions ? "options" : "align"); return; } Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural; const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II->isStr("native")) Kind = Sema::POAK_Native; else if (II->isStr("natural")) Kind = Sema::POAK_Natural; else if (II->isStr("packed")) Kind = Sema::POAK_Packed; else if (II->isStr("power")) Kind = Sema::POAK_Power; else if (II->isStr("mac68k")) Kind = Sema::POAK_Mac68k; else if (II->isStr("reset")) Kind = Sema::POAK_Reset; else { PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option) << IsOptions; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << (IsOptions ? "options" : "align"); return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_align); Toks[0].setLocation(FirstTok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(Kind))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaAlignHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &AlignTok) { ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false); } void PragmaOptionsHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &OptionsTok) { ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true); } // #pragma unused(identifier) void PragmaUnusedHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &UnusedTok) { // FIXME: Should we be expanding macros here? My guess is no. SourceLocation UnusedLoc = UnusedTok.getLocation(); // Lex the left '('. Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused"; return; } // Lex the declaration reference(s). SmallVector Identifiers; SourceLocation RParenLoc; bool LexID = true; while (true) { PP.Lex(Tok); if (LexID) { if (Tok.is(tok::identifier)) { Identifiers.push_back(Tok); LexID = false; continue; } // Illegal token! PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var); return; } // We are execting a ')' or a ','. if (Tok.is(tok::comma)) { LexID = true; continue; } if (Tok.is(tok::r_paren)) { RParenLoc = Tok.getLocation(); break; } // Illegal token! PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "unused"; return; } // Verify that we have a location for the right parenthesis. assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'"); assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments"); // For each identifier token, insert into the token stream a // annot_pragma_unused token followed by the identifier token. // This allows us to cache a "#pragma unused" that occurs inside an inline // C++ member function. Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 2 * Identifiers.size(), llvm::alignOf()); for (unsigned i=0; i != Identifiers.size(); i++) { Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_unused); pragmaUnusedTok.setLocation(UnusedLoc); idTok = Identifiers[i]; } PP.EnterTokenStream(Toks, 2*Identifiers.size(), /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } // #pragma weak identifier // #pragma weak identifier '=' identifier void PragmaWeakHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &WeakTok) { SourceLocation WeakLoc = WeakTok.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak"; return; } Token WeakName = Tok; bool HasAlias = false; Token AliasName; PP.Lex(Tok); if (Tok.is(tok::equal)) { HasAlias = true; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak"; return; } AliasName = Tok; PP.Lex(Tok); } if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak"; return; } if (HasAlias) { Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 3, llvm::alignOf()); Token &pragmaUnusedTok = Toks[0]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_weakalias); pragmaUnusedTok.setLocation(WeakLoc); Toks[1] = WeakName; Toks[2] = AliasName; PP.EnterTokenStream(Toks, 3, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } else { Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 2, llvm::alignOf()); Token &pragmaUnusedTok = Toks[0]; pragmaUnusedTok.startToken(); pragmaUnusedTok.setKind(tok::annot_pragma_weak); pragmaUnusedTok.setLocation(WeakLoc); Toks[1] = WeakName; PP.EnterTokenStream(Toks, 2, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } } // #pragma redefine_extname identifier identifier void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &RedefToken) { SourceLocation RedefLoc = RedefToken.getLocation(); Token Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "redefine_extname"; return; } Token RedefName = Tok; PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "redefine_extname"; return; } Token AliasName = Tok; PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "redefine_extname"; return; } Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 3, llvm::alignOf()); Token &pragmaRedefTok = Toks[0]; pragmaRedefTok.startToken(); pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname); pragmaRedefTok.setLocation(RedefLoc); Toks[1] = RedefName; Toks[2] = AliasName; PP.EnterTokenStream(Toks, 3, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaFPContractHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { tok::OnOffSwitch OOS; if (PP.LexOnOffSwitch(OOS)) return; Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_fp_contract); Toks[0].setLocation(Tok.getLocation()); Toks[0].setAnnotationValue(reinterpret_cast( static_cast(OOS))); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); } void PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { PP.LexUnexpandedToken(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "OPENCL"; return; } IdentifierInfo *ename = Tok.getIdentifierInfo(); SourceLocation NameLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::colon)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename; return; } PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable); return; } IdentifierInfo *op = Tok.getIdentifierInfo(); unsigned state; if (op->isStr("enable")) { state = 1; } else if (op->isStr("disable")) { state = 0; } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable); return; } SourceLocation StateLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "OPENCL EXTENSION"; return; } OpenCLExtData data(ename, state); Token *Toks = (Token*) PP.getPreprocessorAllocator().Allocate( sizeof(Token) * 1, llvm::alignOf()); new (Toks) Token(); Toks[0].startToken(); Toks[0].setKind(tok::annot_pragma_opencl_extension); Toks[0].setLocation(NameLoc); Toks[0].setAnnotationValue(data.getOpaqueValue()); PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, ename, StateLoc, state); } /// \brief Handle '#pragma omp ...' when OpenMP is disabled. /// void PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstTok) { if (PP.getDiagnostics().getDiagnosticLevel(diag::warn_pragma_omp_ignored, FirstTok.getLocation()) != DiagnosticsEngine::Ignored) { PP.Diag(FirstTok, diag::warn_pragma_omp_ignored); PP.getDiagnostics().setDiagnosticMapping(diag::warn_pragma_omp_ignored, diag::MAP_IGNORE, SourceLocation()); } PP.DiscardUntilEndOfDirective(); } /// \brief Handle '#pragma omp ...' when OpenMP is enabled. /// void PragmaOpenMPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstTok) { SmallVector Pragma; Token Tok; Tok.startToken(); Tok.setKind(tok::annot_pragma_openmp); Tok.setLocation(FirstTok.getLocation()); while (Tok.isNot(tok::eod)) { Pragma.push_back(Tok); PP.Lex(Tok); } SourceLocation EodLoc = Tok.getLocation(); Tok.startToken(); Tok.setKind(tok::annot_pragma_openmp_end); Tok.setLocation(EodLoc); Pragma.push_back(Tok); Token *Toks = new Token[Pragma.size()]; std::copy(Pragma.begin(), Pragma.end(), Toks); PP.EnterTokenStream(Toks, Pragma.size(), /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true); } /// \brief Handle '#pragma pointers_to_members' // The grammar for this pragma is as follows: // // ::= ('single' | 'multiple' | 'virtual') '_inheritance' // // #pragma pointers_to_members '(' 'best_case' ')' // #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')' // #pragma pointers_to_members '(' inheritance-model ')' void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation PointersToMembersLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen) << "pointers_to_members"; return; } PP.Lex(Tok); const IdentifierInfo *Arg = Tok.getIdentifierInfo(); if (!Arg) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "pointers_to_members"; return; } PP.Lex(Tok); LangOptions::PragmaMSPointersToMembersKind RepresentationMethod; if (Arg->isStr("best_case")) { RepresentationMethod = LangOptions::PPTMK_BestCase; } else { if (Arg->isStr("full_generality")) { if (Tok.is(tok::comma)) { PP.Lex(Tok); Arg = Tok.getIdentifierInfo(); if (!Arg) { PP.Diag(Tok.getLocation(), diag::err_pragma_pointers_to_members_unknown_kind) << Tok.getKind() << /*OnlyInheritanceModels*/ 0; return; } PP.Lex(Tok); } else if (Tok.is(tok::r_paren)) { // #pragma pointers_to_members(full_generality) implicitly specifies // virtual_inheritance. Arg = 0; RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance; } else { PP.Diag(Tok.getLocation(), diag::err_expected_punc) << "full_generality"; return; } } if (Arg) { if (Arg->isStr("single_inheritance")) { RepresentationMethod = LangOptions::PPTMK_FullGeneralitySingleInheritance; } else if (Arg->isStr("multiple_inheritance")) { RepresentationMethod = LangOptions::PPTMK_FullGeneralityMultipleInheritance; } else if (Arg->isStr("virtual_inheritance")) { RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance; } else { PP.Diag(Tok.getLocation(), diag::err_pragma_pointers_to_members_unknown_kind) << Arg << /*HasPointerDeclaration*/ 1; return; } } } if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected_rparen_after) << (Arg ? Arg->getName() : "full_generality"); return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pointers_to_members"; return; } Token AnnotTok; AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_pointers_to_members); AnnotTok.setLocation(PointersToMembersLoc); AnnotTok.setAnnotationValue( reinterpret_cast(static_cast(RepresentationMethod))); PP.EnterToken(AnnotTok); } /// \brief Handle '#pragma vtordisp' // The grammar for this pragma is as follows: // // ::= ('off' | 'on' | '0' | '1' | '2' ) // // #pragma vtordisp '(' ['push' ','] vtordisp-mode ')' // #pragma vtordisp '(' 'pop' ')' // #pragma vtordisp '(' ')' void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation VtorDispLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) << "vtordisp"; return; } PP.Lex(Tok); Sema::PragmaVtorDispKind Kind = Sema::PVDK_Set; const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II) { if (II->isStr("push")) { // #pragma vtordisp(push, mode) PP.Lex(Tok); if (Tok.isNot(tok::comma)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_punc) << "vtordisp"; return; } PP.Lex(Tok); Kind = Sema::PVDK_Push; // not push, could be on/off } else if (II->isStr("pop")) { // #pragma vtordisp(pop) PP.Lex(Tok); Kind = Sema::PVDK_Pop; } // not push or pop, could be on/off } else { if (Tok.is(tok::r_paren)) { // #pragma vtordisp() Kind = Sema::PVDK_Reset; } } uint64_t Value = 0; if (Kind == Sema::PVDK_Push || Kind == Sema::PVDK_Set) { const IdentifierInfo *II = Tok.getIdentifierInfo(); if (II && II->isStr("off")) { PP.Lex(Tok); Value = 0; } else if (II && II->isStr("on")) { PP.Lex(Tok); Value = 1; } else if (Tok.is(tok::numeric_constant) && PP.parseSimpleIntegerLiteral(Tok, Value)) { if (Value > 2) { PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_integer) << 0 << 2 << "vtordisp"; return; } } else { PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "vtordisp"; return; } } // Finish the pragma: ')' $ if (Tok.isNot(tok::r_paren)) { PP.Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) << "vtordisp"; return; } PP.Lex(Tok); if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "vtordisp"; return; } // Enter the annotation. Token AnnotTok; AnnotTok.startToken(); AnnotTok.setKind(tok::annot_pragma_ms_vtordisp); AnnotTok.setLocation(VtorDispLoc); AnnotTok.setAnnotationValue(reinterpret_cast( static_cast((Kind << 16) | (Value & 0xFFFF)))); PP.EnterToken(AnnotTok); } /// \brief Handle the Microsoft \#pragma detect_mismatch extension. /// /// The syntax is: /// \code /// #pragma detect_mismatch("name", "value") /// \endcode /// Where 'name' and 'value' are quoted strings. The values are embedded in /// the object file and passed along to the linker. If the linker detects a /// mismatch in the object file's values for the given name, a LNK2038 error /// is emitted. See MSDN for more details. void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation CommentLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(CommentLoc, diag::err_expected) << tok::l_paren; return; } // Read the name to embed, which must be a string literal. std::string NameString; if (!PP.LexStringLiteral(Tok, NameString, "pragma detect_mismatch", /*MacroExpansion=*/true)) return; // Read the comma followed by a second string literal. std::string ValueString; if (Tok.isNot(tok::comma)) { PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed); return; } if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch", /*MacroExpansion=*/true)) return; if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; return; } PP.Lex(Tok); // Eat the r_paren. if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed); return; } // If the pragma is lexically sound, notify any interested PPCallbacks. if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaDetectMismatch(CommentLoc, NameString, ValueString); Actions.ActOnPragmaDetectMismatch(NameString, ValueString); } /// \brief Handle the microsoft \#pragma comment extension. /// /// The syntax is: /// \code /// #pragma comment(linker, "foo") /// \endcode /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user. /// "foo" is a string, which is fully macro expanded, and permits string /// concatenation, embedded escape characters etc. See MSDN for more details. void PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) { SourceLocation CommentLoc = Tok.getLocation(); PP.Lex(Tok); if (Tok.isNot(tok::l_paren)) { PP.Diag(CommentLoc, diag::err_pragma_comment_malformed); return; } // Read the identifier. PP.Lex(Tok); if (Tok.isNot(tok::identifier)) { PP.Diag(CommentLoc, diag::err_pragma_comment_malformed); return; } // Verify that this is one of the 5 whitelisted options. IdentifierInfo *II = Tok.getIdentifierInfo(); Sema::PragmaMSCommentKind Kind = llvm::StringSwitch(II->getName()) .Case("linker", Sema::PCK_Linker) .Case("lib", Sema::PCK_Lib) .Case("compiler", Sema::PCK_Compiler) .Case("exestr", Sema::PCK_ExeStr) .Case("user", Sema::PCK_User) .Default(Sema::PCK_Unknown); if (Kind == Sema::PCK_Unknown) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind); return; } // Read the optional string if present. PP.Lex(Tok); std::string ArgumentString; if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString, "pragma comment", /*MacroExpansion=*/true)) return; // FIXME: warn that 'exestr' is deprecated. // FIXME: If the kind is "compiler" warn if the string is present (it is // ignored). // The MSDN docs say that "lib" and "linker" require a string and have a short // whitelist of linker options they support, but in practice MSVC doesn't // issue a diagnostic. Therefore neither does clang. if (Tok.isNot(tok::r_paren)) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); return; } PP.Lex(Tok); // eat the r_paren. if (Tok.isNot(tok::eod)) { PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); return; } // If the pragma is lexically sound, notify any interested PPCallbacks. if (PP.getPPCallbacks()) PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString); Actions.ActOnPragmaMSComment(Kind, ArgumentString); } @