1 //===--- ParsePragma.cpp - Language specific pragma parsing ---------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the language specific #pragma handlers. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "RAIIObjectsForParser.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/Basic/TargetInfo.h" 17 #include "clang/Lex/Preprocessor.h" 18 #include "clang/Parse/ParseDiagnostic.h" 19 #include "clang/Parse/Parser.h" 20 #include "clang/Sema/LoopHint.h" 21 #include "clang/Sema/Scope.h" 22 #include "llvm/ADT/StringSwitch.h" 23 using namespace clang; 24 25 namespace { 26 27 struct PragmaAlignHandler : public PragmaHandler { 28 explicit PragmaAlignHandler() : PragmaHandler("align") {} 29 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 30 Token &FirstToken) override; 31 }; 32 33 struct PragmaGCCVisibilityHandler : public PragmaHandler { 34 explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {} 35 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 36 Token &FirstToken) override; 37 }; 38 39 struct PragmaOptionsHandler : public PragmaHandler { 40 explicit PragmaOptionsHandler() : PragmaHandler("options") {} 41 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 42 Token &FirstToken) override; 43 }; 44 45 struct PragmaPackHandler : public PragmaHandler { 46 explicit PragmaPackHandler() : PragmaHandler("pack") {} 47 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 48 Token &FirstToken) override; 49 }; 50 51 struct PragmaMSStructHandler : public PragmaHandler { 52 explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {} 53 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 54 Token &FirstToken) override; 55 }; 56 57 struct PragmaUnusedHandler : public PragmaHandler { 58 PragmaUnusedHandler() : PragmaHandler("unused") {} 59 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 60 Token &FirstToken) override; 61 }; 62 63 struct PragmaWeakHandler : public PragmaHandler { 64 explicit PragmaWeakHandler() : PragmaHandler("weak") {} 65 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 66 Token &FirstToken) override; 67 }; 68 69 struct PragmaRedefineExtnameHandler : public PragmaHandler { 70 explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {} 71 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 72 Token &FirstToken) override; 73 }; 74 75 struct PragmaOpenCLExtensionHandler : public PragmaHandler { 76 PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {} 77 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 78 Token &FirstToken) override; 79 }; 80 81 82 struct PragmaFPContractHandler : public PragmaHandler { 83 PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {} 84 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 85 Token &FirstToken) override; 86 }; 87 88 struct PragmaNoOpenMPHandler : public PragmaHandler { 89 PragmaNoOpenMPHandler() : PragmaHandler("omp") { } 90 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 91 Token &FirstToken) override; 92 }; 93 94 struct PragmaOpenMPHandler : public PragmaHandler { 95 PragmaOpenMPHandler() : PragmaHandler("omp") { } 96 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 97 Token &FirstToken) override; 98 }; 99 100 /// PragmaCommentHandler - "\#pragma comment ...". 101 struct PragmaCommentHandler : public PragmaHandler { 102 PragmaCommentHandler(Sema &Actions) 103 : PragmaHandler("comment"), Actions(Actions) {} 104 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 105 Token &FirstToken) override; 106 private: 107 Sema &Actions; 108 }; 109 110 struct PragmaDetectMismatchHandler : public PragmaHandler { 111 PragmaDetectMismatchHandler(Sema &Actions) 112 : PragmaHandler("detect_mismatch"), Actions(Actions) {} 113 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 114 Token &FirstToken) override; 115 private: 116 Sema &Actions; 117 }; 118 119 struct PragmaMSPointersToMembers : public PragmaHandler { 120 explicit PragmaMSPointersToMembers() : PragmaHandler("pointers_to_members") {} 121 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 122 Token &FirstToken) override; 123 }; 124 125 struct PragmaMSVtorDisp : public PragmaHandler { 126 explicit PragmaMSVtorDisp() : PragmaHandler("vtordisp") {} 127 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 128 Token &FirstToken) override; 129 }; 130 131 struct PragmaMSPragma : public PragmaHandler { 132 explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {} 133 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 134 Token &FirstToken) override; 135 }; 136 137 /// PragmaOptimizeHandler - "\#pragma clang optimize on/off". 138 struct PragmaOptimizeHandler : public PragmaHandler { 139 PragmaOptimizeHandler(Sema &S) 140 : PragmaHandler("optimize"), Actions(S) {} 141 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 142 Token &FirstToken) override; 143 private: 144 Sema &Actions; 145 }; 146 147 struct PragmaLoopHintHandler : public PragmaHandler { 148 PragmaLoopHintHandler() : PragmaHandler("loop") {} 149 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 150 Token &FirstToken) override; 151 }; 152 153 struct PragmaUnrollHintHandler : public PragmaHandler { 154 PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {} 155 void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, 156 Token &FirstToken) override; 157 }; 158 159 } // end namespace 160 161 void Parser::initializePragmaHandlers() { 162 AlignHandler.reset(new PragmaAlignHandler()); 163 PP.AddPragmaHandler(AlignHandler.get()); 164 165 GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler()); 166 PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get()); 167 168 OptionsHandler.reset(new PragmaOptionsHandler()); 169 PP.AddPragmaHandler(OptionsHandler.get()); 170 171 PackHandler.reset(new PragmaPackHandler()); 172 PP.AddPragmaHandler(PackHandler.get()); 173 174 MSStructHandler.reset(new PragmaMSStructHandler()); 175 PP.AddPragmaHandler(MSStructHandler.get()); 176 177 UnusedHandler.reset(new PragmaUnusedHandler()); 178 PP.AddPragmaHandler(UnusedHandler.get()); 179 180 WeakHandler.reset(new PragmaWeakHandler()); 181 PP.AddPragmaHandler(WeakHandler.get()); 182 183 RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler()); 184 PP.AddPragmaHandler(RedefineExtnameHandler.get()); 185 186 FPContractHandler.reset(new PragmaFPContractHandler()); 187 PP.AddPragmaHandler("STDC", FPContractHandler.get()); 188 189 if (getLangOpts().OpenCL) { 190 OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler()); 191 PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get()); 192 193 PP.AddPragmaHandler("OPENCL", FPContractHandler.get()); 194 } 195 if (getLangOpts().OpenMP) 196 OpenMPHandler.reset(new PragmaOpenMPHandler()); 197 else 198 OpenMPHandler.reset(new PragmaNoOpenMPHandler()); 199 PP.AddPragmaHandler(OpenMPHandler.get()); 200 201 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) { 202 MSCommentHandler.reset(new PragmaCommentHandler(Actions)); 203 PP.AddPragmaHandler(MSCommentHandler.get()); 204 } 205 206 if (getLangOpts().MicrosoftExt) { 207 MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(Actions)); 208 PP.AddPragmaHandler(MSDetectMismatchHandler.get()); 209 MSPointersToMembers.reset(new PragmaMSPointersToMembers()); 210 PP.AddPragmaHandler(MSPointersToMembers.get()); 211 MSVtorDisp.reset(new PragmaMSVtorDisp()); 212 PP.AddPragmaHandler(MSVtorDisp.get()); 213 MSInitSeg.reset(new PragmaMSPragma("init_seg")); 214 PP.AddPragmaHandler(MSInitSeg.get()); 215 MSDataSeg.reset(new PragmaMSPragma("data_seg")); 216 PP.AddPragmaHandler(MSDataSeg.get()); 217 MSBSSSeg.reset(new PragmaMSPragma("bss_seg")); 218 PP.AddPragmaHandler(MSBSSSeg.get()); 219 MSConstSeg.reset(new PragmaMSPragma("const_seg")); 220 PP.AddPragmaHandler(MSConstSeg.get()); 221 MSCodeSeg.reset(new PragmaMSPragma("code_seg")); 222 PP.AddPragmaHandler(MSCodeSeg.get()); 223 MSSection.reset(new PragmaMSPragma("section")); 224 PP.AddPragmaHandler(MSSection.get()); 225 } 226 227 OptimizeHandler.reset(new PragmaOptimizeHandler(Actions)); 228 PP.AddPragmaHandler("clang", OptimizeHandler.get()); 229 230 LoopHintHandler.reset(new PragmaLoopHintHandler()); 231 PP.AddPragmaHandler("clang", LoopHintHandler.get()); 232 233 UnrollHintHandler.reset(new PragmaUnrollHintHandler("unroll")); 234 PP.AddPragmaHandler(UnrollHintHandler.get()); 235 236 NoUnrollHintHandler.reset(new PragmaUnrollHintHandler("nounroll")); 237 PP.AddPragmaHandler(NoUnrollHintHandler.get()); 238 } 239 240 void Parser::resetPragmaHandlers() { 241 // Remove the pragma handlers we installed. 242 PP.RemovePragmaHandler(AlignHandler.get()); 243 AlignHandler.reset(); 244 PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get()); 245 GCCVisibilityHandler.reset(); 246 PP.RemovePragmaHandler(OptionsHandler.get()); 247 OptionsHandler.reset(); 248 PP.RemovePragmaHandler(PackHandler.get()); 249 PackHandler.reset(); 250 PP.RemovePragmaHandler(MSStructHandler.get()); 251 MSStructHandler.reset(); 252 PP.RemovePragmaHandler(UnusedHandler.get()); 253 UnusedHandler.reset(); 254 PP.RemovePragmaHandler(WeakHandler.get()); 255 WeakHandler.reset(); 256 PP.RemovePragmaHandler(RedefineExtnameHandler.get()); 257 RedefineExtnameHandler.reset(); 258 259 if (getLangOpts().OpenCL) { 260 PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get()); 261 OpenCLExtensionHandler.reset(); 262 PP.RemovePragmaHandler("OPENCL", FPContractHandler.get()); 263 } 264 PP.RemovePragmaHandler(OpenMPHandler.get()); 265 OpenMPHandler.reset(); 266 267 if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) { 268 PP.RemovePragmaHandler(MSCommentHandler.get()); 269 MSCommentHandler.reset(); 270 } 271 272 if (getLangOpts().MicrosoftExt) { 273 PP.RemovePragmaHandler(MSDetectMismatchHandler.get()); 274 MSDetectMismatchHandler.reset(); 275 PP.RemovePragmaHandler(MSPointersToMembers.get()); 276 MSPointersToMembers.reset(); 277 PP.RemovePragmaHandler(MSVtorDisp.get()); 278 MSVtorDisp.reset(); 279 PP.RemovePragmaHandler(MSInitSeg.get()); 280 MSInitSeg.reset(); 281 PP.RemovePragmaHandler(MSDataSeg.get()); 282 MSDataSeg.reset(); 283 PP.RemovePragmaHandler(MSBSSSeg.get()); 284 MSBSSSeg.reset(); 285 PP.RemovePragmaHandler(MSConstSeg.get()); 286 MSConstSeg.reset(); 287 PP.RemovePragmaHandler(MSCodeSeg.get()); 288 MSCodeSeg.reset(); 289 PP.RemovePragmaHandler(MSSection.get()); 290 MSSection.reset(); 291 } 292 293 PP.RemovePragmaHandler("STDC", FPContractHandler.get()); 294 FPContractHandler.reset(); 295 296 PP.RemovePragmaHandler("clang", OptimizeHandler.get()); 297 OptimizeHandler.reset(); 298 299 PP.RemovePragmaHandler("clang", LoopHintHandler.get()); 300 LoopHintHandler.reset(); 301 302 PP.RemovePragmaHandler(UnrollHintHandler.get()); 303 UnrollHintHandler.reset(); 304 305 PP.RemovePragmaHandler(NoUnrollHintHandler.get()); 306 NoUnrollHintHandler.reset(); 307 } 308 309 /// \brief Handle the annotation token produced for #pragma unused(...) 310 /// 311 /// Each annot_pragma_unused is followed by the argument token so e.g. 312 /// "#pragma unused(x,y)" becomes: 313 /// annot_pragma_unused 'x' annot_pragma_unused 'y' 314 void Parser::HandlePragmaUnused() { 315 assert(Tok.is(tok::annot_pragma_unused)); 316 SourceLocation UnusedLoc = ConsumeToken(); 317 Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc); 318 ConsumeToken(); // The argument token. 319 } 320 321 void Parser::HandlePragmaVisibility() { 322 assert(Tok.is(tok::annot_pragma_vis)); 323 const IdentifierInfo *VisType = 324 static_cast<IdentifierInfo *>(Tok.getAnnotationValue()); 325 SourceLocation VisLoc = ConsumeToken(); 326 Actions.ActOnPragmaVisibility(VisType, VisLoc); 327 } 328 329 struct PragmaPackInfo { 330 Sema::PragmaPackKind Kind; 331 IdentifierInfo *Name; 332 Token Alignment; 333 SourceLocation LParenLoc; 334 SourceLocation RParenLoc; 335 }; 336 337 void Parser::HandlePragmaPack() { 338 assert(Tok.is(tok::annot_pragma_pack)); 339 PragmaPackInfo *Info = 340 static_cast<PragmaPackInfo *>(Tok.getAnnotationValue()); 341 SourceLocation PragmaLoc = ConsumeToken(); 342 ExprResult Alignment; 343 if (Info->Alignment.is(tok::numeric_constant)) { 344 Alignment = Actions.ActOnNumericConstant(Info->Alignment); 345 if (Alignment.isInvalid()) 346 return; 347 } 348 Actions.ActOnPragmaPack(Info->Kind, Info->Name, Alignment.get(), PragmaLoc, 349 Info->LParenLoc, Info->RParenLoc); 350 } 351 352 void Parser::HandlePragmaMSStruct() { 353 assert(Tok.is(tok::annot_pragma_msstruct)); 354 Sema::PragmaMSStructKind Kind = 355 static_cast<Sema::PragmaMSStructKind>( 356 reinterpret_cast<uintptr_t>(Tok.getAnnotationValue())); 357 Actions.ActOnPragmaMSStruct(Kind); 358 ConsumeToken(); // The annotation token. 359 } 360 361 void Parser::HandlePragmaAlign() { 362 assert(Tok.is(tok::annot_pragma_align)); 363 Sema::PragmaOptionsAlignKind Kind = 364 static_cast<Sema::PragmaOptionsAlignKind>( 365 reinterpret_cast<uintptr_t>(Tok.getAnnotationValue())); 366 SourceLocation PragmaLoc = ConsumeToken(); 367 Actions.ActOnPragmaOptionsAlign(Kind, PragmaLoc); 368 } 369 370 void Parser::HandlePragmaWeak() { 371 assert(Tok.is(tok::annot_pragma_weak)); 372 SourceLocation PragmaLoc = ConsumeToken(); 373 Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc, 374 Tok.getLocation()); 375 ConsumeToken(); // The weak name. 376 } 377 378 void Parser::HandlePragmaWeakAlias() { 379 assert(Tok.is(tok::annot_pragma_weakalias)); 380 SourceLocation PragmaLoc = ConsumeToken(); 381 IdentifierInfo *WeakName = Tok.getIdentifierInfo(); 382 SourceLocation WeakNameLoc = Tok.getLocation(); 383 ConsumeToken(); 384 IdentifierInfo *AliasName = Tok.getIdentifierInfo(); 385 SourceLocation AliasNameLoc = Tok.getLocation(); 386 ConsumeToken(); 387 Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc, 388 WeakNameLoc, AliasNameLoc); 389 390 } 391 392 void Parser::HandlePragmaRedefineExtname() { 393 assert(Tok.is(tok::annot_pragma_redefine_extname)); 394 SourceLocation RedefLoc = ConsumeToken(); 395 IdentifierInfo *RedefName = Tok.getIdentifierInfo(); 396 SourceLocation RedefNameLoc = Tok.getLocation(); 397 ConsumeToken(); 398 IdentifierInfo *AliasName = Tok.getIdentifierInfo(); 399 SourceLocation AliasNameLoc = Tok.getLocation(); 400 ConsumeToken(); 401 Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc, 402 RedefNameLoc, AliasNameLoc); 403 } 404 405 void Parser::HandlePragmaFPContract() { 406 assert(Tok.is(tok::annot_pragma_fp_contract)); 407 tok::OnOffSwitch OOS = 408 static_cast<tok::OnOffSwitch>( 409 reinterpret_cast<uintptr_t>(Tok.getAnnotationValue())); 410 Actions.ActOnPragmaFPContract(OOS); 411 ConsumeToken(); // The annotation token. 412 } 413 414 StmtResult Parser::HandlePragmaCaptured() 415 { 416 assert(Tok.is(tok::annot_pragma_captured)); 417 ConsumeToken(); 418 419 if (Tok.isNot(tok::l_brace)) { 420 PP.Diag(Tok, diag::err_expected) << tok::l_brace; 421 return StmtError(); 422 } 423 424 SourceLocation Loc = Tok.getLocation(); 425 426 ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope); 427 Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default, 428 /*NumParams=*/1); 429 430 StmtResult R = ParseCompoundStatement(); 431 CapturedRegionScope.Exit(); 432 433 if (R.isInvalid()) { 434 Actions.ActOnCapturedRegionError(); 435 return StmtError(); 436 } 437 438 return Actions.ActOnCapturedRegionEnd(R.get()); 439 } 440 441 namespace { 442 typedef llvm::PointerIntPair<IdentifierInfo *, 1, bool> OpenCLExtData; 443 } 444 445 void Parser::HandlePragmaOpenCLExtension() { 446 assert(Tok.is(tok::annot_pragma_opencl_extension)); 447 OpenCLExtData data = 448 OpenCLExtData::getFromOpaqueValue(Tok.getAnnotationValue()); 449 unsigned state = data.getInt(); 450 IdentifierInfo *ename = data.getPointer(); 451 SourceLocation NameLoc = Tok.getLocation(); 452 ConsumeToken(); // The annotation token. 453 454 OpenCLOptions &f = Actions.getOpenCLOptions(); 455 // OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions, 456 // overriding all previously issued extension directives, but only if the 457 // behavior is set to disable." 458 if (state == 0 && ename->isStr("all")) { 459 #define OPENCLEXT(nm) f.nm = 0; 460 #include "clang/Basic/OpenCLExtensions.def" 461 } 462 #define OPENCLEXT(nm) else if (ename->isStr(#nm)) { f.nm = state; } 463 #include "clang/Basic/OpenCLExtensions.def" 464 else { 465 PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename; 466 return; 467 } 468 } 469 470 void Parser::HandlePragmaMSPointersToMembers() { 471 assert(Tok.is(tok::annot_pragma_ms_pointers_to_members)); 472 LangOptions::PragmaMSPointersToMembersKind RepresentationMethod = 473 static_cast<LangOptions::PragmaMSPointersToMembersKind>( 474 reinterpret_cast<uintptr_t>(Tok.getAnnotationValue())); 475 SourceLocation PragmaLoc = ConsumeToken(); // The annotation token. 476 Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc); 477 } 478 479 void Parser::HandlePragmaMSVtorDisp() { 480 assert(Tok.is(tok::annot_pragma_ms_vtordisp)); 481 uintptr_t Value = reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()); 482 Sema::PragmaVtorDispKind Kind = 483 static_cast<Sema::PragmaVtorDispKind>((Value >> 16) & 0xFFFF); 484 MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF); 485 SourceLocation PragmaLoc = ConsumeToken(); // The annotation token. 486 Actions.ActOnPragmaMSVtorDisp(Kind, PragmaLoc, Mode); 487 } 488 489 void Parser::HandlePragmaMSPragma() { 490 assert(Tok.is(tok::annot_pragma_ms_pragma)); 491 // Grab the tokens out of the annotation and enter them into the stream. 492 auto TheTokens = (std::pair<Token*, size_t> *)Tok.getAnnotationValue(); 493 PP.EnterTokenStream(TheTokens->first, TheTokens->second, true, true); 494 SourceLocation PragmaLocation = ConsumeToken(); // The annotation token. 495 assert(Tok.isAnyIdentifier()); 496 StringRef PragmaName = Tok.getIdentifierInfo()->getName(); 497 PP.Lex(Tok); // pragma kind 498 499 // Figure out which #pragma we're dealing with. The switch has no default 500 // because lex shouldn't emit the annotation token for unrecognized pragmas. 501 typedef bool (Parser::*PragmaHandler)(StringRef, SourceLocation); 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); 509 510 if (!(this->*Handler)(PragmaName, PragmaLocation)) { 511 // Pragma handling failed, and has been diagnosed. Slurp up the tokens 512 // until eof (really end of line) to prevent follow-on errors. 513 while (Tok.isNot(tok::eof)) 514 PP.Lex(Tok); 515 PP.Lex(Tok); 516 } 517 } 518 519 bool Parser::HandlePragmaMSSection(StringRef PragmaName, 520 SourceLocation PragmaLocation) { 521 if (Tok.isNot(tok::l_paren)) { 522 PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName; 523 return false; 524 } 525 PP.Lex(Tok); // ( 526 // Parsing code for pragma section 527 if (Tok.isNot(tok::string_literal)) { 528 PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_name) 529 << PragmaName; 530 return false; 531 } 532 ExprResult StringResult = ParseStringLiteralExpression(); 533 if (StringResult.isInvalid()) 534 return false; // Already diagnosed. 535 StringLiteral *SegmentName = cast<StringLiteral>(StringResult.get()); 536 if (SegmentName->getCharByteWidth() != 1) { 537 PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) 538 << PragmaName; 539 return false; 540 } 541 int SectionFlags = ASTContext::PSF_Read; 542 bool SectionFlagsAreDefault = true; 543 while (Tok.is(tok::comma)) { 544 PP.Lex(Tok); // , 545 // Ignore "long" and "short". 546 // They are undocumented, but widely used, section attributes which appear 547 // to do nothing. 548 if (Tok.is(tok::kw_long) || Tok.is(tok::kw_short)) { 549 PP.Lex(Tok); // long/short 550 continue; 551 } 552 553 if (!Tok.isAnyIdentifier()) { 554 PP.Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren) 555 << PragmaName; 556 return false; 557 } 558 ASTContext::PragmaSectionFlag Flag = 559 llvm::StringSwitch<ASTContext::PragmaSectionFlag>( 560 Tok.getIdentifierInfo()->getName()) 561 .Case("read", ASTContext::PSF_Read) 562 .Case("write", ASTContext::PSF_Write) 563 .Case("execute", ASTContext::PSF_Execute) 564 .Case("shared", ASTContext::PSF_Invalid) 565 .Case("nopage", ASTContext::PSF_Invalid) 566 .Case("nocache", ASTContext::PSF_Invalid) 567 .Case("discard", ASTContext::PSF_Invalid) 568 .Case("remove", ASTContext::PSF_Invalid) 569 .Default(ASTContext::PSF_None); 570 if (Flag == ASTContext::PSF_None || Flag == ASTContext::PSF_Invalid) { 571 PP.Diag(PragmaLocation, Flag == ASTContext::PSF_None 572 ? diag::warn_pragma_invalid_specific_action 573 : diag::warn_pragma_unsupported_action) 574 << PragmaName << Tok.getIdentifierInfo()->getName(); 575 return false; 576 } 577 SectionFlags |= Flag; 578 SectionFlagsAreDefault = false; 579 PP.Lex(Tok); // Identifier 580 } 581 // If no section attributes are specified, the section will be marked as 582 // read/write. 583 if (SectionFlagsAreDefault) 584 SectionFlags |= ASTContext::PSF_Write; 585 if (Tok.isNot(tok::r_paren)) { 586 PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName; 587 return false; 588 } 589 PP.Lex(Tok); // ) 590 if (Tok.isNot(tok::eof)) { 591 PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol) 592 << PragmaName; 593 return false; 594 } 595 PP.Lex(Tok); // eof 596 Actions.ActOnPragmaMSSection(PragmaLocation, SectionFlags, SegmentName); 597 return true; 598 } 599 600 bool Parser::HandlePragmaMSSegment(StringRef PragmaName, 601 SourceLocation PragmaLocation) { 602 if (Tok.isNot(tok::l_paren)) { 603 PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName; 604 return false; 605 } 606 PP.Lex(Tok); // ( 607 Sema::PragmaMsStackAction Action = Sema::PSK_Reset; 608 StringRef SlotLabel; 609 if (Tok.isAnyIdentifier()) { 610 StringRef PushPop = Tok.getIdentifierInfo()->getName(); 611 if (PushPop == "push") 612 Action = Sema::PSK_Push; 613 else if (PushPop == "pop") 614 Action = Sema::PSK_Pop; 615 else { 616 PP.Diag(PragmaLocation, 617 diag::warn_pragma_expected_section_push_pop_or_name) 618 << PragmaName; 619 return false; 620 } 621 if (Action != Sema::PSK_Reset) { 622 PP.Lex(Tok); // push | pop 623 if (Tok.is(tok::comma)) { 624 PP.Lex(Tok); // , 625 // If we've got a comma, we either need a label or a string. 626 if (Tok.isAnyIdentifier()) { 627 SlotLabel = Tok.getIdentifierInfo()->getName(); 628 PP.Lex(Tok); // identifier 629 if (Tok.is(tok::comma)) 630 PP.Lex(Tok); 631 else if (Tok.isNot(tok::r_paren)) { 632 PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) 633 << PragmaName; 634 return false; 635 } 636 } 637 } else if (Tok.isNot(tok::r_paren)) { 638 PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName; 639 return false; 640 } 641 } 642 } 643 // Grab the string literal for our section name. 644 StringLiteral *SegmentName = nullptr; 645 if (Tok.isNot(tok::r_paren)) { 646 if (Tok.isNot(tok::string_literal)) { 647 unsigned DiagID = Action != Sema::PSK_Reset ? !SlotLabel.empty() ? 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; 652 return false; 653 } 654 ExprResult StringResult = ParseStringLiteralExpression(); 655 if (StringResult.isInvalid()) 656 return false; // Already diagnosed. 657 SegmentName = cast<StringLiteral>(StringResult.get()); 658 if (SegmentName->getCharByteWidth() != 1) { 659 PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) 660 << PragmaName; 661 return false; 662 } 663 // Setting section "" has no effect 664 if (SegmentName->getLength()) 665 Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set); 666 } 667 if (Tok.isNot(tok::r_paren)) { 668 PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName; 669 return false; 670 } 671 PP.Lex(Tok); // ) 672 if (Tok.isNot(tok::eof)) { 673 PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol) 674 << PragmaName; 675 return false; 676 } 677 PP.Lex(Tok); // eof 678 Actions.ActOnPragmaMSSeg(PragmaLocation, Action, SlotLabel, 679 SegmentName, PragmaName); 680 return true; 681 } 682 683 // #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} ) 684 bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName, 685 SourceLocation PragmaLocation) { 686 if (getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) { 687 PP.Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target); 688 return false; 689 } 690 691 if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen, 692 PragmaName)) 693 return false; 694 695 // Parse either the known section names or the string section name. 696 StringLiteral *SegmentName = nullptr; 697 if (Tok.isAnyIdentifier()) { 698 auto *II = Tok.getIdentifierInfo(); 699 StringRef Section = llvm::StringSwitch<StringRef>(II->getName()) 700 .Case("compiler", "\".CRT$XCC\"") 701 .Case("lib", "\".CRT$XCL\"") 702 .Case("user", "\".CRT$XCU\"") 703 .Default(""); 704 705 if (!Section.empty()) { 706 // Pretend the user wrote the appropriate string literal here. 707 Token Toks[1]; 708 Toks[0].startToken(); 709 Toks[0].setKind(tok::string_literal); 710 Toks[0].setLocation(Tok.getLocation()); 711 Toks[0].setLiteralData(Section.data()); 712 Toks[0].setLength(Section.size()); 713 SegmentName = 714 cast<StringLiteral>(Actions.ActOnStringLiteral(Toks, nullptr).get()); 715 PP.Lex(Tok); 716 } 717 } else if (Tok.is(tok::string_literal)) { 718 ExprResult StringResult = ParseStringLiteralExpression(); 719 if (StringResult.isInvalid()) 720 return false; 721 SegmentName = cast<StringLiteral>(StringResult.get()); 722 if (SegmentName->getCharByteWidth() != 1) { 723 PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string) 724 << PragmaName; 725 return false; 726 } 727 // FIXME: Add support for the '[, func-name]' part of the pragma. 728 } 729 730 if (!SegmentName) { 731 PP.Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName; 732 return false; 733 } 734 735 if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen, 736 PragmaName) || 737 ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol, 738 PragmaName)) 739 return false; 740 741 Actions.ActOnPragmaMSInitSeg(PragmaLocation, SegmentName); 742 return true; 743 } 744 745 struct PragmaLoopHintInfo { 746 Token PragmaName; 747 Token Option; 748 Token *Toks; 749 size_t TokSize; 750 PragmaLoopHintInfo() : Toks(nullptr), TokSize(0) {} 751 }; 752 753 static std::string PragmaLoopHintString(Token PragmaName, Token Option) { 754 std::string PragmaString; 755 if (PragmaName.getIdentifierInfo()->getName() == "loop") { 756 PragmaString = "clang loop "; 757 PragmaString += Option.getIdentifierInfo()->getName(); 758 } else { 759 assert(PragmaName.getIdentifierInfo()->getName() == "unroll" && 760 "Unexpected pragma name"); 761 PragmaString = "unroll"; 762 } 763 return PragmaString; 764 } 765 766 bool Parser::HandlePragmaLoopHint(LoopHint &Hint) { 767 assert(Tok.is(tok::annot_pragma_loop_hint)); 768 PragmaLoopHintInfo *Info = 769 static_cast<PragmaLoopHintInfo *>(Tok.getAnnotationValue()); 770 771 IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo(); 772 Hint.PragmaNameLoc = IdentifierLoc::create( 773 Actions.Context, Info->PragmaName.getLocation(), PragmaNameInfo); 774 775 // It is possible that the loop hint has no option identifier, such as 776 // #pragma unroll(4). 777 IdentifierInfo *OptionInfo = Info->Option.is(tok::identifier) 778 ? Info->Option.getIdentifierInfo() 779 : nullptr; 780 Hint.OptionLoc = IdentifierLoc::create( 781 Actions.Context, Info->Option.getLocation(), OptionInfo); 782 783 Token *Toks = Info->Toks; 784 size_t TokSize = Info->TokSize; 785 786 // Return a valid hint if pragma unroll or nounroll were specified 787 // without an argument. 788 bool PragmaUnroll = PragmaNameInfo->getName() == "unroll"; 789 bool PragmaNoUnroll = PragmaNameInfo->getName() == "nounroll"; 790 if (TokSize == 0 && (PragmaUnroll || PragmaNoUnroll)) { 791 ConsumeToken(); // The annotation token. 792 Hint.Range = Info->PragmaName.getLocation(); 793 return true; 794 } 795 796 // The constant expression is always followed by an eof token, which increases 797 // the TokSize by 1. 798 assert(TokSize > 0 && 799 "PragmaLoopHintInfo::Toks must contain at least one token."); 800 801 // If no option is specified the argument is assumed to be a constant expr. 802 bool StateOption = false; 803 if (OptionInfo) { // Pragma unroll does not specify an option. 804 StateOption = llvm::StringSwitch<bool>(OptionInfo->getName()) 805 .Case("vectorize", true) 806 .Case("interleave", true) 807 .Case("unroll", true) 808 .Default(false); 809 } 810 811 // Verify loop hint has an argument. 812 if (Toks[0].is(tok::eof)) { 813 ConsumeToken(); // The annotation token. 814 Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument) 815 << /*StateArgument=*/StateOption << /*FullKeyword=*/PragmaUnroll; 816 return false; 817 } 818 819 // Validate the argument. 820 if (StateOption) { 821 ConsumeToken(); // The annotation token. 822 bool OptionUnroll = OptionInfo->isStr("unroll"); 823 SourceLocation StateLoc = Toks[0].getLocation(); 824 IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo(); 825 if (!StateInfo || ((OptionUnroll ? !StateInfo->isStr("full") 826 : !StateInfo->isStr("enable")) && 827 !StateInfo->isStr("disable"))) { 828 Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword) 829 << /*FullKeyword=*/OptionUnroll; 830 return false; 831 } 832 if (TokSize > 2) 833 Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 834 << PragmaLoopHintString(Info->PragmaName, Info->Option); 835 Hint.StateLoc = IdentifierLoc::create(Actions.Context, StateLoc, StateInfo); 836 } else { 837 // Enter constant expression including eof terminator into token stream. 838 PP.EnterTokenStream(Toks, TokSize, /*DisableMacroExpansion=*/false, 839 /*OwnsTokens=*/false); 840 ConsumeToken(); // The annotation token. 841 842 ExprResult R = ParseConstantExpression(); 843 844 // Tokens following an error in an ill-formed constant expression will 845 // remain in the token stream and must be removed. 846 if (Tok.isNot(tok::eof)) { 847 Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 848 << PragmaLoopHintString(Info->PragmaName, Info->Option); 849 while (Tok.isNot(tok::eof)) 850 ConsumeAnyToken(); 851 } 852 853 ConsumeToken(); // Consume the constant expression eof terminator. 854 855 if (R.isInvalid() || 856 Actions.CheckLoopHintExpr(R.get(), Toks[0].getLocation())) 857 return false; 858 859 // Argument is a constant expression with an integer type. 860 Hint.ValueExpr = R.get(); 861 } 862 863 Hint.Range = SourceRange(Info->PragmaName.getLocation(), 864 Info->Toks[TokSize - 1].getLocation()); 865 return true; 866 } 867 868 // #pragma GCC visibility comes in two variants: 869 // 'push' '(' [visibility] ')' 870 // 'pop' 871 void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP, 872 PragmaIntroducerKind Introducer, 873 Token &VisTok) { 874 SourceLocation VisLoc = VisTok.getLocation(); 875 876 Token Tok; 877 PP.LexUnexpandedToken(Tok); 878 879 const IdentifierInfo *PushPop = Tok.getIdentifierInfo(); 880 881 const IdentifierInfo *VisType; 882 if (PushPop && PushPop->isStr("pop")) { 883 VisType = nullptr; 884 } else if (PushPop && PushPop->isStr("push")) { 885 PP.LexUnexpandedToken(Tok); 886 if (Tok.isNot(tok::l_paren)) { 887 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) 888 << "visibility"; 889 return; 890 } 891 PP.LexUnexpandedToken(Tok); 892 VisType = Tok.getIdentifierInfo(); 893 if (!VisType) { 894 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) 895 << "visibility"; 896 return; 897 } 898 PP.LexUnexpandedToken(Tok); 899 if (Tok.isNot(tok::r_paren)) { 900 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) 901 << "visibility"; 902 return; 903 } 904 } else { 905 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) 906 << "visibility"; 907 return; 908 } 909 SourceLocation EndLoc = Tok.getLocation(); 910 PP.LexUnexpandedToken(Tok); 911 if (Tok.isNot(tok::eod)) { 912 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 913 << "visibility"; 914 return; 915 } 916 917 Token *Toks = new Token[1]; 918 Toks[0].startToken(); 919 Toks[0].setKind(tok::annot_pragma_vis); 920 Toks[0].setLocation(VisLoc); 921 Toks[0].setAnnotationEndLoc(EndLoc); 922 Toks[0].setAnnotationValue( 923 const_cast<void*>(static_cast<const void*>(VisType))); 924 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, 925 /*OwnsTokens=*/true); 926 } 927 928 // #pragma pack(...) comes in the following delicious flavors: 929 // pack '(' [integer] ')' 930 // pack '(' 'show' ')' 931 // pack '(' ('push' | 'pop') [',' identifier] [, integer] ')' 932 void PragmaPackHandler::HandlePragma(Preprocessor &PP, 933 PragmaIntroducerKind Introducer, 934 Token &PackTok) { 935 SourceLocation PackLoc = PackTok.getLocation(); 936 937 Token Tok; 938 PP.Lex(Tok); 939 if (Tok.isNot(tok::l_paren)) { 940 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack"; 941 return; 942 } 943 944 Sema::PragmaPackKind Kind = Sema::PPK_Default; 945 IdentifierInfo *Name = nullptr; 946 Token Alignment; 947 Alignment.startToken(); 948 SourceLocation LParenLoc = Tok.getLocation(); 949 PP.Lex(Tok); 950 if (Tok.is(tok::numeric_constant)) { 951 Alignment = Tok; 952 953 PP.Lex(Tok); 954 955 // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting 956 // the push/pop stack. 957 // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4) 958 if (PP.getLangOpts().ApplePragmaPack) 959 Kind = Sema::PPK_Push; 960 } else if (Tok.is(tok::identifier)) { 961 const IdentifierInfo *II = Tok.getIdentifierInfo(); 962 if (II->isStr("show")) { 963 Kind = Sema::PPK_Show; 964 PP.Lex(Tok); 965 } else { 966 if (II->isStr("push")) { 967 Kind = Sema::PPK_Push; 968 } else if (II->isStr("pop")) { 969 Kind = Sema::PPK_Pop; 970 } else { 971 PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "pack"; 972 return; 973 } 974 PP.Lex(Tok); 975 976 if (Tok.is(tok::comma)) { 977 PP.Lex(Tok); 978 979 if (Tok.is(tok::numeric_constant)) { 980 Alignment = Tok; 981 982 PP.Lex(Tok); 983 } else if (Tok.is(tok::identifier)) { 984 Name = Tok.getIdentifierInfo(); 985 PP.Lex(Tok); 986 987 if (Tok.is(tok::comma)) { 988 PP.Lex(Tok); 989 990 if (Tok.isNot(tok::numeric_constant)) { 991 PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed); 992 return; 993 } 994 995 Alignment = Tok; 996 997 PP.Lex(Tok); 998 } 999 } else { 1000 PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed); 1001 return; 1002 } 1003 } 1004 } 1005 } else if (PP.getLangOpts().ApplePragmaPack) { 1006 // In MSVC/gcc, #pragma pack() resets the alignment without affecting 1007 // the push/pop stack. 1008 // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop). 1009 Kind = Sema::PPK_Pop; 1010 } 1011 1012 if (Tok.isNot(tok::r_paren)) { 1013 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack"; 1014 return; 1015 } 1016 1017 SourceLocation RParenLoc = Tok.getLocation(); 1018 PP.Lex(Tok); 1019 if (Tok.isNot(tok::eod)) { 1020 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack"; 1021 return; 1022 } 1023 1024 PragmaPackInfo *Info = 1025 (PragmaPackInfo*) PP.getPreprocessorAllocator().Allocate( 1026 sizeof(PragmaPackInfo), llvm::alignOf<PragmaPackInfo>()); 1027 new (Info) PragmaPackInfo(); 1028 Info->Kind = Kind; 1029 Info->Name = Name; 1030 Info->Alignment = Alignment; 1031 Info->LParenLoc = LParenLoc; 1032 Info->RParenLoc = RParenLoc; 1033 1034 Token *Toks = 1035 (Token*) PP.getPreprocessorAllocator().Allocate( 1036 sizeof(Token) * 1, llvm::alignOf<Token>()); 1037 new (Toks) Token(); 1038 Toks[0].startToken(); 1039 Toks[0].setKind(tok::annot_pragma_pack); 1040 Toks[0].setLocation(PackLoc); 1041 Toks[0].setAnnotationEndLoc(RParenLoc); 1042 Toks[0].setAnnotationValue(static_cast<void*>(Info)); 1043 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, 1044 /*OwnsTokens=*/false); 1045 } 1046 1047 // #pragma ms_struct on 1048 // #pragma ms_struct off 1049 void PragmaMSStructHandler::HandlePragma(Preprocessor &PP, 1050 PragmaIntroducerKind Introducer, 1051 Token &MSStructTok) { 1052 Sema::PragmaMSStructKind Kind = Sema::PMSST_OFF; 1053 1054 Token Tok; 1055 PP.Lex(Tok); 1056 if (Tok.isNot(tok::identifier)) { 1057 PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct); 1058 return; 1059 } 1060 SourceLocation EndLoc = Tok.getLocation(); 1061 const IdentifierInfo *II = Tok.getIdentifierInfo(); 1062 if (II->isStr("on")) { 1063 Kind = Sema::PMSST_ON; 1064 PP.Lex(Tok); 1065 } 1066 else if (II->isStr("off") || II->isStr("reset")) 1067 PP.Lex(Tok); 1068 else { 1069 PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct); 1070 return; 1071 } 1072 1073 if (Tok.isNot(tok::eod)) { 1074 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 1075 << "ms_struct"; 1076 return; 1077 } 1078 1079 Token *Toks = 1080 (Token*) PP.getPreprocessorAllocator().Allocate( 1081 sizeof(Token) * 1, llvm::alignOf<Token>()); 1082 new (Toks) Token(); 1083 Toks[0].startToken(); 1084 Toks[0].setKind(tok::annot_pragma_msstruct); 1085 Toks[0].setLocation(MSStructTok.getLocation()); 1086 Toks[0].setAnnotationEndLoc(EndLoc); 1087 Toks[0].setAnnotationValue(reinterpret_cast<void*>( 1088 static_cast<uintptr_t>(Kind))); 1089 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, 1090 /*OwnsTokens=*/false); 1091 } 1092 1093 // #pragma 'align' '=' {'native','natural','mac68k','power','reset'} 1094 // #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'} 1095 static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok, 1096 bool IsOptions) { 1097 Token Tok; 1098 1099 if (IsOptions) { 1100 PP.Lex(Tok); 1101 if (Tok.isNot(tok::identifier) || 1102 !Tok.getIdentifierInfo()->isStr("align")) { 1103 PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align); 1104 return; 1105 } 1106 } 1107 1108 PP.Lex(Tok); 1109 if (Tok.isNot(tok::equal)) { 1110 PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal) 1111 << IsOptions; 1112 return; 1113 } 1114 1115 PP.Lex(Tok); 1116 if (Tok.isNot(tok::identifier)) { 1117 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) 1118 << (IsOptions ? "options" : "align"); 1119 return; 1120 } 1121 1122 Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural; 1123 const IdentifierInfo *II = Tok.getIdentifierInfo(); 1124 if (II->isStr("native")) 1125 Kind = Sema::POAK_Native; 1126 else if (II->isStr("natural")) 1127 Kind = Sema::POAK_Natural; 1128 else if (II->isStr("packed")) 1129 Kind = Sema::POAK_Packed; 1130 else if (II->isStr("power")) 1131 Kind = Sema::POAK_Power; 1132 else if (II->isStr("mac68k")) 1133 Kind = Sema::POAK_Mac68k; 1134 else if (II->isStr("reset")) 1135 Kind = Sema::POAK_Reset; 1136 else { 1137 PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option) 1138 << IsOptions; 1139 return; 1140 } 1141 1142 SourceLocation EndLoc = Tok.getLocation(); 1143 PP.Lex(Tok); 1144 if (Tok.isNot(tok::eod)) { 1145 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 1146 << (IsOptions ? "options" : "align"); 1147 return; 1148 } 1149 1150 Token *Toks = 1151 (Token*) PP.getPreprocessorAllocator().Allocate( 1152 sizeof(Token) * 1, llvm::alignOf<Token>()); 1153 new (Toks) Token(); 1154 Toks[0].startToken(); 1155 Toks[0].setKind(tok::annot_pragma_align); 1156 Toks[0].setLocation(FirstTok.getLocation()); 1157 Toks[0].setAnnotationEndLoc(EndLoc); 1158 Toks[0].setAnnotationValue(reinterpret_cast<void*>( 1159 static_cast<uintptr_t>(Kind))); 1160 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, 1161 /*OwnsTokens=*/false); 1162 } 1163 1164 void PragmaAlignHandler::HandlePragma(Preprocessor &PP, 1165 PragmaIntroducerKind Introducer, 1166 Token &AlignTok) { 1167 ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false); 1168 } 1169 1170 void PragmaOptionsHandler::HandlePragma(Preprocessor &PP, 1171 PragmaIntroducerKind Introducer, 1172 Token &OptionsTok) { 1173 ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true); 1174 } 1175 1176 // #pragma unused(identifier) 1177 void PragmaUnusedHandler::HandlePragma(Preprocessor &PP, 1178 PragmaIntroducerKind Introducer, 1179 Token &UnusedTok) { 1180 // FIXME: Should we be expanding macros here? My guess is no. 1181 SourceLocation UnusedLoc = UnusedTok.getLocation(); 1182 1183 // Lex the left '('. 1184 Token Tok; 1185 PP.Lex(Tok); 1186 if (Tok.isNot(tok::l_paren)) { 1187 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused"; 1188 return; 1189 } 1190 1191 // Lex the declaration reference(s). 1192 SmallVector<Token, 5> Identifiers; 1193 SourceLocation RParenLoc; 1194 bool LexID = true; 1195 1196 while (true) { 1197 PP.Lex(Tok); 1198 1199 if (LexID) { 1200 if (Tok.is(tok::identifier)) { 1201 Identifiers.push_back(Tok); 1202 LexID = false; 1203 continue; 1204 } 1205 1206 // Illegal token! 1207 PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var); 1208 return; 1209 } 1210 1211 // We are execting a ')' or a ','. 1212 if (Tok.is(tok::comma)) { 1213 LexID = true; 1214 continue; 1215 } 1216 1217 if (Tok.is(tok::r_paren)) { 1218 RParenLoc = Tok.getLocation(); 1219 break; 1220 } 1221 1222 // Illegal token! 1223 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused"; 1224 return; 1225 } 1226 1227 PP.Lex(Tok); 1228 if (Tok.isNot(tok::eod)) { 1229 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << 1230 "unused"; 1231 return; 1232 } 1233 1234 // Verify that we have a location for the right parenthesis. 1235 assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'"); 1236 assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments"); 1237 1238 // For each identifier token, insert into the token stream a 1239 // annot_pragma_unused token followed by the identifier token. 1240 // This allows us to cache a "#pragma unused" that occurs inside an inline 1241 // C++ member function. 1242 1243 Token *Toks = 1244 (Token*) PP.getPreprocessorAllocator().Allocate( 1245 sizeof(Token) * 2 * Identifiers.size(), llvm::alignOf<Token>()); 1246 for (unsigned i=0; i != Identifiers.size(); i++) { 1247 Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1]; 1248 pragmaUnusedTok.startToken(); 1249 pragmaUnusedTok.setKind(tok::annot_pragma_unused); 1250 pragmaUnusedTok.setLocation(UnusedLoc); 1251 idTok = Identifiers[i]; 1252 } 1253 PP.EnterTokenStream(Toks, 2*Identifiers.size(), 1254 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); 1255 } 1256 1257 // #pragma weak identifier 1258 // #pragma weak identifier '=' identifier 1259 void PragmaWeakHandler::HandlePragma(Preprocessor &PP, 1260 PragmaIntroducerKind Introducer, 1261 Token &WeakTok) { 1262 SourceLocation WeakLoc = WeakTok.getLocation(); 1263 1264 Token Tok; 1265 PP.Lex(Tok); 1266 if (Tok.isNot(tok::identifier)) { 1267 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak"; 1268 return; 1269 } 1270 1271 Token WeakName = Tok; 1272 bool HasAlias = false; 1273 Token AliasName; 1274 1275 PP.Lex(Tok); 1276 if (Tok.is(tok::equal)) { 1277 HasAlias = true; 1278 PP.Lex(Tok); 1279 if (Tok.isNot(tok::identifier)) { 1280 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) 1281 << "weak"; 1282 return; 1283 } 1284 AliasName = Tok; 1285 PP.Lex(Tok); 1286 } 1287 1288 if (Tok.isNot(tok::eod)) { 1289 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak"; 1290 return; 1291 } 1292 1293 if (HasAlias) { 1294 Token *Toks = 1295 (Token*) PP.getPreprocessorAllocator().Allocate( 1296 sizeof(Token) * 3, llvm::alignOf<Token>()); 1297 Token &pragmaUnusedTok = Toks[0]; 1298 pragmaUnusedTok.startToken(); 1299 pragmaUnusedTok.setKind(tok::annot_pragma_weakalias); 1300 pragmaUnusedTok.setLocation(WeakLoc); 1301 pragmaUnusedTok.setAnnotationEndLoc(AliasName.getLocation()); 1302 Toks[1] = WeakName; 1303 Toks[2] = AliasName; 1304 PP.EnterTokenStream(Toks, 3, 1305 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); 1306 } else { 1307 Token *Toks = 1308 (Token*) PP.getPreprocessorAllocator().Allocate( 1309 sizeof(Token) * 2, llvm::alignOf<Token>()); 1310 Token &pragmaUnusedTok = Toks[0]; 1311 pragmaUnusedTok.startToken(); 1312 pragmaUnusedTok.setKind(tok::annot_pragma_weak); 1313 pragmaUnusedTok.setLocation(WeakLoc); 1314 pragmaUnusedTok.setAnnotationEndLoc(WeakLoc); 1315 Toks[1] = WeakName; 1316 PP.EnterTokenStream(Toks, 2, 1317 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); 1318 } 1319 } 1320 1321 // #pragma redefine_extname identifier identifier 1322 void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP, 1323 PragmaIntroducerKind Introducer, 1324 Token &RedefToken) { 1325 SourceLocation RedefLoc = RedefToken.getLocation(); 1326 1327 Token Tok; 1328 PP.Lex(Tok); 1329 if (Tok.isNot(tok::identifier)) { 1330 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << 1331 "redefine_extname"; 1332 return; 1333 } 1334 1335 Token RedefName = Tok; 1336 PP.Lex(Tok); 1337 1338 if (Tok.isNot(tok::identifier)) { 1339 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) 1340 << "redefine_extname"; 1341 return; 1342 } 1343 1344 Token AliasName = Tok; 1345 PP.Lex(Tok); 1346 1347 if (Tok.isNot(tok::eod)) { 1348 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << 1349 "redefine_extname"; 1350 return; 1351 } 1352 1353 Token *Toks = 1354 (Token*) PP.getPreprocessorAllocator().Allocate( 1355 sizeof(Token) * 3, llvm::alignOf<Token>()); 1356 Token &pragmaRedefTok = Toks[0]; 1357 pragmaRedefTok.startToken(); 1358 pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname); 1359 pragmaRedefTok.setLocation(RedefLoc); 1360 pragmaRedefTok.setAnnotationEndLoc(AliasName.getLocation()); 1361 Toks[1] = RedefName; 1362 Toks[2] = AliasName; 1363 PP.EnterTokenStream(Toks, 3, 1364 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/false); 1365 } 1366 1367 1368 void 1369 PragmaFPContractHandler::HandlePragma(Preprocessor &PP, 1370 PragmaIntroducerKind Introducer, 1371 Token &Tok) { 1372 tok::OnOffSwitch OOS; 1373 if (PP.LexOnOffSwitch(OOS)) 1374 return; 1375 1376 Token *Toks = 1377 (Token*) PP.getPreprocessorAllocator().Allocate( 1378 sizeof(Token) * 1, llvm::alignOf<Token>()); 1379 new (Toks) Token(); 1380 Toks[0].startToken(); 1381 Toks[0].setKind(tok::annot_pragma_fp_contract); 1382 Toks[0].setLocation(Tok.getLocation()); 1383 Toks[0].setAnnotationEndLoc(Tok.getLocation()); 1384 Toks[0].setAnnotationValue(reinterpret_cast<void*>( 1385 static_cast<uintptr_t>(OOS))); 1386 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, 1387 /*OwnsTokens=*/false); 1388 } 1389 1390 void 1391 PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP, 1392 PragmaIntroducerKind Introducer, 1393 Token &Tok) { 1394 PP.LexUnexpandedToken(Tok); 1395 if (Tok.isNot(tok::identifier)) { 1396 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << 1397 "OPENCL"; 1398 return; 1399 } 1400 IdentifierInfo *ename = Tok.getIdentifierInfo(); 1401 SourceLocation NameLoc = Tok.getLocation(); 1402 1403 PP.Lex(Tok); 1404 if (Tok.isNot(tok::colon)) { 1405 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename; 1406 return; 1407 } 1408 1409 PP.Lex(Tok); 1410 if (Tok.isNot(tok::identifier)) { 1411 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable); 1412 return; 1413 } 1414 IdentifierInfo *op = Tok.getIdentifierInfo(); 1415 1416 unsigned state; 1417 if (op->isStr("enable")) { 1418 state = 1; 1419 } else if (op->isStr("disable")) { 1420 state = 0; 1421 } else { 1422 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable); 1423 return; 1424 } 1425 SourceLocation StateLoc = Tok.getLocation(); 1426 1427 PP.Lex(Tok); 1428 if (Tok.isNot(tok::eod)) { 1429 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << 1430 "OPENCL EXTENSION"; 1431 return; 1432 } 1433 1434 OpenCLExtData data(ename, state); 1435 Token *Toks = 1436 (Token*) PP.getPreprocessorAllocator().Allocate( 1437 sizeof(Token) * 1, llvm::alignOf<Token>()); 1438 new (Toks) Token(); 1439 Toks[0].startToken(); 1440 Toks[0].setKind(tok::annot_pragma_opencl_extension); 1441 Toks[0].setLocation(NameLoc); 1442 Toks[0].setAnnotationValue(data.getOpaqueValue()); 1443 Toks[0].setAnnotationEndLoc(StateLoc); 1444 PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, 1445 /*OwnsTokens=*/false); 1446 1447 if (PP.getPPCallbacks()) 1448 PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, ename, 1449 StateLoc, state); 1450 } 1451 1452 /// \brief Handle '#pragma omp ...' when OpenMP is disabled. 1453 /// 1454 void 1455 PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP, 1456 PragmaIntroducerKind Introducer, 1457 Token &FirstTok) { 1458 if (!PP.getDiagnostics().isIgnored(diag::warn_pragma_omp_ignored, 1459 FirstTok.getLocation())) { 1460 PP.Diag(FirstTok, diag::warn_pragma_omp_ignored); 1461 PP.getDiagnostics().setSeverity(diag::warn_pragma_omp_ignored, 1462 diag::Severity::Ignored, SourceLocation()); 1463 } 1464 PP.DiscardUntilEndOfDirective(); 1465 } 1466 1467 /// \brief Handle '#pragma omp ...' when OpenMP is enabled. 1468 /// 1469 void 1470 PragmaOpenMPHandler::HandlePragma(Preprocessor &PP, 1471 PragmaIntroducerKind Introducer, 1472 Token &FirstTok) { 1473 SmallVector<Token, 16> Pragma; 1474 Token Tok; 1475 Tok.startToken(); 1476 Tok.setKind(tok::annot_pragma_openmp); 1477 Tok.setLocation(FirstTok.getLocation()); 1478 1479 while (Tok.isNot(tok::eod)) { 1480 Pragma.push_back(Tok); 1481 PP.Lex(Tok); 1482 } 1483 SourceLocation EodLoc = Tok.getLocation(); 1484 Tok.startToken(); 1485 Tok.setKind(tok::annot_pragma_openmp_end); 1486 Tok.setLocation(EodLoc); 1487 Pragma.push_back(Tok); 1488 1489 Token *Toks = new Token[Pragma.size()]; 1490 std::copy(Pragma.begin(), Pragma.end(), Toks); 1491 PP.EnterTokenStream(Toks, Pragma.size(), 1492 /*DisableMacroExpansion=*/true, /*OwnsTokens=*/true); 1493 } 1494 1495 /// \brief Handle '#pragma pointers_to_members' 1496 // The grammar for this pragma is as follows: 1497 // 1498 // <inheritance model> ::= ('single' | 'multiple' | 'virtual') '_inheritance' 1499 // 1500 // #pragma pointers_to_members '(' 'best_case' ')' 1501 // #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')' 1502 // #pragma pointers_to_members '(' inheritance-model ')' 1503 void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP, 1504 PragmaIntroducerKind Introducer, 1505 Token &Tok) { 1506 SourceLocation PointersToMembersLoc = Tok.getLocation(); 1507 PP.Lex(Tok); 1508 if (Tok.isNot(tok::l_paren)) { 1509 PP.Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen) 1510 << "pointers_to_members"; 1511 return; 1512 } 1513 PP.Lex(Tok); 1514 const IdentifierInfo *Arg = Tok.getIdentifierInfo(); 1515 if (!Arg) { 1516 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) 1517 << "pointers_to_members"; 1518 return; 1519 } 1520 PP.Lex(Tok); 1521 1522 LangOptions::PragmaMSPointersToMembersKind RepresentationMethod; 1523 if (Arg->isStr("best_case")) { 1524 RepresentationMethod = LangOptions::PPTMK_BestCase; 1525 } else { 1526 if (Arg->isStr("full_generality")) { 1527 if (Tok.is(tok::comma)) { 1528 PP.Lex(Tok); 1529 1530 Arg = Tok.getIdentifierInfo(); 1531 if (!Arg) { 1532 PP.Diag(Tok.getLocation(), 1533 diag::err_pragma_pointers_to_members_unknown_kind) 1534 << Tok.getKind() << /*OnlyInheritanceModels*/ 0; 1535 return; 1536 } 1537 PP.Lex(Tok); 1538 } else if (Tok.is(tok::r_paren)) { 1539 // #pragma pointers_to_members(full_generality) implicitly specifies 1540 // virtual_inheritance. 1541 Arg = nullptr; 1542 RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance; 1543 } else { 1544 PP.Diag(Tok.getLocation(), diag::err_expected_punc) 1545 << "full_generality"; 1546 return; 1547 } 1548 } 1549 1550 if (Arg) { 1551 if (Arg->isStr("single_inheritance")) { 1552 RepresentationMethod = 1553 LangOptions::PPTMK_FullGeneralitySingleInheritance; 1554 } else if (Arg->isStr("multiple_inheritance")) { 1555 RepresentationMethod = 1556 LangOptions::PPTMK_FullGeneralityMultipleInheritance; 1557 } else if (Arg->isStr("virtual_inheritance")) { 1558 RepresentationMethod = 1559 LangOptions::PPTMK_FullGeneralityVirtualInheritance; 1560 } else { 1561 PP.Diag(Tok.getLocation(), 1562 diag::err_pragma_pointers_to_members_unknown_kind) 1563 << Arg << /*HasPointerDeclaration*/ 1; 1564 return; 1565 } 1566 } 1567 } 1568 1569 if (Tok.isNot(tok::r_paren)) { 1570 PP.Diag(Tok.getLocation(), diag::err_expected_rparen_after) 1571 << (Arg ? Arg->getName() : "full_generality"); 1572 return; 1573 } 1574 1575 SourceLocation EndLoc = Tok.getLocation(); 1576 PP.Lex(Tok); 1577 if (Tok.isNot(tok::eod)) { 1578 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 1579 << "pointers_to_members"; 1580 return; 1581 } 1582 1583 Token AnnotTok; 1584 AnnotTok.startToken(); 1585 AnnotTok.setKind(tok::annot_pragma_ms_pointers_to_members); 1586 AnnotTok.setLocation(PointersToMembersLoc); 1587 AnnotTok.setAnnotationEndLoc(EndLoc); 1588 AnnotTok.setAnnotationValue( 1589 reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod))); 1590 PP.EnterToken(AnnotTok); 1591 } 1592 1593 /// \brief Handle '#pragma vtordisp' 1594 // The grammar for this pragma is as follows: 1595 // 1596 // <vtordisp-mode> ::= ('off' | 'on' | '0' | '1' | '2' ) 1597 // 1598 // #pragma vtordisp '(' ['push' ','] vtordisp-mode ')' 1599 // #pragma vtordisp '(' 'pop' ')' 1600 // #pragma vtordisp '(' ')' 1601 void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP, 1602 PragmaIntroducerKind Introducer, 1603 Token &Tok) { 1604 SourceLocation VtorDispLoc = Tok.getLocation(); 1605 PP.Lex(Tok); 1606 if (Tok.isNot(tok::l_paren)) { 1607 PP.Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) << "vtordisp"; 1608 return; 1609 } 1610 PP.Lex(Tok); 1611 1612 Sema::PragmaVtorDispKind Kind = Sema::PVDK_Set; 1613 const IdentifierInfo *II = Tok.getIdentifierInfo(); 1614 if (II) { 1615 if (II->isStr("push")) { 1616 // #pragma vtordisp(push, mode) 1617 PP.Lex(Tok); 1618 if (Tok.isNot(tok::comma)) { 1619 PP.Diag(VtorDispLoc, diag::warn_pragma_expected_punc) << "vtordisp"; 1620 return; 1621 } 1622 PP.Lex(Tok); 1623 Kind = Sema::PVDK_Push; 1624 // not push, could be on/off 1625 } else if (II->isStr("pop")) { 1626 // #pragma vtordisp(pop) 1627 PP.Lex(Tok); 1628 Kind = Sema::PVDK_Pop; 1629 } 1630 // not push or pop, could be on/off 1631 } else { 1632 if (Tok.is(tok::r_paren)) { 1633 // #pragma vtordisp() 1634 Kind = Sema::PVDK_Reset; 1635 } 1636 } 1637 1638 1639 uint64_t Value = 0; 1640 if (Kind == Sema::PVDK_Push || Kind == Sema::PVDK_Set) { 1641 const IdentifierInfo *II = Tok.getIdentifierInfo(); 1642 if (II && II->isStr("off")) { 1643 PP.Lex(Tok); 1644 Value = 0; 1645 } else if (II && II->isStr("on")) { 1646 PP.Lex(Tok); 1647 Value = 1; 1648 } else if (Tok.is(tok::numeric_constant) && 1649 PP.parseSimpleIntegerLiteral(Tok, Value)) { 1650 if (Value > 2) { 1651 PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_integer) 1652 << 0 << 2 << "vtordisp"; 1653 return; 1654 } 1655 } else { 1656 PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) 1657 << "vtordisp"; 1658 return; 1659 } 1660 } 1661 1662 // Finish the pragma: ')' $ 1663 if (Tok.isNot(tok::r_paren)) { 1664 PP.Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) << "vtordisp"; 1665 return; 1666 } 1667 SourceLocation EndLoc = Tok.getLocation(); 1668 PP.Lex(Tok); 1669 if (Tok.isNot(tok::eod)) { 1670 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 1671 << "vtordisp"; 1672 return; 1673 } 1674 1675 // Enter the annotation. 1676 Token AnnotTok; 1677 AnnotTok.startToken(); 1678 AnnotTok.setKind(tok::annot_pragma_ms_vtordisp); 1679 AnnotTok.setLocation(VtorDispLoc); 1680 AnnotTok.setAnnotationEndLoc(EndLoc); 1681 AnnotTok.setAnnotationValue(reinterpret_cast<void *>( 1682 static_cast<uintptr_t>((Kind << 16) | (Value & 0xFFFF)))); 1683 PP.EnterToken(AnnotTok); 1684 } 1685 1686 /// \brief Handle all MS pragmas. Simply forwards the tokens after inserting 1687 /// an annotation token. 1688 void PragmaMSPragma::HandlePragma(Preprocessor &PP, 1689 PragmaIntroducerKind Introducer, 1690 Token &Tok) { 1691 Token EoF, AnnotTok; 1692 EoF.startToken(); 1693 EoF.setKind(tok::eof); 1694 AnnotTok.startToken(); 1695 AnnotTok.setKind(tok::annot_pragma_ms_pragma); 1696 AnnotTok.setLocation(Tok.getLocation()); 1697 AnnotTok.setAnnotationEndLoc(Tok.getLocation()); 1698 SmallVector<Token, 8> TokenVector; 1699 // Suck up all of the tokens before the eod. 1700 for (; Tok.isNot(tok::eod); PP.Lex(Tok)) { 1701 TokenVector.push_back(Tok); 1702 AnnotTok.setAnnotationEndLoc(Tok.getLocation()); 1703 } 1704 // Add a sentinal EoF token to the end of the list. 1705 TokenVector.push_back(EoF); 1706 // We must allocate this array with new because EnterTokenStream is going to 1707 // delete it later. 1708 Token *TokenArray = new Token[TokenVector.size()]; 1709 std::copy(TokenVector.begin(), TokenVector.end(), TokenArray); 1710 auto Value = new (PP.getPreprocessorAllocator()) 1711 std::pair<Token*, size_t>(std::make_pair(TokenArray, TokenVector.size())); 1712 AnnotTok.setAnnotationValue(Value); 1713 PP.EnterToken(AnnotTok); 1714 } 1715 1716 /// \brief Handle the Microsoft \#pragma detect_mismatch extension. 1717 /// 1718 /// The syntax is: 1719 /// \code 1720 /// #pragma detect_mismatch("name", "value") 1721 /// \endcode 1722 /// Where 'name' and 'value' are quoted strings. The values are embedded in 1723 /// the object file and passed along to the linker. If the linker detects a 1724 /// mismatch in the object file's values for the given name, a LNK2038 error 1725 /// is emitted. See MSDN for more details. 1726 void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, 1727 PragmaIntroducerKind Introducer, 1728 Token &Tok) { 1729 SourceLocation CommentLoc = Tok.getLocation(); 1730 PP.Lex(Tok); 1731 if (Tok.isNot(tok::l_paren)) { 1732 PP.Diag(CommentLoc, diag::err_expected) << tok::l_paren; 1733 return; 1734 } 1735 1736 // Read the name to embed, which must be a string literal. 1737 std::string NameString; 1738 if (!PP.LexStringLiteral(Tok, NameString, 1739 "pragma detect_mismatch", 1740 /*MacroExpansion=*/true)) 1741 return; 1742 1743 // Read the comma followed by a second string literal. 1744 std::string ValueString; 1745 if (Tok.isNot(tok::comma)) { 1746 PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed); 1747 return; 1748 } 1749 1750 if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch", 1751 /*MacroExpansion=*/true)) 1752 return; 1753 1754 if (Tok.isNot(tok::r_paren)) { 1755 PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; 1756 return; 1757 } 1758 PP.Lex(Tok); // Eat the r_paren. 1759 1760 if (Tok.isNot(tok::eod)) { 1761 PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed); 1762 return; 1763 } 1764 1765 // If the pragma is lexically sound, notify any interested PPCallbacks. 1766 if (PP.getPPCallbacks()) 1767 PP.getPPCallbacks()->PragmaDetectMismatch(CommentLoc, NameString, 1768 ValueString); 1769 1770 Actions.ActOnPragmaDetectMismatch(NameString, ValueString); 1771 } 1772 1773 /// \brief Handle the microsoft \#pragma comment extension. 1774 /// 1775 /// The syntax is: 1776 /// \code 1777 /// #pragma comment(linker, "foo") 1778 /// \endcode 1779 /// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user. 1780 /// "foo" is a string, which is fully macro expanded, and permits string 1781 /// concatenation, embedded escape characters etc. See MSDN for more details. 1782 void PragmaCommentHandler::HandlePragma(Preprocessor &PP, 1783 PragmaIntroducerKind Introducer, 1784 Token &Tok) { 1785 SourceLocation CommentLoc = Tok.getLocation(); 1786 PP.Lex(Tok); 1787 if (Tok.isNot(tok::l_paren)) { 1788 PP.Diag(CommentLoc, diag::err_pragma_comment_malformed); 1789 return; 1790 } 1791 1792 // Read the identifier. 1793 PP.Lex(Tok); 1794 if (Tok.isNot(tok::identifier)) { 1795 PP.Diag(CommentLoc, diag::err_pragma_comment_malformed); 1796 return; 1797 } 1798 1799 // Verify that this is one of the 5 whitelisted options. 1800 IdentifierInfo *II = Tok.getIdentifierInfo(); 1801 Sema::PragmaMSCommentKind Kind = 1802 llvm::StringSwitch<Sema::PragmaMSCommentKind>(II->getName()) 1803 .Case("linker", Sema::PCK_Linker) 1804 .Case("lib", Sema::PCK_Lib) 1805 .Case("compiler", Sema::PCK_Compiler) 1806 .Case("exestr", Sema::PCK_ExeStr) 1807 .Case("user", Sema::PCK_User) 1808 .Default(Sema::PCK_Unknown); 1809 if (Kind == Sema::PCK_Unknown) { 1810 PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind); 1811 return; 1812 } 1813 1814 // On PS4, issue a warning about any pragma comments other than 1815 // #pragma comment lib. 1816 if (PP.getTargetInfo().getTriple().isPS4() && Kind != Sema::PCK_Lib) { 1817 PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored) 1818 << II->getName(); 1819 return; 1820 } 1821 1822 // Read the optional string if present. 1823 PP.Lex(Tok); 1824 std::string ArgumentString; 1825 if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString, 1826 "pragma comment", 1827 /*MacroExpansion=*/true)) 1828 return; 1829 1830 // FIXME: warn that 'exestr' is deprecated. 1831 // FIXME: If the kind is "compiler" warn if the string is present (it is 1832 // ignored). 1833 // The MSDN docs say that "lib" and "linker" require a string and have a short 1834 // whitelist of linker options they support, but in practice MSVC doesn't 1835 // issue a diagnostic. Therefore neither does clang. 1836 1837 if (Tok.isNot(tok::r_paren)) { 1838 PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); 1839 return; 1840 } 1841 PP.Lex(Tok); // eat the r_paren. 1842 1843 if (Tok.isNot(tok::eod)) { 1844 PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed); 1845 return; 1846 } 1847 1848 // If the pragma is lexically sound, notify any interested PPCallbacks. 1849 if (PP.getPPCallbacks()) 1850 PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString); 1851 1852 Actions.ActOnPragmaMSComment(Kind, ArgumentString); 1853 } 1854 1855 // #pragma clang optimize off 1856 // #pragma clang optimize on 1857 void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, 1858 PragmaIntroducerKind Introducer, 1859 Token &FirstToken) { 1860 Token Tok; 1861 PP.Lex(Tok); 1862 if (Tok.is(tok::eod)) { 1863 PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument) 1864 << "clang optimize" << /*Expected=*/true << "'on' or 'off'"; 1865 return; 1866 } 1867 if (Tok.isNot(tok::identifier)) { 1868 PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) 1869 << PP.getSpelling(Tok); 1870 return; 1871 } 1872 const IdentifierInfo *II = Tok.getIdentifierInfo(); 1873 // The only accepted values are 'on' or 'off'. 1874 bool IsOn = false; 1875 if (II->isStr("on")) { 1876 IsOn = true; 1877 } else if (!II->isStr("off")) { 1878 PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) 1879 << PP.getSpelling(Tok); 1880 return; 1881 } 1882 PP.Lex(Tok); 1883 1884 if (Tok.isNot(tok::eod)) { 1885 PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument) 1886 << PP.getSpelling(Tok); 1887 return; 1888 } 1889 1890 Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation()); 1891 } 1892 1893 /// \brief Parses loop or unroll pragma hint value and fills in Info. 1894 static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName, 1895 Token Option, bool ValueInParens, 1896 PragmaLoopHintInfo &Info) { 1897 SmallVector<Token, 1> ValueList; 1898 int OpenParens = ValueInParens ? 1 : 0; 1899 // Read constant expression. 1900 while (Tok.isNot(tok::eod)) { 1901 if (Tok.is(tok::l_paren)) 1902 OpenParens++; 1903 else if (Tok.is(tok::r_paren)) { 1904 OpenParens--; 1905 if (OpenParens == 0 && ValueInParens) 1906 break; 1907 } 1908 1909 ValueList.push_back(Tok); 1910 PP.Lex(Tok); 1911 } 1912 1913 if (ValueInParens) { 1914 // Read ')' 1915 if (Tok.isNot(tok::r_paren)) { 1916 PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren; 1917 return true; 1918 } 1919 PP.Lex(Tok); 1920 } 1921 1922 Token EOFTok; 1923 EOFTok.startToken(); 1924 EOFTok.setKind(tok::eof); 1925 EOFTok.setLocation(Tok.getLocation()); 1926 ValueList.push_back(EOFTok); // Terminates expression for parsing. 1927 1928 Token *TokenArray = (Token *)PP.getPreprocessorAllocator().Allocate( 1929 ValueList.size() * sizeof(Token), llvm::alignOf<Token>()); 1930 std::copy(ValueList.begin(), ValueList.end(), TokenArray); 1931 Info.Toks = TokenArray; 1932 Info.TokSize = ValueList.size(); 1933 1934 Info.PragmaName = PragmaName; 1935 Info.Option = Option; 1936 return false; 1937 } 1938 1939 /// \brief Handle the \#pragma clang loop directive. 1940 /// #pragma clang 'loop' loop-hints 1941 /// 1942 /// loop-hints: 1943 /// loop-hint loop-hints[opt] 1944 /// 1945 /// loop-hint: 1946 /// 'vectorize' '(' loop-hint-keyword ')' 1947 /// 'interleave' '(' loop-hint-keyword ')' 1948 /// 'unroll' '(' unroll-hint-keyword ')' 1949 /// 'vectorize_width' '(' loop-hint-value ')' 1950 /// 'interleave_count' '(' loop-hint-value ')' 1951 /// 'unroll_count' '(' loop-hint-value ')' 1952 /// 1953 /// loop-hint-keyword: 1954 /// 'enable' 1955 /// 'disable' 1956 /// 1957 /// unroll-hint-keyword: 1958 /// 'full' 1959 /// 'disable' 1960 /// 1961 /// loop-hint-value: 1962 /// constant-expression 1963 /// 1964 /// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to 1965 /// try vectorizing the instructions of the loop it precedes. Specifying 1966 /// interleave(enable) or interleave_count(_value_) instructs llvm to try 1967 /// interleaving multiple iterations of the loop it precedes. The width of the 1968 /// vector instructions is specified by vectorize_width() and the number of 1969 /// interleaved loop iterations is specified by interleave_count(). Specifying a 1970 /// value of 1 effectively disables vectorization/interleaving, even if it is 1971 /// possible and profitable, and 0 is invalid. The loop vectorizer currently 1972 /// only works on inner loops. 1973 /// 1974 /// The unroll and unroll_count directives control the concatenation 1975 /// unroller. Specifying unroll(full) instructs llvm to try to 1976 /// unroll the loop completely, and unroll(disable) disables unrolling 1977 /// for the loop. Specifying unroll_count(_value_) instructs llvm to 1978 /// try to unroll the loop the number of times indicated by the value. 1979 void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP, 1980 PragmaIntroducerKind Introducer, 1981 Token &Tok) { 1982 // Incoming token is "loop" from "#pragma clang loop". 1983 Token PragmaName = Tok; 1984 SmallVector<Token, 1> TokenList; 1985 1986 // Lex the optimization option and verify it is an identifier. 1987 PP.Lex(Tok); 1988 if (Tok.isNot(tok::identifier)) { 1989 PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option) 1990 << /*MissingOption=*/true << ""; 1991 return; 1992 } 1993 1994 while (Tok.is(tok::identifier)) { 1995 Token Option = Tok; 1996 IdentifierInfo *OptionInfo = Tok.getIdentifierInfo(); 1997 1998 bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->getName()) 1999 .Case("vectorize", true) 2000 .Case("interleave", true) 2001 .Case("unroll", true) 2002 .Case("vectorize_width", true) 2003 .Case("interleave_count", true) 2004 .Case("unroll_count", true) 2005 .Default(false); 2006 if (!OptionValid) { 2007 PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option) 2008 << /*MissingOption=*/false << OptionInfo; 2009 return; 2010 } 2011 PP.Lex(Tok); 2012 2013 // Read '(' 2014 if (Tok.isNot(tok::l_paren)) { 2015 PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren; 2016 return; 2017 } 2018 PP.Lex(Tok); 2019 2020 auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo; 2021 if (ParseLoopHintValue(PP, Tok, PragmaName, Option, /*ValueInParens=*/true, 2022 *Info)) 2023 return; 2024 2025 // Generate the loop hint token. 2026 Token LoopHintTok; 2027 LoopHintTok.startToken(); 2028 LoopHintTok.setKind(tok::annot_pragma_loop_hint); 2029 LoopHintTok.setLocation(PragmaName.getLocation()); 2030 LoopHintTok.setAnnotationEndLoc(PragmaName.getLocation()); 2031 LoopHintTok.setAnnotationValue(static_cast<void *>(Info)); 2032 TokenList.push_back(LoopHintTok); 2033 } 2034 2035 if (Tok.isNot(tok::eod)) { 2036 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 2037 << "clang loop"; 2038 return; 2039 } 2040 2041 Token *TokenArray = new Token[TokenList.size()]; 2042 std::copy(TokenList.begin(), TokenList.end(), TokenArray); 2043 2044 PP.EnterTokenStream(TokenArray, TokenList.size(), 2045 /*DisableMacroExpansion=*/false, 2046 /*OwnsTokens=*/true); 2047 } 2048 2049 /// \brief Handle the loop unroll optimization pragmas. 2050 /// #pragma unroll 2051 /// #pragma unroll unroll-hint-value 2052 /// #pragma unroll '(' unroll-hint-value ')' 2053 /// #pragma nounroll 2054 /// 2055 /// unroll-hint-value: 2056 /// constant-expression 2057 /// 2058 /// Loop unrolling hints can be specified with '#pragma unroll' or 2059 /// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally 2060 /// contained in parentheses. With no argument the directive instructs llvm to 2061 /// try to unroll the loop completely. A positive integer argument can be 2062 /// specified to indicate the number of times the loop should be unrolled. To 2063 /// maximize compatibility with other compilers the unroll count argument can be 2064 /// specified with or without parentheses. Specifying, '#pragma nounroll' 2065 /// disables unrolling of the loop. 2066 void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP, 2067 PragmaIntroducerKind Introducer, 2068 Token &Tok) { 2069 // Incoming token is "unroll" for "#pragma unroll", or "nounroll" for 2070 // "#pragma nounroll". 2071 Token PragmaName = Tok; 2072 PP.Lex(Tok); 2073 auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo; 2074 if (Tok.is(tok::eod)) { 2075 // nounroll or unroll pragma without an argument. 2076 Info->PragmaName = PragmaName; 2077 Info->Option.startToken(); 2078 } else if (PragmaName.getIdentifierInfo()->getName() == "nounroll") { 2079 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 2080 << "nounroll"; 2081 return; 2082 } else { 2083 // Unroll pragma with an argument: "#pragma unroll N" or 2084 // "#pragma unroll(N)". 2085 // Read '(' if it exists. 2086 bool ValueInParens = Tok.is(tok::l_paren); 2087 if (ValueInParens) 2088 PP.Lex(Tok); 2089 2090 Token Option; 2091 Option.startToken(); 2092 if (ParseLoopHintValue(PP, Tok, PragmaName, Option, ValueInParens, *Info)) 2093 return; 2094 2095 // In CUDA, the argument to '#pragma unroll' should not be contained in 2096 // parentheses. 2097 if (PP.getLangOpts().CUDA && ValueInParens) 2098 PP.Diag(Info->Toks[0].getLocation(), 2099 diag::warn_pragma_unroll_cuda_value_in_parens); 2100 2101 if (Tok.isNot(tok::eod)) { 2102 PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) 2103 << "unroll"; 2104 return; 2105 } 2106 } 2107 2108 // Generate the hint token. 2109 Token *TokenArray = new Token[1]; 2110 TokenArray[0].startToken(); 2111 TokenArray[0].setKind(tok::annot_pragma_loop_hint); 2112 TokenArray[0].setLocation(PragmaName.getLocation()); 2113 TokenArray[0].setAnnotationEndLoc(PragmaName.getLocation()); 2114 TokenArray[0].setAnnotationValue(static_cast<void *>(Info)); 2115 PP.EnterTokenStream(TokenArray, 1, /*DisableMacroExpansion=*/false, 2116 /*OwnsTokens=*/true); 2117 } 2118