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;
165 void Parser::initializePragmaHandlers() {
166 AlignHandler.reset(
new PragmaAlignHandler());
169 GCCVisibilityHandler.reset(
new PragmaGCCVisibilityHandler());
172 OptionsHandler.reset(
new PragmaOptionsHandler());
175 PackHandler.reset(
new PragmaPackHandler());
178 MSStructHandler.reset(
new PragmaMSStructHandler());
181 UnusedHandler.reset(
new PragmaUnusedHandler());
184 WeakHandler.reset(
new PragmaWeakHandler());
187 RedefineExtnameHandler.reset(
new PragmaRedefineExtnameHandler());
190 FPContractHandler.reset(
new PragmaFPContractHandler());
194 OpenCLExtensionHandler.reset(
new PragmaOpenCLExtensionHandler());
200 OpenMPHandler.reset(
new PragmaOpenMPHandler());
202 OpenMPHandler.reset(
new PragmaNoOpenMPHandler());
206 MSCommentHandler.reset(
new PragmaCommentHandler(Actions));
211 MSDetectMismatchHandler.reset(
new PragmaDetectMismatchHandler(Actions));
213 MSPointersToMembers.reset(
new PragmaMSPointersToMembers());
215 MSVtorDisp.reset(
new PragmaMSVtorDisp());
217 MSInitSeg.reset(
new PragmaMSPragma(
"init_seg"));
219 MSDataSeg.reset(
new PragmaMSPragma(
"data_seg"));
221 MSBSSSeg.reset(
new PragmaMSPragma(
"bss_seg"));
223 MSConstSeg.reset(
new PragmaMSPragma(
"const_seg"));
225 MSCodeSeg.reset(
new PragmaMSPragma(
"code_seg"));
227 MSSection.reset(
new PragmaMSPragma(
"section"));
229 MSRuntimeChecks.reset(
new PragmaMSRuntimeChecksHandler());
233 OptimizeHandler.reset(
new PragmaOptimizeHandler(Actions));
236 LoopHintHandler.reset(
new PragmaLoopHintHandler());
239 UnrollHintHandler.reset(
new PragmaUnrollHintHandler(
"unroll"));
242 NoUnrollHintHandler.reset(
new PragmaUnrollHintHandler(
"nounroll"));
246 void Parser::resetPragmaHandlers() {
249 AlignHandler.reset();
251 GCCVisibilityHandler.reset();
253 OptionsHandler.reset();
257 MSStructHandler.reset();
259 UnusedHandler.reset();
263 RedefineExtnameHandler.reset();
267 OpenCLExtensionHandler.reset();
271 OpenMPHandler.reset();
275 MSCommentHandler.reset();
280 MSDetectMismatchHandler.reset();
282 MSPointersToMembers.reset();
298 MSRuntimeChecks.reset();
302 FPContractHandler.reset();
305 OptimizeHandler.reset();
308 LoopHintHandler.reset();
311 UnrollHintHandler.reset();
314 NoUnrollHintHandler.reset();
322 void Parser::HandlePragmaUnused() {
323 assert(Tok.
is(tok::annot_pragma_unused));
329 void Parser::HandlePragmaVisibility() {
330 assert(Tok.
is(tok::annot_pragma_vis));
338 struct PragmaPackInfo {
347 void Parser::HandlePragmaPack() {
348 assert(Tok.
is(tok::annot_pragma_pack));
349 PragmaPackInfo *Info =
353 if (Info->Alignment.is(tok::numeric_constant)) {
359 Info->LParenLoc, Info->RParenLoc);
362 void Parser::HandlePragmaMSStruct() {
363 assert(Tok.
is(tok::annot_pragma_msstruct));
371 void Parser::HandlePragmaAlign() {
372 assert(Tok.
is(tok::annot_pragma_align));
380 void Parser::HandlePragmaDump() {
381 assert(Tok.
is(tok::annot_pragma_dump));
388 void Parser::HandlePragmaWeak() {
389 assert(Tok.
is(tok::annot_pragma_weak));
396 void Parser::HandlePragmaWeakAlias() {
397 assert(Tok.
is(tok::annot_pragma_weakalias));
406 WeakNameLoc, AliasNameLoc);
410 void Parser::HandlePragmaRedefineExtname() {
411 assert(Tok.
is(tok::annot_pragma_redefine_extname));
420 RedefNameLoc, AliasNameLoc);
423 void Parser::HandlePragmaFPContract() {
424 assert(Tok.
is(tok::annot_pragma_fp_contract));
434 assert(Tok.
is(tok::annot_pragma_captured));
437 if (Tok.
isNot(tok::l_brace)) {
438 PP.
Diag(Tok, diag::err_expected) << tok::l_brace;
449 CapturedRegionScope.Exit();
460 typedef llvm::PointerIntPair<IdentifierInfo *, 1, bool> OpenCLExtData;
463 void Parser::HandlePragmaOpenCLExtension() {
464 assert(Tok.
is(tok::annot_pragma_opencl_extension));
467 unsigned state = data.getInt();
476 if (state == 0 && ename->
isStr(
"all")) {
477 #define OPENCLEXT(nm) f.nm = 0;
478 #include "clang/Basic/OpenCLExtensions.def"
480 #define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; }
481 #include "clang/Basic/OpenCLExtensions.def"
483 PP.
Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
488 void Parser::HandlePragmaMSPointersToMembers() {
489 assert(Tok.
is(tok::annot_pragma_ms_pointers_to_members));
497 void Parser::HandlePragmaMSVtorDisp() {
498 assert(Tok.
is(tok::annot_pragma_ms_vtordisp));
502 MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF);
507 void Parser::HandlePragmaMSPragma() {
508 assert(Tok.
is(tok::annot_pragma_ms_pragma));
520 PragmaHandler Handler = llvm::StringSwitch<PragmaHandler>(PragmaName)
521 .Case(
"data_seg", &Parser::HandlePragmaMSSegment)
522 .Case(
"bss_seg", &Parser::HandlePragmaMSSegment)
523 .Case(
"const_seg", &Parser::HandlePragmaMSSegment)
524 .Case(
"code_seg", &Parser::HandlePragmaMSSegment)
525 .Case(
"section", &Parser::HandlePragmaMSSection)
526 .Case(
"init_seg", &Parser::HandlePragmaMSInitSeg);
528 if (!(this->*Handler)(PragmaName, PragmaLocation)) {
537 bool Parser::HandlePragmaMSSection(StringRef PragmaName,
539 if (Tok.
isNot(tok::l_paren)) {
540 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
545 if (Tok.
isNot(tok::string_literal)) {
546 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_section_name)
550 ExprResult StringResult = ParseStringLiteralExpression();
555 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
560 bool SectionFlagsAreDefault =
true;
561 while (Tok.
is(tok::comma)) {
566 if (Tok.
is(tok::kw_long) || Tok.
is(tok::kw_short)) {
572 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren)
577 llvm::StringSwitch<ASTContext::PragmaSectionFlag>(
590 ? diag::warn_pragma_invalid_specific_action
591 : diag::warn_pragma_unsupported_action)
595 SectionFlags |= Flag;
596 SectionFlagsAreDefault =
false;
601 if (SectionFlagsAreDefault)
603 if (Tok.
isNot(tok::r_paren)) {
604 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
609 PP.
Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
618 bool Parser::HandlePragmaMSSegment(StringRef PragmaName,
620 if (Tok.
isNot(tok::l_paren)) {
621 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
629 if (PushPop ==
"push")
631 else if (PushPop ==
"pop")
634 PP.
Diag(PragmaLocation,
635 diag::warn_pragma_expected_section_push_pop_or_name)
641 if (Tok.
is(tok::comma)) {
647 if (Tok.
is(tok::comma))
649 else if (Tok.
isNot(tok::r_paren)) {
650 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_punc)
655 }
else if (Tok.
isNot(tok::r_paren)) {
656 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName;
663 if (Tok.
isNot(tok::r_paren)) {
664 if (Tok.
isNot(tok::string_literal)) {
666 diag::warn_pragma_expected_section_name :
667 diag::warn_pragma_expected_section_label_or_name :
668 diag::warn_pragma_expected_section_push_pop_or_name;
669 PP.
Diag(PragmaLocation, DiagID) << PragmaName;
672 ExprResult StringResult = ParseStringLiteralExpression();
675 SegmentName = cast<StringLiteral>(StringResult.
get());
677 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
685 if (Tok.
isNot(tok::r_paren)) {
686 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
691 PP.
Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
697 SegmentName, PragmaName);
702 bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName,
704 if (
getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) {
705 PP.
Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target);
709 if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen,
717 StringRef Section = llvm::StringSwitch<StringRef>(II->getName())
718 .Case(
"compiler",
"\".CRT$XCC\"")
719 .Case(
"lib",
"\".CRT$XCL\"")
720 .Case(
"user",
"\".CRT$XCU\"")
723 if (!Section.empty()) {
727 Toks[0].
setKind(tok::string_literal);
735 }
else if (Tok.
is(tok::string_literal)) {
736 ExprResult StringResult = ParseStringLiteralExpression();
739 SegmentName = cast<StringLiteral>(StringResult.
get());
741 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
749 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName;
753 if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen,
755 ExpectAndConsume(
tok::eof, diag::warn_pragma_extra_tokens_at_eol,
764 struct PragmaLoopHintInfo {
772 std::string PragmaString;
774 PragmaString =
"clang loop ";
778 "Unexpected pragma name");
779 PragmaString =
"unroll";
784 bool Parser::HandlePragmaLoopHint(
LoopHint &Hint) {
785 assert(Tok.
is(tok::annot_pragma_loop_hint));
786 PragmaLoopHintInfo *Info =
789 IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo();
791 Actions.
Context, Info->PragmaName.getLocation(), PragmaNameInfo);
796 ? Info->Option.getIdentifierInfo()
799 Actions.
Context, Info->Option.getLocation(), OptionInfo);
801 const Token *Toks = Info->Toks.data();
802 size_t TokSize = Info->Toks.size();
806 bool PragmaUnroll = PragmaNameInfo->
getName() ==
"unroll";
807 bool PragmaNoUnroll = PragmaNameInfo->
getName() ==
"nounroll";
808 if (TokSize == 0 && (PragmaUnroll || PragmaNoUnroll)) {
810 Hint.
Range = Info->PragmaName.getLocation();
816 assert(TokSize > 0 &&
817 "PragmaLoopHintInfo::Toks must contain at least one token.");
820 bool OptionUnroll =
false;
821 bool StateOption =
false;
823 OptionUnroll = OptionInfo->isStr(
"unroll");
824 StateOption = llvm::StringSwitch<bool>(OptionInfo->getName())
825 .Case(
"vectorize",
true)
826 .Case(
"interleave",
true)
827 .Case(
"unroll",
true)
834 Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument)
835 << StateOption << OptionUnroll;
845 (!StateInfo->
isStr(
"enable") && !StateInfo->
isStr(
"disable") &&
846 ((OptionUnroll && !StateInfo->
isStr(
"full")) ||
847 (!OptionUnroll && !StateInfo->
isStr(
"assume_safety"))))) {
848 Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword)
884 Info->Toks[TokSize - 1].getLocation());
891 void PragmaGCCVisibilityHandler::HandlePragma(
Preprocessor &PP,
902 if (PushPop && PushPop->
isStr(
"pop")) {
904 }
else if (PushPop && PushPop->
isStr(
"push")) {
906 if (Tok.
isNot(tok::l_paren)) {
919 if (Tok.
isNot(tok::r_paren)) {
931 if (Tok.
isNot(tok::eod)) {
939 Toks[0].
setKind(tok::annot_pragma_vis);
943 const_cast<void*>(static_cast<const void*>(VisType)));
959 if (Tok.
isNot(tok::l_paren)) {
960 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_lparen) <<
"pack";
970 if (Tok.
is(tok::numeric_constant)) {
980 }
else if (Tok.
is(tok::identifier)) {
982 if (II->
isStr(
"show")) {
986 if (II->
isStr(
"push")) {
988 }
else if (II->
isStr(
"pop")) {
991 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_invalid_action) <<
"pack";
996 if (Tok.
is(tok::comma)) {
999 if (Tok.
is(tok::numeric_constant)) {
1003 }
else if (Tok.
is(tok::identifier)) {
1007 if (Tok.
is(tok::comma)) {
1010 if (Tok.
isNot(tok::numeric_constant)) {
1032 if (Tok.
isNot(tok::r_paren)) {
1033 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_rparen) <<
"pack";
1039 if (Tok.
isNot(tok::eod)) {
1040 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"pack";
1044 PragmaPackInfo *Info =
1046 sizeof(PragmaPackInfo), llvm::alignOf<PragmaPackInfo>());
1047 new (Info) PragmaPackInfo();
1050 Info->Alignment = Alignment;
1051 Info->LParenLoc = LParenLoc;
1052 Info->RParenLoc = RParenLoc;
1056 sizeof(
Token) * 1, llvm::alignOf<Token>());
1059 Toks[0].
setKind(tok::annot_pragma_pack);
1069 void PragmaMSStructHandler::HandlePragma(
Preprocessor &PP,
1071 Token &MSStructTok) {
1076 if (Tok.
isNot(tok::identifier)) {
1082 if (II->
isStr(
"on")) {
1086 else if (II->
isStr(
"off") || II->
isStr(
"reset"))
1093 if (Tok.
isNot(tok::eod)) {
1101 sizeof(
Token) * 1, llvm::alignOf<Token>());
1104 Toks[0].
setKind(tok::annot_pragma_msstruct);
1108 static_cast<uintptr_t>(Kind)));
1121 if (Tok.
isNot(tok::identifier) ||
1129 if (Tok.
isNot(tok::equal)) {
1136 if (Tok.
isNot(tok::identifier)) {
1138 << (IsOptions ?
"options" :
"align");
1144 if (II->
isStr(
"native"))
1146 else if (II->
isStr(
"natural"))
1148 else if (II->
isStr(
"packed"))
1150 else if (II->
isStr(
"power"))
1152 else if (II->
isStr(
"mac68k"))
1154 else if (II->
isStr(
"reset"))
1164 if (Tok.
isNot(tok::eod)) {
1166 << (IsOptions ?
"options" :
"align");
1172 sizeof(
Token) * 1, llvm::alignOf<Token>());
1175 Toks[0].
setKind(tok::annot_pragma_align);
1179 static_cast<uintptr_t>(Kind)));
1184 void PragmaAlignHandler::HandlePragma(
Preprocessor &PP,
1190 void PragmaOptionsHandler::HandlePragma(
Preprocessor &PP,
1192 Token &OptionsTok) {
1197 void PragmaUnusedHandler::HandlePragma(
Preprocessor &PP,
1206 if (Tok.
isNot(tok::l_paren)) {
1207 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_lparen) <<
"unused";
1220 if (Tok.
is(tok::identifier)) {
1221 Identifiers.push_back(Tok);
1232 if (Tok.
is(tok::comma)) {
1237 if (Tok.
is(tok::r_paren)) {
1243 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_punc) <<
"unused";
1248 if (Tok.
isNot(tok::eod)) {
1255 assert(RParenLoc.
isValid() &&
"Valid '#pragma unused' must have ')'");
1256 assert(!Identifiers.empty() &&
"Valid '#pragma unused' must have arguments");
1265 sizeof(
Token) * 2 * Identifiers.size(), llvm::alignOf<Token>());
1266 for (
unsigned i=0; i != Identifiers.size(); i++) {
1267 Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
1269 pragmaUnusedTok.
setKind(tok::annot_pragma_unused);
1271 idTok = Identifiers[i];
1286 if (Tok.
isNot(tok::identifier)) {
1287 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_identifier) <<
"weak";
1291 Token WeakName = Tok;
1292 bool HasAlias =
false;
1296 if (Tok.
is(tok::equal)) {
1299 if (Tok.
isNot(tok::identifier)) {
1308 if (Tok.
isNot(tok::eod)) {
1309 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"weak";
1316 sizeof(
Token) * 3, llvm::alignOf<Token>());
1317 Token &pragmaUnusedTok = Toks[0];
1319 pragmaUnusedTok.
setKind(tok::annot_pragma_weakalias);
1323 Toks[2] = AliasName;
1329 sizeof(
Token) * 2, llvm::alignOf<Token>());
1330 Token &pragmaUnusedTok = Toks[0];
1332 pragmaUnusedTok.
setKind(tok::annot_pragma_weak);
1342 void PragmaRedefineExtnameHandler::HandlePragma(
Preprocessor &PP,
1344 Token &RedefToken) {
1349 if (Tok.
isNot(tok::identifier)) {
1355 Token RedefName = Tok;
1358 if (Tok.
isNot(tok::identifier)) {
1360 <<
"redefine_extname";
1364 Token AliasName = Tok;
1367 if (Tok.
isNot(tok::eod)) {
1375 sizeof(
Token) * 3, llvm::alignOf<Token>());
1376 Token &pragmaRedefTok = Toks[0];
1378 pragmaRedefTok.
setKind(tok::annot_pragma_redefine_extname);
1381 Toks[1] = RedefName;
1382 Toks[2] = AliasName;
1389 PragmaFPContractHandler::HandlePragma(
Preprocessor &PP,
1398 sizeof(
Token) * 1, llvm::alignOf<Token>());
1401 Toks[0].
setKind(tok::annot_pragma_fp_contract);
1405 static_cast<uintptr_t>(OOS)));
1411 PragmaOpenCLExtensionHandler::HandlePragma(
Preprocessor &PP,
1415 if (Tok.
isNot(tok::identifier)) {
1424 if (Tok.
isNot(tok::colon)) {
1425 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_colon) << ename;
1430 if (Tok.
isNot(tok::identifier)) {
1431 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_enable_disable);
1437 if (op->
isStr(
"enable")) {
1439 }
else if (op->
isStr(
"disable")) {
1442 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_enable_disable);
1448 if (Tok.
isNot(tok::eod)) {
1454 OpenCLExtData data(ename, state);
1457 sizeof(
Token) * 1, llvm::alignOf<Token>());
1460 Toks[0].
setKind(tok::annot_pragma_opencl_extension);
1480 PP.
Diag(FirstTok, diag::warn_pragma_omp_ignored);
1496 Tok.
setKind(tok::annot_pragma_openmp);
1499 while (Tok.
isNot(tok::eod)) {
1500 Pragma.push_back(Tok);
1505 Tok.
setKind(tok::annot_pragma_openmp_end);
1507 Pragma.push_back(Tok);
1510 std::copy(Pragma.begin(), Pragma.end(), Toks);
1523 void PragmaMSPointersToMembers::HandlePragma(
Preprocessor &PP,
1528 if (Tok.
isNot(tok::l_paren)) {
1529 PP.
Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen)
1530 <<
"pointers_to_members";
1537 <<
"pointers_to_members";
1543 if (Arg->
isStr(
"best_case")) {
1546 if (Arg->
isStr(
"full_generality")) {
1547 if (Tok.
is(tok::comma)) {
1553 diag::err_pragma_pointers_to_members_unknown_kind)
1558 }
else if (Tok.
is(tok::r_paren)) {
1565 <<
"full_generality";
1571 if (Arg->
isStr(
"single_inheritance")) {
1572 RepresentationMethod =
1574 }
else if (Arg->
isStr(
"multiple_inheritance")) {
1575 RepresentationMethod =
1577 }
else if (Arg->
isStr(
"virtual_inheritance")) {
1578 RepresentationMethod =
1582 diag::err_pragma_pointers_to_members_unknown_kind)
1589 if (Tok.
isNot(tok::r_paren)) {
1591 << (Arg ? Arg->
getName() :
"full_generality");
1597 if (Tok.
isNot(tok::eod)) {
1599 <<
"pointers_to_members";
1605 AnnotTok.
setKind(tok::annot_pragma_ms_pointers_to_members);
1609 reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod)));
1626 if (Tok.
isNot(tok::l_paren)) {
1627 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) <<
"vtordisp";
1635 if (II->
isStr(
"push")) {
1638 if (Tok.
isNot(tok::comma)) {
1639 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_punc) <<
"vtordisp";
1645 }
else if (II->
isStr(
"pop")) {
1652 if (Tok.
is(tok::r_paren)) {
1662 if (II && II->
isStr(
"off")) {
1665 }
else if (II && II->
isStr(
"on")) {
1668 }
else if (Tok.
is(tok::numeric_constant) &&
1672 << 0 << 2 <<
"vtordisp";
1683 if (Tok.
isNot(tok::r_paren)) {
1684 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) <<
"vtordisp";
1689 if (Tok.
isNot(tok::eod)) {
1698 AnnotTok.
setKind(tok::annot_pragma_ms_vtordisp);
1702 static_cast<uintptr_t>((Kind << 16) | (Value & 0xFFFF))));
1711 Token EoF, AnnotTok;
1715 AnnotTok.
setKind(tok::annot_pragma_ms_pragma);
1720 for (; Tok.
isNot(tok::eod); PP.
Lex(Tok)) {
1721 TokenVector.push_back(Tok);
1725 TokenVector.push_back(EoF);
1728 Token *TokenArray =
new Token[TokenVector.size()];
1729 std::copy(TokenVector.begin(), TokenVector.end(), TokenArray);
1731 std::pair<Token*, size_t>(std::make_pair(TokenArray, TokenVector.size()));
1746 void PragmaDetectMismatchHandler::HandlePragma(
Preprocessor &PP,
1751 if (Tok.
isNot(tok::l_paren)) {
1752 PP.
Diag(CommentLoc, diag::err_expected) << tok::l_paren;
1757 std::string NameString;
1759 "pragma detect_mismatch",
1764 std::string ValueString;
1765 if (Tok.
isNot(tok::comma)) {
1766 PP.
Diag(Tok.
getLocation(), diag::err_pragma_detect_mismatch_malformed);
1774 if (Tok.
isNot(tok::r_paren)) {
1780 if (Tok.
isNot(tok::eod)) {
1781 PP.
Diag(Tok.
getLocation(), diag::err_pragma_detect_mismatch_malformed);
1790 Actions.ActOnPragmaDetectMismatch(NameString, ValueString);
1802 void PragmaCommentHandler::HandlePragma(
Preprocessor &PP,
1807 if (Tok.
isNot(tok::l_paren)) {
1808 PP.
Diag(CommentLoc, diag::err_pragma_comment_malformed);
1814 if (Tok.
isNot(tok::identifier)) {
1815 PP.
Diag(CommentLoc, diag::err_pragma_comment_malformed);
1822 llvm::StringSwitch<Sema::PragmaMSCommentKind>(II->
getName())
1844 std::string ArgumentString;
1857 if (Tok.
isNot(tok::r_paren)) {
1863 if (Tok.
isNot(tok::eod)) {
1872 Actions.ActOnPragmaMSComment(Kind, ArgumentString);
1877 void PragmaOptimizeHandler::HandlePragma(
Preprocessor &PP,
1879 Token &FirstToken) {
1882 if (Tok.
is(tok::eod)) {
1884 <<
"clang optimize" <<
true <<
"'on' or 'off'";
1887 if (Tok.
isNot(tok::identifier)) {
1888 PP.
Diag(Tok.
getLocation(), diag::err_pragma_optimize_invalid_argument)
1895 if (II->
isStr(
"on")) {
1897 }
else if (!II->
isStr(
"off")) {
1898 PP.
Diag(Tok.
getLocation(), diag::err_pragma_optimize_invalid_argument)
1904 if (Tok.
isNot(tok::eod)) {
1910 Actions.ActOnPragmaOptimize(IsOn, FirstToken.
getLocation());
1915 Token Option,
bool ValueInParens,
1916 PragmaLoopHintInfo &Info) {
1918 int OpenParens = ValueInParens ? 1 : 0;
1920 while (Tok.
isNot(tok::eod)) {
1921 if (Tok.
is(tok::l_paren))
1923 else if (Tok.
is(tok::r_paren)) {
1925 if (OpenParens == 0 && ValueInParens)
1929 ValueList.push_back(Tok);
1933 if (ValueInParens) {
1935 if (Tok.
isNot(tok::r_paren)) {
1946 ValueList.push_back(EOFTok);
1950 Info.PragmaName = PragmaName;
1951 Info.Option = Option;
2000 void PragmaLoopHintHandler::HandlePragma(
Preprocessor &PP,
2004 Token PragmaName = Tok;
2009 if (Tok.
isNot(tok::identifier)) {
2015 while (Tok.
is(tok::identifier)) {
2019 bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->
getName())
2020 .Case(
"vectorize",
true)
2021 .Case(
"interleave",
true)
2022 .Case(
"unroll",
true)
2023 .Case(
"vectorize_width",
true)
2024 .Case(
"interleave_count",
true)
2025 .Case(
"unroll_count",
true)
2029 <<
false << OptionInfo;
2035 if (Tok.
isNot(tok::l_paren)) {
2049 LoopHintTok.
setKind(tok::annot_pragma_loop_hint);
2053 TokenList.push_back(LoopHintTok);
2056 if (Tok.
isNot(tok::eod)) {
2062 Token *TokenArray =
new Token[TokenList.size()];
2063 std::copy(TokenList.begin(), TokenList.end(), TokenArray);
2087 void PragmaUnrollHintHandler::HandlePragma(
Preprocessor &PP,
2092 Token PragmaName = Tok;
2095 if (Tok.
is(tok::eod)) {
2097 Info->PragmaName = PragmaName;
2098 Info->Option.startToken();
2107 bool ValueInParens = Tok.
is(tok::l_paren);
2119 PP.
Diag(Info->Toks[0].getLocation(),
2120 diag::warn_pragma_unroll_cuda_value_in_parens);
2122 if (Tok.
isNot(tok::eod)) {
2132 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...
Parser - This implements a parser for the C family of languages.
static IdentifierLoc * create(ASTContext &Ctx, SourceLocation Loc, IdentifierInfo *Ident)
void ActOnPragmaFPContract(tok::OnOffSwitch OOS)
ActOnPragmaFPContract - Called on well formed #pragma {STDC,OPENCL} FP_CONTRACT.
bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value)
Parses a simple integer literal to get its numeric value.
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
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
One of these records is kept for each identifier that is lexed.
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
const LangOptions & getLangOpts() const
Token - This structure provides full information about a lexed token.
void setKind(tok::TokenKind K)
const TargetInfo & getTargetInfo() const
A location where the result (returned value) of evaluating a statement should be stored.
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
Forwarding function for diagnostics.
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.
EmptyPragmaHandler - A pragma handler which takes no action, which can be used to ignore particular p...
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.
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.
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
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
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.
PragmaHandler - Instances of this interface defined to handle the various pragmas that the language f...
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)
ActOnPragmaMSPointersToMembers - called on well formed #pragma pointers_to_members(representation met...
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)
ActOnPragmaRedefineExtname - Called on well formed #pragma redefine_extname oldname newname...
This is a scope that can contain a declaration.
ExprResult ParseConstantExpression(TypeCastState isTypeCast=NotTypeCast)
SourceLocation ConsumeToken()
ConsumeToken - Consume the current 'peek token' and lex the next one.
Do not present this diagnostic, ignore it.
StringLiteral - This represents a string literal expression, e.g.
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)
ActOnStringLiteral - The specified tokens were lexed as pasted string fragments (e.g.
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.
void ActOnPragmaDump(Scope *S, SourceLocation Loc, IdentifierInfo *II)
Called on #pragma clang __debug dump II.
IdentifierInfo * getIdentifierInfo() const