22 #include "llvm/ADT/StringSwitch.h"
23 using namespace clang;
30 Token &FirstToken)
override;
34 explicit PragmaGCCVisibilityHandler() :
PragmaHandler(
"visibility") {}
36 Token &FirstToken)
override;
42 Token &FirstToken)
override;
48 Token &FirstToken)
override;
52 explicit PragmaMSStructHandler() :
PragmaHandler(
"ms_struct") {}
54 Token &FirstToken)
override;
60 Token &FirstToken)
override;
66 Token &FirstToken)
override;
70 explicit PragmaRedefineExtnameHandler() :
PragmaHandler(
"redefine_extname") {}
72 Token &FirstToken)
override;
76 PragmaOpenCLExtensionHandler() :
PragmaHandler(
"EXTENSION") {}
78 Token &FirstToken)
override;
85 Token &FirstToken)
override;
91 Token &FirstToken)
override;
97 Token &FirstToken)
override;
102 PragmaCommentHandler(
Sema &Actions)
105 Token &FirstToken)
override;
111 PragmaDetectMismatchHandler(
Sema &Actions)
114 Token &FirstToken)
override;
120 explicit PragmaMSPointersToMembers() :
PragmaHandler(
"pointers_to_members") {}
122 Token &FirstToken)
override;
128 Token &FirstToken)
override;
132 explicit PragmaMSPragma(
const char *name) :
PragmaHandler(name) {}
134 Token &FirstToken)
override;
139 PragmaOptimizeHandler(
Sema &
S)
142 Token &FirstToken)
override;
150 Token &FirstToken)
override;
154 PragmaUnrollHintHandler(
const char *name) :
PragmaHandler(name) {}
156 Token &FirstToken)
override;
161 void Parser::initializePragmaHandlers() {
162 AlignHandler.reset(
new PragmaAlignHandler());
165 GCCVisibilityHandler.reset(
new PragmaGCCVisibilityHandler());
168 OptionsHandler.reset(
new PragmaOptionsHandler());
171 PackHandler.reset(
new PragmaPackHandler());
174 MSStructHandler.reset(
new PragmaMSStructHandler());
177 UnusedHandler.reset(
new PragmaUnusedHandler());
180 WeakHandler.reset(
new PragmaWeakHandler());
183 RedefineExtnameHandler.reset(
new PragmaRedefineExtnameHandler());
186 FPContractHandler.reset(
new PragmaFPContractHandler());
190 OpenCLExtensionHandler.reset(
new PragmaOpenCLExtensionHandler());
196 OpenMPHandler.reset(
new PragmaOpenMPHandler());
198 OpenMPHandler.reset(
new PragmaNoOpenMPHandler());
202 MSCommentHandler.reset(
new PragmaCommentHandler(Actions));
207 MSDetectMismatchHandler.reset(
new PragmaDetectMismatchHandler(Actions));
209 MSPointersToMembers.reset(
new PragmaMSPointersToMembers());
211 MSVtorDisp.reset(
new PragmaMSVtorDisp());
213 MSInitSeg.reset(
new PragmaMSPragma(
"init_seg"));
215 MSDataSeg.reset(
new PragmaMSPragma(
"data_seg"));
217 MSBSSSeg.reset(
new PragmaMSPragma(
"bss_seg"));
219 MSConstSeg.reset(
new PragmaMSPragma(
"const_seg"));
221 MSCodeSeg.reset(
new PragmaMSPragma(
"code_seg"));
223 MSSection.reset(
new PragmaMSPragma(
"section"));
227 OptimizeHandler.reset(
new PragmaOptimizeHandler(Actions));
230 LoopHintHandler.reset(
new PragmaLoopHintHandler());
233 UnrollHintHandler.reset(
new PragmaUnrollHintHandler(
"unroll"));
236 NoUnrollHintHandler.reset(
new PragmaUnrollHintHandler(
"nounroll"));
240 void Parser::resetPragmaHandlers() {
243 AlignHandler.reset();
245 GCCVisibilityHandler.reset();
247 OptionsHandler.reset();
251 MSStructHandler.reset();
253 UnusedHandler.reset();
257 RedefineExtnameHandler.reset();
261 OpenCLExtensionHandler.reset();
265 OpenMPHandler.reset();
269 MSCommentHandler.reset();
274 MSDetectMismatchHandler.reset();
276 MSPointersToMembers.reset();
294 FPContractHandler.reset();
297 OptimizeHandler.reset();
300 LoopHintHandler.reset();
303 UnrollHintHandler.reset();
306 NoUnrollHintHandler.reset();
314 void Parser::HandlePragmaUnused() {
315 assert(Tok.
is(tok::annot_pragma_unused));
321 void Parser::HandlePragmaVisibility() {
322 assert(Tok.
is(tok::annot_pragma_vis));
337 void Parser::HandlePragmaPack() {
338 assert(Tok.
is(tok::annot_pragma_pack));
343 if (Info->Alignment.is(tok::numeric_constant)) {
349 Info->LParenLoc, Info->RParenLoc);
352 void Parser::HandlePragmaMSStruct() {
353 assert(Tok.
is(tok::annot_pragma_msstruct));
361 void Parser::HandlePragmaAlign() {
362 assert(Tok.
is(tok::annot_pragma_align));
370 void Parser::HandlePragmaWeak() {
371 assert(Tok.
is(tok::annot_pragma_weak));
378 void Parser::HandlePragmaWeakAlias() {
379 assert(Tok.
is(tok::annot_pragma_weakalias));
388 WeakNameLoc, AliasNameLoc);
392 void Parser::HandlePragmaRedefineExtname() {
393 assert(Tok.
is(tok::annot_pragma_redefine_extname));
402 RedefNameLoc, AliasNameLoc);
405 void Parser::HandlePragmaFPContract() {
406 assert(Tok.
is(tok::annot_pragma_fp_contract));
416 assert(Tok.
is(tok::annot_pragma_captured));
419 if (Tok.
isNot(tok::l_brace)) {
420 PP.
Diag(Tok, diag::err_expected) << tok::l_brace;
431 CapturedRegionScope.Exit();
442 typedef llvm::PointerIntPair<IdentifierInfo *, 1, bool> OpenCLExtData;
445 void Parser::HandlePragmaOpenCLExtension() {
446 assert(Tok.
is(tok::annot_pragma_opencl_extension));
449 unsigned state = data.getInt();
458 if (state == 0 && ename->
isStr(
"all")) {
459 #define OPENCLEXT(nm) f.nm = 0;
460 #include "clang/Basic/OpenCLExtensions.def"
462 #define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; }
463 #include "clang/Basic/OpenCLExtensions.def"
465 PP.
Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
470 void Parser::HandlePragmaMSPointersToMembers() {
471 assert(Tok.
is(tok::annot_pragma_ms_pointers_to_members));
479 void Parser::HandlePragmaMSVtorDisp() {
480 assert(Tok.
is(tok::annot_pragma_ms_vtordisp));
484 MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF);
489 void Parser::HandlePragmaMSPragma() {
490 assert(Tok.
is(tok::annot_pragma_ms_pragma));
502 PragmaHandler Handler = llvm::StringSwitch<PragmaHandler>(PragmaName)
503 .Case(
"data_seg", &Parser::HandlePragmaMSSegment)
504 .Case(
"bss_seg", &Parser::HandlePragmaMSSegment)
505 .Case(
"const_seg", &Parser::HandlePragmaMSSegment)
506 .Case(
"code_seg", &Parser::HandlePragmaMSSegment)
507 .Case(
"section", &Parser::HandlePragmaMSSection)
508 .Case(
"init_seg", &Parser::HandlePragmaMSInitSeg);
510 if (!(this->*Handler)(PragmaName, PragmaLocation)) {
519 bool Parser::HandlePragmaMSSection(StringRef PragmaName,
521 if (Tok.
isNot(tok::l_paren)) {
522 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
527 if (Tok.
isNot(tok::string_literal)) {
528 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_section_name)
532 ExprResult StringResult = ParseStringLiteralExpression();
537 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
542 bool SectionFlagsAreDefault =
true;
543 while (Tok.
is(tok::comma)) {
548 if (Tok.
is(tok::kw_long) || Tok.
is(tok::kw_short)) {
554 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren)
559 llvm::StringSwitch<ASTContext::PragmaSectionFlag>(
572 ? diag::warn_pragma_invalid_specific_action
573 : diag::warn_pragma_unsupported_action)
577 SectionFlags |= Flag;
578 SectionFlagsAreDefault =
false;
583 if (SectionFlagsAreDefault)
585 if (Tok.
isNot(tok::r_paren)) {
586 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
591 PP.
Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
600 bool Parser::HandlePragmaMSSegment(StringRef PragmaName,
602 if (Tok.
isNot(tok::l_paren)) {
603 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
611 if (PushPop ==
"push")
613 else if (PushPop ==
"pop")
616 PP.
Diag(PragmaLocation,
617 diag::warn_pragma_expected_section_push_pop_or_name)
623 if (Tok.
is(tok::comma)) {
629 if (Tok.
is(tok::comma))
631 else if (Tok.
isNot(tok::r_paren)) {
632 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_punc)
637 }
else if (Tok.
isNot(tok::r_paren)) {
638 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName;
645 if (Tok.
isNot(tok::r_paren)) {
646 if (Tok.
isNot(tok::string_literal)) {
648 diag::warn_pragma_expected_section_name :
649 diag::warn_pragma_expected_section_label_or_name :
650 diag::warn_pragma_expected_section_push_pop_or_name;
651 PP.
Diag(PragmaLocation, DiagID) << PragmaName;
654 ExprResult StringResult = ParseStringLiteralExpression();
657 SegmentName = cast<StringLiteral>(StringResult.
get());
659 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
667 if (Tok.
isNot(tok::r_paren)) {
668 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
673 PP.
Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
679 SegmentName, PragmaName);
684 bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName,
686 if (
getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) {
687 PP.
Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target);
691 if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen,
699 StringRef Section = llvm::StringSwitch<StringRef>(II->getName())
700 .Case(
"compiler",
"\".CRT$XCC\"")
701 .Case(
"lib",
"\".CRT$XCL\"")
702 .Case(
"user",
"\".CRT$XCU\"")
705 if (!Section.empty()) {
709 Toks[0].
setKind(tok::string_literal);
717 }
else if (Tok.
is(tok::string_literal)) {
718 ExprResult StringResult = ParseStringLiteralExpression();
721 SegmentName = cast<StringLiteral>(StringResult.
get());
723 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
731 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName;
735 if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen,
737 ExpectAndConsume(
tok::eof, diag::warn_pragma_extra_tokens_at_eol,
754 std::string PragmaString;
756 PragmaString =
"clang loop ";
760 "Unexpected pragma name");
761 PragmaString =
"unroll";
766 bool Parser::HandlePragmaLoopHint(
LoopHint &Hint) {
767 assert(Tok.
is(tok::annot_pragma_loop_hint));
771 IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo();
773 Actions.
Context, Info->PragmaName.getLocation(), PragmaNameInfo);
778 ? Info->Option.getIdentifierInfo()
781 Actions.
Context, Info->Option.getLocation(), OptionInfo);
783 Token *Toks = Info->Toks;
784 size_t TokSize = Info->TokSize;
788 bool PragmaUnroll = PragmaNameInfo->
getName() ==
"unroll";
789 bool PragmaNoUnroll = PragmaNameInfo->
getName() ==
"nounroll";
790 if (TokSize == 0 && (PragmaUnroll || PragmaNoUnroll)) {
792 Hint.
Range = Info->PragmaName.getLocation();
798 assert(TokSize > 0 &&
799 "PragmaLoopHintInfo::Toks must contain at least one token.");
802 bool OptionUnroll =
false;
803 bool StateOption =
false;
805 OptionUnroll = OptionInfo->isStr(
"unroll");
806 StateOption = llvm::StringSwitch<bool>(OptionInfo->getName())
807 .Case(
"vectorize",
true)
808 .Case(
"interleave",
true)
809 .Case(
"unroll",
true)
816 Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument)
817 << StateOption << OptionUnroll;
827 ((OptionUnroll ? !StateInfo->
isStr(
"full")
828 : !StateInfo->
isStr(
"enable") &&
829 !StateInfo->
isStr(
"assume_safety")) &&
830 !StateInfo->
isStr(
"disable"))) {
831 Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword)
867 Info->Toks[TokSize - 1].getLocation());
874 void PragmaGCCVisibilityHandler::HandlePragma(
Preprocessor &PP,
885 if (PushPop && PushPop->
isStr(
"pop")) {
887 }
else if (PushPop && PushPop->
isStr(
"push")) {
889 if (Tok.
isNot(tok::l_paren)) {
902 if (Tok.
isNot(tok::r_paren)) {
914 if (Tok.
isNot(tok::eod)) {
922 Toks[0].
setKind(tok::annot_pragma_vis);
926 const_cast<void*>(static_cast<const void*>(VisType)));
942 if (Tok.
isNot(tok::l_paren)) {
943 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_lparen) <<
"pack";
953 if (Tok.
is(tok::numeric_constant)) {
963 }
else if (Tok.
is(tok::identifier)) {
965 if (II->
isStr(
"show")) {
969 if (II->
isStr(
"push")) {
971 }
else if (II->
isStr(
"pop")) {
974 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_invalid_action) <<
"pack";
979 if (Tok.
is(tok::comma)) {
982 if (Tok.
is(tok::numeric_constant)) {
986 }
else if (Tok.
is(tok::identifier)) {
990 if (Tok.
is(tok::comma)) {
993 if (Tok.
isNot(tok::numeric_constant)) {
1015 if (Tok.
isNot(tok::r_paren)) {
1016 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_rparen) <<
"pack";
1022 if (Tok.
isNot(tok::eod)) {
1023 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"pack";
1039 sizeof(
Token) * 1, llvm::alignOf<Token>());
1042 Toks[0].
setKind(tok::annot_pragma_pack);
1052 void PragmaMSStructHandler::HandlePragma(
Preprocessor &PP,
1054 Token &MSStructTok) {
1059 if (Tok.
isNot(tok::identifier)) {
1065 if (II->
isStr(
"on")) {
1069 else if (II->
isStr(
"off") || II->
isStr(
"reset"))
1076 if (Tok.
isNot(tok::eod)) {
1084 sizeof(
Token) * 1, llvm::alignOf<Token>());
1087 Toks[0].
setKind(tok::annot_pragma_msstruct);
1091 static_cast<uintptr_t>(Kind)));
1104 if (Tok.
isNot(tok::identifier) ||
1112 if (Tok.
isNot(tok::equal)) {
1119 if (Tok.
isNot(tok::identifier)) {
1121 << (IsOptions ?
"options" :
"align");
1127 if (II->
isStr(
"native"))
1129 else if (II->
isStr(
"natural"))
1131 else if (II->
isStr(
"packed"))
1133 else if (II->
isStr(
"power"))
1135 else if (II->
isStr(
"mac68k"))
1137 else if (II->
isStr(
"reset"))
1147 if (Tok.
isNot(tok::eod)) {
1149 << (IsOptions ?
"options" :
"align");
1155 sizeof(
Token) * 1, llvm::alignOf<Token>());
1158 Toks[0].
setKind(tok::annot_pragma_align);
1162 static_cast<uintptr_t>(Kind)));
1167 void PragmaAlignHandler::HandlePragma(
Preprocessor &PP,
1173 void PragmaOptionsHandler::HandlePragma(
Preprocessor &PP,
1175 Token &OptionsTok) {
1180 void PragmaUnusedHandler::HandlePragma(
Preprocessor &PP,
1189 if (Tok.
isNot(tok::l_paren)) {
1190 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_lparen) <<
"unused";
1203 if (Tok.
is(tok::identifier)) {
1204 Identifiers.push_back(Tok);
1215 if (Tok.
is(tok::comma)) {
1220 if (Tok.
is(tok::r_paren)) {
1226 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_punc) <<
"unused";
1231 if (Tok.
isNot(tok::eod)) {
1238 assert(RParenLoc.
isValid() &&
"Valid '#pragma unused' must have ')'");
1239 assert(!Identifiers.empty() &&
"Valid '#pragma unused' must have arguments");
1248 sizeof(
Token) * 2 * Identifiers.size(), llvm::alignOf<Token>());
1249 for (
unsigned i=0; i != Identifiers.size(); i++) {
1250 Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
1252 pragmaUnusedTok.
setKind(tok::annot_pragma_unused);
1254 idTok = Identifiers[i];
1269 if (Tok.
isNot(tok::identifier)) {
1270 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_identifier) <<
"weak";
1274 Token WeakName = Tok;
1275 bool HasAlias =
false;
1279 if (Tok.
is(tok::equal)) {
1282 if (Tok.
isNot(tok::identifier)) {
1291 if (Tok.
isNot(tok::eod)) {
1292 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"weak";
1299 sizeof(
Token) * 3, llvm::alignOf<Token>());
1300 Token &pragmaUnusedTok = Toks[0];
1302 pragmaUnusedTok.
setKind(tok::annot_pragma_weakalias);
1306 Toks[2] = AliasName;
1312 sizeof(
Token) * 2, llvm::alignOf<Token>());
1313 Token &pragmaUnusedTok = Toks[0];
1315 pragmaUnusedTok.
setKind(tok::annot_pragma_weak);
1325 void PragmaRedefineExtnameHandler::HandlePragma(
Preprocessor &PP,
1327 Token &RedefToken) {
1332 if (Tok.
isNot(tok::identifier)) {
1338 Token RedefName = Tok;
1341 if (Tok.
isNot(tok::identifier)) {
1343 <<
"redefine_extname";
1347 Token AliasName = Tok;
1350 if (Tok.
isNot(tok::eod)) {
1358 sizeof(
Token) * 3, llvm::alignOf<Token>());
1359 Token &pragmaRedefTok = Toks[0];
1361 pragmaRedefTok.
setKind(tok::annot_pragma_redefine_extname);
1364 Toks[1] = RedefName;
1365 Toks[2] = AliasName;
1372 PragmaFPContractHandler::HandlePragma(
Preprocessor &PP,
1381 sizeof(
Token) * 1, llvm::alignOf<Token>());
1384 Toks[0].
setKind(tok::annot_pragma_fp_contract);
1388 static_cast<uintptr_t>(OOS)));
1394 PragmaOpenCLExtensionHandler::HandlePragma(
Preprocessor &PP,
1398 if (Tok.
isNot(tok::identifier)) {
1407 if (Tok.
isNot(tok::colon)) {
1408 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_colon) << ename;
1413 if (Tok.
isNot(tok::identifier)) {
1414 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_enable_disable);
1420 if (op->
isStr(
"enable")) {
1422 }
else if (op->
isStr(
"disable")) {
1425 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_enable_disable);
1431 if (Tok.
isNot(tok::eod)) {
1437 OpenCLExtData data(ename, state);
1440 sizeof(
Token) * 1, llvm::alignOf<Token>());
1443 Toks[0].
setKind(tok::annot_pragma_opencl_extension);
1463 PP.
Diag(FirstTok, diag::warn_pragma_omp_ignored);
1479 Tok.
setKind(tok::annot_pragma_openmp);
1482 while (Tok.
isNot(tok::eod)) {
1483 Pragma.push_back(Tok);
1488 Tok.
setKind(tok::annot_pragma_openmp_end);
1490 Pragma.push_back(Tok);
1493 std::copy(Pragma.begin(), Pragma.end(), Toks);
1506 void PragmaMSPointersToMembers::HandlePragma(
Preprocessor &PP,
1511 if (Tok.
isNot(tok::l_paren)) {
1512 PP.
Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen)
1513 <<
"pointers_to_members";
1520 <<
"pointers_to_members";
1526 if (Arg->
isStr(
"best_case")) {
1529 if (Arg->
isStr(
"full_generality")) {
1530 if (Tok.
is(tok::comma)) {
1536 diag::err_pragma_pointers_to_members_unknown_kind)
1541 }
else if (Tok.
is(tok::r_paren)) {
1548 <<
"full_generality";
1554 if (Arg->
isStr(
"single_inheritance")) {
1555 RepresentationMethod =
1557 }
else if (Arg->
isStr(
"multiple_inheritance")) {
1558 RepresentationMethod =
1560 }
else if (Arg->
isStr(
"virtual_inheritance")) {
1561 RepresentationMethod =
1565 diag::err_pragma_pointers_to_members_unknown_kind)
1572 if (Tok.
isNot(tok::r_paren)) {
1574 << (Arg ? Arg->
getName() :
"full_generality");
1580 if (Tok.
isNot(tok::eod)) {
1582 <<
"pointers_to_members";
1588 AnnotTok.
setKind(tok::annot_pragma_ms_pointers_to_members);
1592 reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod)));
1609 if (Tok.
isNot(tok::l_paren)) {
1610 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) <<
"vtordisp";
1618 if (II->
isStr(
"push")) {
1621 if (Tok.
isNot(tok::comma)) {
1622 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_punc) <<
"vtordisp";
1628 }
else if (II->
isStr(
"pop")) {
1635 if (Tok.
is(tok::r_paren)) {
1645 if (II && II->
isStr(
"off")) {
1648 }
else if (II && II->
isStr(
"on")) {
1651 }
else if (Tok.
is(tok::numeric_constant) &&
1655 << 0 << 2 <<
"vtordisp";
1666 if (Tok.
isNot(tok::r_paren)) {
1667 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) <<
"vtordisp";
1672 if (Tok.
isNot(tok::eod)) {
1681 AnnotTok.
setKind(tok::annot_pragma_ms_vtordisp);
1685 static_cast<uintptr_t>((Kind << 16) | (Value & 0xFFFF))));
1694 Token EoF, AnnotTok;
1698 AnnotTok.
setKind(tok::annot_pragma_ms_pragma);
1703 for (; Tok.
isNot(tok::eod); PP.
Lex(Tok)) {
1704 TokenVector.push_back(Tok);
1708 TokenVector.push_back(EoF);
1711 Token *TokenArray =
new Token[TokenVector.size()];
1712 std::copy(TokenVector.begin(), TokenVector.end(), TokenArray);
1714 std::pair<Token*, size_t>(std::make_pair(TokenArray, TokenVector.size()));
1729 void PragmaDetectMismatchHandler::HandlePragma(
Preprocessor &PP,
1734 if (Tok.
isNot(tok::l_paren)) {
1735 PP.
Diag(CommentLoc, diag::err_expected) << tok::l_paren;
1740 std::string NameString;
1742 "pragma detect_mismatch",
1747 std::string ValueString;
1748 if (Tok.
isNot(tok::comma)) {
1749 PP.
Diag(Tok.
getLocation(), diag::err_pragma_detect_mismatch_malformed);
1757 if (Tok.
isNot(tok::r_paren)) {
1763 if (Tok.
isNot(tok::eod)) {
1764 PP.
Diag(Tok.
getLocation(), diag::err_pragma_detect_mismatch_malformed);
1773 Actions.ActOnPragmaDetectMismatch(NameString, ValueString);
1785 void PragmaCommentHandler::HandlePragma(
Preprocessor &PP,
1790 if (Tok.
isNot(tok::l_paren)) {
1791 PP.
Diag(CommentLoc, diag::err_pragma_comment_malformed);
1797 if (Tok.
isNot(tok::identifier)) {
1798 PP.
Diag(CommentLoc, diag::err_pragma_comment_malformed);
1805 llvm::StringSwitch<Sema::PragmaMSCommentKind>(II->
getName())
1827 std::string ArgumentString;
1840 if (Tok.
isNot(tok::r_paren)) {
1846 if (Tok.
isNot(tok::eod)) {
1855 Actions.ActOnPragmaMSComment(Kind, ArgumentString);
1860 void PragmaOptimizeHandler::HandlePragma(
Preprocessor &PP,
1862 Token &FirstToken) {
1865 if (Tok.
is(tok::eod)) {
1867 <<
"clang optimize" <<
true <<
"'on' or 'off'";
1870 if (Tok.
isNot(tok::identifier)) {
1871 PP.
Diag(Tok.
getLocation(), diag::err_pragma_optimize_invalid_argument)
1878 if (II->
isStr(
"on")) {
1880 }
else if (!II->
isStr(
"off")) {
1881 PP.
Diag(Tok.
getLocation(), diag::err_pragma_optimize_invalid_argument)
1887 if (Tok.
isNot(tok::eod)) {
1893 Actions.ActOnPragmaOptimize(IsOn, FirstToken.
getLocation());
1898 Token Option,
bool ValueInParens,
1901 int OpenParens = ValueInParens ? 1 : 0;
1903 while (Tok.
isNot(tok::eod)) {
1904 if (Tok.
is(tok::l_paren))
1906 else if (Tok.
is(tok::r_paren)) {
1908 if (OpenParens == 0 && ValueInParens)
1912 ValueList.push_back(Tok);
1916 if (ValueInParens) {
1918 if (Tok.
isNot(tok::r_paren)) {
1929 ValueList.push_back(EOFTok);
1932 ValueList.size() *
sizeof(
Token), llvm::alignOf<Token>());
1933 std::copy(ValueList.begin(), ValueList.end(), TokenArray);
1934 Info.
Toks = TokenArray;
1935 Info.
TokSize = ValueList.size();
1983 void PragmaLoopHintHandler::HandlePragma(
Preprocessor &PP,
1987 Token PragmaName = Tok;
1992 if (Tok.
isNot(tok::identifier)) {
1998 while (Tok.
is(tok::identifier)) {
2002 bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->
getName())
2003 .Case(
"vectorize",
true)
2004 .Case(
"interleave",
true)
2005 .Case(
"unroll",
true)
2006 .Case(
"vectorize_width",
true)
2007 .Case(
"interleave_count",
true)
2008 .Case(
"unroll_count",
true)
2012 <<
false << OptionInfo;
2018 if (Tok.
isNot(tok::l_paren)) {
2032 LoopHintTok.
setKind(tok::annot_pragma_loop_hint);
2036 TokenList.push_back(LoopHintTok);
2039 if (Tok.
isNot(tok::eod)) {
2045 Token *TokenArray =
new Token[TokenList.size()];
2046 std::copy(TokenList.begin(), TokenList.end(), TokenArray);
2070 void PragmaUnrollHintHandler::HandlePragma(
Preprocessor &PP,
2075 Token PragmaName = Tok;
2078 if (Tok.
is(tok::eod)) {
2080 Info->PragmaName = PragmaName;
2081 Info->Option.startToken();
2090 bool ValueInParens = Tok.
is(tok::l_paren);
2102 PP.
Diag(Info->Toks[0].getLocation(),
2103 diag::warn_pragma_unroll_cuda_value_in_parens);
2105 if (Tok.
isNot(tok::eod)) {
2115 TokenArray[0].
setKind(tok::annot_pragma_loop_hint);
Defines the clang::ASTContext interface.
IdentifierLoc * PragmaNameLoc
llvm::BumpPtrAllocator & getPreprocessorAllocator()
bool CheckLoopHintExpr(Expr *E, SourceLocation Loc)
void ActOnPragmaMSStruct(PragmaMSStructKind Kind)
ActOnPragmaMSStruct - Called on well formed #pragma ms_struct [on|off].
void ActOnPragmaWeakAlias(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
void ActOnCapturedRegionStart(SourceLocation Loc, Scope *CurScope, CapturedRegionKind Kind, unsigned NumParams)
const LangOptions & getLangOpts() const
void ActOnPragmaMSSeg(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, StringLiteral *SegmentName, llvm::StringRef PragmaName)
Called on well formed #pragma bss_seg/data_seg/const_seg/code_seg.
void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler)
Add the specified pragma handler to this preprocessor.
static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName, Token Option, bool ValueInParens, PragmaLoopHintInfo &Info)
Parses loop or unroll pragma hint value and fills in Info.
virtual void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name, SourceLocation StateLoc, unsigned State)
Called when an OpenCL extension is either disabled or enabled with a pragma.
bool LexStringLiteral(Token &Result, std::string &String, const char *DiagnosticTag, bool AllowMacroExpansion)
Lex a string literal, which may be the concatenation of multiple string literals and may even come fr...
This indicates that the scope corresponds to a function, which means that labels are set here...
static IdentifierLoc * create(ASTContext &Ctx, SourceLocation Loc, IdentifierInfo *Ident)
void ActOnPragmaFPContract(tok::OnOffSwitch OOS)
bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value)
Parses a simple integer literal to get its numeric value. Floating point literals and user defined li...
void EnterToken(const Token &Tok)
Enters a token in the token stream to be lexed next.
static std::string PragmaLoopHintString(Token PragmaName, Token Option)
IdentifierLoc * OptionLoc
bool isAnyIdentifier() const
Return true if this is a raw identifier (when lexing in raw mode) or a non-keyword identifier (when l...
OpenCLOptions & getOpenCLOptions()
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
const LangOptions & getLangOpts() const
void setKind(tok::TokenKind K)
const TargetInfo & getTargetInfo() const
void ActOnPragmaMSSection(SourceLocation PragmaLocation, int SectionFlags, StringLiteral *SegmentName)
Called on well formed #pragma section().
unsigned getLength() const
void ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, SourceLocation PragmaLoc)
ActOnPragmaOptionsAlign - Called on well formed #pragma options align.
void ActOnPragmaPack(PragmaPackKind Kind, IdentifierInfo *Name, Expr *Alignment, SourceLocation PragmaLoc, SourceLocation LParenLoc, SourceLocation RParenLoc)
ActOnPragmaPack - Called on well formed #pragma pack(...).
tok::TokenKind getKind() const
const TargetInfo & getTargetInfo() const
ExprResult ActOnNumericConstant(const Token &Tok, Scope *UDLScope=nullptr)
PragmaIntroducerKind
Describes how the pragma was introduced, e.g., with #pragma, _Pragma, or __pragma.
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
void LexUnexpandedToken(Token &Result)
Just like Lex, but disables macro expansion of identifier tokens.
void * getAnnotationValue() const
Sema - This implements semantic analysis and AST building for C.
void setAnnotationValue(void *val)
StringRef getName() const
Return the actual identifier string.
void ActOnPragmaMSInitSeg(SourceLocation PragmaLocation, StringLiteral *SegmentName)
Called on well-formed #pragma init_seg().
bool LexOnOffSwitch(tok::OnOffSwitch &OOS)
Lex an on-off-switch (C99 6.10.6p2) and verify that it is followed by EOD. Return true if the token i...
Defines the clang::Preprocessor interface.
void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler)
Remove the specific pragma handler from this preprocessor.
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
void ActOnPragmaUnused(const Token &Identifier, Scope *curScope, SourceLocation PragmaLoc)
ActOnPragmaUnused - Called on well-formed '#pragma unused'.
bool isNot(tok::TokenKind K) const
virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, StringRef Str)
Callback invoked when a #pragma comment directive is read.
static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok, bool IsOptions)
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
void setLength(unsigned Len)
void ActOnPragmaMSVtorDisp(PragmaVtorDispKind Kind, SourceLocation PragmaLoc, MSVtorDispAttr::Mode Value)
Called on well formed #pragma vtordisp().
void ActOnPragmaWeakID(IdentifierInfo *WeakName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc)
ActOnPragmaWeakID - Called on well formed #pragma weak ident.
bool isValid() const
Return true if this is a valid SourceLocation object.
void setAnnotationEndLoc(SourceLocation L)
Scope * getCurScope() const
void EnterTokenStream(const Token *Toks, unsigned NumToks, bool DisableMacroExpansion, bool OwnsTokens)
Add a "macro" context to the top of the include stack, which will cause the lexer to start returning ...
StmtResult ActOnCapturedRegionEnd(Stmt *S)
void Lex(Token &Result)
Lex the next token for this preprocessor.
unsigned getCharByteWidth() const
PPCallbacks * getPPCallbacks() const
Accessors for preprocessor callbacks.
PragmaMSPointersToMembersKind
bool is(tok::TokenKind K) const
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
DiagnosticsEngine & getDiagnostics() const
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
void ActOnCapturedRegionError()
virtual void PragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value)
Callback invoked when a #pragma detect_mismatch directive is read.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
#pragma vtordisp(push, mode)
void setLiteralData(const char *Ptr)
OnOffSwitch
Defines the possible values of an on-off-switch (C99 6.10.6p2).
void ActOnPragmaMSPointersToMembers(LangOptions::PragmaMSPointersToMembersKind Kind, SourceLocation PragmaLoc)
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc)
This allows the client to specify that certain warnings are ignored.
void ActOnPragmaRedefineExtname(IdentifierInfo *WeakName, IdentifierInfo *AliasName, SourceLocation PragmaLoc, SourceLocation WeakNameLoc, SourceLocation AliasNameLoc)
This is a scope that can contain a declaration. Some scopes just contain loop constructs but don't co...
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
SourceLocation ConsumeToken()
Do not present this diagnostic, ignore it.
Sema::PragmaPackKind Kind
Defines the clang::TargetInfo interface.
void ActOnPragmaVisibility(const IdentifierInfo *VisType, SourceLocation PragmaLoc)
ActOnPragmaVisibility - Called on well formed #pragma GCC visibility... .
void DiscardUntilEndOfDirective()
Read and discard all tokens remaining on the current line until the tok::eod token is found...
ExprResult ActOnStringLiteral(ArrayRef< Token > StringToks, Scope *UDLScope=nullptr)
Loop optimization hint for loop and unroll pragmas.
void setLocation(SourceLocation L)
A trivial tuple used to represent a source range.
void startToken()
Reset all flags to cleared.
ArrayRef< SVal > ValueList
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
IdentifierInfo * getIdentifierInfo() const