1 //===--- PPMacroExpansion.cpp - Top level Macro Expansion -----------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the top level handling of macro expansion for the 10 // preprocessor. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Basic/Attributes.h" 15 #include "clang/Basic/FileManager.h" 16 #include "clang/Basic/IdentifierTable.h" 17 #include "clang/Basic/LLVM.h" 18 #include "clang/Basic/LangOptions.h" 19 #include "clang/Basic/ObjCRuntime.h" 20 #include "clang/Basic/SourceLocation.h" 21 #include "clang/Basic/TargetInfo.h" 22 #include "clang/Lex/CodeCompletionHandler.h" 23 #include "clang/Lex/DirectoryLookup.h" 24 #include "clang/Lex/ExternalPreprocessorSource.h" 25 #include "clang/Lex/HeaderSearch.h" 26 #include "clang/Lex/LexDiagnostic.h" 27 #include "clang/Lex/MacroArgs.h" 28 #include "clang/Lex/MacroInfo.h" 29 #include "clang/Lex/Preprocessor.h" 30 #include "clang/Lex/PreprocessorLexer.h" 31 #include "clang/Lex/Token.h" 32 #include "llvm/ADT/ArrayRef.h" 33 #include "llvm/ADT/DenseMap.h" 34 #include "llvm/ADT/DenseSet.h" 35 #include "llvm/ADT/FoldingSet.h" 36 #include "llvm/ADT/None.h" 37 #include "llvm/ADT/Optional.h" 38 #include "llvm/ADT/SmallString.h" 39 #include "llvm/ADT/SmallVector.h" 40 #include "llvm/ADT/STLExtras.h" 41 #include "llvm/ADT/StringRef.h" 42 #include "llvm/ADT/StringSwitch.h" 43 #include "llvm/Support/Casting.h" 44 #include "llvm/Support/ErrorHandling.h" 45 #include "llvm/Support/Format.h" 46 #include "llvm/Support/Path.h" 47 #include "llvm/Support/raw_ostream.h" 48 #include <algorithm> 49 #include <cassert> 50 #include <cstddef> 51 #include <cstring> 52 #include <ctime> 53 #include <string> 54 #include <tuple> 55 #include <utility> 56 57 using namespace clang; 58 59 MacroDirective * 60 Preprocessor::getLocalMacroDirectiveHistory(const IdentifierInfo *II) const { 61 if (!II->hadMacroDefinition()) 62 return nullptr; 63 auto Pos = CurSubmoduleState->Macros.find(II); 64 return Pos == CurSubmoduleState->Macros.end() ? nullptr 65 : Pos->second.getLatest(); 66 } 67 68 void Preprocessor::appendMacroDirective(IdentifierInfo *II, MacroDirective *MD){ 69 assert(MD && "MacroDirective should be non-zero!"); 70 assert(!MD->getPrevious() && "Already attached to a MacroDirective history."); 71 72 MacroState &StoredMD = CurSubmoduleState->Macros[II]; 73 auto *OldMD = StoredMD.getLatest(); 74 MD->setPrevious(OldMD); 75 StoredMD.setLatest(MD); 76 StoredMD.overrideActiveModuleMacros(*this, II); 77 78 if (needModuleMacros()) { 79 // Track that we created a new macro directive, so we know we should 80 // consider building a ModuleMacro for it when we get to the end of 81 // the module. 82 PendingModuleMacroNames.push_back(II); 83 } 84 85 // Set up the identifier as having associated macro history. 86 II->setHasMacroDefinition(true); 87 if (!MD->isDefined() && LeafModuleMacros.find(II) == LeafModuleMacros.end()) 88 II->setHasMacroDefinition(false); 89 if (II->isFromAST()) 90 II->setChangedSinceDeserialization(); 91 } 92 93 void Preprocessor::setLoadedMacroDirective(IdentifierInfo *II, 94 MacroDirective *ED, 95 MacroDirective *MD) { 96 // Normally, when a macro is defined, it goes through appendMacroDirective() 97 // above, which chains a macro to previous defines, undefs, etc. 98 // However, in a pch, the whole macro history up to the end of the pch is 99 // stored, so ASTReader goes through this function instead. 100 // However, built-in macros are already registered in the Preprocessor 101 // ctor, and ASTWriter stops writing the macro chain at built-in macros, 102 // so in that case the chain from the pch needs to be spliced to the existing 103 // built-in. 104 105 assert(II && MD); 106 MacroState &StoredMD = CurSubmoduleState->Macros[II]; 107 108 if (auto *OldMD = StoredMD.getLatest()) { 109 // shouldIgnoreMacro() in ASTWriter also stops at macros from the 110 // predefines buffer in module builds. However, in module builds, modules 111 // are loaded completely before predefines are processed, so StoredMD 112 // will be nullptr for them when they're loaded. StoredMD should only be 113 // non-nullptr for builtins read from a pch file. 114 assert(OldMD->getMacroInfo()->isBuiltinMacro() && 115 "only built-ins should have an entry here"); 116 assert(!OldMD->getPrevious() && "builtin should only have a single entry"); 117 ED->setPrevious(OldMD); 118 StoredMD.setLatest(MD); 119 } else { 120 StoredMD = MD; 121 } 122 123 // Setup the identifier as having associated macro history. 124 II->setHasMacroDefinition(true); 125 if (!MD->isDefined() && LeafModuleMacros.find(II) == LeafModuleMacros.end()) 126 II->setHasMacroDefinition(false); 127 } 128 129 ModuleMacro *Preprocessor::addModuleMacro(Module *Mod, IdentifierInfo *II, 130 MacroInfo *Macro, 131 ArrayRef<ModuleMacro *> Overrides, 132 bool &New) { 133 llvm::FoldingSetNodeID ID; 134 ModuleMacro::Profile(ID, Mod, II); 135 136 void *InsertPos; 137 if (auto *MM = ModuleMacros.FindNodeOrInsertPos(ID, InsertPos)) { 138 New = false; 139 return MM; 140 } 141 142 auto *MM = ModuleMacro::create(*this, Mod, II, Macro, Overrides); 143 ModuleMacros.InsertNode(MM, InsertPos); 144 145 // Each overridden macro is now overridden by one more macro. 146 bool HidAny = false; 147 for (auto *O : Overrides) { 148 HidAny |= (O->NumOverriddenBy == 0); 149 ++O->NumOverriddenBy; 150 } 151 152 // If we were the first overrider for any macro, it's no longer a leaf. 153 auto &LeafMacros = LeafModuleMacros[II]; 154 if (HidAny) { 155 LeafMacros.erase(std::remove_if(LeafMacros.begin(), LeafMacros.end(), 156 [](ModuleMacro *MM) { 157 return MM->NumOverriddenBy != 0; 158 }), 159 LeafMacros.end()); 160 } 161 162 // The new macro is always a leaf macro. 163 LeafMacros.push_back(MM); 164 // The identifier now has defined macros (that may or may not be visible). 165 II->setHasMacroDefinition(true); 166 167 New = true; 168 return MM; 169 } 170 171 ModuleMacro *Preprocessor::getModuleMacro(Module *Mod, IdentifierInfo *II) { 172 llvm::FoldingSetNodeID ID; 173 ModuleMacro::Profile(ID, Mod, II); 174 175 void *InsertPos; 176 return ModuleMacros.FindNodeOrInsertPos(ID, InsertPos); 177 } 178 179 void Preprocessor::updateModuleMacroInfo(const IdentifierInfo *II, 180 ModuleMacroInfo &Info) { 181 assert(Info.ActiveModuleMacrosGeneration != 182 CurSubmoduleState->VisibleModules.getGeneration() && 183 "don't need to update this macro name info"); 184 Info.ActiveModuleMacrosGeneration = 185 CurSubmoduleState->VisibleModules.getGeneration(); 186 187 auto Leaf = LeafModuleMacros.find(II); 188 if (Leaf == LeafModuleMacros.end()) { 189 // No imported macros at all: nothing to do. 190 return; 191 } 192 193 Info.ActiveModuleMacros.clear(); 194 195 // Every macro that's locally overridden is overridden by a visible macro. 196 llvm::DenseMap<ModuleMacro *, int> NumHiddenOverrides; 197 for (auto *O : Info.OverriddenMacros) 198 NumHiddenOverrides[O] = -1; 199 200 // Collect all macros that are not overridden by a visible macro. 201 llvm::SmallVector<ModuleMacro *, 16> Worklist; 202 for (auto *LeafMM : Leaf->second) { 203 assert(LeafMM->getNumOverridingMacros() == 0 && "leaf macro overridden"); 204 if (NumHiddenOverrides.lookup(LeafMM) == 0) 205 Worklist.push_back(LeafMM); 206 } 207 while (!Worklist.empty()) { 208 auto *MM = Worklist.pop_back_val(); 209 if (CurSubmoduleState->VisibleModules.isVisible(MM->getOwningModule())) { 210 // We only care about collecting definitions; undefinitions only act 211 // to override other definitions. 212 if (MM->getMacroInfo()) 213 Info.ActiveModuleMacros.push_back(MM); 214 } else { 215 for (auto *O : MM->overrides()) 216 if ((unsigned)++NumHiddenOverrides[O] == O->getNumOverridingMacros()) 217 Worklist.push_back(O); 218 } 219 } 220 // Our reverse postorder walk found the macros in reverse order. 221 std::reverse(Info.ActiveModuleMacros.begin(), Info.ActiveModuleMacros.end()); 222 223 // Determine whether the macro name is ambiguous. 224 MacroInfo *MI = nullptr; 225 bool IsSystemMacro = true; 226 bool IsAmbiguous = false; 227 if (auto *MD = Info.MD) { 228 while (MD && isa<VisibilityMacroDirective>(MD)) 229 MD = MD->getPrevious(); 230 if (auto *DMD = dyn_cast_or_null<DefMacroDirective>(MD)) { 231 MI = DMD->getInfo(); 232 IsSystemMacro &= SourceMgr.isInSystemHeader(DMD->getLocation()); 233 } 234 } 235 for (auto *Active : Info.ActiveModuleMacros) { 236 auto *NewMI = Active->getMacroInfo(); 237 238 // Before marking the macro as ambiguous, check if this is a case where 239 // both macros are in system headers. If so, we trust that the system 240 // did not get it wrong. This also handles cases where Clang's own 241 // headers have a different spelling of certain system macros: 242 // #define LONG_MAX __LONG_MAX__ (clang's limits.h) 243 // #define LONG_MAX 0x7fffffffffffffffL (system's limits.h) 244 // 245 // FIXME: Remove the defined-in-system-headers check. clang's limits.h 246 // overrides the system limits.h's macros, so there's no conflict here. 247 if (MI && NewMI != MI && 248 !MI->isIdenticalTo(*NewMI, *this, /*Syntactically=*/true)) 249 IsAmbiguous = true; 250 IsSystemMacro &= Active->getOwningModule()->IsSystem || 251 SourceMgr.isInSystemHeader(NewMI->getDefinitionLoc()); 252 MI = NewMI; 253 } 254 Info.IsAmbiguous = IsAmbiguous && !IsSystemMacro; 255 } 256 257 void Preprocessor::dumpMacroInfo(const IdentifierInfo *II) { 258 ArrayRef<ModuleMacro*> Leaf; 259 auto LeafIt = LeafModuleMacros.find(II); 260 if (LeafIt != LeafModuleMacros.end()) 261 Leaf = LeafIt->second; 262 const MacroState *State = nullptr; 263 auto Pos = CurSubmoduleState->Macros.find(II); 264 if (Pos != CurSubmoduleState->Macros.end()) 265 State = &Pos->second; 266 267 llvm::errs() << "MacroState " << State << " " << II->getNameStart(); 268 if (State && State->isAmbiguous(*this, II)) 269 llvm::errs() << " ambiguous"; 270 if (State && !State->getOverriddenMacros().empty()) { 271 llvm::errs() << " overrides"; 272 for (auto *O : State->getOverriddenMacros()) 273 llvm::errs() << " " << O->getOwningModule()->getFullModuleName(); 274 } 275 llvm::errs() << "\n"; 276 277 // Dump local macro directives. 278 for (auto *MD = State ? State->getLatest() : nullptr; MD; 279 MD = MD->getPrevious()) { 280 llvm::errs() << " "; 281 MD->dump(); 282 } 283 284 // Dump module macros. 285 llvm::DenseSet<ModuleMacro*> Active; 286 for (auto *MM : State ? State->getActiveModuleMacros(*this, II) : None) 287 Active.insert(MM); 288 llvm::DenseSet<ModuleMacro*> Visited; 289 llvm::SmallVector<ModuleMacro *, 16> Worklist(Leaf.begin(), Leaf.end()); 290 while (!Worklist.empty()) { 291 auto *MM = Worklist.pop_back_val(); 292 llvm::errs() << " ModuleMacro " << MM << " " 293 << MM->getOwningModule()->getFullModuleName(); 294 if (!MM->getMacroInfo()) 295 llvm::errs() << " undef"; 296 297 if (Active.count(MM)) 298 llvm::errs() << " active"; 299 else if (!CurSubmoduleState->VisibleModules.isVisible( 300 MM->getOwningModule())) 301 llvm::errs() << " hidden"; 302 else if (MM->getMacroInfo()) 303 llvm::errs() << " overridden"; 304 305 if (!MM->overrides().empty()) { 306 llvm::errs() << " overrides"; 307 for (auto *O : MM->overrides()) { 308 llvm::errs() << " " << O->getOwningModule()->getFullModuleName(); 309 if (Visited.insert(O).second) 310 Worklist.push_back(O); 311 } 312 } 313 llvm::errs() << "\n"; 314 if (auto *MI = MM->getMacroInfo()) { 315 llvm::errs() << " "; 316 MI->dump(); 317 llvm::errs() << "\n"; 318 } 319 } 320 } 321 322 /// RegisterBuiltinMacro - Register the specified identifier in the identifier 323 /// table and mark it as a builtin macro to be expanded. 324 static IdentifierInfo *RegisterBuiltinMacro(Preprocessor &PP, const char *Name){ 325 // Get the identifier. 326 IdentifierInfo *Id = PP.getIdentifierInfo(Name); 327 328 // Mark it as being a macro that is builtin. 329 MacroInfo *MI = PP.AllocateMacroInfo(SourceLocation()); 330 MI->setIsBuiltinMacro(); 331 PP.appendDefMacroDirective(Id, MI); 332 return Id; 333 } 334 335 /// RegisterBuiltinMacros - Register builtin macros, such as __LINE__ with the 336 /// identifier table. 337 void Preprocessor::RegisterBuiltinMacros() { 338 Ident__LINE__ = RegisterBuiltinMacro(*this, "__LINE__"); 339 Ident__FILE__ = RegisterBuiltinMacro(*this, "__FILE__"); 340 Ident__DATE__ = RegisterBuiltinMacro(*this, "__DATE__"); 341 Ident__TIME__ = RegisterBuiltinMacro(*this, "__TIME__"); 342 Ident__COUNTER__ = RegisterBuiltinMacro(*this, "__COUNTER__"); 343 Ident_Pragma = RegisterBuiltinMacro(*this, "_Pragma"); 344 345 // C++ Standing Document Extensions. 346 if (LangOpts.CPlusPlus) 347 Ident__has_cpp_attribute = 348 RegisterBuiltinMacro(*this, "__has_cpp_attribute"); 349 else 350 Ident__has_cpp_attribute = nullptr; 351 352 // GCC Extensions. 353 Ident__BASE_FILE__ = RegisterBuiltinMacro(*this, "__BASE_FILE__"); 354 Ident__INCLUDE_LEVEL__ = RegisterBuiltinMacro(*this, "__INCLUDE_LEVEL__"); 355 Ident__TIMESTAMP__ = RegisterBuiltinMacro(*this, "__TIMESTAMP__"); 356 357 // Microsoft Extensions. 358 if (LangOpts.MicrosoftExt) { 359 Ident__identifier = RegisterBuiltinMacro(*this, "__identifier"); 360 Ident__pragma = RegisterBuiltinMacro(*this, "__pragma"); 361 } else { 362 Ident__identifier = nullptr; 363 Ident__pragma = nullptr; 364 } 365 366 // Clang Extensions. 367 Ident__FILE_NAME__ = RegisterBuiltinMacro(*this, "__FILE_NAME__"); 368 Ident__has_feature = RegisterBuiltinMacro(*this, "__has_feature"); 369 Ident__has_extension = RegisterBuiltinMacro(*this, "__has_extension"); 370 Ident__has_builtin = RegisterBuiltinMacro(*this, "__has_builtin"); 371 Ident__has_attribute = RegisterBuiltinMacro(*this, "__has_attribute"); 372 Ident__has_c_attribute = RegisterBuiltinMacro(*this, "__has_c_attribute"); 373 Ident__has_declspec = RegisterBuiltinMacro(*this, "__has_declspec_attribute"); 374 Ident__has_include = RegisterBuiltinMacro(*this, "__has_include"); 375 Ident__has_include_next = RegisterBuiltinMacro(*this, "__has_include_next"); 376 Ident__has_warning = RegisterBuiltinMacro(*this, "__has_warning"); 377 Ident__is_identifier = RegisterBuiltinMacro(*this, "__is_identifier"); 378 Ident__is_target_arch = RegisterBuiltinMacro(*this, "__is_target_arch"); 379 Ident__is_target_vendor = RegisterBuiltinMacro(*this, "__is_target_vendor"); 380 Ident__is_target_os = RegisterBuiltinMacro(*this, "__is_target_os"); 381 Ident__is_target_environment = 382 RegisterBuiltinMacro(*this, "__is_target_environment"); 383 384 // Modules. 385 Ident__building_module = RegisterBuiltinMacro(*this, "__building_module"); 386 if (!LangOpts.CurrentModule.empty()) 387 Ident__MODULE__ = RegisterBuiltinMacro(*this, "__MODULE__"); 388 else 389 Ident__MODULE__ = nullptr; 390 } 391 392 /// isTrivialSingleTokenExpansion - Return true if MI, which has a single token 393 /// in its expansion, currently expands to that token literally. 394 static bool isTrivialSingleTokenExpansion(const MacroInfo *MI, 395 const IdentifierInfo *MacroIdent, 396 Preprocessor &PP) { 397 IdentifierInfo *II = MI->getReplacementToken(0).getIdentifierInfo(); 398 399 // If the token isn't an identifier, it's always literally expanded. 400 if (!II) return true; 401 402 // If the information about this identifier is out of date, update it from 403 // the external source. 404 if (II->isOutOfDate()) 405 PP.getExternalSource()->updateOutOfDateIdentifier(*II); 406 407 // If the identifier is a macro, and if that macro is enabled, it may be 408 // expanded so it's not a trivial expansion. 409 if (auto *ExpansionMI = PP.getMacroInfo(II)) 410 if (ExpansionMI->isEnabled() && 411 // Fast expanding "#define X X" is ok, because X would be disabled. 412 II != MacroIdent) 413 return false; 414 415 // If this is an object-like macro invocation, it is safe to trivially expand 416 // it. 417 if (MI->isObjectLike()) return true; 418 419 // If this is a function-like macro invocation, it's safe to trivially expand 420 // as long as the identifier is not a macro argument. 421 return std::find(MI->param_begin(), MI->param_end(), II) == MI->param_end(); 422 } 423 424 /// isNextPPTokenLParen - Determine whether the next preprocessor token to be 425 /// lexed is a '('. If so, consume the token and return true, if not, this 426 /// method should have no observable side-effect on the lexed tokens. 427 bool Preprocessor::isNextPPTokenLParen() { 428 // Do some quick tests for rejection cases. 429 unsigned Val; 430 if (CurLexer) 431 Val = CurLexer->isNextPPTokenLParen(); 432 else 433 Val = CurTokenLexer->isNextTokenLParen(); 434 435 if (Val == 2) { 436 // We have run off the end. If it's a source file we don't 437 // examine enclosing ones (C99 5.1.1.2p4). Otherwise walk up the 438 // macro stack. 439 if (CurPPLexer) 440 return false; 441 for (const IncludeStackInfo &Entry : llvm::reverse(IncludeMacroStack)) { 442 if (Entry.TheLexer) 443 Val = Entry.TheLexer->isNextPPTokenLParen(); 444 else 445 Val = Entry.TheTokenLexer->isNextTokenLParen(); 446 447 if (Val != 2) 448 break; 449 450 // Ran off the end of a source file? 451 if (Entry.ThePPLexer) 452 return false; 453 } 454 } 455 456 // Okay, if we know that the token is a '(', lex it and return. Otherwise we 457 // have found something that isn't a '(' or we found the end of the 458 // translation unit. In either case, return false. 459 return Val == 1; 460 } 461 462 /// HandleMacroExpandedIdentifier - If an identifier token is read that is to be 463 /// expanded as a macro, handle it and return the next token as 'Identifier'. 464 bool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier, 465 const MacroDefinition &M) { 466 MacroInfo *MI = M.getMacroInfo(); 467 468 // If this is a macro expansion in the "#if !defined(x)" line for the file, 469 // then the macro could expand to different things in other contexts, we need 470 // to disable the optimization in this case. 471 if (CurPPLexer) CurPPLexer->MIOpt.ExpandedMacro(); 472 473 // If this is a builtin macro, like __LINE__ or _Pragma, handle it specially. 474 if (MI->isBuiltinMacro()) { 475 if (Callbacks) 476 Callbacks->MacroExpands(Identifier, M, Identifier.getLocation(), 477 /*Args=*/nullptr); 478 ExpandBuiltinMacro(Identifier); 479 return true; 480 } 481 482 /// Args - If this is a function-like macro expansion, this contains, 483 /// for each macro argument, the list of tokens that were provided to the 484 /// invocation. 485 MacroArgs *Args = nullptr; 486 487 // Remember where the end of the expansion occurred. For an object-like 488 // macro, this is the identifier. For a function-like macro, this is the ')'. 489 SourceLocation ExpansionEnd = Identifier.getLocation(); 490 491 // If this is a function-like macro, read the arguments. 492 if (MI->isFunctionLike()) { 493 // Remember that we are now parsing the arguments to a macro invocation. 494 // Preprocessor directives used inside macro arguments are not portable, and 495 // this enables the warning. 496 InMacroArgs = true; 497 ArgMacro = &Identifier; 498 499 Args = ReadMacroCallArgumentList(Identifier, MI, ExpansionEnd); 500 501 // Finished parsing args. 502 InMacroArgs = false; 503 ArgMacro = nullptr; 504 505 // If there was an error parsing the arguments, bail out. 506 if (!Args) return true; 507 508 ++NumFnMacroExpanded; 509 } else { 510 ++NumMacroExpanded; 511 } 512 513 // Notice that this macro has been used. 514 markMacroAsUsed(MI); 515 516 // Remember where the token is expanded. 517 SourceLocation ExpandLoc = Identifier.getLocation(); 518 SourceRange ExpansionRange(ExpandLoc, ExpansionEnd); 519 520 if (Callbacks) { 521 if (InMacroArgs) { 522 // We can have macro expansion inside a conditional directive while 523 // reading the function macro arguments. To ensure, in that case, that 524 // MacroExpands callbacks still happen in source order, queue this 525 // callback to have it happen after the function macro callback. 526 DelayedMacroExpandsCallbacks.push_back( 527 MacroExpandsInfo(Identifier, M, ExpansionRange)); 528 } else { 529 Callbacks->MacroExpands(Identifier, M, ExpansionRange, Args); 530 if (!DelayedMacroExpandsCallbacks.empty()) { 531 for (const MacroExpandsInfo &Info : DelayedMacroExpandsCallbacks) { 532 // FIXME: We lose macro args info with delayed callback. 533 Callbacks->MacroExpands(Info.Tok, Info.MD, Info.Range, 534 /*Args=*/nullptr); 535 } 536 DelayedMacroExpandsCallbacks.clear(); 537 } 538 } 539 } 540 541 // If the macro definition is ambiguous, complain. 542 if (M.isAmbiguous()) { 543 Diag(Identifier, diag::warn_pp_ambiguous_macro) 544 << Identifier.getIdentifierInfo(); 545 Diag(MI->getDefinitionLoc(), diag::note_pp_ambiguous_macro_chosen) 546 << Identifier.getIdentifierInfo(); 547 M.forAllDefinitions([&](const MacroInfo *OtherMI) { 548 if (OtherMI != MI) 549 Diag(OtherMI->getDefinitionLoc(), diag::note_pp_ambiguous_macro_other) 550 << Identifier.getIdentifierInfo(); 551 }); 552 } 553 554 // If we started lexing a macro, enter the macro expansion body. 555 556 // If this macro expands to no tokens, don't bother to push it onto the 557 // expansion stack, only to take it right back off. 558 if (MI->getNumTokens() == 0) { 559 // No need for arg info. 560 if (Args) Args->destroy(*this); 561 562 // Propagate whitespace info as if we had pushed, then popped, 563 // a macro context. 564 Identifier.setFlag(Token::LeadingEmptyMacro); 565 PropagateLineStartLeadingSpaceInfo(Identifier); 566 ++NumFastMacroExpanded; 567 return false; 568 } else if (MI->getNumTokens() == 1 && 569 isTrivialSingleTokenExpansion(MI, Identifier.getIdentifierInfo(), 570 *this)) { 571 // Otherwise, if this macro expands into a single trivially-expanded 572 // token: expand it now. This handles common cases like 573 // "#define VAL 42". 574 575 // No need for arg info. 576 if (Args) Args->destroy(*this); 577 578 // Propagate the isAtStartOfLine/hasLeadingSpace markers of the macro 579 // identifier to the expanded token. 580 bool isAtStartOfLine = Identifier.isAtStartOfLine(); 581 bool hasLeadingSpace = Identifier.hasLeadingSpace(); 582 583 // Replace the result token. 584 Identifier = MI->getReplacementToken(0); 585 586 // Restore the StartOfLine/LeadingSpace markers. 587 Identifier.setFlagValue(Token::StartOfLine , isAtStartOfLine); 588 Identifier.setFlagValue(Token::LeadingSpace, hasLeadingSpace); 589 590 // Update the tokens location to include both its expansion and physical 591 // locations. 592 SourceLocation Loc = 593 SourceMgr.createExpansionLoc(Identifier.getLocation(), ExpandLoc, 594 ExpansionEnd,Identifier.getLength()); 595 Identifier.setLocation(Loc); 596 597 // If this is a disabled macro or #define X X, we must mark the result as 598 // unexpandable. 599 if (IdentifierInfo *NewII = Identifier.getIdentifierInfo()) { 600 if (MacroInfo *NewMI = getMacroInfo(NewII)) 601 if (!NewMI->isEnabled() || NewMI == MI) { 602 Identifier.setFlag(Token::DisableExpand); 603 // Don't warn for "#define X X" like "#define bool bool" from 604 // stdbool.h. 605 if (NewMI != MI || MI->isFunctionLike()) 606 Diag(Identifier, diag::pp_disabled_macro_expansion); 607 } 608 } 609 610 // Since this is not an identifier token, it can't be macro expanded, so 611 // we're done. 612 ++NumFastMacroExpanded; 613 return true; 614 } 615 616 // Start expanding the macro. 617 EnterMacro(Identifier, ExpansionEnd, MI, Args); 618 return false; 619 } 620 621 enum Bracket { 622 Brace, 623 Paren 624 }; 625 626 /// CheckMatchedBrackets - Returns true if the braces and parentheses in the 627 /// token vector are properly nested. 628 static bool CheckMatchedBrackets(const SmallVectorImpl<Token> &Tokens) { 629 SmallVector<Bracket, 8> Brackets; 630 for (SmallVectorImpl<Token>::const_iterator I = Tokens.begin(), 631 E = Tokens.end(); 632 I != E; ++I) { 633 if (I->is(tok::l_paren)) { 634 Brackets.push_back(Paren); 635 } else if (I->is(tok::r_paren)) { 636 if (Brackets.empty() || Brackets.back() == Brace) 637 return false; 638 Brackets.pop_back(); 639 } else if (I->is(tok::l_brace)) { 640 Brackets.push_back(Brace); 641 } else if (I->is(tok::r_brace)) { 642 if (Brackets.empty() || Brackets.back() == Paren) 643 return false; 644 Brackets.pop_back(); 645 } 646 } 647 return Brackets.empty(); 648 } 649 650 /// GenerateNewArgTokens - Returns true if OldTokens can be converted to a new 651 /// vector of tokens in NewTokens. The new number of arguments will be placed 652 /// in NumArgs and the ranges which need to surrounded in parentheses will be 653 /// in ParenHints. 654 /// Returns false if the token stream cannot be changed. If this is because 655 /// of an initializer list starting a macro argument, the range of those 656 /// initializer lists will be place in InitLists. 657 static bool GenerateNewArgTokens(Preprocessor &PP, 658 SmallVectorImpl<Token> &OldTokens, 659 SmallVectorImpl<Token> &NewTokens, 660 unsigned &NumArgs, 661 SmallVectorImpl<SourceRange> &ParenHints, 662 SmallVectorImpl<SourceRange> &InitLists) { 663 if (!CheckMatchedBrackets(OldTokens)) 664 return false; 665 666 // Once it is known that the brackets are matched, only a simple count of the 667 // braces is needed. 668 unsigned Braces = 0; 669 670 // First token of a new macro argument. 671 SmallVectorImpl<Token>::iterator ArgStartIterator = OldTokens.begin(); 672 673 // First closing brace in a new macro argument. Used to generate 674 // SourceRanges for InitLists. 675 SmallVectorImpl<Token>::iterator ClosingBrace = OldTokens.end(); 676 NumArgs = 0; 677 Token TempToken; 678 // Set to true when a macro separator token is found inside a braced list. 679 // If true, the fixed argument spans multiple old arguments and ParenHints 680 // will be updated. 681 bool FoundSeparatorToken = false; 682 for (SmallVectorImpl<Token>::iterator I = OldTokens.begin(), 683 E = OldTokens.end(); 684 I != E; ++I) { 685 if (I->is(tok::l_brace)) { 686 ++Braces; 687 } else if (I->is(tok::r_brace)) { 688 --Braces; 689 if (Braces == 0 && ClosingBrace == E && FoundSeparatorToken) 690 ClosingBrace = I; 691 } else if (I->is(tok::eof)) { 692 // EOF token is used to separate macro arguments 693 if (Braces != 0) { 694 // Assume comma separator is actually braced list separator and change 695 // it back to a comma. 696 FoundSeparatorToken = true; 697 I->setKind(tok::comma); 698 I->setLength(1); 699 } else { // Braces == 0 700 // Separator token still separates arguments. 701 ++NumArgs; 702 703 // If the argument starts with a brace, it can't be fixed with 704 // parentheses. A different diagnostic will be given. 705 if (FoundSeparatorToken && ArgStartIterator->is(tok::l_brace)) { 706 InitLists.push_back( 707 SourceRange(ArgStartIterator->getLocation(), 708 PP.getLocForEndOfToken(ClosingBrace->getLocation()))); 709 ClosingBrace = E; 710 } 711 712 // Add left paren 713 if (FoundSeparatorToken) { 714 TempToken.startToken(); 715 TempToken.setKind(tok::l_paren); 716 TempToken.setLocation(ArgStartIterator->getLocation()); 717 TempToken.setLength(0); 718 NewTokens.push_back(TempToken); 719 } 720 721 // Copy over argument tokens 722 NewTokens.insert(NewTokens.end(), ArgStartIterator, I); 723 724 // Add right paren and store the paren locations in ParenHints 725 if (FoundSeparatorToken) { 726 SourceLocation Loc = PP.getLocForEndOfToken((I - 1)->getLocation()); 727 TempToken.startToken(); 728 TempToken.setKind(tok::r_paren); 729 TempToken.setLocation(Loc); 730 TempToken.setLength(0); 731 NewTokens.push_back(TempToken); 732 ParenHints.push_back(SourceRange(ArgStartIterator->getLocation(), 733 Loc)); 734 } 735 736 // Copy separator token 737 NewTokens.push_back(*I); 738 739 // Reset values 740 ArgStartIterator = I + 1; 741 FoundSeparatorToken = false; 742 } 743 } 744 } 745 746 return !ParenHints.empty() && InitLists.empty(); 747 } 748 749 /// ReadFunctionLikeMacroArgs - After reading "MACRO" and knowing that the next 750 /// token is the '(' of the macro, this method is invoked to read all of the 751 /// actual arguments specified for the macro invocation. This returns null on 752 /// error. 753 MacroArgs *Preprocessor::ReadMacroCallArgumentList(Token &MacroName, 754 MacroInfo *MI, 755 SourceLocation &MacroEnd) { 756 // The number of fixed arguments to parse. 757 unsigned NumFixedArgsLeft = MI->getNumParams(); 758 bool isVariadic = MI->isVariadic(); 759 760 // Outer loop, while there are more arguments, keep reading them. 761 Token Tok; 762 763 // Read arguments as unexpanded tokens. This avoids issues, e.g., where 764 // an argument value in a macro could expand to ',' or '(' or ')'. 765 LexUnexpandedToken(Tok); 766 assert(Tok.is(tok::l_paren) && "Error computing l-paren-ness?"); 767 768 // ArgTokens - Build up a list of tokens that make up each argument. Each 769 // argument is separated by an EOF token. Use a SmallVector so we can avoid 770 // heap allocations in the common case. 771 SmallVector<Token, 64> ArgTokens; 772 bool ContainsCodeCompletionTok = false; 773 bool FoundElidedComma = false; 774 775 SourceLocation TooManyArgsLoc; 776 777 unsigned NumActuals = 0; 778 while (Tok.isNot(tok::r_paren)) { 779 if (ContainsCodeCompletionTok && Tok.isOneOf(tok::eof, tok::eod)) 780 break; 781 782 assert(Tok.isOneOf(tok::l_paren, tok::comma) && 783 "only expect argument separators here"); 784 785 size_t ArgTokenStart = ArgTokens.size(); 786 SourceLocation ArgStartLoc = Tok.getLocation(); 787 788 // C99 6.10.3p11: Keep track of the number of l_parens we have seen. Note 789 // that we already consumed the first one. 790 unsigned NumParens = 0; 791 792 while (true) { 793 // Read arguments as unexpanded tokens. This avoids issues, e.g., where 794 // an argument value in a macro could expand to ',' or '(' or ')'. 795 LexUnexpandedToken(Tok); 796 797 if (Tok.isOneOf(tok::eof, tok::eod)) { // "#if f(<eof>" & "#if f(\n" 798 if (!ContainsCodeCompletionTok) { 799 Diag(MacroName, diag::err_unterm_macro_invoc); 800 Diag(MI->getDefinitionLoc(), diag::note_macro_here) 801 << MacroName.getIdentifierInfo(); 802 // Do not lose the EOF/EOD. Return it to the client. 803 MacroName = Tok; 804 return nullptr; 805 } 806 // Do not lose the EOF/EOD. 807 auto Toks = llvm::make_unique<Token[]>(1); 808 Toks[0] = Tok; 809 EnterTokenStream(std::move(Toks), 1, true, /*IsReinject*/ false); 810 break; 811 } else if (Tok.is(tok::r_paren)) { 812 // If we found the ) token, the macro arg list is done. 813 if (NumParens-- == 0) { 814 MacroEnd = Tok.getLocation(); 815 if (!ArgTokens.empty() && 816 ArgTokens.back().commaAfterElided()) { 817 FoundElidedComma = true; 818 } 819 break; 820 } 821 } else if (Tok.is(tok::l_paren)) { 822 ++NumParens; 823 } else if (Tok.is(tok::comma) && NumParens == 0 && 824 !(Tok.getFlags() & Token::IgnoredComma)) { 825 // In Microsoft-compatibility mode, single commas from nested macro 826 // expansions should not be considered as argument separators. We test 827 // for this with the IgnoredComma token flag above. 828 829 // Comma ends this argument if there are more fixed arguments expected. 830 // However, if this is a variadic macro, and this is part of the 831 // variadic part, then the comma is just an argument token. 832 if (!isVariadic) break; 833 if (NumFixedArgsLeft > 1) 834 break; 835 } else if (Tok.is(tok::comment) && !KeepMacroComments) { 836 // If this is a comment token in the argument list and we're just in 837 // -C mode (not -CC mode), discard the comment. 838 continue; 839 } else if (!Tok.isAnnotation() && Tok.getIdentifierInfo() != nullptr) { 840 // Reading macro arguments can cause macros that we are currently 841 // expanding from to be popped off the expansion stack. Doing so causes 842 // them to be reenabled for expansion. Here we record whether any 843 // identifiers we lex as macro arguments correspond to disabled macros. 844 // If so, we mark the token as noexpand. This is a subtle aspect of 845 // C99 6.10.3.4p2. 846 if (MacroInfo *MI = getMacroInfo(Tok.getIdentifierInfo())) 847 if (!MI->isEnabled()) 848 Tok.setFlag(Token::DisableExpand); 849 } else if (Tok.is(tok::code_completion)) { 850 ContainsCodeCompletionTok = true; 851 if (CodeComplete) 852 CodeComplete->CodeCompleteMacroArgument(MacroName.getIdentifierInfo(), 853 MI, NumActuals); 854 // Don't mark that we reached the code-completion point because the 855 // parser is going to handle the token and there will be another 856 // code-completion callback. 857 } 858 859 ArgTokens.push_back(Tok); 860 } 861 862 // If this was an empty argument list foo(), don't add this as an empty 863 // argument. 864 if (ArgTokens.empty() && Tok.getKind() == tok::r_paren) 865 break; 866 867 // If this is not a variadic macro, and too many args were specified, emit 868 // an error. 869 if (!isVariadic && NumFixedArgsLeft == 0 && TooManyArgsLoc.isInvalid()) { 870 if (ArgTokens.size() != ArgTokenStart) 871 TooManyArgsLoc = ArgTokens[ArgTokenStart].getLocation(); 872 else 873 TooManyArgsLoc = ArgStartLoc; 874 } 875 876 // Empty arguments are standard in C99 and C++0x, and are supported as an 877 // extension in other modes. 878 if (ArgTokens.size() == ArgTokenStart && !LangOpts.C99) 879 Diag(Tok, LangOpts.CPlusPlus11 ? 880 diag::warn_cxx98_compat_empty_fnmacro_arg : 881 diag::ext_empty_fnmacro_arg); 882 883 // Add a marker EOF token to the end of the token list for this argument. 884 Token EOFTok; 885 EOFTok.startToken(); 886 EOFTok.setKind(tok::eof); 887 EOFTok.setLocation(Tok.getLocation()); 888 EOFTok.setLength(0); 889 ArgTokens.push_back(EOFTok); 890 ++NumActuals; 891 if (!ContainsCodeCompletionTok && NumFixedArgsLeft != 0) 892 --NumFixedArgsLeft; 893 } 894 895 // Okay, we either found the r_paren. Check to see if we parsed too few 896 // arguments. 897 unsigned MinArgsExpected = MI->getNumParams(); 898 899 // If this is not a variadic macro, and too many args were specified, emit 900 // an error. 901 if (!isVariadic && NumActuals > MinArgsExpected && 902 !ContainsCodeCompletionTok) { 903 // Emit the diagnostic at the macro name in case there is a missing ). 904 // Emitting it at the , could be far away from the macro name. 905 Diag(TooManyArgsLoc, diag::err_too_many_args_in_macro_invoc); 906 Diag(MI->getDefinitionLoc(), diag::note_macro_here) 907 << MacroName.getIdentifierInfo(); 908 909 // Commas from braced initializer lists will be treated as argument 910 // separators inside macros. Attempt to correct for this with parentheses. 911 // TODO: See if this can be generalized to angle brackets for templates 912 // inside macro arguments. 913 914 SmallVector<Token, 4> FixedArgTokens; 915 unsigned FixedNumArgs = 0; 916 SmallVector<SourceRange, 4> ParenHints, InitLists; 917 if (!GenerateNewArgTokens(*this, ArgTokens, FixedArgTokens, FixedNumArgs, 918 ParenHints, InitLists)) { 919 if (!InitLists.empty()) { 920 DiagnosticBuilder DB = 921 Diag(MacroName, 922 diag::note_init_list_at_beginning_of_macro_argument); 923 for (SourceRange Range : InitLists) 924 DB << Range; 925 } 926 return nullptr; 927 } 928 if (FixedNumArgs != MinArgsExpected) 929 return nullptr; 930 931 DiagnosticBuilder DB = Diag(MacroName, diag::note_suggest_parens_for_macro); 932 for (SourceRange ParenLocation : ParenHints) { 933 DB << FixItHint::CreateInsertion(ParenLocation.getBegin(), "("); 934 DB << FixItHint::CreateInsertion(ParenLocation.getEnd(), ")"); 935 } 936 ArgTokens.swap(FixedArgTokens); 937 NumActuals = FixedNumArgs; 938 } 939 940 // See MacroArgs instance var for description of this. 941 bool isVarargsElided = false; 942 943 if (ContainsCodeCompletionTok) { 944 // Recover from not-fully-formed macro invocation during code-completion. 945 Token EOFTok; 946 EOFTok.startToken(); 947 EOFTok.setKind(tok::eof); 948 EOFTok.setLocation(Tok.getLocation()); 949 EOFTok.setLength(0); 950 for (; NumActuals < MinArgsExpected; ++NumActuals) 951 ArgTokens.push_back(EOFTok); 952 } 953 954 if (NumActuals < MinArgsExpected) { 955 // There are several cases where too few arguments is ok, handle them now. 956 if (NumActuals == 0 && MinArgsExpected == 1) { 957 // #define A(X) or #define A(...) ---> A() 958 959 // If there is exactly one argument, and that argument is missing, 960 // then we have an empty "()" argument empty list. This is fine, even if 961 // the macro expects one argument (the argument is just empty). 962 isVarargsElided = MI->isVariadic(); 963 } else if ((FoundElidedComma || MI->isVariadic()) && 964 (NumActuals+1 == MinArgsExpected || // A(x, ...) -> A(X) 965 (NumActuals == 0 && MinArgsExpected == 2))) {// A(x,...) -> A() 966 // Varargs where the named vararg parameter is missing: OK as extension. 967 // #define A(x, ...) 968 // A("blah") 969 // 970 // If the macro contains the comma pasting extension, the diagnostic 971 // is suppressed; we know we'll get another diagnostic later. 972 if (!MI->hasCommaPasting()) { 973 Diag(Tok, diag::ext_missing_varargs_arg); 974 Diag(MI->getDefinitionLoc(), diag::note_macro_here) 975 << MacroName.getIdentifierInfo(); 976 } 977 978 // Remember this occurred, allowing us to elide the comma when used for 979 // cases like: 980 // #define A(x, foo...) blah(a, ## foo) 981 // #define B(x, ...) blah(a, ## __VA_ARGS__) 982 // #define C(...) blah(a, ## __VA_ARGS__) 983 // A(x) B(x) C() 984 isVarargsElided = true; 985 } else if (!ContainsCodeCompletionTok) { 986 // Otherwise, emit the error. 987 Diag(Tok, diag::err_too_few_args_in_macro_invoc); 988 Diag(MI->getDefinitionLoc(), diag::note_macro_here) 989 << MacroName.getIdentifierInfo(); 990 return nullptr; 991 } 992 993 // Add a marker EOF token to the end of the token list for this argument. 994 SourceLocation EndLoc = Tok.getLocation(); 995 Tok.startToken(); 996 Tok.setKind(tok::eof); 997 Tok.setLocation(EndLoc); 998 Tok.setLength(0); 999 ArgTokens.push_back(Tok); 1000 1001 // If we expect two arguments, add both as empty. 1002 if (NumActuals == 0 && MinArgsExpected == 2) 1003 ArgTokens.push_back(Tok); 1004 1005 } else if (NumActuals > MinArgsExpected && !MI->isVariadic() && 1006 !ContainsCodeCompletionTok) { 1007 // Emit the diagnostic at the macro name in case there is a missing ). 1008 // Emitting it at the , could be far away from the macro name. 1009 Diag(MacroName, diag::err_too_many_args_in_macro_invoc); 1010 Diag(MI->getDefinitionLoc(), diag::note_macro_here) 1011 << MacroName.getIdentifierInfo(); 1012 return nullptr; 1013 } 1014 1015 return MacroArgs::create(MI, ArgTokens, isVarargsElided, *this); 1016 } 1017 1018 /// Keeps macro expanded tokens for TokenLexers. 1019 // 1020 /// Works like a stack; a TokenLexer adds the macro expanded tokens that is 1021 /// going to lex in the cache and when it finishes the tokens are removed 1022 /// from the end of the cache. 1023 Token *Preprocessor::cacheMacroExpandedTokens(TokenLexer *tokLexer, 1024 ArrayRef<Token> tokens) { 1025 assert(tokLexer); 1026 if (tokens.empty()) 1027 return nullptr; 1028 1029 size_t newIndex = MacroExpandedTokens.size(); 1030 bool cacheNeedsToGrow = tokens.size() > 1031 MacroExpandedTokens.capacity()-MacroExpandedTokens.size(); 1032 MacroExpandedTokens.append(tokens.begin(), tokens.end()); 1033 1034 if (cacheNeedsToGrow) { 1035 // Go through all the TokenLexers whose 'Tokens' pointer points in the 1036 // buffer and update the pointers to the (potential) new buffer array. 1037 for (const auto &Lexer : MacroExpandingLexersStack) { 1038 TokenLexer *prevLexer; 1039 size_t tokIndex; 1040 std::tie(prevLexer, tokIndex) = Lexer; 1041 prevLexer->Tokens = MacroExpandedTokens.data() + tokIndex; 1042 } 1043 } 1044 1045 MacroExpandingLexersStack.push_back(std::make_pair(tokLexer, newIndex)); 1046 return MacroExpandedTokens.data() + newIndex; 1047 } 1048 1049 void Preprocessor::removeCachedMacroExpandedTokensOfLastLexer() { 1050 assert(!MacroExpandingLexersStack.empty()); 1051 size_t tokIndex = MacroExpandingLexersStack.back().second; 1052 assert(tokIndex < MacroExpandedTokens.size()); 1053 // Pop the cached macro expanded tokens from the end. 1054 MacroExpandedTokens.resize(tokIndex); 1055 MacroExpandingLexersStack.pop_back(); 1056 } 1057 1058 /// ComputeDATE_TIME - Compute the current time, enter it into the specified 1059 /// scratch buffer, then return DATELoc/TIMELoc locations with the position of 1060 /// the identifier tokens inserted. 1061 static void ComputeDATE_TIME(SourceLocation &DATELoc, SourceLocation &TIMELoc, 1062 Preprocessor &PP) { 1063 time_t TT = time(nullptr); 1064 struct tm *TM = localtime(&TT); 1065 1066 static const char * const Months[] = { 1067 "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec" 1068 }; 1069 1070 { 1071 SmallString<32> TmpBuffer; 1072 llvm::raw_svector_ostream TmpStream(TmpBuffer); 1073 TmpStream << llvm::format("\"%s %2d %4d\"", Months[TM->tm_mon], 1074 TM->tm_mday, TM->tm_year + 1900); 1075 Token TmpTok; 1076 TmpTok.startToken(); 1077 PP.CreateString(TmpStream.str(), TmpTok); 1078 DATELoc = TmpTok.getLocation(); 1079 } 1080 1081 { 1082 SmallString<32> TmpBuffer; 1083 llvm::raw_svector_ostream TmpStream(TmpBuffer); 1084 TmpStream << llvm::format("\"%02d:%02d:%02d\"", 1085 TM->tm_hour, TM->tm_min, TM->tm_sec); 1086 Token TmpTok; 1087 TmpTok.startToken(); 1088 PP.CreateString(TmpStream.str(), TmpTok); 1089 TIMELoc = TmpTok.getLocation(); 1090 } 1091 } 1092 1093 /// HasFeature - Return true if we recognize and implement the feature 1094 /// specified by the identifier as a standard language feature. 1095 static bool HasFeature(const Preprocessor &PP, StringRef Feature) { 1096 const LangOptions &LangOpts = PP.getLangOpts(); 1097 1098 // Normalize the feature name, __foo__ becomes foo. 1099 if (Feature.startswith("__") && Feature.endswith("__") && Feature.size() >= 4) 1100 Feature = Feature.substr(2, Feature.size() - 4); 1101 1102 #define FEATURE(Name, Predicate) .Case(#Name, Predicate) 1103 return llvm::StringSwitch<bool>(Feature) 1104 #include "clang/Basic/Features.def" 1105 .Default(false); 1106 #undef FEATURE 1107 } 1108 1109 /// HasExtension - Return true if we recognize and implement the feature 1110 /// specified by the identifier, either as an extension or a standard language 1111 /// feature. 1112 static bool HasExtension(const Preprocessor &PP, StringRef Extension) { 1113 if (HasFeature(PP, Extension)) 1114 return true; 1115 1116 // If the use of an extension results in an error diagnostic, extensions are 1117 // effectively unavailable, so just return false here. 1118 if (PP.getDiagnostics().getExtensionHandlingBehavior() >= 1119 diag::Severity::Error) 1120 return false; 1121 1122 const LangOptions &LangOpts = PP.getLangOpts(); 1123 1124 // Normalize the extension name, __foo__ becomes foo. 1125 if (Extension.startswith("__") && Extension.endswith("__") && 1126 Extension.size() >= 4) 1127 Extension = Extension.substr(2, Extension.size() - 4); 1128 1129 // Because we inherit the feature list from HasFeature, this string switch 1130 // must be less restrictive than HasFeature's. 1131 #define EXTENSION(Name, Predicate) .Case(#Name, Predicate) 1132 return llvm::StringSwitch<bool>(Extension) 1133 #include "clang/Basic/Features.def" 1134 .Default(false); 1135 #undef EXTENSION 1136 } 1137 1138 /// EvaluateHasIncludeCommon - Process a '__has_include("path")' 1139 /// or '__has_include_next("path")' expression. 1140 /// Returns true if successful. 1141 static bool EvaluateHasIncludeCommon(Token &Tok, 1142 IdentifierInfo *II, Preprocessor &PP, 1143 const DirectoryLookup *LookupFrom, 1144 const FileEntry *LookupFromFile) { 1145 // Save the location of the current token. If a '(' is later found, use 1146 // that location. If not, use the end of this location instead. 1147 SourceLocation LParenLoc = Tok.getLocation(); 1148 1149 // These expressions are only allowed within a preprocessor directive. 1150 if (!PP.isParsingIfOrElifDirective()) { 1151 PP.Diag(LParenLoc, diag::err_pp_directive_required) << II; 1152 // Return a valid identifier token. 1153 assert(Tok.is(tok::identifier)); 1154 Tok.setIdentifierInfo(II); 1155 return false; 1156 } 1157 1158 // Get '('. If we don't have a '(', try to form a header-name token. 1159 do { 1160 if (PP.LexHeaderName(Tok)) 1161 return false; 1162 } while (Tok.getKind() == tok::comment); 1163 1164 // Ensure we have a '('. 1165 if (Tok.isNot(tok::l_paren)) { 1166 // No '(', use end of last token. 1167 LParenLoc = PP.getLocForEndOfToken(LParenLoc); 1168 PP.Diag(LParenLoc, diag::err_pp_expected_after) << II << tok::l_paren; 1169 // If the next token looks like a filename or the start of one, 1170 // assume it is and process it as such. 1171 if (Tok.isNot(tok::header_name)) 1172 return false; 1173 } else { 1174 // Save '(' location for possible missing ')' message. 1175 LParenLoc = Tok.getLocation(); 1176 if (PP.LexHeaderName(Tok)) 1177 return false; 1178 } 1179 1180 if (Tok.isNot(tok::header_name)) { 1181 PP.Diag(Tok.getLocation(), diag::err_pp_expects_filename); 1182 return false; 1183 } 1184 1185 // Reserve a buffer to get the spelling. 1186 SmallString<128> FilenameBuffer; 1187 bool Invalid = false; 1188 StringRef Filename = PP.getSpelling(Tok, FilenameBuffer, &Invalid); 1189 if (Invalid) 1190 return false; 1191 1192 SourceLocation FilenameLoc = Tok.getLocation(); 1193 1194 // Get ')'. 1195 PP.LexNonComment(Tok); 1196 1197 // Ensure we have a trailing ). 1198 if (Tok.isNot(tok::r_paren)) { 1199 PP.Diag(PP.getLocForEndOfToken(FilenameLoc), diag::err_pp_expected_after) 1200 << II << tok::r_paren; 1201 PP.Diag(LParenLoc, diag::note_matching) << tok::l_paren; 1202 return false; 1203 } 1204 1205 bool isAngled = PP.GetIncludeFilenameSpelling(Tok.getLocation(), Filename); 1206 // If GetIncludeFilenameSpelling set the start ptr to null, there was an 1207 // error. 1208 if (Filename.empty()) 1209 return false; 1210 1211 // Search include directories. 1212 const DirectoryLookup *CurDir; 1213 const FileEntry *File = 1214 PP.LookupFile(FilenameLoc, Filename, isAngled, LookupFrom, LookupFromFile, 1215 CurDir, nullptr, nullptr, nullptr, nullptr, nullptr); 1216 1217 if (PPCallbacks *Callbacks = PP.getPPCallbacks()) { 1218 SrcMgr::CharacteristicKind FileType = SrcMgr::C_User; 1219 if (File) 1220 FileType = PP.getHeaderSearchInfo().getFileDirFlavor(File); 1221 Callbacks->HasInclude(FilenameLoc, Filename, isAngled, File, FileType); 1222 } 1223 1224 // Get the result value. A result of true means the file exists. 1225 return File != nullptr; 1226 } 1227 1228 /// EvaluateHasInclude - Process a '__has_include("path")' expression. 1229 /// Returns true if successful. 1230 static bool EvaluateHasInclude(Token &Tok, IdentifierInfo *II, 1231 Preprocessor &PP) { 1232 return EvaluateHasIncludeCommon(Tok, II, PP, nullptr, nullptr); 1233 } 1234 1235 /// EvaluateHasIncludeNext - Process '__has_include_next("path")' expression. 1236 /// Returns true if successful. 1237 static bool EvaluateHasIncludeNext(Token &Tok, 1238 IdentifierInfo *II, Preprocessor &PP) { 1239 // __has_include_next is like __has_include, except that we start 1240 // searching after the current found directory. If we can't do this, 1241 // issue a diagnostic. 1242 // FIXME: Factor out duplication with 1243 // Preprocessor::HandleIncludeNextDirective. 1244 const DirectoryLookup *Lookup = PP.GetCurDirLookup(); 1245 const FileEntry *LookupFromFile = nullptr; 1246 if (PP.isInPrimaryFile() && PP.getLangOpts().IsHeaderFile) { 1247 // If the main file is a header, then it's either for PCH/AST generation, 1248 // or libclang opened it. Either way, handle it as a normal include below 1249 // and do not complain about __has_include_next. 1250 } else if (PP.isInPrimaryFile()) { 1251 Lookup = nullptr; 1252 PP.Diag(Tok, diag::pp_include_next_in_primary); 1253 } else if (PP.getCurrentLexerSubmodule()) { 1254 // Start looking up in the directory *after* the one in which the current 1255 // file would be found, if any. 1256 assert(PP.getCurrentLexer() && "#include_next directive in macro?"); 1257 LookupFromFile = PP.getCurrentLexer()->getFileEntry(); 1258 Lookup = nullptr; 1259 } else if (!Lookup) { 1260 PP.Diag(Tok, diag::pp_include_next_absolute_path); 1261 } else { 1262 // Start looking up in the next directory. 1263 ++Lookup; 1264 } 1265 1266 return EvaluateHasIncludeCommon(Tok, II, PP, Lookup, LookupFromFile); 1267 } 1268 1269 /// Process single-argument builtin feature-like macros that return 1270 /// integer values. 1271 static void EvaluateFeatureLikeBuiltinMacro(llvm::raw_svector_ostream& OS, 1272 Token &Tok, IdentifierInfo *II, 1273 Preprocessor &PP, 1274 llvm::function_ref< 1275 int(Token &Tok, 1276 bool &HasLexedNextTok)> Op) { 1277 // Parse the initial '('. 1278 PP.LexUnexpandedToken(Tok); 1279 if (Tok.isNot(tok::l_paren)) { 1280 PP.Diag(Tok.getLocation(), diag::err_pp_expected_after) << II 1281 << tok::l_paren; 1282 1283 // Provide a dummy '0' value on output stream to elide further errors. 1284 if (!Tok.isOneOf(tok::eof, tok::eod)) { 1285 OS << 0; 1286 Tok.setKind(tok::numeric_constant); 1287 } 1288 return; 1289 } 1290 1291 unsigned ParenDepth = 1; 1292 SourceLocation LParenLoc = Tok.getLocation(); 1293 llvm::Optional<int> Result; 1294 1295 Token ResultTok; 1296 bool SuppressDiagnostic = false; 1297 while (true) { 1298 // Parse next token. 1299 PP.LexUnexpandedToken(Tok); 1300 1301 already_lexed: 1302 switch (Tok.getKind()) { 1303 case tok::eof: 1304 case tok::eod: 1305 // Don't provide even a dummy value if the eod or eof marker is 1306 // reached. Simply provide a diagnostic. 1307 PP.Diag(Tok.getLocation(), diag::err_unterm_macro_invoc); 1308 return; 1309 1310 case tok::comma: 1311 if (!SuppressDiagnostic) { 1312 PP.Diag(Tok.getLocation(), diag::err_too_many_args_in_macro_invoc); 1313 SuppressDiagnostic = true; 1314 } 1315 continue; 1316 1317 case tok::l_paren: 1318 ++ParenDepth; 1319 if (Result.hasValue()) 1320 break; 1321 if (!SuppressDiagnostic) { 1322 PP.Diag(Tok.getLocation(), diag::err_pp_nested_paren) << II; 1323 SuppressDiagnostic = true; 1324 } 1325 continue; 1326 1327 case tok::r_paren: 1328 if (--ParenDepth > 0) 1329 continue; 1330 1331 // The last ')' has been reached; return the value if one found or 1332 // a diagnostic and a dummy value. 1333 if (Result.hasValue()) { 1334 OS << Result.getValue(); 1335 // For strict conformance to __has_cpp_attribute rules, use 'L' 1336 // suffix for dated literals. 1337 if (Result.getValue() > 1) 1338 OS << 'L'; 1339 } else { 1340 OS << 0; 1341 if (!SuppressDiagnostic) 1342 PP.Diag(Tok.getLocation(), diag::err_too_few_args_in_macro_invoc); 1343 } 1344 Tok.setKind(tok::numeric_constant); 1345 return; 1346 1347 default: { 1348 // Parse the macro argument, if one not found so far. 1349 if (Result.hasValue()) 1350 break; 1351 1352 bool HasLexedNextToken = false; 1353 Result = Op(Tok, HasLexedNextToken); 1354 ResultTok = Tok; 1355 if (HasLexedNextToken) 1356 goto already_lexed; 1357 continue; 1358 } 1359 } 1360 1361 // Diagnose missing ')'. 1362 if (!SuppressDiagnostic) { 1363 if (auto Diag = PP.Diag(Tok.getLocation(), diag::err_pp_expected_after)) { 1364 if (IdentifierInfo *LastII = ResultTok.getIdentifierInfo()) 1365 Diag << LastII; 1366 else 1367 Diag << ResultTok.getKind(); 1368 Diag << tok::r_paren << ResultTok.getLocation(); 1369 } 1370 PP.Diag(LParenLoc, diag::note_matching) << tok::l_paren; 1371 SuppressDiagnostic = true; 1372 } 1373 } 1374 } 1375 1376 /// Helper function to return the IdentifierInfo structure of a Token 1377 /// or generate a diagnostic if none available. 1378 static IdentifierInfo *ExpectFeatureIdentifierInfo(Token &Tok, 1379 Preprocessor &PP, 1380 signed DiagID) { 1381 IdentifierInfo *II; 1382 if (!Tok.isAnnotation() && (II = Tok.getIdentifierInfo())) 1383 return II; 1384 1385 PP.Diag(Tok.getLocation(), DiagID); 1386 return nullptr; 1387 } 1388 1389 /// Implements the __is_target_arch builtin macro. 1390 static bool isTargetArch(const TargetInfo &TI, const IdentifierInfo *II) { 1391 std::string ArchName = II->getName().lower() + "--"; 1392 llvm::Triple Arch(ArchName); 1393 const llvm::Triple &TT = TI.getTriple(); 1394 if (TT.isThumb()) { 1395 // arm matches thumb or thumbv7. armv7 matches thumbv7. 1396 if ((Arch.getSubArch() == llvm::Triple::NoSubArch || 1397 Arch.getSubArch() == TT.getSubArch()) && 1398 ((TT.getArch() == llvm::Triple::thumb && 1399 Arch.getArch() == llvm::Triple::arm) || 1400 (TT.getArch() == llvm::Triple::thumbeb && 1401 Arch.getArch() == llvm::Triple::armeb))) 1402 return true; 1403 } 1404 // Check the parsed arch when it has no sub arch to allow Clang to 1405 // match thumb to thumbv7 but to prohibit matching thumbv6 to thumbv7. 1406 return (Arch.getSubArch() == llvm::Triple::NoSubArch || 1407 Arch.getSubArch() == TT.getSubArch()) && 1408 Arch.getArch() == TT.getArch(); 1409 } 1410 1411 /// Implements the __is_target_vendor builtin macro. 1412 static bool isTargetVendor(const TargetInfo &TI, const IdentifierInfo *II) { 1413 StringRef VendorName = TI.getTriple().getVendorName(); 1414 if (VendorName.empty()) 1415 VendorName = "unknown"; 1416 return VendorName.equals_lower(II->getName()); 1417 } 1418 1419 /// Implements the __is_target_os builtin macro. 1420 static bool isTargetOS(const TargetInfo &TI, const IdentifierInfo *II) { 1421 std::string OSName = 1422 (llvm::Twine("unknown-unknown-") + II->getName().lower()).str(); 1423 llvm::Triple OS(OSName); 1424 if (OS.getOS() == llvm::Triple::Darwin) { 1425 // Darwin matches macos, ios, etc. 1426 return TI.getTriple().isOSDarwin(); 1427 } 1428 return TI.getTriple().getOS() == OS.getOS(); 1429 } 1430 1431 /// Implements the __is_target_environment builtin macro. 1432 static bool isTargetEnvironment(const TargetInfo &TI, 1433 const IdentifierInfo *II) { 1434 std::string EnvName = (llvm::Twine("---") + II->getName().lower()).str(); 1435 llvm::Triple Env(EnvName); 1436 return TI.getTriple().getEnvironment() == Env.getEnvironment(); 1437 } 1438 1439 /// ExpandBuiltinMacro - If an identifier token is read that is to be expanded 1440 /// as a builtin macro, handle it and return the next token as 'Tok'. 1441 void Preprocessor::ExpandBuiltinMacro(Token &Tok) { 1442 // Figure out which token this is. 1443 IdentifierInfo *II = Tok.getIdentifierInfo(); 1444 assert(II && "Can't be a macro without id info!"); 1445 1446 // If this is an _Pragma or Microsoft __pragma directive, expand it, 1447 // invoke the pragma handler, then lex the token after it. 1448 if (II == Ident_Pragma) 1449 return Handle_Pragma(Tok); 1450 else if (II == Ident__pragma) // in non-MS mode this is null 1451 return HandleMicrosoft__pragma(Tok); 1452 1453 ++NumBuiltinMacroExpanded; 1454 1455 SmallString<128> TmpBuffer; 1456 llvm::raw_svector_ostream OS(TmpBuffer); 1457 1458 // Set up the return result. 1459 Tok.setIdentifierInfo(nullptr); 1460 Tok.clearFlag(Token::NeedsCleaning); 1461 bool IsAtStartOfLine = Tok.isAtStartOfLine(); 1462 bool HasLeadingSpace = Tok.hasLeadingSpace(); 1463 1464 if (II == Ident__LINE__) { 1465 // C99 6.10.8: "__LINE__: The presumed line number (within the current 1466 // source file) of the current source line (an integer constant)". This can 1467 // be affected by #line. 1468 SourceLocation Loc = Tok.getLocation(); 1469 1470 // Advance to the location of the first _, this might not be the first byte 1471 // of the token if it starts with an escaped newline. 1472 Loc = AdvanceToTokenCharacter(Loc, 0); 1473 1474 // One wrinkle here is that GCC expands __LINE__ to location of the *end* of 1475 // a macro expansion. This doesn't matter for object-like macros, but 1476 // can matter for a function-like macro that expands to contain __LINE__. 1477 // Skip down through expansion points until we find a file loc for the 1478 // end of the expansion history. 1479 Loc = SourceMgr.getExpansionRange(Loc).getEnd(); 1480 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Loc); 1481 1482 // __LINE__ expands to a simple numeric value. 1483 OS << (PLoc.isValid()? PLoc.getLine() : 1); 1484 Tok.setKind(tok::numeric_constant); 1485 } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__ || 1486 II == Ident__FILE_NAME__) { 1487 // C99 6.10.8: "__FILE__: The presumed name of the current source file (a 1488 // character string literal)". This can be affected by #line. 1489 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation()); 1490 1491 // __BASE_FILE__ is a GNU extension that returns the top of the presumed 1492 // #include stack instead of the current file. 1493 if (II == Ident__BASE_FILE__ && PLoc.isValid()) { 1494 SourceLocation NextLoc = PLoc.getIncludeLoc(); 1495 while (NextLoc.isValid()) { 1496 PLoc = SourceMgr.getPresumedLoc(NextLoc); 1497 if (PLoc.isInvalid()) 1498 break; 1499 1500 NextLoc = PLoc.getIncludeLoc(); 1501 } 1502 } 1503 1504 // Escape this filename. Turn '\' -> '\\' '"' -> '\"' 1505 SmallString<128> FN; 1506 if (PLoc.isValid()) { 1507 // __FILE_NAME__ is a Clang-specific extension that expands to the 1508 // the last part of __FILE__. 1509 if (II == Ident__FILE_NAME__) { 1510 // Try to get the last path component, failing that return the original 1511 // presumed location. 1512 StringRef PLFileName = llvm::sys::path::filename(PLoc.getFilename()); 1513 if (PLFileName != "") 1514 FN += PLFileName; 1515 else 1516 FN += PLoc.getFilename(); 1517 } else { 1518 FN += PLoc.getFilename(); 1519 } 1520 Lexer::Stringify(FN); 1521 OS << '"' << FN << '"'; 1522 } 1523 Tok.setKind(tok::string_literal); 1524 } else if (II == Ident__DATE__) { 1525 Diag(Tok.getLocation(), diag::warn_pp_date_time); 1526 if (!DATELoc.isValid()) 1527 ComputeDATE_TIME(DATELoc, TIMELoc, *this); 1528 Tok.setKind(tok::string_literal); 1529 Tok.setLength(strlen("\"Mmm dd yyyy\"")); 1530 Tok.setLocation(SourceMgr.createExpansionLoc(DATELoc, Tok.getLocation(), 1531 Tok.getLocation(), 1532 Tok.getLength())); 1533 return; 1534 } else if (II == Ident__TIME__) { 1535 Diag(Tok.getLocation(), diag::warn_pp_date_time); 1536 if (!TIMELoc.isValid()) 1537 ComputeDATE_TIME(DATELoc, TIMELoc, *this); 1538 Tok.setKind(tok::string_literal); 1539 Tok.setLength(strlen("\"hh:mm:ss\"")); 1540 Tok.setLocation(SourceMgr.createExpansionLoc(TIMELoc, Tok.getLocation(), 1541 Tok.getLocation(), 1542 Tok.getLength())); 1543 return; 1544 } else if (II == Ident__INCLUDE_LEVEL__) { 1545 // Compute the presumed include depth of this token. This can be affected 1546 // by GNU line markers. 1547 unsigned Depth = 0; 1548 1549 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation()); 1550 if (PLoc.isValid()) { 1551 PLoc = SourceMgr.getPresumedLoc(PLoc.getIncludeLoc()); 1552 for (; PLoc.isValid(); ++Depth) 1553 PLoc = SourceMgr.getPresumedLoc(PLoc.getIncludeLoc()); 1554 } 1555 1556 // __INCLUDE_LEVEL__ expands to a simple numeric value. 1557 OS << Depth; 1558 Tok.setKind(tok::numeric_constant); 1559 } else if (II == Ident__TIMESTAMP__) { 1560 Diag(Tok.getLocation(), diag::warn_pp_date_time); 1561 // MSVC, ICC, GCC, VisualAge C++ extension. The generated string should be 1562 // of the form "Ddd Mmm dd hh::mm::ss yyyy", which is returned by asctime. 1563 1564 // Get the file that we are lexing out of. If we're currently lexing from 1565 // a macro, dig into the include stack. 1566 const FileEntry *CurFile = nullptr; 1567 PreprocessorLexer *TheLexer = getCurrentFileLexer(); 1568 1569 if (TheLexer) 1570 CurFile = SourceMgr.getFileEntryForID(TheLexer->getFileID()); 1571 1572 const char *Result; 1573 if (CurFile) { 1574 time_t TT = CurFile->getModificationTime(); 1575 struct tm *TM = localtime(&TT); 1576 Result = asctime(TM); 1577 } else { 1578 Result = "??? ??? ?? ??:??:?? ????\n"; 1579 } 1580 // Surround the string with " and strip the trailing newline. 1581 OS << '"' << StringRef(Result).drop_back() << '"'; 1582 Tok.setKind(tok::string_literal); 1583 } else if (II == Ident__COUNTER__) { 1584 // __COUNTER__ expands to a simple numeric value. 1585 OS << CounterValue++; 1586 Tok.setKind(tok::numeric_constant); 1587 } else if (II == Ident__has_feature) { 1588 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, 1589 [this](Token &Tok, bool &HasLexedNextToken) -> int { 1590 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this, 1591 diag::err_feature_check_malformed); 1592 return II && HasFeature(*this, II->getName()); 1593 }); 1594 } else if (II == Ident__has_extension) { 1595 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, 1596 [this](Token &Tok, bool &HasLexedNextToken) -> int { 1597 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this, 1598 diag::err_feature_check_malformed); 1599 return II && HasExtension(*this, II->getName()); 1600 }); 1601 } else if (II == Ident__has_builtin) { 1602 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, 1603 [this](Token &Tok, bool &HasLexedNextToken) -> int { 1604 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this, 1605 diag::err_feature_check_malformed); 1606 const LangOptions &LangOpts = getLangOpts(); 1607 if (!II) 1608 return false; 1609 else if (II->getBuiltinID() != 0) { 1610 switch (II->getBuiltinID()) { 1611 case Builtin::BI__builtin_operator_new: 1612 case Builtin::BI__builtin_operator_delete: 1613 // denotes date of behavior change to support calling arbitrary 1614 // usual allocation and deallocation functions. Required by libc++ 1615 return 201802; 1616 default: 1617 return true; 1618 } 1619 return true; 1620 } else { 1621 return llvm::StringSwitch<bool>(II->getName()) 1622 .Case("__make_integer_seq", LangOpts.CPlusPlus) 1623 .Case("__type_pack_element", LangOpts.CPlusPlus) 1624 .Case("__builtin_available", true) 1625 .Case("__is_target_arch", true) 1626 .Case("__is_target_vendor", true) 1627 .Case("__is_target_os", true) 1628 .Case("__is_target_environment", true) 1629 .Case("__builtin_LINE", true) 1630 .Case("__builtin_FILE", true) 1631 .Case("__builtin_FUNCTION", true) 1632 .Case("__builtin_COLUMN", true) 1633 .Case("__builtin_bit_cast", true) 1634 .Default(false); 1635 } 1636 }); 1637 } else if (II == Ident__is_identifier) { 1638 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, 1639 [](Token &Tok, bool &HasLexedNextToken) -> int { 1640 return Tok.is(tok::identifier); 1641 }); 1642 } else if (II == Ident__has_attribute) { 1643 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, 1644 [this](Token &Tok, bool &HasLexedNextToken) -> int { 1645 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this, 1646 diag::err_feature_check_malformed); 1647 return II ? hasAttribute(AttrSyntax::GNU, nullptr, II, 1648 getTargetInfo(), getLangOpts()) : 0; 1649 }); 1650 } else if (II == Ident__has_declspec) { 1651 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, 1652 [this](Token &Tok, bool &HasLexedNextToken) -> int { 1653 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this, 1654 diag::err_feature_check_malformed); 1655 return II ? hasAttribute(AttrSyntax::Declspec, nullptr, II, 1656 getTargetInfo(), getLangOpts()) : 0; 1657 }); 1658 } else if (II == Ident__has_cpp_attribute || 1659 II == Ident__has_c_attribute) { 1660 bool IsCXX = II == Ident__has_cpp_attribute; 1661 EvaluateFeatureLikeBuiltinMacro( 1662 OS, Tok, II, *this, [&](Token &Tok, bool &HasLexedNextToken) -> int { 1663 IdentifierInfo *ScopeII = nullptr; 1664 IdentifierInfo *II = ExpectFeatureIdentifierInfo( 1665 Tok, *this, diag::err_feature_check_malformed); 1666 if (!II) 1667 return false; 1668 1669 // It is possible to receive a scope token. Read the "::", if it is 1670 // available, and the subsequent identifier. 1671 LexUnexpandedToken(Tok); 1672 if (Tok.isNot(tok::coloncolon)) 1673 HasLexedNextToken = true; 1674 else { 1675 ScopeII = II; 1676 LexUnexpandedToken(Tok); 1677 II = ExpectFeatureIdentifierInfo(Tok, *this, 1678 diag::err_feature_check_malformed); 1679 } 1680 1681 AttrSyntax Syntax = IsCXX ? AttrSyntax::CXX : AttrSyntax::C; 1682 return II ? hasAttribute(Syntax, ScopeII, II, getTargetInfo(), 1683 getLangOpts()) 1684 : 0; 1685 }); 1686 } else if (II == Ident__has_include || 1687 II == Ident__has_include_next) { 1688 // The argument to these two builtins should be a parenthesized 1689 // file name string literal using angle brackets (<>) or 1690 // double-quotes (""). 1691 bool Value; 1692 if (II == Ident__has_include) 1693 Value = EvaluateHasInclude(Tok, II, *this); 1694 else 1695 Value = EvaluateHasIncludeNext(Tok, II, *this); 1696 1697 if (Tok.isNot(tok::r_paren)) 1698 return; 1699 OS << (int)Value; 1700 Tok.setKind(tok::numeric_constant); 1701 } else if (II == Ident__has_warning) { 1702 // The argument should be a parenthesized string literal. 1703 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, 1704 [this](Token &Tok, bool &HasLexedNextToken) -> int { 1705 std::string WarningName; 1706 SourceLocation StrStartLoc = Tok.getLocation(); 1707 1708 HasLexedNextToken = Tok.is(tok::string_literal); 1709 if (!FinishLexStringLiteral(Tok, WarningName, "'__has_warning'", 1710 /*AllowMacroExpansion=*/false)) 1711 return false; 1712 1713 // FIXME: Should we accept "-R..." flags here, or should that be 1714 // handled by a separate __has_remark? 1715 if (WarningName.size() < 3 || WarningName[0] != '-' || 1716 WarningName[1] != 'W') { 1717 Diag(StrStartLoc, diag::warn_has_warning_invalid_option); 1718 return false; 1719 } 1720 1721 // Finally, check if the warning flags maps to a diagnostic group. 1722 // We construct a SmallVector here to talk to getDiagnosticIDs(). 1723 // Although we don't use the result, this isn't a hot path, and not 1724 // worth special casing. 1725 SmallVector<diag::kind, 10> Diags; 1726 return !getDiagnostics().getDiagnosticIDs()-> 1727 getDiagnosticsInGroup(diag::Flavor::WarningOrError, 1728 WarningName.substr(2), Diags); 1729 }); 1730 } else if (II == Ident__building_module) { 1731 // The argument to this builtin should be an identifier. The 1732 // builtin evaluates to 1 when that identifier names the module we are 1733 // currently building. 1734 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, 1735 [this](Token &Tok, bool &HasLexedNextToken) -> int { 1736 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this, 1737 diag::err_expected_id_building_module); 1738 return getLangOpts().isCompilingModule() && II && 1739 (II->getName() == getLangOpts().CurrentModule); 1740 }); 1741 } else if (II == Ident__MODULE__) { 1742 // The current module as an identifier. 1743 OS << getLangOpts().CurrentModule; 1744 IdentifierInfo *ModuleII = getIdentifierInfo(getLangOpts().CurrentModule); 1745 Tok.setIdentifierInfo(ModuleII); 1746 Tok.setKind(ModuleII->getTokenID()); 1747 } else if (II == Ident__identifier) { 1748 SourceLocation Loc = Tok.getLocation(); 1749 1750 // We're expecting '__identifier' '(' identifier ')'. Try to recover 1751 // if the parens are missing. 1752 LexNonComment(Tok); 1753 if (Tok.isNot(tok::l_paren)) { 1754 // No '(', use end of last token. 1755 Diag(getLocForEndOfToken(Loc), diag::err_pp_expected_after) 1756 << II << tok::l_paren; 1757 // If the next token isn't valid as our argument, we can't recover. 1758 if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) 1759 Tok.setKind(tok::identifier); 1760 return; 1761 } 1762 1763 SourceLocation LParenLoc = Tok.getLocation(); 1764 LexNonComment(Tok); 1765 1766 if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) 1767 Tok.setKind(tok::identifier); 1768 else { 1769 Diag(Tok.getLocation(), diag::err_pp_identifier_arg_not_identifier) 1770 << Tok.getKind(); 1771 // Don't walk past anything that's not a real token. 1772 if (Tok.isOneOf(tok::eof, tok::eod) || Tok.isAnnotation()) 1773 return; 1774 } 1775 1776 // Discard the ')', preserving 'Tok' as our result. 1777 Token RParen; 1778 LexNonComment(RParen); 1779 if (RParen.isNot(tok::r_paren)) { 1780 Diag(getLocForEndOfToken(Tok.getLocation()), diag::err_pp_expected_after) 1781 << Tok.getKind() << tok::r_paren; 1782 Diag(LParenLoc, diag::note_matching) << tok::l_paren; 1783 } 1784 return; 1785 } else if (II == Ident__is_target_arch) { 1786 EvaluateFeatureLikeBuiltinMacro( 1787 OS, Tok, II, *this, [this](Token &Tok, bool &HasLexedNextToken) -> int { 1788 IdentifierInfo *II = ExpectFeatureIdentifierInfo( 1789 Tok, *this, diag::err_feature_check_malformed); 1790 return II && isTargetArch(getTargetInfo(), II); 1791 }); 1792 } else if (II == Ident__is_target_vendor) { 1793 EvaluateFeatureLikeBuiltinMacro( 1794 OS, Tok, II, *this, [this](Token &Tok, bool &HasLexedNextToken) -> int { 1795 IdentifierInfo *II = ExpectFeatureIdentifierInfo( 1796 Tok, *this, diag::err_feature_check_malformed); 1797 return II && isTargetVendor(getTargetInfo(), II); 1798 }); 1799 } else if (II == Ident__is_target_os) { 1800 EvaluateFeatureLikeBuiltinMacro( 1801 OS, Tok, II, *this, [this](Token &Tok, bool &HasLexedNextToken) -> int { 1802 IdentifierInfo *II = ExpectFeatureIdentifierInfo( 1803 Tok, *this, diag::err_feature_check_malformed); 1804 return II && isTargetOS(getTargetInfo(), II); 1805 }); 1806 } else if (II == Ident__is_target_environment) { 1807 EvaluateFeatureLikeBuiltinMacro( 1808 OS, Tok, II, *this, [this](Token &Tok, bool &HasLexedNextToken) -> int { 1809 IdentifierInfo *II = ExpectFeatureIdentifierInfo( 1810 Tok, *this, diag::err_feature_check_malformed); 1811 return II && isTargetEnvironment(getTargetInfo(), II); 1812 }); 1813 } else { 1814 llvm_unreachable("Unknown identifier!"); 1815 } 1816 CreateString(OS.str(), Tok, Tok.getLocation(), Tok.getLocation()); 1817 Tok.setFlagValue(Token::StartOfLine, IsAtStartOfLine); 1818 Tok.setFlagValue(Token::LeadingSpace, HasLeadingSpace); 1819 } 1820 1821 void Preprocessor::markMacroAsUsed(MacroInfo *MI) { 1822 // If the 'used' status changed, and the macro requires 'unused' warning, 1823 // remove its SourceLocation from the warn-for-unused-macro locations. 1824 if (MI->isWarnIfUnused() && !MI->isUsed()) 1825 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc()); 1826 MI->setIsUsed(true); 1827 } 1828