23 #include "llvm/ADT/StringSwitch.h"
24 using namespace clang;
31 Token &FirstToken)
override;
35 explicit PragmaGCCVisibilityHandler() :
PragmaHandler(
"visibility") {}
37 Token &FirstToken)
override;
43 Token &FirstToken)
override;
49 Token &FirstToken)
override;
53 explicit PragmaMSStructHandler() :
PragmaHandler(
"ms_struct") {}
55 Token &FirstToken)
override;
61 Token &FirstToken)
override;
67 Token &FirstToken)
override;
71 explicit PragmaRedefineExtnameHandler() :
PragmaHandler(
"redefine_extname") {}
73 Token &FirstToken)
override;
77 PragmaOpenCLExtensionHandler() :
PragmaHandler(
"EXTENSION") {}
79 Token &FirstToken)
override;
86 Token &FirstToken)
override;
92 Token &FirstToken)
override;
98 Token &FirstToken)
override;
103 PragmaCommentHandler(
Sema &Actions)
106 Token &FirstToken)
override;
112 PragmaDetectMismatchHandler(
Sema &Actions)
115 Token &FirstToken)
override;
121 explicit PragmaMSPointersToMembers() :
PragmaHandler(
"pointers_to_members") {}
123 Token &FirstToken)
override;
129 Token &FirstToken)
override;
133 explicit PragmaMSPragma(
const char *name) :
PragmaHandler(name) {}
135 Token &FirstToken)
override;
140 PragmaOptimizeHandler(
Sema &
S)
143 Token &FirstToken)
override;
151 Token &FirstToken)
override;
155 PragmaUnrollHintHandler(
const char *name) :
PragmaHandler(name) {}
157 Token &FirstToken)
override;
166 void Parser::initializePragmaHandlers() {
167 AlignHandler.reset(
new PragmaAlignHandler());
170 GCCVisibilityHandler.reset(
new PragmaGCCVisibilityHandler());
173 OptionsHandler.reset(
new PragmaOptionsHandler());
176 PackHandler.reset(
new PragmaPackHandler());
179 MSStructHandler.reset(
new PragmaMSStructHandler());
182 UnusedHandler.reset(
new PragmaUnusedHandler());
185 WeakHandler.reset(
new PragmaWeakHandler());
188 RedefineExtnameHandler.reset(
new PragmaRedefineExtnameHandler());
191 FPContractHandler.reset(
new PragmaFPContractHandler());
195 OpenCLExtensionHandler.reset(
new PragmaOpenCLExtensionHandler());
201 OpenMPHandler.reset(
new PragmaOpenMPHandler());
203 OpenMPHandler.reset(
new PragmaNoOpenMPHandler());
207 MSCommentHandler.reset(
new PragmaCommentHandler(Actions));
212 MSDetectMismatchHandler.reset(
new PragmaDetectMismatchHandler(Actions));
214 MSPointersToMembers.reset(
new PragmaMSPointersToMembers());
216 MSVtorDisp.reset(
new PragmaMSVtorDisp());
218 MSInitSeg.reset(
new PragmaMSPragma(
"init_seg"));
220 MSDataSeg.reset(
new PragmaMSPragma(
"data_seg"));
222 MSBSSSeg.reset(
new PragmaMSPragma(
"bss_seg"));
224 MSConstSeg.reset(
new PragmaMSPragma(
"const_seg"));
226 MSCodeSeg.reset(
new PragmaMSPragma(
"code_seg"));
228 MSSection.reset(
new PragmaMSPragma(
"section"));
230 MSRuntimeChecks.reset(
new PragmaMSRuntimeChecksHandler());
234 OptimizeHandler.reset(
new PragmaOptimizeHandler(Actions));
237 LoopHintHandler.reset(
new PragmaLoopHintHandler());
240 UnrollHintHandler.reset(
new PragmaUnrollHintHandler(
"unroll"));
243 NoUnrollHintHandler.reset(
new PragmaUnrollHintHandler(
"nounroll"));
247 void Parser::resetPragmaHandlers() {
250 AlignHandler.reset();
252 GCCVisibilityHandler.reset();
254 OptionsHandler.reset();
258 MSStructHandler.reset();
260 UnusedHandler.reset();
264 RedefineExtnameHandler.reset();
268 OpenCLExtensionHandler.reset();
272 OpenMPHandler.reset();
276 MSCommentHandler.reset();
281 MSDetectMismatchHandler.reset();
283 MSPointersToMembers.reset();
299 MSRuntimeChecks.reset();
303 FPContractHandler.reset();
306 OptimizeHandler.reset();
309 LoopHintHandler.reset();
312 UnrollHintHandler.reset();
315 NoUnrollHintHandler.reset();
323 void Parser::HandlePragmaUnused() {
324 assert(Tok.
is(tok::annot_pragma_unused));
330 void Parser::HandlePragmaVisibility() {
331 assert(Tok.
is(tok::annot_pragma_vis));
339 struct PragmaPackInfo {
346 void Parser::HandlePragmaPack() {
347 assert(Tok.
is(tok::annot_pragma_pack));
348 PragmaPackInfo *Info =
352 if (Info->Alignment.is(tok::numeric_constant)) {
361 void Parser::HandlePragmaMSStruct() {
362 assert(Tok.
is(tok::annot_pragma_msstruct));
369 void Parser::HandlePragmaAlign() {
370 assert(Tok.
is(tok::annot_pragma_align));
378 void Parser::HandlePragmaDump() {
379 assert(Tok.
is(tok::annot_pragma_dump));
386 void Parser::HandlePragmaWeak() {
387 assert(Tok.
is(tok::annot_pragma_weak));
394 void Parser::HandlePragmaWeakAlias() {
395 assert(Tok.
is(tok::annot_pragma_weakalias));
404 WeakNameLoc, AliasNameLoc);
408 void Parser::HandlePragmaRedefineExtname() {
409 assert(Tok.
is(tok::annot_pragma_redefine_extname));
418 RedefNameLoc, AliasNameLoc);
421 void Parser::HandlePragmaFPContract() {
422 assert(Tok.
is(tok::annot_pragma_fp_contract));
432 assert(Tok.
is(tok::annot_pragma_captured));
435 if (Tok.
isNot(tok::l_brace)) {
436 PP.
Diag(Tok, diag::err_expected) << tok::l_brace;
447 CapturedRegionScope.Exit();
458 typedef llvm::PointerIntPair<IdentifierInfo *, 1, bool> OpenCLExtData;
461 void Parser::HandlePragmaOpenCLExtension() {
462 assert(Tok.
is(tok::annot_pragma_opencl_extension));
465 unsigned state = data.getInt();
476 if (state == 0 && ename->
isStr(
"all")) {
477 #define OPENCLEXT(nm) \
478 if (Supp.is_##nm##_supported_extension(CLVer)) \
480 #include "clang/Basic/OpenCLExtensions.def"
482 #define OPENCLEXT(nm) else if (ename->isStr(#nm)) \
483 if (Supp.is_##nm##_supported_extension(CLVer)) \
485 else if (Supp.is_##nm##_supported_core(CLVer)) \
486 PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << ename; \
488 PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << ename;
489 #include "clang/Basic/OpenCLExtensions.def"
491 PP.
Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
496 void Parser::HandlePragmaMSPointersToMembers() {
497 assert(Tok.
is(tok::annot_pragma_ms_pointers_to_members));
505 void Parser::HandlePragmaMSVtorDisp() {
506 assert(Tok.
is(tok::annot_pragma_ms_vtordisp));
510 MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF);
515 void Parser::HandlePragmaMSPragma() {
516 assert(Tok.
is(tok::annot_pragma_ms_pragma));
520 PP.EnterTokenStream(std::move(TheTokens->first), TheTokens->second,
true);
529 PragmaHandler Handler = llvm::StringSwitch<PragmaHandler>(PragmaName)
530 .Case(
"data_seg", &Parser::HandlePragmaMSSegment)
531 .Case(
"bss_seg", &Parser::HandlePragmaMSSegment)
532 .Case(
"const_seg", &Parser::HandlePragmaMSSegment)
533 .Case(
"code_seg", &Parser::HandlePragmaMSSegment)
534 .Case(
"section", &Parser::HandlePragmaMSSection)
535 .Case(
"init_seg", &Parser::HandlePragmaMSInitSeg);
537 if (!(this->*Handler)(PragmaName, PragmaLocation)) {
546 bool Parser::HandlePragmaMSSection(StringRef PragmaName,
548 if (Tok.
isNot(tok::l_paren)) {
549 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
554 if (Tok.
isNot(tok::string_literal)) {
555 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_section_name)
559 ExprResult StringResult = ParseStringLiteralExpression();
564 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
569 bool SectionFlagsAreDefault =
true;
570 while (Tok.
is(tok::comma)) {
575 if (Tok.
is(tok::kw_long) || Tok.
is(tok::kw_short)) {
581 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren)
586 llvm::StringSwitch<ASTContext::PragmaSectionFlag>(
599 ? diag::warn_pragma_invalid_specific_action
600 : diag::warn_pragma_unsupported_action)
604 SectionFlags |= Flag;
605 SectionFlagsAreDefault =
false;
610 if (SectionFlagsAreDefault)
612 if (Tok.
isNot(tok::r_paren)) {
613 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
618 PP.
Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
627 bool Parser::HandlePragmaMSSegment(StringRef PragmaName,
629 if (Tok.
isNot(tok::l_paren)) {
630 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
638 if (PushPop ==
"push")
640 else if (PushPop ==
"pop")
643 PP.
Diag(PragmaLocation,
644 diag::warn_pragma_expected_section_push_pop_or_name)
650 if (Tok.
is(tok::comma)) {
656 if (Tok.
is(tok::comma))
658 else if (Tok.
isNot(tok::r_paren)) {
659 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_punc)
664 }
else if (Tok.
isNot(tok::r_paren)) {
665 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName;
672 if (Tok.
isNot(tok::r_paren)) {
673 if (Tok.
isNot(tok::string_literal)) {
675 diag::warn_pragma_expected_section_name :
676 diag::warn_pragma_expected_section_label_or_name :
677 diag::warn_pragma_expected_section_push_pop_or_name;
678 PP.
Diag(PragmaLocation, DiagID) << PragmaName;
681 ExprResult StringResult = ParseStringLiteralExpression();
684 SegmentName = cast<StringLiteral>(StringResult.
get());
686 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
694 if (Tok.
isNot(tok::r_paren)) {
695 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
700 PP.
Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
706 SegmentName, PragmaName);
711 bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName,
713 if (
getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) {
714 PP.
Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target);
718 if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen,
726 StringRef Section = llvm::StringSwitch<StringRef>(II->getName())
727 .Case(
"compiler",
"\".CRT$XCC\"")
728 .Case(
"lib",
"\".CRT$XCL\"")
729 .Case(
"user",
"\".CRT$XCU\"")
732 if (!Section.empty()) {
736 Toks[0].
setKind(tok::string_literal);
744 }
else if (Tok.
is(tok::string_literal)) {
745 ExprResult StringResult = ParseStringLiteralExpression();
748 SegmentName = cast<StringLiteral>(StringResult.
get());
750 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
758 PP.
Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName;
762 if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen,
764 ExpectAndConsume(
tok::eof, diag::warn_pragma_extra_tokens_at_eol,
773 struct PragmaLoopHintInfo {
781 std::string PragmaString;
783 PragmaString =
"clang loop ";
787 "Unexpected pragma name");
788 PragmaString =
"unroll";
793 bool Parser::HandlePragmaLoopHint(
LoopHint &Hint) {
794 assert(Tok.
is(tok::annot_pragma_loop_hint));
795 PragmaLoopHintInfo *Info =
798 IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo();
800 Actions.
Context, Info->PragmaName.getLocation(), PragmaNameInfo);
805 ? Info->Option.getIdentifierInfo()
808 Actions.
Context, Info->Option.getLocation(), OptionInfo);
814 bool PragmaUnroll = PragmaNameInfo->
getName() ==
"unroll";
815 bool PragmaNoUnroll = PragmaNameInfo->
getName() ==
"nounroll";
816 if (Toks.empty() && (PragmaUnroll || PragmaNoUnroll)) {
818 Hint.
Range = Info->PragmaName.getLocation();
824 assert(!Toks.empty() &&
825 "PragmaLoopHintInfo::Toks must contain at least one token.");
828 bool OptionUnroll =
false;
829 bool OptionDistribute =
false;
830 bool StateOption =
false;
832 OptionUnroll = OptionInfo->isStr(
"unroll");
833 OptionDistribute = OptionInfo->isStr(
"distribute");
834 StateOption = llvm::StringSwitch<bool>(OptionInfo->getName())
835 .Case(
"vectorize",
true)
836 .Case(
"interleave",
true)
838 OptionUnroll || OptionDistribute;
841 bool AssumeSafetyArg = !OptionUnroll && !OptionDistribute;
845 Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument)
846 << StateOption << OptionUnroll
857 bool Valid = StateInfo &&
858 llvm::StringSwitch<bool>(StateInfo->
getName())
859 .Cases(
"enable",
"disable",
true)
860 .Case(
"full", OptionUnroll)
861 .Case(
"assume_safety", AssumeSafetyArg)
864 Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword)
875 PP.EnterTokenStream(Toks,
false);
900 Info->Toks.back().getLocation());
907 void PragmaGCCVisibilityHandler::HandlePragma(
Preprocessor &PP,
918 if (PushPop && PushPop->
isStr(
"pop")) {
920 }
else if (PushPop && PushPop->
isStr(
"push")) {
922 if (Tok.
isNot(tok::l_paren)) {
935 if (Tok.
isNot(tok::r_paren)) {
947 if (Tok.
isNot(tok::eod)) {
953 auto Toks = llvm::make_unique<Token[]>(1);
954 Toks[0].startToken();
955 Toks[0].setKind(tok::annot_pragma_vis);
956 Toks[0].setLocation(VisLoc);
957 Toks[0].setAnnotationEndLoc(EndLoc);
958 Toks[0].setAnnotationValue(
959 const_cast<void*>(static_cast<const void*>(VisType)));
960 PP.EnterTokenStream(std::move(Toks), 1,
true);
974 if (Tok.
isNot(tok::l_paren)) {
975 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_lparen) <<
"pack";
984 if (Tok.
is(tok::numeric_constant)) {
994 }
else if (Tok.
is(tok::identifier)) {
996 if (II->
isStr(
"show")) {
1000 if (II->
isStr(
"push")) {
1002 }
else if (II->
isStr(
"pop")) {
1005 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_invalid_action) <<
"pack";
1010 if (Tok.
is(tok::comma)) {
1013 if (Tok.
is(tok::numeric_constant)) {
1018 }
else if (Tok.
is(tok::identifier)) {
1022 if (Tok.
is(tok::comma)) {
1025 if (Tok.
isNot(tok::numeric_constant)) {
1048 if (Tok.
isNot(tok::r_paren)) {
1049 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_rparen) <<
"pack";
1055 if (Tok.
isNot(tok::eod)) {
1056 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"pack";
1060 PragmaPackInfo *Info =
1063 Info->SlotLabel = SlotLabel;
1064 Info->Alignment = Alignment;
1068 Toks[0].startToken();
1069 Toks[0].setKind(tok::annot_pragma_pack);
1070 Toks[0].setLocation(PackLoc);
1071 Toks[0].setAnnotationEndLoc(RParenLoc);
1072 Toks[0].setAnnotationValue(static_cast<void*>(Info));
1073 PP.EnterTokenStream(Toks,
true);
1078 void PragmaMSStructHandler::HandlePragma(
Preprocessor &PP,
1080 Token &MSStructTok) {
1085 if (Tok.
isNot(tok::identifier)) {
1091 if (II->
isStr(
"on")) {
1095 else if (II->
isStr(
"off") || II->
isStr(
"reset"))
1102 if (Tok.
isNot(tok::eod)) {
1110 Toks[0].startToken();
1111 Toks[0].setKind(tok::annot_pragma_msstruct);
1113 Toks[0].setAnnotationEndLoc(EndLoc);
1114 Toks[0].setAnnotationValue(reinterpret_cast<void*>(
1115 static_cast<uintptr_t>(Kind)));
1116 PP.EnterTokenStream(Toks,
true);
1127 if (Tok.
isNot(tok::identifier) ||
1135 if (Tok.
isNot(tok::equal)) {
1142 if (Tok.
isNot(tok::identifier)) {
1144 << (IsOptions ?
"options" :
"align");
1150 if (II->
isStr(
"native"))
1152 else if (II->
isStr(
"natural"))
1154 else if (II->
isStr(
"packed"))
1156 else if (II->
isStr(
"power"))
1158 else if (II->
isStr(
"mac68k"))
1160 else if (II->
isStr(
"reset"))
1170 if (Tok.
isNot(tok::eod)) {
1172 << (IsOptions ?
"options" :
"align");
1178 Toks[0].startToken();
1179 Toks[0].setKind(tok::annot_pragma_align);
1181 Toks[0].setAnnotationEndLoc(EndLoc);
1182 Toks[0].setAnnotationValue(reinterpret_cast<void*>(
1183 static_cast<uintptr_t>(Kind)));
1184 PP.EnterTokenStream(Toks,
true);
1187 void PragmaAlignHandler::HandlePragma(
Preprocessor &PP,
1193 void PragmaOptionsHandler::HandlePragma(
Preprocessor &PP,
1195 Token &OptionsTok) {
1200 void PragmaUnusedHandler::HandlePragma(
Preprocessor &PP,
1209 if (Tok.
isNot(tok::l_paren)) {
1210 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_lparen) <<
"unused";
1223 if (Tok.
is(tok::identifier)) {
1224 Identifiers.push_back(Tok);
1235 if (Tok.
is(tok::comma)) {
1240 if (Tok.
is(tok::r_paren)) {
1246 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_punc) <<
"unused";
1251 if (Tok.
isNot(tok::eod)) {
1258 assert(RParenLoc.
isValid() &&
"Valid '#pragma unused' must have ')'");
1259 assert(!Identifiers.empty() &&
"Valid '#pragma unused' must have arguments");
1268 2 * Identifiers.size());
1269 for (
unsigned i=0; i != Identifiers.size(); i++) {
1270 Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
1272 pragmaUnusedTok.
setKind(tok::annot_pragma_unused);
1274 idTok = Identifiers[i];
1276 PP.EnterTokenStream(Toks,
true);
1288 if (Tok.
isNot(tok::identifier)) {
1289 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_identifier) <<
"weak";
1293 Token WeakName = Tok;
1294 bool HasAlias =
false;
1298 if (Tok.
is(tok::equal)) {
1301 if (Tok.
isNot(tok::identifier)) {
1310 if (Tok.
isNot(tok::eod)) {
1311 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"weak";
1318 Token &pragmaUnusedTok = Toks[0];
1320 pragmaUnusedTok.
setKind(tok::annot_pragma_weakalias);
1324 Toks[2] = AliasName;
1325 PP.EnterTokenStream(Toks,
true);
1329 Token &pragmaUnusedTok = Toks[0];
1331 pragmaUnusedTok.
setKind(tok::annot_pragma_weak);
1335 PP.EnterTokenStream(Toks,
true);
1340 void PragmaRedefineExtnameHandler::HandlePragma(
Preprocessor &PP,
1342 Token &RedefToken) {
1347 if (Tok.
isNot(tok::identifier)) {
1353 Token RedefName = Tok;
1356 if (Tok.
isNot(tok::identifier)) {
1358 <<
"redefine_extname";
1362 Token AliasName = Tok;
1365 if (Tok.
isNot(tok::eod)) {
1373 Token &pragmaRedefTok = Toks[0];
1375 pragmaRedefTok.
setKind(tok::annot_pragma_redefine_extname);
1378 Toks[1] = RedefName;
1379 Toks[2] = AliasName;
1380 PP.EnterTokenStream(Toks,
true);
1385 PragmaFPContractHandler::HandlePragma(
Preprocessor &PP,
1394 Toks[0].startToken();
1395 Toks[0].setKind(tok::annot_pragma_fp_contract);
1398 Toks[0].setAnnotationValue(reinterpret_cast<void*>(
1399 static_cast<uintptr_t>(OOS)));
1400 PP.EnterTokenStream(Toks,
true);
1404 PragmaOpenCLExtensionHandler::HandlePragma(
Preprocessor &PP,
1408 if (Tok.
isNot(tok::identifier)) {
1417 if (Tok.
isNot(tok::colon)) {
1418 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_colon) << ename;
1423 if (Tok.
isNot(tok::identifier)) {
1424 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_enable_disable);
1430 if (op->
isStr(
"enable")) {
1432 }
else if (op->
isStr(
"disable")) {
1435 PP.
Diag(Tok.
getLocation(), diag::warn_pragma_expected_enable_disable);
1441 if (Tok.
isNot(tok::eod)) {
1447 OpenCLExtData data(ename, state);
1450 Toks[0].startToken();
1451 Toks[0].setKind(tok::annot_pragma_opencl_extension);
1452 Toks[0].setLocation(NameLoc);
1453 Toks[0].setAnnotationValue(data.getOpaqueValue());
1454 Toks[0].setAnnotationEndLoc(StateLoc);
1455 PP.EnterTokenStream(Toks,
true);
1470 PP.
Diag(FirstTok, diag::warn_pragma_omp_ignored);
1486 Tok.
setKind(tok::annot_pragma_openmp);
1489 while (Tok.
isNot(tok::eod)) {
1490 Pragma.push_back(Tok);
1495 Tok.
setKind(tok::annot_pragma_openmp_end);
1497 Pragma.push_back(Tok);
1499 auto Toks = llvm::make_unique<Token[]>(Pragma.size());
1500 std::copy(Pragma.begin(), Pragma.end(), Toks.get());
1501 PP.EnterTokenStream(std::move(Toks), Pragma.size(),
1513 void PragmaMSPointersToMembers::HandlePragma(
Preprocessor &PP,
1518 if (Tok.
isNot(tok::l_paren)) {
1519 PP.
Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen)
1520 <<
"pointers_to_members";
1527 <<
"pointers_to_members";
1533 if (Arg->
isStr(
"best_case")) {
1536 if (Arg->
isStr(
"full_generality")) {
1537 if (Tok.
is(tok::comma)) {
1543 diag::err_pragma_pointers_to_members_unknown_kind)
1548 }
else if (Tok.
is(tok::r_paren)) {
1555 <<
"full_generality";
1561 if (Arg->
isStr(
"single_inheritance")) {
1562 RepresentationMethod =
1564 }
else if (Arg->
isStr(
"multiple_inheritance")) {
1565 RepresentationMethod =
1567 }
else if (Arg->
isStr(
"virtual_inheritance")) {
1568 RepresentationMethod =
1572 diag::err_pragma_pointers_to_members_unknown_kind)
1579 if (Tok.
isNot(tok::r_paren)) {
1581 << (Arg ? Arg->
getName() :
"full_generality");
1587 if (Tok.
isNot(tok::eod)) {
1589 <<
"pointers_to_members";
1595 AnnotTok.
setKind(tok::annot_pragma_ms_pointers_to_members);
1599 reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod)));
1616 if (Tok.
isNot(tok::l_paren)) {
1617 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) <<
"vtordisp";
1625 if (II->
isStr(
"push")) {
1628 if (Tok.
isNot(tok::comma)) {
1629 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_punc) <<
"vtordisp";
1635 }
else if (II->
isStr(
"pop")) {
1642 if (Tok.
is(tok::r_paren)) {
1652 if (II && II->
isStr(
"off")) {
1655 }
else if (II && II->
isStr(
"on")) {
1658 }
else if (Tok.
is(tok::numeric_constant) &&
1662 << 0 << 2 <<
"vtordisp";
1673 if (Tok.
isNot(tok::r_paren)) {
1674 PP.
Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) <<
"vtordisp";
1679 if (Tok.
isNot(tok::eod)) {
1688 AnnotTok.
setKind(tok::annot_pragma_ms_vtordisp);
1692 static_cast<uintptr_t>((Action << 16) | (Value & 0xFFFF))));
1701 Token EoF, AnnotTok;
1705 AnnotTok.
setKind(tok::annot_pragma_ms_pragma);
1710 for (; Tok.
isNot(tok::eod); PP.
Lex(Tok)) {
1711 TokenVector.push_back(Tok);
1715 TokenVector.push_back(EoF);
1718 auto TokenArray = llvm::make_unique<Token[]>(TokenVector.size());
1719 std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get());
1721 std::pair<std::unique_ptr<
Token[]>,
size_t>(std::move(TokenArray),
1722 TokenVector.size());
1737 void PragmaDetectMismatchHandler::HandlePragma(
Preprocessor &PP,
1742 if (Tok.
isNot(tok::l_paren)) {
1743 PP.
Diag(DetectMismatchLoc, diag::err_expected) << tok::l_paren;
1748 std::string NameString;
1750 "pragma detect_mismatch",
1755 std::string ValueString;
1756 if (Tok.
isNot(tok::comma)) {
1757 PP.
Diag(Tok.
getLocation(), diag::err_pragma_detect_mismatch_malformed);
1765 if (Tok.
isNot(tok::r_paren)) {
1771 if (Tok.
isNot(tok::eod)) {
1772 PP.
Diag(Tok.
getLocation(), diag::err_pragma_detect_mismatch_malformed);
1781 Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString);
1793 void PragmaCommentHandler::HandlePragma(
Preprocessor &PP,
1798 if (Tok.
isNot(tok::l_paren)) {
1799 PP.
Diag(CommentLoc, diag::err_pragma_comment_malformed);
1805 if (Tok.
isNot(tok::identifier)) {
1806 PP.
Diag(CommentLoc, diag::err_pragma_comment_malformed);
1813 llvm::StringSwitch<PragmaMSCommentKind>(II->
getName())
1835 std::string ArgumentString;
1848 if (Tok.
isNot(tok::r_paren)) {
1854 if (Tok.
isNot(tok::eod)) {
1863 Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString);
1868 void PragmaOptimizeHandler::HandlePragma(
Preprocessor &PP,
1870 Token &FirstToken) {
1873 if (Tok.
is(tok::eod)) {
1875 <<
"clang optimize" <<
true <<
"'on' or 'off'";
1878 if (Tok.
isNot(tok::identifier)) {
1879 PP.
Diag(Tok.
getLocation(), diag::err_pragma_optimize_invalid_argument)
1886 if (II->
isStr(
"on")) {
1888 }
else if (!II->
isStr(
"off")) {
1889 PP.
Diag(Tok.
getLocation(), diag::err_pragma_optimize_invalid_argument)
1895 if (Tok.
isNot(tok::eod)) {
1901 Actions.ActOnPragmaOptimize(IsOn, FirstToken.
getLocation());
1906 Token Option,
bool ValueInParens,
1907 PragmaLoopHintInfo &Info) {
1909 int OpenParens = ValueInParens ? 1 : 0;
1911 while (Tok.
isNot(tok::eod)) {
1912 if (Tok.
is(tok::l_paren))
1914 else if (Tok.
is(tok::r_paren)) {
1916 if (OpenParens == 0 && ValueInParens)
1920 ValueList.push_back(Tok);
1924 if (ValueInParens) {
1926 if (Tok.
isNot(tok::r_paren)) {
1937 ValueList.push_back(EOFTok);
1941 Info.PragmaName = PragmaName;
1942 Info.Option = Option;
1991 void PragmaLoopHintHandler::HandlePragma(
Preprocessor &PP,
1995 Token PragmaName = Tok;
2000 if (Tok.
isNot(tok::identifier)) {
2006 while (Tok.
is(tok::identifier)) {
2010 bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->
getName())
2011 .Case(
"vectorize",
true)
2012 .Case(
"interleave",
true)
2013 .Case(
"unroll",
true)
2014 .Case(
"distribute",
true)
2015 .Case(
"vectorize_width",
true)
2016 .Case(
"interleave_count",
true)
2017 .Case(
"unroll_count",
true)
2021 <<
false << OptionInfo;
2027 if (Tok.
isNot(tok::l_paren)) {
2041 LoopHintTok.
setKind(tok::annot_pragma_loop_hint);
2045 TokenList.push_back(LoopHintTok);
2048 if (Tok.
isNot(tok::eod)) {
2054 auto TokenArray = llvm::make_unique<Token[]>(TokenList.size());
2055 std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());
2057 PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
2078 void PragmaUnrollHintHandler::HandlePragma(
Preprocessor &PP,
2083 Token PragmaName = Tok;
2086 if (Tok.
is(tok::eod)) {
2088 Info->PragmaName = PragmaName;
2089 Info->Option.startToken();
2098 bool ValueInParens = Tok.
is(tok::l_paren);
2110 PP.
Diag(Info->Toks[0].getLocation(),
2111 diag::warn_pragma_unroll_cuda_value_in_parens);
2113 if (Tok.
isNot(tok::eod)) {
2121 auto TokenArray = llvm::make_unique<Token[]>(1);
2122 TokenArray[0].startToken();
2123 TokenArray[0].setKind(tok::annot_pragma_loop_hint);
2124 TokenArray[0].setLocation(PragmaName.
getLocation());
2125 TokenArray[0].setAnnotationEndLoc(PragmaName.
getLocation());
2126 TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
2127 PP.EnterTokenStream(std::move(TokenArray), 1,
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)
OpenCL supported extensions and optional core features.
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...
void ActOnPragmaMSVtorDisp(PragmaMsStackAction Action, SourceLocation PragmaLoc, MSVtorDispAttr::Mode Value)
Called on well formed #pragma vtordisp().
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.
const LangOptions & getLangOpts() const
Token - This structure provides full information about a lexed token.
void setKind(tok::TokenKind K)
i32 captured_struct **param SharedsTy A type which contains references the shared variables *param Shareds Context with the list of shared variables from the p *TaskFunction *param Data Additional data for task generation like final * state
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.
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.
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok, bool IsOptions)
Encodes a location in the source.
void setLength(unsigned Len)
void ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, StringRef SlotLabel, Expr *Alignment)
ActOnPragmaPack - Called on well formed #pragma pack(...).
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
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.
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.
ActionResult< Stmt * > StmtResult
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.
OpenCLOptions & getSupportedOpenCLOpts()
Get supported OpenCL extensions and optional core features.
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