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 (isa_and_nonnull<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.
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 [cpp.replace]p15, C23 6.10.5p12
997 //
998 // C++20 and C23 allow this construct, but standards before that
999 // do not (we allow it as an extension).
1000 unsigned ID;
1002 ID = diag::warn_cxx17_compat_missing_varargs_arg;
1003 else if (getLangOpts().CPlusPlus)
1004 ID = diag::ext_cxx_missing_varargs_arg;
1005 else if (getLangOpts().C23)
1006 ID = diag::warn_c17_compat_missing_varargs_arg;
1007 else
1008 ID = diag::ext_c_missing_varargs_arg;
1009 Diag(Tok, ID);
1010 Diag(MI->getDefinitionLoc(), diag::note_macro_here)
1011 << MacroName.getIdentifierInfo();
1012 }
1013
1014 // Remember this occurred, allowing us to elide the comma when used for
1015 // cases like:
1016 // #define A(x, foo...) blah(a, ## foo)
1017 // #define B(x, ...) blah(a, ## __VA_ARGS__)
1018 // #define C(...) blah(a, ## __VA_ARGS__)
1019 // A(x) B(x) C()
1020 isVarargsElided = true;
1021 } else if (!ContainsCodeCompletionTok) {
1022 // Otherwise, emit the error.
1023 Diag(Tok, diag::err_too_few_args_in_macro_invoc);
1024 Diag(MI->getDefinitionLoc(), diag::note_macro_here)
1025 << MacroName.getIdentifierInfo();
1026 return nullptr;
1027 }
1028
1029 // Add a marker EOF token to the end of the token list for this argument.
1030 SourceLocation EndLoc = Tok.getLocation();
1031 Tok.startToken();
1032 Tok.setKind(tok::eof);
1033 Tok.setLocation(EndLoc);
1034 Tok.setLength(0);
1035 ArgTokens.push_back(Tok);
1036
1037 // If we expect two arguments, add both as empty.
1038 if (NumActuals == 0 && MinArgsExpected == 2)
1039 ArgTokens.push_back(Tok);
1040
1041 } else if (NumActuals > MinArgsExpected && !MI->isVariadic() &&
1042 !ContainsCodeCompletionTok) {
1043 // Emit the diagnostic at the macro name in case there is a missing ).
1044 // Emitting it at the , could be far away from the macro name.
1045 Diag(MacroName, diag::err_too_many_args_in_macro_invoc);
1046 Diag(MI->getDefinitionLoc(), diag::note_macro_here)
1047 << MacroName.getIdentifierInfo();
1048 return nullptr;
1049 }
1050
1051 return MacroArgs::create(MI, ArgTokens, isVarargsElided, *this);
1052}
1053
1054/// Keeps macro expanded tokens for TokenLexers.
1055//
1056/// Works like a stack; a TokenLexer adds the macro expanded tokens that is
1057/// going to lex in the cache and when it finishes the tokens are removed
1058/// from the end of the cache.
1059Token *Preprocessor::cacheMacroExpandedTokens(TokenLexer *tokLexer,
1060 ArrayRef<Token> tokens) {
1061 assert(tokLexer);
1062 if (tokens.empty())
1063 return nullptr;
1064
1065 size_t newIndex = MacroExpandedTokens.size();
1066 bool cacheNeedsToGrow = tokens.size() >
1067 MacroExpandedTokens.capacity()-MacroExpandedTokens.size();
1068 MacroExpandedTokens.append(tokens.begin(), tokens.end());
1069
1070 if (cacheNeedsToGrow) {
1071 // Go through all the TokenLexers whose 'Tokens' pointer points in the
1072 // buffer and update the pointers to the (potential) new buffer array.
1073 for (const auto &Lexer : MacroExpandingLexersStack) {
1074 TokenLexer *prevLexer;
1075 size_t tokIndex;
1076 std::tie(prevLexer, tokIndex) = Lexer;
1077 prevLexer->Tokens = MacroExpandedTokens.data() + tokIndex;
1078 }
1079 }
1080
1081 MacroExpandingLexersStack.push_back(std::make_pair(tokLexer, newIndex));
1082 return MacroExpandedTokens.data() + newIndex;
1083}
1084
1085void Preprocessor::removeCachedMacroExpandedTokensOfLastLexer() {
1086 assert(!MacroExpandingLexersStack.empty());
1087 size_t tokIndex = MacroExpandingLexersStack.back().second;
1088 assert(tokIndex < MacroExpandedTokens.size());
1089 // Pop the cached macro expanded tokens from the end.
1090 MacroExpandedTokens.resize(tokIndex);
1091 MacroExpandingLexersStack.pop_back();
1092}
1093
1094/// ComputeDATE_TIME - Compute the current time, enter it into the specified
1095/// scratch buffer, then return DATELoc/TIMELoc locations with the position of
1096/// the identifier tokens inserted.
1097static void ComputeDATE_TIME(SourceLocation &DATELoc, SourceLocation &TIMELoc,
1098 Preprocessor &PP) {
1099 time_t TT;
1100 std::tm *TM;
1103 TM = std::gmtime(&TT);
1104 } else {
1105 TT = std::time(nullptr);
1106 TM = std::localtime(&TT);
1107 }
1108
1109 static const char * const Months[] = {
1110 "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
1111 };
1112
1113 {
1114 SmallString<32> TmpBuffer;
1115 llvm::raw_svector_ostream TmpStream(TmpBuffer);
1116 if (TM)
1117 TmpStream << llvm::format("\"%s %2d %4d\"", Months[TM->tm_mon],
1118 TM->tm_mday, TM->tm_year + 1900);
1119 else
1120 TmpStream << "??? ?? ????";
1121 Token TmpTok;
1122 TmpTok.startToken();
1123 PP.CreateString(TmpStream.str(), TmpTok);
1124 DATELoc = TmpTok.getLocation();
1125 }
1126
1127 {
1128 SmallString<32> TmpBuffer;
1129 llvm::raw_svector_ostream TmpStream(TmpBuffer);
1130 if (TM)
1131 TmpStream << llvm::format("\"%02d:%02d:%02d\"", TM->tm_hour, TM->tm_min,
1132 TM->tm_sec);
1133 else
1134 TmpStream << "??:??:??";
1135 Token TmpTok;
1136 TmpTok.startToken();
1137 PP.CreateString(TmpStream.str(), TmpTok);
1138 TIMELoc = TmpTok.getLocation();
1139 }
1140}
1141
1142/// HasFeature - Return true if we recognize and implement the feature
1143/// specified by the identifier as a standard language feature.
1144static bool HasFeature(const Preprocessor &PP, StringRef Feature) {
1145 const LangOptions &LangOpts = PP.getLangOpts();
1146
1147 // Normalize the feature name, __foo__ becomes foo.
1148 if (Feature.starts_with("__") && Feature.ends_with("__") &&
1149 Feature.size() >= 4)
1150 Feature = Feature.substr(2, Feature.size() - 4);
1151
1152#define FEATURE(Name, Predicate) .Case(#Name, Predicate)
1153 return llvm::StringSwitch<bool>(Feature)
1154#include "clang/Basic/Features.def"
1155 .Default(false);
1156#undef FEATURE
1157}
1158
1159/// HasExtension - Return true if we recognize and implement the feature
1160/// specified by the identifier, either as an extension or a standard language
1161/// feature.
1162static bool HasExtension(const Preprocessor &PP, StringRef Extension) {
1163 if (HasFeature(PP, Extension))
1164 return true;
1165
1166 // If the use of an extension results in an error diagnostic, extensions are
1167 // effectively unavailable, so just return false here.
1170 return false;
1171
1172 const LangOptions &LangOpts = PP.getLangOpts();
1173
1174 // Normalize the extension name, __foo__ becomes foo.
1175 if (Extension.starts_with("__") && Extension.ends_with("__") &&
1176 Extension.size() >= 4)
1177 Extension = Extension.substr(2, Extension.size() - 4);
1178
1179 // Because we inherit the feature list from HasFeature, this string switch
1180 // must be less restrictive than HasFeature's.
1181#define EXTENSION(Name, Predicate) .Case(#Name, Predicate)
1182 return llvm::StringSwitch<bool>(Extension)
1183#include "clang/Basic/Features.def"
1184 .Default(false);
1185#undef EXTENSION
1186}
1187
1188/// EvaluateHasIncludeCommon - Process a '__has_include("path")'
1189/// or '__has_include_next("path")' expression.
1190/// Returns true if successful.
1192 Preprocessor &PP,
1193 ConstSearchDirIterator LookupFrom,
1194 const FileEntry *LookupFromFile) {
1195 // Save the location of the current token. If a '(' is later found, use
1196 // that location. If not, use the end of this location instead.
1197 SourceLocation LParenLoc = Tok.getLocation();
1198
1199 // These expressions are only allowed within a preprocessor directive.
1200 if (!PP.isParsingIfOrElifDirective()) {
1201 PP.Diag(LParenLoc, diag::err_pp_directive_required) << II;
1202 // Return a valid identifier token.
1203 assert(Tok.is(tok::identifier));
1204 Tok.setIdentifierInfo(II);
1205 return false;
1206 }
1207
1208 // Get '('. If we don't have a '(', try to form a header-name token.
1209 do {
1210 if (PP.LexHeaderName(Tok))
1211 return false;
1212 } while (Tok.getKind() == tok::comment);
1213
1214 // Ensure we have a '('.
1215 if (Tok.isNot(tok::l_paren)) {
1216 // No '(', use end of last token.
1217 LParenLoc = PP.getLocForEndOfToken(LParenLoc);
1218 PP.Diag(LParenLoc, diag::err_pp_expected_after) << II << tok::l_paren;
1219 // If the next token looks like a filename or the start of one,
1220 // assume it is and process it as such.
1221 if (Tok.isNot(tok::header_name))
1222 return false;
1223 } else {
1224 // Save '(' location for possible missing ')' message.
1225 LParenLoc = Tok.getLocation();
1226 if (PP.LexHeaderName(Tok))
1227 return false;
1228 }
1229
1230 if (Tok.isNot(tok::header_name)) {
1231 PP.Diag(Tok.getLocation(), diag::err_pp_expects_filename);
1232 return false;
1233 }
1234
1235 // Reserve a buffer to get the spelling.
1236 SmallString<128> FilenameBuffer;
1237 bool Invalid = false;
1238 StringRef Filename = PP.getSpelling(Tok, FilenameBuffer, &Invalid);
1239 if (Invalid)
1240 return false;
1241
1242 SourceLocation FilenameLoc = Tok.getLocation();
1243
1244 // Get ')'.
1245 PP.LexNonComment(Tok);
1246
1247 // Ensure we have a trailing ).
1248 if (Tok.isNot(tok::r_paren)) {
1249 PP.Diag(PP.getLocForEndOfToken(FilenameLoc), diag::err_pp_expected_after)
1250 << II << tok::r_paren;
1251 PP.Diag(LParenLoc, diag::note_matching) << tok::l_paren;
1252 return false;
1253 }
1254
1255 bool isAngled = PP.GetIncludeFilenameSpelling(Tok.getLocation(), Filename);
1256 // If GetIncludeFilenameSpelling set the start ptr to null, there was an
1257 // error.
1258 if (Filename.empty())
1259 return false;
1260
1261 // Passing this to LookupFile forces header search to check whether the found
1262 // file belongs to a module. Skipping that check could incorrectly mark
1263 // modular header as textual, causing issues down the line.
1265
1266 // Search include directories.
1268 PP.LookupFile(FilenameLoc, Filename, isAngled, LookupFrom, LookupFromFile,
1269 nullptr, nullptr, nullptr, &KH, nullptr, nullptr);
1270
1271 if (PPCallbacks *Callbacks = PP.getPPCallbacks()) {
1273 if (File)
1275 Callbacks->HasInclude(FilenameLoc, Filename, isAngled, File, FileType);
1276 }
1277
1278 // Get the result value. A result of true means the file exists.
1279 return File.has_value();
1280}
1281
1282bool Preprocessor::EvaluateHasInclude(Token &Tok, IdentifierInfo *II) {
1283 return EvaluateHasIncludeCommon(Tok, II, *this, nullptr, nullptr);
1284}
1285
1286bool Preprocessor::EvaluateHasIncludeNext(Token &Tok, IdentifierInfo *II) {
1287 ConstSearchDirIterator Lookup = nullptr;
1288 const FileEntry *LookupFromFile;
1289 std::tie(Lookup, LookupFromFile) = getIncludeNextStart(Tok);
1290
1291 return EvaluateHasIncludeCommon(Tok, II, *this, Lookup, LookupFromFile);
1292}
1293
1294/// Process single-argument builtin feature-like macros that return
1295/// integer values.
1296static void EvaluateFeatureLikeBuiltinMacro(llvm::raw_svector_ostream& OS,
1297 Token &Tok, IdentifierInfo *II,
1298 Preprocessor &PP, bool ExpandArgs,
1299 llvm::function_ref<
1300 int(Token &Tok,
1301 bool &HasLexedNextTok)> Op) {
1302 // Parse the initial '('.
1303 PP.LexUnexpandedToken(Tok);
1304 if (Tok.isNot(tok::l_paren)) {
1305 PP.Diag(Tok.getLocation(), diag::err_pp_expected_after) << II
1306 << tok::l_paren;
1307
1308 // Provide a dummy '0' value on output stream to elide further errors.
1309 if (!Tok.isOneOf(tok::eof, tok::eod)) {
1310 OS << 0;
1311 Tok.setKind(tok::numeric_constant);
1312 }
1313 return;
1314 }
1315
1316 unsigned ParenDepth = 1;
1317 SourceLocation LParenLoc = Tok.getLocation();
1318 std::optional<int> Result;
1319
1320 Token ResultTok;
1321 bool SuppressDiagnostic = false;
1322 while (true) {
1323 // Parse next token.
1324 if (ExpandArgs)
1325 PP.Lex(Tok);
1326 else
1327 PP.LexUnexpandedToken(Tok);
1328
1329already_lexed:
1330 switch (Tok.getKind()) {
1331 case tok::eof:
1332 case tok::eod:
1333 // Don't provide even a dummy value if the eod or eof marker is
1334 // reached. Simply provide a diagnostic.
1335 PP.Diag(Tok.getLocation(), diag::err_unterm_macro_invoc);
1336 return;
1337
1338 case tok::comma:
1339 if (!SuppressDiagnostic) {
1340 PP.Diag(Tok.getLocation(), diag::err_too_many_args_in_macro_invoc);
1341 SuppressDiagnostic = true;
1342 }
1343 continue;
1344
1345 case tok::l_paren:
1346 ++ParenDepth;
1347 if (Result)
1348 break;
1349 if (!SuppressDiagnostic) {
1350 PP.Diag(Tok.getLocation(), diag::err_pp_nested_paren) << II;
1351 SuppressDiagnostic = true;
1352 }
1353 continue;
1354
1355 case tok::r_paren:
1356 if (--ParenDepth > 0)
1357 continue;
1358
1359 // The last ')' has been reached; return the value if one found or
1360 // a diagnostic and a dummy value.
1361 if (Result) {
1362 OS << *Result;
1363 // For strict conformance to __has_cpp_attribute rules, use 'L'
1364 // suffix for dated literals.
1365 if (*Result > 1)
1366 OS << 'L';
1367 } else {
1368 OS << 0;
1369 if (!SuppressDiagnostic)
1370 PP.Diag(Tok.getLocation(), diag::err_too_few_args_in_macro_invoc);
1371 }
1372 Tok.setKind(tok::numeric_constant);
1373 return;
1374
1375 default: {
1376 // Parse the macro argument, if one not found so far.
1377 if (Result)
1378 break;
1379
1380 bool HasLexedNextToken = false;
1381 Result = Op(Tok, HasLexedNextToken);
1382 ResultTok = Tok;
1383 if (HasLexedNextToken)
1384 goto already_lexed;
1385 continue;
1386 }
1387 }
1388
1389 // Diagnose missing ')'.
1390 if (!SuppressDiagnostic) {
1391 if (auto Diag = PP.Diag(Tok.getLocation(), diag::err_pp_expected_after)) {
1392 if (IdentifierInfo *LastII = ResultTok.getIdentifierInfo())
1393 Diag << LastII;
1394 else
1395 Diag << ResultTok.getKind();
1396 Diag << tok::r_paren << ResultTok.getLocation();
1397 }
1398 PP.Diag(LParenLoc, diag::note_matching) << tok::l_paren;
1399 SuppressDiagnostic = true;
1400 }
1401 }
1402}
1403
1404/// Helper function to return the IdentifierInfo structure of a Token
1405/// or generate a diagnostic if none available.
1407 Preprocessor &PP,
1408 signed DiagID) {
1409 IdentifierInfo *II;
1410 if (!Tok.isAnnotation() && (II = Tok.getIdentifierInfo()))
1411 return II;
1412
1413 PP.Diag(Tok.getLocation(), DiagID);
1414 return nullptr;
1415}
1416
1417/// Implements the __is_target_arch builtin macro.
1418static bool isTargetArch(const TargetInfo &TI, const IdentifierInfo *II) {
1419 std::string ArchName = II->getName().lower() + "--";
1420 llvm::Triple Arch(ArchName);
1421 const llvm::Triple &TT = TI.getTriple();
1422 if (TT.isThumb()) {
1423 // arm matches thumb or thumbv7. armv7 matches thumbv7.
1424 if ((Arch.getSubArch() == llvm::Triple::NoSubArch ||
1425 Arch.getSubArch() == TT.getSubArch()) &&
1426 ((TT.getArch() == llvm::Triple::thumb &&
1427 Arch.getArch() == llvm::Triple::arm) ||
1428 (TT.getArch() == llvm::Triple::thumbeb &&
1429 Arch.getArch() == llvm::Triple::armeb)))
1430 return true;
1431 }
1432 // Check the parsed arch when it has no sub arch to allow Clang to
1433 // match thumb to thumbv7 but to prohibit matching thumbv6 to thumbv7.
1434 return (Arch.getSubArch() == llvm::Triple::NoSubArch ||
1435 Arch.getSubArch() == TT.getSubArch()) &&
1436 Arch.getArch() == TT.getArch();
1437}
1438
1439/// Implements the __is_target_vendor builtin macro.
1440static bool isTargetVendor(const TargetInfo &TI, const IdentifierInfo *II) {
1441 StringRef VendorName = TI.getTriple().getVendorName();
1442 if (VendorName.empty())
1443 VendorName = "unknown";
1444 return VendorName.equals_insensitive(II->getName());
1445}
1446
1447/// Implements the __is_target_os builtin macro.
1448static bool isTargetOS(const TargetInfo &TI, const IdentifierInfo *II) {
1449 std::string OSName =
1450 (llvm::Twine("unknown-unknown-") + II->getName().lower()).str();
1451 llvm::Triple OS(OSName);
1452 if (OS.getOS() == llvm::Triple::Darwin) {
1453 // Darwin matches macos, ios, etc.
1454 return TI.getTriple().isOSDarwin();
1455 }
1456 return TI.getTriple().getOS() == OS.getOS();
1457}
1458
1459/// Implements the __is_target_environment builtin macro.
1460static bool isTargetEnvironment(const TargetInfo &TI,
1461 const IdentifierInfo *II) {
1462 std::string EnvName = (llvm::Twine("---") + II->getName().lower()).str();
1463 llvm::Triple Env(EnvName);
1464 // The unknown environment is matched only if
1465 // '__is_target_environment(unknown)' is used.
1466 if (Env.getEnvironment() == llvm::Triple::UnknownEnvironment &&
1467 EnvName != "---unknown")
1468 return false;
1469 return TI.getTriple().getEnvironment() == Env.getEnvironment();
1470}
1471
1472/// Implements the __is_target_variant_os builtin macro.
1473static bool isTargetVariantOS(const TargetInfo &TI, const IdentifierInfo *II) {
1474 if (TI.getTriple().isOSDarwin()) {
1475 const llvm::Triple *VariantTriple = TI.getDarwinTargetVariantTriple();
1476 if (!VariantTriple)
1477 return false;
1478
1479 std::string OSName =
1480 (llvm::Twine("unknown-unknown-") + II->getName().lower()).str();
1481 llvm::Triple OS(OSName);
1482 if (OS.getOS() == llvm::Triple::Darwin) {
1483 // Darwin matches macos, ios, etc.
1484 return VariantTriple->isOSDarwin();
1485 }
1486 return VariantTriple->getOS() == OS.getOS();
1487 }
1488 return false;
1489}
1490
1491/// Implements the __is_target_variant_environment builtin macro.
1493 const IdentifierInfo *II) {
1494 if (TI.getTriple().isOSDarwin()) {
1495 const llvm::Triple *VariantTriple = TI.getDarwinTargetVariantTriple();
1496 if (!VariantTriple)
1497 return false;
1498 std::string EnvName = (llvm::Twine("---") + II->getName().lower()).str();
1499 llvm::Triple Env(EnvName);
1500 return VariantTriple->getEnvironment() == Env.getEnvironment();
1501 }
1502 return false;
1503}
1504
1505/// ExpandBuiltinMacro - If an identifier token is read that is to be expanded
1506/// as a builtin macro, handle it and return the next token as 'Tok'.
1507void Preprocessor::ExpandBuiltinMacro(Token &Tok) {
1508 // Figure out which token this is.
1510 assert(II && "Can't be a macro without id info!");
1511
1512 // If this is an _Pragma or Microsoft __pragma directive, expand it,
1513 // invoke the pragma handler, then lex the token after it.
1514 if (II == Ident_Pragma)
1515 return Handle_Pragma(Tok);
1516 else if (II == Ident__pragma) // in non-MS mode this is null
1517 return HandleMicrosoft__pragma(Tok);
1518
1519 ++NumBuiltinMacroExpanded;
1520
1521 SmallString<128> TmpBuffer;
1522 llvm::raw_svector_ostream OS(TmpBuffer);
1523
1524 // Set up the return result.
1525 Tok.setIdentifierInfo(nullptr);
1527 bool IsAtStartOfLine = Tok.isAtStartOfLine();
1528 bool HasLeadingSpace = Tok.hasLeadingSpace();
1529
1530 if (II == Ident__LINE__) {
1531 // C99 6.10.8: "__LINE__: The presumed line number (within the current
1532 // source file) of the current source line (an integer constant)". This can
1533 // be affected by #line.
1535
1536 // Advance to the location of the first _, this might not be the first byte
1537 // of the token if it starts with an escaped newline.
1539
1540 // One wrinkle here is that GCC expands __LINE__ to location of the *end* of
1541 // a macro expansion. This doesn't matter for object-like macros, but
1542 // can matter for a function-like macro that expands to contain __LINE__.
1543 // Skip down through expansion points until we find a file loc for the
1544 // end of the expansion history.
1545 Loc = SourceMgr.getExpansionRange(Loc).getEnd();
1546 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Loc);
1547
1548 // __LINE__ expands to a simple numeric value.
1549 OS << (PLoc.isValid()? PLoc.getLine() : 1);
1550 Tok.setKind(tok::numeric_constant);
1551 } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__ ||
1552 II == Ident__FILE_NAME__) {
1553 // C99 6.10.8: "__FILE__: The presumed name of the current source file (a
1554 // character string literal)". This can be affected by #line.
1555 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation());
1556
1557 // __BASE_FILE__ is a GNU extension that returns the top of the presumed
1558 // #include stack instead of the current file.
1559 if (II == Ident__BASE_FILE__ && PLoc.isValid()) {
1560 SourceLocation NextLoc = PLoc.getIncludeLoc();
1561 while (NextLoc.isValid()) {
1562 PLoc = SourceMgr.getPresumedLoc(NextLoc);
1563 if (PLoc.isInvalid())
1564 break;
1565
1566 NextLoc = PLoc.getIncludeLoc();
1567 }
1568 }
1569
1570 // Escape this filename. Turn '\' -> '\\' '"' -> '\"'
1572 if (PLoc.isValid()) {
1573 // __FILE_NAME__ is a Clang-specific extension that expands to the
1574 // the last part of __FILE__.
1575 if (II == Ident__FILE_NAME__) {
1577 } else {
1578 FN += PLoc.getFilename();
1580 }
1581 Lexer::Stringify(FN);
1582 OS << '"' << FN << '"';
1583 }
1584 Tok.setKind(tok::string_literal);
1585 } else if (II == Ident__DATE__) {
1586 Diag(Tok.getLocation(), diag::warn_pp_date_time);
1587 if (!DATELoc.isValid())
1588 ComputeDATE_TIME(DATELoc, TIMELoc, *this);
1589 Tok.setKind(tok::string_literal);
1590 Tok.setLength(strlen("\"Mmm dd yyyy\""));
1591 Tok.setLocation(SourceMgr.createExpansionLoc(DATELoc, Tok.getLocation(),
1592 Tok.getLocation(),
1593 Tok.getLength()));
1594 return;
1595 } else if (II == Ident__TIME__) {
1596 Diag(Tok.getLocation(), diag::warn_pp_date_time);
1597 if (!TIMELoc.isValid())
1598 ComputeDATE_TIME(DATELoc, TIMELoc, *this);
1599 Tok.setKind(tok::string_literal);
1600 Tok.setLength(strlen("\"hh:mm:ss\""));
1601 Tok.setLocation(SourceMgr.createExpansionLoc(TIMELoc, Tok.getLocation(),
1602 Tok.getLocation(),
1603 Tok.getLength()));
1604 return;
1605 } else if (II == Ident__INCLUDE_LEVEL__) {
1606 // Compute the presumed include depth of this token. This can be affected
1607 // by GNU line markers.
1608 unsigned Depth = 0;
1609
1610 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation());
1611 if (PLoc.isValid()) {
1612 PLoc = SourceMgr.getPresumedLoc(PLoc.getIncludeLoc());
1613 for (; PLoc.isValid(); ++Depth)
1614 PLoc = SourceMgr.getPresumedLoc(PLoc.getIncludeLoc());
1615 }
1616
1617 // __INCLUDE_LEVEL__ expands to a simple numeric value.
1618 OS << Depth;
1619 Tok.setKind(tok::numeric_constant);
1620 } else if (II == Ident__TIMESTAMP__) {
1621 Diag(Tok.getLocation(), diag::warn_pp_date_time);
1622 // MSVC, ICC, GCC, VisualAge C++ extension. The generated string should be
1623 // of the form "Ddd Mmm dd hh::mm::ss yyyy", which is returned by asctime.
1624 const char *Result;
1625 if (getPreprocessorOpts().SourceDateEpoch) {
1626 time_t TT = *getPreprocessorOpts().SourceDateEpoch;
1627 std::tm *TM = std::gmtime(&TT);
1628 Result = asctime(TM);
1629 } else {
1630 // Get the file that we are lexing out of. If we're currently lexing from
1631 // a macro, dig into the include stack.
1632 const FileEntry *CurFile = nullptr;
1633 if (PreprocessorLexer *TheLexer = getCurrentFileLexer())
1634 CurFile = SourceMgr.getFileEntryForID(TheLexer->getFileID());
1635 if (CurFile) {
1636 time_t TT = CurFile->getModificationTime();
1637 struct tm *TM = localtime(&TT);
1638 Result = asctime(TM);
1639 } else {
1640 Result = "??? ??? ?? ??:??:?? ????\n";
1641 }
1642 }
1643 // Surround the string with " and strip the trailing newline.
1644 OS << '"' << StringRef(Result).drop_back() << '"';
1645 Tok.setKind(tok::string_literal);
1646 } else if (II == Ident__FLT_EVAL_METHOD__) {
1647 // __FLT_EVAL_METHOD__ is set to the default value.
1648 OS << getTUFPEvalMethod();
1649 // __FLT_EVAL_METHOD__ expands to a simple numeric value.
1650 Tok.setKind(tok::numeric_constant);
1651 if (getLastFPEvalPragmaLocation().isValid()) {
1652 // The program is ill-formed. The value of __FLT_EVAL_METHOD__ is altered
1653 // by the pragma.
1654 Diag(Tok, diag::err_illegal_use_of_flt_eval_macro);
1655 Diag(getLastFPEvalPragmaLocation(), diag::note_pragma_entered_here);
1656 }
1657 } else if (II == Ident__COUNTER__) {
1658 // __COUNTER__ expands to a simple numeric value.
1659 OS << CounterValue++;
1660 Tok.setKind(tok::numeric_constant);
1661 } else if (II == Ident__has_feature) {
1662 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1663 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1665 diag::err_feature_check_malformed);
1666 return II && HasFeature(*this, II->getName());
1667 });
1668 } else if (II == Ident__has_extension) {
1669 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1670 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1672 diag::err_feature_check_malformed);
1673 return II && HasExtension(*this, II->getName());
1674 });
1675 } else if (II == Ident__has_builtin) {
1676 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1677 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1679 diag::err_feature_check_malformed);
1680 if (!II)
1681 return false;
1682 else if (II->getBuiltinID() != 0) {
1683 switch (II->getBuiltinID()) {
1684 case Builtin::BI__builtin_cpu_is:
1685 return getTargetInfo().supportsCpuIs();
1686 case Builtin::BI__builtin_cpu_init:
1687 return getTargetInfo().supportsCpuInit();
1688 case Builtin::BI__builtin_cpu_supports:
1690 case Builtin::BI__builtin_operator_new:
1691 case Builtin::BI__builtin_operator_delete:
1692 // denotes date of behavior change to support calling arbitrary
1693 // usual allocation and deallocation functions. Required by libc++
1694 return 201802;
1695 default:
1697 getBuiltinInfo().getRequiredFeatures(II->getBuiltinID()),
1698 getTargetInfo().getTargetOpts().FeatureMap);
1699 }
1700 return true;
1701 } else if (II->getTokenID() != tok::identifier ||
1703 // Treat all keywords that introduce a custom syntax of the form
1704 //
1705 // '__some_keyword' '(' [...] ')'
1706 //
1707 // as being "builtin functions", even if the syntax isn't a valid
1708 // function call (for example, because the builtin takes a type
1709 // argument).
1710 if (II->getName().starts_with("__builtin_") ||
1711 II->getName().starts_with("__is_") ||
1712 II->getName().starts_with("__has_"))
1713 return true;
1714 return llvm::StringSwitch<bool>(II->getName())
1715 .Case("__array_rank", true)
1716 .Case("__array_extent", true)
1717#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) .Case("__" #Trait, true)
1718#include "clang/Basic/TransformTypeTraits.def"
1719 .Default(false);
1720 } else {
1721 return llvm::StringSwitch<bool>(II->getName())
1722 // Report builtin templates as being builtins.
1723 .Case("__make_integer_seq", getLangOpts().CPlusPlus)
1724 .Case("__type_pack_element", getLangOpts().CPlusPlus)
1725 // Likewise for some builtin preprocessor macros.
1726 // FIXME: This is inconsistent; we usually suggest detecting
1727 // builtin macros via #ifdef. Don't add more cases here.
1728 .Case("__is_target_arch", true)
1729 .Case("__is_target_vendor", true)
1730 .Case("__is_target_os", true)
1731 .Case("__is_target_environment", true)
1732 .Case("__is_target_variant_os", true)
1733 .Case("__is_target_variant_environment", true)
1734 .Default(false);
1735 }
1736 });
1737 } else if (II == Ident__has_constexpr_builtin) {
1739 OS, Tok, II, *this, false,
1740 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1742 Tok, *this, diag::err_feature_check_malformed);
1743 if (!II)
1744 return false;
1745 unsigned BuiltinOp = II->getBuiltinID();
1746 return BuiltinOp != 0 &&
1747 this->getBuiltinInfo().isConstantEvaluated(BuiltinOp);
1748 });
1749 } else if (II == Ident__is_identifier) {
1750 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1751 [](Token &Tok, bool &HasLexedNextToken) -> int {
1752 return Tok.is(tok::identifier);
1753 });
1754 } else if (II == Ident__has_attribute) {
1755 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, true,
1756 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1758 diag::err_feature_check_malformed);
1760 II, getTargetInfo(), getLangOpts())
1761 : 0;
1762 });
1763 } else if (II == Ident__has_declspec) {
1764 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, true,
1765 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1767 diag::err_feature_check_malformed);
1768 if (II) {
1769 const LangOptions &LangOpts = getLangOpts();
1770 return LangOpts.DeclSpecKeyword &&
1772 II, getTargetInfo(), LangOpts);
1773 }
1774
1775 return false;
1776 });
1777 } else if (II == Ident__has_cpp_attribute ||
1778 II == Ident__has_c_attribute) {
1779 bool IsCXX = II == Ident__has_cpp_attribute;
1780 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, true,
1781 [&](Token &Tok, bool &HasLexedNextToken) -> int {
1782 IdentifierInfo *ScopeII = nullptr;
1784 Tok, *this, diag::err_feature_check_malformed);
1785 if (!II)
1786 return false;
1787
1788 // It is possible to receive a scope token. Read the "::", if it is
1789 // available, and the subsequent identifier.
1790 LexUnexpandedToken(Tok);
1791 if (Tok.isNot(tok::coloncolon))
1792 HasLexedNextToken = true;
1793 else {
1794 ScopeII = II;
1795 // Lex an expanded token for the attribute name.
1796 Lex(Tok);
1797 II = ExpectFeatureIdentifierInfo(Tok, *this,
1798 diag::err_feature_check_malformed);
1799 }
1800
1804 return II ? hasAttribute(Syntax, ScopeII, II, getTargetInfo(),
1805 getLangOpts())
1806 : 0;
1807 });
1808 } else if (II == Ident__has_include ||
1809 II == Ident__has_include_next) {
1810 // The argument to these two builtins should be a parenthesized
1811 // file name string literal using angle brackets (<>) or
1812 // double-quotes ("").
1813 bool Value;
1814 if (II == Ident__has_include)
1815 Value = EvaluateHasInclude(Tok, II);
1816 else
1817 Value = EvaluateHasIncludeNext(Tok, II);
1818
1819 if (Tok.isNot(tok::r_paren))
1820 return;
1821 OS << (int)Value;
1822 Tok.setKind(tok::numeric_constant);
1823 } else if (II == Ident__has_warning) {
1824 // The argument should be a parenthesized string literal.
1825 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1826 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1827 std::string WarningName;
1828 SourceLocation StrStartLoc = Tok.getLocation();
1829
1830 HasLexedNextToken = Tok.is(tok::string_literal);
1831 if (!FinishLexStringLiteral(Tok, WarningName, "'__has_warning'",
1832 /*AllowMacroExpansion=*/false))
1833 return false;
1834
1835 // FIXME: Should we accept "-R..." flags here, or should that be
1836 // handled by a separate __has_remark?
1837 if (WarningName.size() < 3 || WarningName[0] != '-' ||
1838 WarningName[1] != 'W') {
1839 Diag(StrStartLoc, diag::warn_has_warning_invalid_option);
1840 return false;
1841 }
1842
1843 // Finally, check if the warning flags maps to a diagnostic group.
1844 // We construct a SmallVector here to talk to getDiagnosticIDs().
1845 // Although we don't use the result, this isn't a hot path, and not
1846 // worth special casing.
1848 return !getDiagnostics().getDiagnosticIDs()->
1850 WarningName.substr(2), Diags);
1851 });
1852 } else if (II == Ident__building_module) {
1853 // The argument to this builtin should be an identifier. The
1854 // builtin evaluates to 1 when that identifier names the module we are
1855 // currently building.
1856 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1857 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1859 diag::err_expected_id_building_module);
1860 return getLangOpts().isCompilingModule() && II &&
1861 (II->getName() == getLangOpts().CurrentModule);
1862 });
1863 } else if (II == Ident__MODULE__) {
1864 // The current module as an identifier.
1865 OS << getLangOpts().CurrentModule;
1866 IdentifierInfo *ModuleII = getIdentifierInfo(getLangOpts().CurrentModule);
1867 Tok.setIdentifierInfo(ModuleII);
1868 Tok.setKind(ModuleII->getTokenID());
1869 } else if (II == Ident__identifier) {
1871
1872 // We're expecting '__identifier' '(' identifier ')'. Try to recover
1873 // if the parens are missing.
1874 LexNonComment(Tok);
1875 if (Tok.isNot(tok::l_paren)) {
1876 // No '(', use end of last token.
1877 Diag(getLocForEndOfToken(Loc), diag::err_pp_expected_after)
1878 << II << tok::l_paren;
1879 // If the next token isn't valid as our argument, we can't recover.
1880 if (!Tok.isAnnotation() && Tok.getIdentifierInfo())
1881 Tok.setKind(tok::identifier);
1882 return;
1883 }
1884
1885 SourceLocation LParenLoc = Tok.getLocation();
1886 LexNonComment(Tok);
1887
1888 if (!Tok.isAnnotation() && Tok.getIdentifierInfo())
1889 Tok.setKind(tok::identifier);
1890 else if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) {
1891 StringLiteralParser Literal(Tok, *this,
1893 if (Literal.hadError)
1894 return;
1895
1897 Tok.setKind(tok::identifier);
1898 } else {
1899 Diag(Tok.getLocation(), diag::err_pp_identifier_arg_not_identifier)
1900 << Tok.getKind();
1901 // Don't walk past anything that's not a real token.
1902 if (Tok.isOneOf(tok::eof, tok::eod) || Tok.isAnnotation())
1903 return;
1904 }
1905
1906 // Discard the ')', preserving 'Tok' as our result.
1907 Token RParen;
1908 LexNonComment(RParen);
1909 if (RParen.isNot(tok::r_paren)) {
1910 Diag(getLocForEndOfToken(Tok.getLocation()), diag::err_pp_expected_after)
1911 << Tok.getKind() << tok::r_paren;
1912 Diag(LParenLoc, diag::note_matching) << tok::l_paren;
1913 }
1914 return;
1915 } else if (II == Ident__is_target_arch) {
1917 OS, Tok, II, *this, false,
1918 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1920 Tok, *this, diag::err_feature_check_malformed);
1921 return II && isTargetArch(getTargetInfo(), II);
1922 });
1923 } else if (II == Ident__is_target_vendor) {
1925 OS, Tok, II, *this, false,
1926 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1928 Tok, *this, diag::err_feature_check_malformed);
1929 return II && isTargetVendor(getTargetInfo(), II);
1930 });
1931 } else if (II == Ident__is_target_os) {
1933 OS, Tok, II, *this, false,
1934 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1936 Tok, *this, diag::err_feature_check_malformed);
1937 return II && isTargetOS(getTargetInfo(), II);
1938 });
1939 } else if (II == Ident__is_target_environment) {
1941 OS, Tok, II, *this, false,
1942 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1944 Tok, *this, diag::err_feature_check_malformed);
1945 return II && isTargetEnvironment(getTargetInfo(), II);
1946 });
1947 } else if (II == Ident__is_target_variant_os) {
1949 OS, Tok, II, *this, false,
1950 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1952 Tok, *this, diag::err_feature_check_malformed);
1953 return II && isTargetVariantOS(getTargetInfo(), II);
1954 });
1955 } else if (II == Ident__is_target_variant_environment) {
1957 OS, Tok, II, *this, false,
1958 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1960 Tok, *this, diag::err_feature_check_malformed);
1961 return II && isTargetVariantEnvironment(getTargetInfo(), II);
1962 });
1963 } else {
1964 llvm_unreachable("Unknown identifier!");
1965 }
1966 CreateString(OS.str(), Tok, Tok.getLocation(), Tok.getLocation());
1967 Tok.setFlagValue(Token::StartOfLine, IsAtStartOfLine);
1968 Tok.setFlagValue(Token::LeadingSpace, HasLeadingSpace);
1969}
1970
1972 // If the 'used' status changed, and the macro requires 'unused' warning,
1973 // remove its SourceLocation from the warn-for-unused-macro locations.
1974 if (MI->isWarnIfUnused() && !MI->isUsed())
1975 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
1976 MI->setIsUsed(true);
1977}
1978
1980 const LangOptions &LangOpts,
1981 const TargetInfo &TI) {
1982 LangOpts.remapPathPrefix(Path);
1983 if (LangOpts.UseTargetPathSeparator) {
1984 if (TI.getTriple().isOSWindows())
1985 llvm::sys::path::remove_dots(Path, false,
1986 llvm::sys::path::Style::windows_backslash);
1987 else
1988 llvm::sys::path::remove_dots(Path, false, llvm::sys::path::Style::posix);
1989 }
1990}
1991
1993 const PresumedLoc &PLoc,
1994 const LangOptions &LangOpts,
1995 const TargetInfo &TI) {
1996 // Try to get the last path component, failing that return the original
1997 // presumed location.
1998 StringRef PLFileName = llvm::sys::path::filename(PLoc.getFilename());
1999 if (PLFileName.empty())
2000 PLFileName = PLoc.getFilename();
2001 FileName.append(PLFileName.begin(), PLFileName.end());
2002 processPathForFileMacro(FileName, LangOpts, TI);
2003}
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:2976
StringRef Identifier
Definition: Format.cpp:2984
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.
llvm::MachO::FileType FileType
Definition: MachO.h:46
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.
uint32_t Id
Definition: SemaARM.cpp:1140
SourceRange Range
Definition: SemaObjC.cpp:757
SourceLocation Loc
Definition: SemaObjC.cpp:758
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(const 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:557
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:461
bool UseTargetPathSeparator
Indicates whether to use target's platform-specific file separator when FILE macro is used and when c...
Definition: LangOptions.h:567
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:602
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:516
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, const 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:218
virtual bool supportsCpuSupports() const
Definition: TargetInfo.h:1498
virtual bool supportsCpuInit() const
Definition: TargetInfo.h:1500
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1256
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:1801
virtual bool supportsCpuIs() const
Definition: TargetInfo.h:1499
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.
Definition: CNFFormula.h:35
@ 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:59
@ CPlusPlus
Definition: LangStandard.h:55
@ CPlusPlus11
Definition: LangStandard.h:56
@ 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.