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