1 //===--- PPMacroExpansion.cpp - Top level Macro Expansion -----------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the top level handling of macro expansion for the
10 // preprocessor.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Basic/AttributeCommonInfo.h"
15 #include "clang/Basic/Attributes.h"
16 #include "clang/Basic/Builtins.h"
17 #include "clang/Basic/FileManager.h"
18 #include "clang/Basic/IdentifierTable.h"
19 #include "clang/Basic/LLVM.h"
20 #include "clang/Basic/LangOptions.h"
21 #include "clang/Basic/ObjCRuntime.h"
22 #include "clang/Basic/SourceLocation.h"
23 #include "clang/Basic/TargetInfo.h"
24 #include "clang/Lex/CodeCompletionHandler.h"
25 #include "clang/Lex/DirectoryLookup.h"
26 #include "clang/Lex/ExternalPreprocessorSource.h"
27 #include "clang/Lex/HeaderSearch.h"
28 #include "clang/Lex/LexDiagnostic.h"
29 #include "clang/Lex/LiteralSupport.h"
30 #include "clang/Lex/MacroArgs.h"
31 #include "clang/Lex/MacroInfo.h"
32 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Lex/PreprocessorLexer.h"
34 #include "clang/Lex/PreprocessorOptions.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
60 using namespace clang;
61
62 MacroDirective *
getLocalMacroDirectiveHistory(const IdentifierInfo * II) const63 Preprocessor::getLocalMacroDirectiveHistory(const IdentifierInfo *II) const {
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
appendMacroDirective(IdentifierInfo * II,MacroDirective * MD)71 void Preprocessor::appendMacroDirective(IdentifierInfo *II, MacroDirective *MD){
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())
93 II->setChangedSinceDeserialization();
94 }
95
setLoadedMacroDirective(IdentifierInfo * II,MacroDirective * ED,MacroDirective * MD)96 void Preprocessor::setLoadedMacroDirective(IdentifierInfo *II,
97 MacroDirective *ED,
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
addModuleMacro(Module * Mod,IdentifierInfo * II,MacroInfo * Macro,ArrayRef<ModuleMacro * > Overrides,bool & New)132 ModuleMacro *Preprocessor::addModuleMacro(Module *Mod, IdentifierInfo *II,
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
getModuleMacro(Module * Mod,const IdentifierInfo * II)171 ModuleMacro *Preprocessor::getModuleMacro(Module *Mod,
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
updateModuleMacroInfo(const IdentifierInfo * II,ModuleMacroInfo & Info)180 void 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.
202 llvm::SmallVector<ModuleMacro *, 16> Worklist;
203 for (auto *LeafMM : Leaf->second) {
204 assert(LeafMM->getNumOverridingMacros() == 0 && "leaf macro overridden");
205 if (NumHiddenOverrides.lookup(LeafMM) == 0)
206 Worklist.push_back(LeafMM);
207 }
208 while (!Worklist.empty()) {
209 auto *MM = Worklist.pop_back_val();
210 if (CurSubmoduleState->VisibleModules.isVisible(MM->getOwningModule())) {
211 // We only care about collecting definitions; undefinitions only act
212 // to override other definitions.
213 if (MM->getMacroInfo())
214 Info.ActiveModuleMacros.push_back(MM);
215 } else {
216 for (auto *O : MM->overrides())
217 if ((unsigned)++NumHiddenOverrides[O] == O->getNumOverridingMacros())
218 Worklist.push_back(O);
219 }
220 }
221 // Our reverse postorder walk found the macros in reverse order.
222 std::reverse(Info.ActiveModuleMacros.begin(), Info.ActiveModuleMacros.end());
223
224 // Determine whether the macro name is ambiguous.
225 MacroInfo *MI = nullptr;
226 bool IsSystemMacro = true;
227 bool IsAmbiguous = false;
228 if (auto *MD = Info.MD) {
229 while (MD && isa<VisibilityMacroDirective>(MD))
230 MD = MD->getPrevious();
231 if (auto *DMD = dyn_cast_or_null<DefMacroDirective>(MD)) {
232 MI = DMD->getInfo();
233 IsSystemMacro &= SourceMgr.isInSystemHeader(DMD->getLocation());
234 }
235 }
236 for (auto *Active : Info.ActiveModuleMacros) {
237 auto *NewMI = Active->getMacroInfo();
238
239 // Before marking the macro as ambiguous, check if this is a case where
240 // both macros are in system headers. If so, we trust that the system
241 // did not get it wrong. This also handles cases where Clang's own
242 // headers have a different spelling of certain system macros:
243 // #define LONG_MAX __LONG_MAX__ (clang's limits.h)
244 // #define LONG_MAX 0x7fffffffffffffffL (system's limits.h)
245 //
246 // FIXME: Remove the defined-in-system-headers check. clang's limits.h
247 // overrides the system limits.h's macros, so there's no conflict here.
248 if (MI && NewMI != MI &&
249 !MI->isIdenticalTo(*NewMI, *this, /*Syntactically=*/true))
250 IsAmbiguous = true;
251 IsSystemMacro &= Active->getOwningModule()->IsSystem ||
252 SourceMgr.isInSystemHeader(NewMI->getDefinitionLoc());
253 MI = NewMI;
254 }
255 Info.IsAmbiguous = IsAmbiguous && !IsSystemMacro;
256 }
257
dumpMacroInfo(const IdentifierInfo * II)258 void Preprocessor::dumpMacroInfo(const IdentifierInfo *II) {
259 ArrayRef<ModuleMacro*> Leaf;
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.
286 llvm::DenseSet<ModuleMacro*> Active;
287 for (auto *MM :
288 State ? State->getActiveModuleMacros(*this, II) : std::nullopt)
289 Active.insert(MM);
290 llvm::DenseSet<ModuleMacro*> Visited;
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.
RegisterBuiltinMacro(Preprocessor & PP,const char * Name)326 static IdentifierInfo *RegisterBuiltinMacro(Preprocessor &PP, const char *Name){
327 // Get the identifier.
328 IdentifierInfo *Id = PP.getIdentifierInfo(Name);
329
330 // Mark it as being a macro that is builtin.
331 MacroInfo *MI = PP.AllocateMacroInfo(SourceLocation());
332 MI->setIsBuiltinMacro();
333 PP.appendDefMacroDirective(Id, MI);
334 return Id;
335 }
336
337 /// RegisterBuiltinMacros - Register builtin macros, such as __LINE__ with the
338 /// identifier table.
RegisterBuiltinMacros()339 void 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.
349 if (getLangOpts().CPlusPlus)
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.
isTrivialSingleTokenExpansion(const MacroInfo * MI,const IdentifierInfo * MacroIdent,Preprocessor & PP)407 static bool isTrivialSingleTokenExpansion(const MacroInfo *MI,
408 const IdentifierInfo *MacroIdent,
409 Preprocessor &PP) {
410 IdentifierInfo *II = MI->getReplacementToken(0).getIdentifierInfo();
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())
418 PP.getExternalSource()->updateOutOfDateIdentifier(*II);
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.
isNextPPTokenLParen()440 bool 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'.
HandleMacroExpandedIdentifier(Token & Identifier,const MacroDefinition & M)477 bool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier,
478 const MacroDefinition &M) {
479 emitMacroExpansionWarnings(Identifier);
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.
579 Identifier.setFlag(Token::LeadingEmptyMacro);
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.
599 Identifier = MI->getReplacementToken(0);
600
601 // Restore the StartOfLine/LeadingSpace markers.
602 Identifier.setFlagValue(Token::StartOfLine , isAtStartOfLine);
603 Identifier.setFlagValue(Token::LeadingSpace, hasLeadingSpace);
604
605 // Update the tokens location to include both its expansion and physical
606 // locations.
607 SourceLocation Loc =
608 SourceMgr.createExpansionLoc(Identifier.getLocation(), ExpandLoc,
609 ExpansionEnd,Identifier.getLength());
610 Identifier.setLocation(Loc);
611
612 // If this is a disabled macro or #define X X, we must mark the result as
613 // unexpandable.
614 if (IdentifierInfo *NewII = Identifier.getIdentifierInfo()) {
615 if (MacroInfo *NewMI = getMacroInfo(NewII))
616 if (!NewMI->isEnabled() || NewMI == MI) {
617 Identifier.setFlag(Token::DisableExpand);
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
636 enum Bracket {
637 Brace,
638 Paren
639 };
640
641 /// CheckMatchedBrackets - Returns true if the braces and parentheses in the
642 /// token vector are properly nested.
CheckMatchedBrackets(const SmallVectorImpl<Token> & Tokens)643 static bool CheckMatchedBrackets(const SmallVectorImpl<Token> &Tokens) {
644 SmallVector<Bracket, 8> Brackets;
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.
GenerateNewArgTokens(Preprocessor & PP,SmallVectorImpl<Token> & OldTokens,SmallVectorImpl<Token> & NewTokens,unsigned & NumArgs,SmallVectorImpl<SourceRange> & ParenHints,SmallVectorImpl<SourceRange> & InitLists)672 static bool GenerateNewArgTokens(Preprocessor &PP,
673 SmallVectorImpl<Token> &OldTokens,
674 SmallVectorImpl<Token> &NewTokens,
675 unsigned &NumArgs,
676 SmallVectorImpl<SourceRange> &ParenHints,
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.
ReadMacroCallArgumentList(Token & MacroName,MacroInfo * MI,SourceLocation & MacroEnd)768 MacroArgs *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 ')'.
780 LexUnexpandedToken(Tok);
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 ')'.
810 LexUnexpandedToken(Tok);
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.
848 Tok.clearFlag(Token::IgnoredComma);
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.
869 if (MacroInfo *MI = getMacroInfo(Tok.getIdentifierInfo()))
870 if (!MI->isEnabled())
871 Tok.setFlag(Token::DisableExpand);
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)
902 Diag(Tok, getLangOpts().CPlusPlus11
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()) {
943 DiagnosticBuilder DB =
944 Diag(MacroName,
945 diag::note_init_list_at_beginning_of_macro_argument);
946 for (SourceRange Range : InitLists)
947 DB << Range;
948 }
949 return nullptr;
950 }
951 if (FixedNumArgs != MinArgsExpected)
952 return nullptr;
953
954 DiagnosticBuilder DB = Diag(MacroName, diag::note_suggest_parens_for_macro);
955 for (SourceRange ParenLocation : ParenHints) {
956 DB << FixItHint::CreateInsertion(ParenLocation.getBegin(), "(");
957 DB << FixItHint::CreateInsertion(ParenLocation.getEnd(), ")");
958 }
959 ArgTokens.swap(FixedArgTokens);
960 NumActuals = FixedNumArgs;
961 }
962
963 // See MacroArgs instance var for description of this.
964 bool isVarargsElided = false;
965
966 if (ContainsCodeCompletionTok) {
967 // Recover from not-fully-formed macro invocation during code-completion.
968 Token EOFTok;
969 EOFTok.startToken();
970 EOFTok.setKind(tok::eof);
971 EOFTok.setLocation(Tok.getLocation());
972 EOFTok.setLength(0);
973 for (; NumActuals < MinArgsExpected; ++NumActuals)
974 ArgTokens.push_back(EOFTok);
975 }
976
977 if (NumActuals < MinArgsExpected) {
978 // There are several cases where too few arguments is ok, handle them now.
979 if (NumActuals == 0 && MinArgsExpected == 1) {
980 // #define A(X) or #define A(...) ---> A()
981
982 // If there is exactly one argument, and that argument is missing,
983 // then we have an empty "()" argument empty list. This is fine, even if
984 // the macro expects one argument (the argument is just empty).
985 isVarargsElided = MI->isVariadic();
986 } else if ((FoundElidedComma || MI->isVariadic()) &&
987 (NumActuals+1 == MinArgsExpected || // A(x, ...) -> A(X)
988 (NumActuals == 0 && MinArgsExpected == 2))) {// A(x,...) -> A()
989 // Varargs where the named vararg parameter is missing: OK as extension.
990 // #define A(x, ...)
991 // A("blah")
992 //
993 // If the macro contains the comma pasting extension, the diagnostic
994 // is suppressed; we know we'll get another diagnostic later.
995 if (!MI->hasCommaPasting()) {
996 // C++20 allows this construct, but standards before C++20 and all C
997 // standards do not allow the construct (we allow it as an extension).
998 Diag(Tok, getLangOpts().CPlusPlus20
999 ? diag::warn_cxx17_compat_missing_varargs_arg
1000 : diag::ext_missing_varargs_arg);
1001 Diag(MI->getDefinitionLoc(), diag::note_macro_here)
1002 << MacroName.getIdentifierInfo();
1003 }
1004
1005 // Remember this occurred, allowing us to elide the comma when used for
1006 // cases like:
1007 // #define A(x, foo...) blah(a, ## foo)
1008 // #define B(x, ...) blah(a, ## __VA_ARGS__)
1009 // #define C(...) blah(a, ## __VA_ARGS__)
1010 // A(x) B(x) C()
1011 isVarargsElided = true;
1012 } else if (!ContainsCodeCompletionTok) {
1013 // Otherwise, emit the error.
1014 Diag(Tok, diag::err_too_few_args_in_macro_invoc);
1015 Diag(MI->getDefinitionLoc(), diag::note_macro_here)
1016 << MacroName.getIdentifierInfo();
1017 return nullptr;
1018 }
1019
1020 // Add a marker EOF token to the end of the token list for this argument.
1021 SourceLocation EndLoc = Tok.getLocation();
1022 Tok.startToken();
1023 Tok.setKind(tok::eof);
1024 Tok.setLocation(EndLoc);
1025 Tok.setLength(0);
1026 ArgTokens.push_back(Tok);
1027
1028 // If we expect two arguments, add both as empty.
1029 if (NumActuals == 0 && MinArgsExpected == 2)
1030 ArgTokens.push_back(Tok);
1031
1032 } else if (NumActuals > MinArgsExpected && !MI->isVariadic() &&
1033 !ContainsCodeCompletionTok) {
1034 // Emit the diagnostic at the macro name in case there is a missing ).
1035 // Emitting it at the , could be far away from the macro name.
1036 Diag(MacroName, diag::err_too_many_args_in_macro_invoc);
1037 Diag(MI->getDefinitionLoc(), diag::note_macro_here)
1038 << MacroName.getIdentifierInfo();
1039 return nullptr;
1040 }
1041
1042 return MacroArgs::create(MI, ArgTokens, isVarargsElided, *this);
1043 }
1044
1045 /// Keeps macro expanded tokens for TokenLexers.
1046 //
1047 /// Works like a stack; a TokenLexer adds the macro expanded tokens that is
1048 /// going to lex in the cache and when it finishes the tokens are removed
1049 /// from the end of the cache.
cacheMacroExpandedTokens(TokenLexer * tokLexer,ArrayRef<Token> tokens)1050 Token *Preprocessor::cacheMacroExpandedTokens(TokenLexer *tokLexer,
1051 ArrayRef<Token> tokens) {
1052 assert(tokLexer);
1053 if (tokens.empty())
1054 return nullptr;
1055
1056 size_t newIndex = MacroExpandedTokens.size();
1057 bool cacheNeedsToGrow = tokens.size() >
1058 MacroExpandedTokens.capacity()-MacroExpandedTokens.size();
1059 MacroExpandedTokens.append(tokens.begin(), tokens.end());
1060
1061 if (cacheNeedsToGrow) {
1062 // Go through all the TokenLexers whose 'Tokens' pointer points in the
1063 // buffer and update the pointers to the (potential) new buffer array.
1064 for (const auto &Lexer : MacroExpandingLexersStack) {
1065 TokenLexer *prevLexer;
1066 size_t tokIndex;
1067 std::tie(prevLexer, tokIndex) = Lexer;
1068 prevLexer->Tokens = MacroExpandedTokens.data() + tokIndex;
1069 }
1070 }
1071
1072 MacroExpandingLexersStack.push_back(std::make_pair(tokLexer, newIndex));
1073 return MacroExpandedTokens.data() + newIndex;
1074 }
1075
removeCachedMacroExpandedTokensOfLastLexer()1076 void Preprocessor::removeCachedMacroExpandedTokensOfLastLexer() {
1077 assert(!MacroExpandingLexersStack.empty());
1078 size_t tokIndex = MacroExpandingLexersStack.back().second;
1079 assert(tokIndex < MacroExpandedTokens.size());
1080 // Pop the cached macro expanded tokens from the end.
1081 MacroExpandedTokens.resize(tokIndex);
1082 MacroExpandingLexersStack.pop_back();
1083 }
1084
1085 /// ComputeDATE_TIME - Compute the current time, enter it into the specified
1086 /// scratch buffer, then return DATELoc/TIMELoc locations with the position of
1087 /// the identifier tokens inserted.
ComputeDATE_TIME(SourceLocation & DATELoc,SourceLocation & TIMELoc,Preprocessor & PP)1088 static void ComputeDATE_TIME(SourceLocation &DATELoc, SourceLocation &TIMELoc,
1089 Preprocessor &PP) {
1090 time_t TT;
1091 std::tm *TM;
1092 if (PP.getPreprocessorOpts().SourceDateEpoch) {
1093 TT = *PP.getPreprocessorOpts().SourceDateEpoch;
1094 TM = std::gmtime(&TT);
1095 } else {
1096 TT = std::time(nullptr);
1097 TM = std::localtime(&TT);
1098 }
1099
1100 static const char * const Months[] = {
1101 "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
1102 };
1103
1104 {
1105 SmallString<32> TmpBuffer;
1106 llvm::raw_svector_ostream TmpStream(TmpBuffer);
1107 if (TM)
1108 TmpStream << llvm::format("\"%s %2d %4d\"", Months[TM->tm_mon],
1109 TM->tm_mday, TM->tm_year + 1900);
1110 else
1111 TmpStream << "??? ?? ????";
1112 Token TmpTok;
1113 TmpTok.startToken();
1114 PP.CreateString(TmpStream.str(), TmpTok);
1115 DATELoc = TmpTok.getLocation();
1116 }
1117
1118 {
1119 SmallString<32> TmpBuffer;
1120 llvm::raw_svector_ostream TmpStream(TmpBuffer);
1121 if (TM)
1122 TmpStream << llvm::format("\"%02d:%02d:%02d\"", TM->tm_hour, TM->tm_min,
1123 TM->tm_sec);
1124 else
1125 TmpStream << "??:??:??";
1126 Token TmpTok;
1127 TmpTok.startToken();
1128 PP.CreateString(TmpStream.str(), TmpTok);
1129 TIMELoc = TmpTok.getLocation();
1130 }
1131 }
1132
1133 /// HasFeature - Return true if we recognize and implement the feature
1134 /// specified by the identifier as a standard language feature.
HasFeature(const Preprocessor & PP,StringRef Feature)1135 static bool HasFeature(const Preprocessor &PP, StringRef Feature) {
1136 const LangOptions &LangOpts = PP.getLangOpts();
1137
1138 // Normalize the feature name, __foo__ becomes foo.
1139 if (Feature.starts_with("__") && Feature.ends_with("__") &&
1140 Feature.size() >= 4)
1141 Feature = Feature.substr(2, Feature.size() - 4);
1142
1143 #define FEATURE(Name, Predicate) .Case(#Name, Predicate)
1144 return llvm::StringSwitch<bool>(Feature)
1145 #include "clang/Basic/Features.def"
1146 .Default(false);
1147 #undef FEATURE
1148 }
1149
1150 /// HasExtension - Return true if we recognize and implement the feature
1151 /// specified by the identifier, either as an extension or a standard language
1152 /// feature.
HasExtension(const Preprocessor & PP,StringRef Extension)1153 static bool HasExtension(const Preprocessor &PP, StringRef Extension) {
1154 if (HasFeature(PP, Extension))
1155 return true;
1156
1157 // If the use of an extension results in an error diagnostic, extensions are
1158 // effectively unavailable, so just return false here.
1159 if (PP.getDiagnostics().getExtensionHandlingBehavior() >=
1160 diag::Severity::Error)
1161 return false;
1162
1163 const LangOptions &LangOpts = PP.getLangOpts();
1164
1165 // Normalize the extension name, __foo__ becomes foo.
1166 if (Extension.starts_with("__") && Extension.ends_with("__") &&
1167 Extension.size() >= 4)
1168 Extension = Extension.substr(2, Extension.size() - 4);
1169
1170 // Because we inherit the feature list from HasFeature, this string switch
1171 // must be less restrictive than HasFeature's.
1172 #define EXTENSION(Name, Predicate) .Case(#Name, Predicate)
1173 return llvm::StringSwitch<bool>(Extension)
1174 #include "clang/Basic/Features.def"
1175 .Default(false);
1176 #undef EXTENSION
1177 }
1178
1179 /// EvaluateHasIncludeCommon - Process a '__has_include("path")'
1180 /// or '__has_include_next("path")' expression.
1181 /// Returns true if successful.
EvaluateHasIncludeCommon(Token & Tok,IdentifierInfo * II,Preprocessor & PP,ConstSearchDirIterator LookupFrom,const FileEntry * LookupFromFile)1182 static bool EvaluateHasIncludeCommon(Token &Tok, IdentifierInfo *II,
1183 Preprocessor &PP,
1184 ConstSearchDirIterator LookupFrom,
1185 const FileEntry *LookupFromFile) {
1186 // Save the location of the current token. If a '(' is later found, use
1187 // that location. If not, use the end of this location instead.
1188 SourceLocation LParenLoc = Tok.getLocation();
1189
1190 // These expressions are only allowed within a preprocessor directive.
1191 if (!PP.isParsingIfOrElifDirective()) {
1192 PP.Diag(LParenLoc, diag::err_pp_directive_required) << II;
1193 // Return a valid identifier token.
1194 assert(Tok.is(tok::identifier));
1195 Tok.setIdentifierInfo(II);
1196 return false;
1197 }
1198
1199 // Get '('. If we don't have a '(', try to form a header-name token.
1200 do {
1201 if (PP.LexHeaderName(Tok))
1202 return false;
1203 } while (Tok.getKind() == tok::comment);
1204
1205 // Ensure we have a '('.
1206 if (Tok.isNot(tok::l_paren)) {
1207 // No '(', use end of last token.
1208 LParenLoc = PP.getLocForEndOfToken(LParenLoc);
1209 PP.Diag(LParenLoc, diag::err_pp_expected_after) << II << tok::l_paren;
1210 // If the next token looks like a filename or the start of one,
1211 // assume it is and process it as such.
1212 if (Tok.isNot(tok::header_name))
1213 return false;
1214 } else {
1215 // Save '(' location for possible missing ')' message.
1216 LParenLoc = Tok.getLocation();
1217 if (PP.LexHeaderName(Tok))
1218 return false;
1219 }
1220
1221 if (Tok.isNot(tok::header_name)) {
1222 PP.Diag(Tok.getLocation(), diag::err_pp_expects_filename);
1223 return false;
1224 }
1225
1226 // Reserve a buffer to get the spelling.
1227 SmallString<128> FilenameBuffer;
1228 bool Invalid = false;
1229 StringRef Filename = PP.getSpelling(Tok, FilenameBuffer, &Invalid);
1230 if (Invalid)
1231 return false;
1232
1233 SourceLocation FilenameLoc = Tok.getLocation();
1234
1235 // Get ')'.
1236 PP.LexNonComment(Tok);
1237
1238 // Ensure we have a trailing ).
1239 if (Tok.isNot(tok::r_paren)) {
1240 PP.Diag(PP.getLocForEndOfToken(FilenameLoc), diag::err_pp_expected_after)
1241 << II << tok::r_paren;
1242 PP.Diag(LParenLoc, diag::note_matching) << tok::l_paren;
1243 return false;
1244 }
1245
1246 bool isAngled = PP.GetIncludeFilenameSpelling(Tok.getLocation(), Filename);
1247 // If GetIncludeFilenameSpelling set the start ptr to null, there was an
1248 // error.
1249 if (Filename.empty())
1250 return false;
1251
1252 // Passing this to LookupFile forces header search to check whether the found
1253 // file belongs to a module. Skipping that check could incorrectly mark
1254 // modular header as textual, causing issues down the line.
1255 ModuleMap::KnownHeader KH;
1256
1257 // Search include directories.
1258 OptionalFileEntryRef File =
1259 PP.LookupFile(FilenameLoc, Filename, isAngled, LookupFrom, LookupFromFile,
1260 nullptr, nullptr, nullptr, &KH, nullptr, nullptr);
1261
1262 if (PPCallbacks *Callbacks = PP.getPPCallbacks()) {
1263 SrcMgr::CharacteristicKind FileType = SrcMgr::C_User;
1264 if (File)
1265 FileType = PP.getHeaderSearchInfo().getFileDirFlavor(*File);
1266 Callbacks->HasInclude(FilenameLoc, Filename, isAngled, File, FileType);
1267 }
1268
1269 // Get the result value. A result of true means the file exists.
1270 return File.has_value();
1271 }
1272
EvaluateHasInclude(Token & Tok,IdentifierInfo * II)1273 bool Preprocessor::EvaluateHasInclude(Token &Tok, IdentifierInfo *II) {
1274 return EvaluateHasIncludeCommon(Tok, II, *this, nullptr, nullptr);
1275 }
1276
EvaluateHasIncludeNext(Token & Tok,IdentifierInfo * II)1277 bool Preprocessor::EvaluateHasIncludeNext(Token &Tok, IdentifierInfo *II) {
1278 ConstSearchDirIterator Lookup = nullptr;
1279 const FileEntry *LookupFromFile;
1280 std::tie(Lookup, LookupFromFile) = getIncludeNextStart(Tok);
1281
1282 return EvaluateHasIncludeCommon(Tok, II, *this, Lookup, LookupFromFile);
1283 }
1284
1285 /// Process single-argument builtin feature-like macros that return
1286 /// integer values.
EvaluateFeatureLikeBuiltinMacro(llvm::raw_svector_ostream & OS,Token & Tok,IdentifierInfo * II,Preprocessor & PP,bool ExpandArgs,llvm::function_ref<int (Token & Tok,bool & HasLexedNextTok)> Op)1287 static void EvaluateFeatureLikeBuiltinMacro(llvm::raw_svector_ostream& OS,
1288 Token &Tok, IdentifierInfo *II,
1289 Preprocessor &PP, bool ExpandArgs,
1290 llvm::function_ref<
1291 int(Token &Tok,
1292 bool &HasLexedNextTok)> Op) {
1293 // Parse the initial '('.
1294 PP.LexUnexpandedToken(Tok);
1295 if (Tok.isNot(tok::l_paren)) {
1296 PP.Diag(Tok.getLocation(), diag::err_pp_expected_after) << II
1297 << tok::l_paren;
1298
1299 // Provide a dummy '0' value on output stream to elide further errors.
1300 if (!Tok.isOneOf(tok::eof, tok::eod)) {
1301 OS << 0;
1302 Tok.setKind(tok::numeric_constant);
1303 }
1304 return;
1305 }
1306
1307 unsigned ParenDepth = 1;
1308 SourceLocation LParenLoc = Tok.getLocation();
1309 std::optional<int> Result;
1310
1311 Token ResultTok;
1312 bool SuppressDiagnostic = false;
1313 while (true) {
1314 // Parse next token.
1315 if (ExpandArgs)
1316 PP.Lex(Tok);
1317 else
1318 PP.LexUnexpandedToken(Tok);
1319
1320 already_lexed:
1321 switch (Tok.getKind()) {
1322 case tok::eof:
1323 case tok::eod:
1324 // Don't provide even a dummy value if the eod or eof marker is
1325 // reached. Simply provide a diagnostic.
1326 PP.Diag(Tok.getLocation(), diag::err_unterm_macro_invoc);
1327 return;
1328
1329 case tok::comma:
1330 if (!SuppressDiagnostic) {
1331 PP.Diag(Tok.getLocation(), diag::err_too_many_args_in_macro_invoc);
1332 SuppressDiagnostic = true;
1333 }
1334 continue;
1335
1336 case tok::l_paren:
1337 ++ParenDepth;
1338 if (Result)
1339 break;
1340 if (!SuppressDiagnostic) {
1341 PP.Diag(Tok.getLocation(), diag::err_pp_nested_paren) << II;
1342 SuppressDiagnostic = true;
1343 }
1344 continue;
1345
1346 case tok::r_paren:
1347 if (--ParenDepth > 0)
1348 continue;
1349
1350 // The last ')' has been reached; return the value if one found or
1351 // a diagnostic and a dummy value.
1352 if (Result) {
1353 OS << *Result;
1354 // For strict conformance to __has_cpp_attribute rules, use 'L'
1355 // suffix for dated literals.
1356 if (*Result > 1)
1357 OS << 'L';
1358 } else {
1359 OS << 0;
1360 if (!SuppressDiagnostic)
1361 PP.Diag(Tok.getLocation(), diag::err_too_few_args_in_macro_invoc);
1362 }
1363 Tok.setKind(tok::numeric_constant);
1364 return;
1365
1366 default: {
1367 // Parse the macro argument, if one not found so far.
1368 if (Result)
1369 break;
1370
1371 bool HasLexedNextToken = false;
1372 Result = Op(Tok, HasLexedNextToken);
1373 ResultTok = Tok;
1374 if (HasLexedNextToken)
1375 goto already_lexed;
1376 continue;
1377 }
1378 }
1379
1380 // Diagnose missing ')'.
1381 if (!SuppressDiagnostic) {
1382 if (auto Diag = PP.Diag(Tok.getLocation(), diag::err_pp_expected_after)) {
1383 if (IdentifierInfo *LastII = ResultTok.getIdentifierInfo())
1384 Diag << LastII;
1385 else
1386 Diag << ResultTok.getKind();
1387 Diag << tok::r_paren << ResultTok.getLocation();
1388 }
1389 PP.Diag(LParenLoc, diag::note_matching) << tok::l_paren;
1390 SuppressDiagnostic = true;
1391 }
1392 }
1393 }
1394
1395 /// Helper function to return the IdentifierInfo structure of a Token
1396 /// or generate a diagnostic if none available.
ExpectFeatureIdentifierInfo(Token & Tok,Preprocessor & PP,signed DiagID)1397 static IdentifierInfo *ExpectFeatureIdentifierInfo(Token &Tok,
1398 Preprocessor &PP,
1399 signed DiagID) {
1400 IdentifierInfo *II;
1401 if (!Tok.isAnnotation() && (II = Tok.getIdentifierInfo()))
1402 return II;
1403
1404 PP.Diag(Tok.getLocation(), DiagID);
1405 return nullptr;
1406 }
1407
1408 /// Implements the __is_target_arch builtin macro.
isTargetArch(const TargetInfo & TI,const IdentifierInfo * II)1409 static bool isTargetArch(const TargetInfo &TI, const IdentifierInfo *II) {
1410 std::string ArchName = II->getName().lower() + "--";
1411 llvm::Triple Arch(ArchName);
1412 const llvm::Triple &TT = TI.getTriple();
1413 if (TT.isThumb()) {
1414 // arm matches thumb or thumbv7. armv7 matches thumbv7.
1415 if ((Arch.getSubArch() == llvm::Triple::NoSubArch ||
1416 Arch.getSubArch() == TT.getSubArch()) &&
1417 ((TT.getArch() == llvm::Triple::thumb &&
1418 Arch.getArch() == llvm::Triple::arm) ||
1419 (TT.getArch() == llvm::Triple::thumbeb &&
1420 Arch.getArch() == llvm::Triple::armeb)))
1421 return true;
1422 }
1423 // Check the parsed arch when it has no sub arch to allow Clang to
1424 // match thumb to thumbv7 but to prohibit matching thumbv6 to thumbv7.
1425 return (Arch.getSubArch() == llvm::Triple::NoSubArch ||
1426 Arch.getSubArch() == TT.getSubArch()) &&
1427 Arch.getArch() == TT.getArch();
1428 }
1429
1430 /// Implements the __is_target_vendor builtin macro.
isTargetVendor(const TargetInfo & TI,const IdentifierInfo * II)1431 static bool isTargetVendor(const TargetInfo &TI, const IdentifierInfo *II) {
1432 StringRef VendorName = TI.getTriple().getVendorName();
1433 if (VendorName.empty())
1434 VendorName = "unknown";
1435 return VendorName.equals_insensitive(II->getName());
1436 }
1437
1438 /// Implements the __is_target_os builtin macro.
isTargetOS(const TargetInfo & TI,const IdentifierInfo * II)1439 static bool isTargetOS(const TargetInfo &TI, const IdentifierInfo *II) {
1440 std::string OSName =
1441 (llvm::Twine("unknown-unknown-") + II->getName().lower()).str();
1442 llvm::Triple OS(OSName);
1443 if (OS.getOS() == llvm::Triple::Darwin) {
1444 // Darwin matches macos, ios, etc.
1445 return TI.getTriple().isOSDarwin();
1446 }
1447 return TI.getTriple().getOS() == OS.getOS();
1448 }
1449
1450 /// Implements the __is_target_environment builtin macro.
isTargetEnvironment(const TargetInfo & TI,const IdentifierInfo * II)1451 static bool isTargetEnvironment(const TargetInfo &TI,
1452 const IdentifierInfo *II) {
1453 std::string EnvName = (llvm::Twine("---") + II->getName().lower()).str();
1454 llvm::Triple Env(EnvName);
1455 // The unknown environment is matched only if
1456 // '__is_target_environment(unknown)' is used.
1457 if (Env.getEnvironment() == llvm::Triple::UnknownEnvironment &&
1458 EnvName != "---unknown")
1459 return false;
1460 return TI.getTriple().getEnvironment() == Env.getEnvironment();
1461 }
1462
1463 /// Implements the __is_target_variant_os builtin macro.
isTargetVariantOS(const TargetInfo & TI,const IdentifierInfo * II)1464 static bool isTargetVariantOS(const TargetInfo &TI, const IdentifierInfo *II) {
1465 if (TI.getTriple().isOSDarwin()) {
1466 const llvm::Triple *VariantTriple = TI.getDarwinTargetVariantTriple();
1467 if (!VariantTriple)
1468 return false;
1469
1470 std::string OSName =
1471 (llvm::Twine("unknown-unknown-") + II->getName().lower()).str();
1472 llvm::Triple OS(OSName);
1473 if (OS.getOS() == llvm::Triple::Darwin) {
1474 // Darwin matches macos, ios, etc.
1475 return VariantTriple->isOSDarwin();
1476 }
1477 return VariantTriple->getOS() == OS.getOS();
1478 }
1479 return false;
1480 }
1481
1482 /// Implements the __is_target_variant_environment builtin macro.
isTargetVariantEnvironment(const TargetInfo & TI,const IdentifierInfo * II)1483 static bool isTargetVariantEnvironment(const TargetInfo &TI,
1484 const IdentifierInfo *II) {
1485 if (TI.getTriple().isOSDarwin()) {
1486 const llvm::Triple *VariantTriple = TI.getDarwinTargetVariantTriple();
1487 if (!VariantTriple)
1488 return false;
1489 std::string EnvName = (llvm::Twine("---") + II->getName().lower()).str();
1490 llvm::Triple Env(EnvName);
1491 return VariantTriple->getEnvironment() == Env.getEnvironment();
1492 }
1493 return false;
1494 }
1495
1496 /// ExpandBuiltinMacro - If an identifier token is read that is to be expanded
1497 /// as a builtin macro, handle it and return the next token as 'Tok'.
ExpandBuiltinMacro(Token & Tok)1498 void Preprocessor::ExpandBuiltinMacro(Token &Tok) {
1499 // Figure out which token this is.
1500 IdentifierInfo *II = Tok.getIdentifierInfo();
1501 assert(II && "Can't be a macro without id info!");
1502
1503 // If this is an _Pragma or Microsoft __pragma directive, expand it,
1504 // invoke the pragma handler, then lex the token after it.
1505 if (II == Ident_Pragma)
1506 return Handle_Pragma(Tok);
1507 else if (II == Ident__pragma) // in non-MS mode this is null
1508 return HandleMicrosoft__pragma(Tok);
1509
1510 ++NumBuiltinMacroExpanded;
1511
1512 SmallString<128> TmpBuffer;
1513 llvm::raw_svector_ostream OS(TmpBuffer);
1514
1515 // Set up the return result.
1516 Tok.setIdentifierInfo(nullptr);
1517 Tok.clearFlag(Token::NeedsCleaning);
1518 bool IsAtStartOfLine = Tok.isAtStartOfLine();
1519 bool HasLeadingSpace = Tok.hasLeadingSpace();
1520
1521 if (II == Ident__LINE__) {
1522 // C99 6.10.8: "__LINE__: The presumed line number (within the current
1523 // source file) of the current source line (an integer constant)". This can
1524 // be affected by #line.
1525 SourceLocation Loc = Tok.getLocation();
1526
1527 // Advance to the location of the first _, this might not be the first byte
1528 // of the token if it starts with an escaped newline.
1529 Loc = AdvanceToTokenCharacter(Loc, 0);
1530
1531 // One wrinkle here is that GCC expands __LINE__ to location of the *end* of
1532 // a macro expansion. This doesn't matter for object-like macros, but
1533 // can matter for a function-like macro that expands to contain __LINE__.
1534 // Skip down through expansion points until we find a file loc for the
1535 // end of the expansion history.
1536 Loc = SourceMgr.getExpansionRange(Loc).getEnd();
1537 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Loc);
1538
1539 // __LINE__ expands to a simple numeric value.
1540 OS << (PLoc.isValid()? PLoc.getLine() : 1);
1541 Tok.setKind(tok::numeric_constant);
1542 } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__ ||
1543 II == Ident__FILE_NAME__) {
1544 // C99 6.10.8: "__FILE__: The presumed name of the current source file (a
1545 // character string literal)". This can be affected by #line.
1546 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation());
1547
1548 // __BASE_FILE__ is a GNU extension that returns the top of the presumed
1549 // #include stack instead of the current file.
1550 if (II == Ident__BASE_FILE__ && PLoc.isValid()) {
1551 SourceLocation NextLoc = PLoc.getIncludeLoc();
1552 while (NextLoc.isValid()) {
1553 PLoc = SourceMgr.getPresumedLoc(NextLoc);
1554 if (PLoc.isInvalid())
1555 break;
1556
1557 NextLoc = PLoc.getIncludeLoc();
1558 }
1559 }
1560
1561 // Escape this filename. Turn '\' -> '\\' '"' -> '\"'
1562 SmallString<256> FN;
1563 if (PLoc.isValid()) {
1564 // __FILE_NAME__ is a Clang-specific extension that expands to the
1565 // the last part of __FILE__.
1566 if (II == Ident__FILE_NAME__) {
1567 processPathToFileName(FN, PLoc, getLangOpts(), getTargetInfo());
1568 } else {
1569 FN += PLoc.getFilename();
1570 processPathForFileMacro(FN, getLangOpts(), getTargetInfo());
1571 }
1572 Lexer::Stringify(FN);
1573 OS << '"' << FN << '"';
1574 }
1575 Tok.setKind(tok::string_literal);
1576 } else if (II == Ident__DATE__) {
1577 Diag(Tok.getLocation(), diag::warn_pp_date_time);
1578 if (!DATELoc.isValid())
1579 ComputeDATE_TIME(DATELoc, TIMELoc, *this);
1580 Tok.setKind(tok::string_literal);
1581 Tok.setLength(strlen("\"Mmm dd yyyy\""));
1582 Tok.setLocation(SourceMgr.createExpansionLoc(DATELoc, Tok.getLocation(),
1583 Tok.getLocation(),
1584 Tok.getLength()));
1585 return;
1586 } else if (II == Ident__TIME__) {
1587 Diag(Tok.getLocation(), diag::warn_pp_date_time);
1588 if (!TIMELoc.isValid())
1589 ComputeDATE_TIME(DATELoc, TIMELoc, *this);
1590 Tok.setKind(tok::string_literal);
1591 Tok.setLength(strlen("\"hh:mm:ss\""));
1592 Tok.setLocation(SourceMgr.createExpansionLoc(TIMELoc, Tok.getLocation(),
1593 Tok.getLocation(),
1594 Tok.getLength()));
1595 return;
1596 } else if (II == Ident__INCLUDE_LEVEL__) {
1597 // Compute the presumed include depth of this token. This can be affected
1598 // by GNU line markers.
1599 unsigned Depth = 0;
1600
1601 PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation());
1602 if (PLoc.isValid()) {
1603 PLoc = SourceMgr.getPresumedLoc(PLoc.getIncludeLoc());
1604 for (; PLoc.isValid(); ++Depth)
1605 PLoc = SourceMgr.getPresumedLoc(PLoc.getIncludeLoc());
1606 }
1607
1608 // __INCLUDE_LEVEL__ expands to a simple numeric value.
1609 OS << Depth;
1610 Tok.setKind(tok::numeric_constant);
1611 } else if (II == Ident__TIMESTAMP__) {
1612 Diag(Tok.getLocation(), diag::warn_pp_date_time);
1613 // MSVC, ICC, GCC, VisualAge C++ extension. The generated string should be
1614 // of the form "Ddd Mmm dd hh::mm::ss yyyy", which is returned by asctime.
1615 const char *Result;
1616 if (getPreprocessorOpts().SourceDateEpoch) {
1617 time_t TT = *getPreprocessorOpts().SourceDateEpoch;
1618 std::tm *TM = std::gmtime(&TT);
1619 Result = asctime(TM);
1620 } else {
1621 // Get the file that we are lexing out of. If we're currently lexing from
1622 // a macro, dig into the include stack.
1623 const FileEntry *CurFile = nullptr;
1624 if (PreprocessorLexer *TheLexer = getCurrentFileLexer())
1625 CurFile = SourceMgr.getFileEntryForID(TheLexer->getFileID());
1626 if (CurFile) {
1627 time_t TT = CurFile->getModificationTime();
1628 struct tm *TM = localtime(&TT);
1629 Result = asctime(TM);
1630 } else {
1631 Result = "??? ??? ?? ??:??:?? ????\n";
1632 }
1633 }
1634 // Surround the string with " and strip the trailing newline.
1635 OS << '"' << StringRef(Result).drop_back() << '"';
1636 Tok.setKind(tok::string_literal);
1637 } else if (II == Ident__FLT_EVAL_METHOD__) {
1638 // __FLT_EVAL_METHOD__ is set to the default value.
1639 OS << getTUFPEvalMethod();
1640 // __FLT_EVAL_METHOD__ expands to a simple numeric value.
1641 Tok.setKind(tok::numeric_constant);
1642 if (getLastFPEvalPragmaLocation().isValid()) {
1643 // The program is ill-formed. The value of __FLT_EVAL_METHOD__ is altered
1644 // by the pragma.
1645 Diag(Tok, diag::err_illegal_use_of_flt_eval_macro);
1646 Diag(getLastFPEvalPragmaLocation(), diag::note_pragma_entered_here);
1647 }
1648 } else if (II == Ident__COUNTER__) {
1649 // __COUNTER__ expands to a simple numeric value.
1650 OS << CounterValue++;
1651 Tok.setKind(tok::numeric_constant);
1652 } else if (II == Ident__has_feature) {
1653 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1654 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1655 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
1656 diag::err_feature_check_malformed);
1657 return II && HasFeature(*this, II->getName());
1658 });
1659 } else if (II == Ident__has_extension) {
1660 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1661 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1662 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
1663 diag::err_feature_check_malformed);
1664 return II && HasExtension(*this, II->getName());
1665 });
1666 } else if (II == Ident__has_builtin) {
1667 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1668 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1669 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
1670 diag::err_feature_check_malformed);
1671 if (!II)
1672 return false;
1673 else if (II->getBuiltinID() != 0) {
1674 switch (II->getBuiltinID()) {
1675 case Builtin::BI__builtin_operator_new:
1676 case Builtin::BI__builtin_operator_delete:
1677 // denotes date of behavior change to support calling arbitrary
1678 // usual allocation and deallocation functions. Required by libc++
1679 return 201802;
1680 default:
1681 return Builtin::evaluateRequiredTargetFeatures(
1682 getBuiltinInfo().getRequiredFeatures(II->getBuiltinID()),
1683 getTargetInfo().getTargetOpts().FeatureMap);
1684 }
1685 return true;
1686 } else if (II->getTokenID() != tok::identifier ||
1687 II->hasRevertedTokenIDToIdentifier()) {
1688 // Treat all keywords that introduce a custom syntax of the form
1689 //
1690 // '__some_keyword' '(' [...] ')'
1691 //
1692 // as being "builtin functions", even if the syntax isn't a valid
1693 // function call (for example, because the builtin takes a type
1694 // argument).
1695 if (II->getName().starts_with("__builtin_") ||
1696 II->getName().starts_with("__is_") ||
1697 II->getName().starts_with("__has_"))
1698 return true;
1699 return llvm::StringSwitch<bool>(II->getName())
1700 .Case("__array_rank", true)
1701 .Case("__array_extent", true)
1702 .Case("__reference_binds_to_temporary", true)
1703 .Case("__reference_constructs_from_temporary", true)
1704 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) .Case("__" #Trait, true)
1705 #include "clang/Basic/TransformTypeTraits.def"
1706 .Default(false);
1707 } else {
1708 return llvm::StringSwitch<bool>(II->getName())
1709 // Report builtin templates as being builtins.
1710 .Case("__make_integer_seq", getLangOpts().CPlusPlus)
1711 .Case("__type_pack_element", getLangOpts().CPlusPlus)
1712 // Likewise for some builtin preprocessor macros.
1713 // FIXME: This is inconsistent; we usually suggest detecting
1714 // builtin macros via #ifdef. Don't add more cases here.
1715 .Case("__is_target_arch", true)
1716 .Case("__is_target_vendor", true)
1717 .Case("__is_target_os", true)
1718 .Case("__is_target_environment", true)
1719 .Case("__is_target_variant_os", true)
1720 .Case("__is_target_variant_environment", true)
1721 .Default(false);
1722 }
1723 });
1724 } else if (II == Ident__has_constexpr_builtin) {
1725 EvaluateFeatureLikeBuiltinMacro(
1726 OS, Tok, II, *this, false,
1727 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1728 IdentifierInfo *II = ExpectFeatureIdentifierInfo(
1729 Tok, *this, diag::err_feature_check_malformed);
1730 if (!II)
1731 return false;
1732 unsigned BuiltinOp = II->getBuiltinID();
1733 return BuiltinOp != 0 &&
1734 this->getBuiltinInfo().isConstantEvaluated(BuiltinOp);
1735 });
1736 } else if (II == Ident__is_identifier) {
1737 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1738 [](Token &Tok, bool &HasLexedNextToken) -> int {
1739 return Tok.is(tok::identifier);
1740 });
1741 } else if (II == Ident__has_attribute) {
1742 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, true,
1743 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1744 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
1745 diag::err_feature_check_malformed);
1746 return II ? hasAttribute(AttributeCommonInfo::Syntax::AS_GNU, nullptr,
1747 II, getTargetInfo(), getLangOpts())
1748 : 0;
1749 });
1750 } else if (II == Ident__has_declspec) {
1751 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, true,
1752 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1753 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
1754 diag::err_feature_check_malformed);
1755 if (II) {
1756 const LangOptions &LangOpts = getLangOpts();
1757 return LangOpts.DeclSpecKeyword &&
1758 hasAttribute(AttributeCommonInfo::Syntax::AS_Declspec, nullptr,
1759 II, getTargetInfo(), LangOpts);
1760 }
1761
1762 return false;
1763 });
1764 } else if (II == Ident__has_cpp_attribute ||
1765 II == Ident__has_c_attribute) {
1766 bool IsCXX = II == Ident__has_cpp_attribute;
1767 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, true,
1768 [&](Token &Tok, bool &HasLexedNextToken) -> int {
1769 IdentifierInfo *ScopeII = nullptr;
1770 IdentifierInfo *II = ExpectFeatureIdentifierInfo(
1771 Tok, *this, diag::err_feature_check_malformed);
1772 if (!II)
1773 return false;
1774
1775 // It is possible to receive a scope token. Read the "::", if it is
1776 // available, and the subsequent identifier.
1777 LexUnexpandedToken(Tok);
1778 if (Tok.isNot(tok::coloncolon))
1779 HasLexedNextToken = true;
1780 else {
1781 ScopeII = II;
1782 // Lex an expanded token for the attribute name.
1783 Lex(Tok);
1784 II = ExpectFeatureIdentifierInfo(Tok, *this,
1785 diag::err_feature_check_malformed);
1786 }
1787
1788 AttributeCommonInfo::Syntax Syntax =
1789 IsCXX ? AttributeCommonInfo::Syntax::AS_CXX11
1790 : AttributeCommonInfo::Syntax::AS_C23;
1791 return II ? hasAttribute(Syntax, ScopeII, II, getTargetInfo(),
1792 getLangOpts())
1793 : 0;
1794 });
1795 } else if (II == Ident__has_include ||
1796 II == Ident__has_include_next) {
1797 // The argument to these two builtins should be a parenthesized
1798 // file name string literal using angle brackets (<>) or
1799 // double-quotes ("").
1800 bool Value;
1801 if (II == Ident__has_include)
1802 Value = EvaluateHasInclude(Tok, II);
1803 else
1804 Value = EvaluateHasIncludeNext(Tok, II);
1805
1806 if (Tok.isNot(tok::r_paren))
1807 return;
1808 OS << (int)Value;
1809 Tok.setKind(tok::numeric_constant);
1810 } else if (II == Ident__has_warning) {
1811 // The argument should be a parenthesized string literal.
1812 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1813 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1814 std::string WarningName;
1815 SourceLocation StrStartLoc = Tok.getLocation();
1816
1817 HasLexedNextToken = Tok.is(tok::string_literal);
1818 if (!FinishLexStringLiteral(Tok, WarningName, "'__has_warning'",
1819 /*AllowMacroExpansion=*/false))
1820 return false;
1821
1822 // FIXME: Should we accept "-R..." flags here, or should that be
1823 // handled by a separate __has_remark?
1824 if (WarningName.size() < 3 || WarningName[0] != '-' ||
1825 WarningName[1] != 'W') {
1826 Diag(StrStartLoc, diag::warn_has_warning_invalid_option);
1827 return false;
1828 }
1829
1830 // Finally, check if the warning flags maps to a diagnostic group.
1831 // We construct a SmallVector here to talk to getDiagnosticIDs().
1832 // Although we don't use the result, this isn't a hot path, and not
1833 // worth special casing.
1834 SmallVector<diag::kind, 10> Diags;
1835 return !getDiagnostics().getDiagnosticIDs()->
1836 getDiagnosticsInGroup(diag::Flavor::WarningOrError,
1837 WarningName.substr(2), Diags);
1838 });
1839 } else if (II == Ident__building_module) {
1840 // The argument to this builtin should be an identifier. The
1841 // builtin evaluates to 1 when that identifier names the module we are
1842 // currently building.
1843 EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
1844 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1845 IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
1846 diag::err_expected_id_building_module);
1847 return getLangOpts().isCompilingModule() && II &&
1848 (II->getName() == getLangOpts().CurrentModule);
1849 });
1850 } else if (II == Ident__MODULE__) {
1851 // The current module as an identifier.
1852 OS << getLangOpts().CurrentModule;
1853 IdentifierInfo *ModuleII = getIdentifierInfo(getLangOpts().CurrentModule);
1854 Tok.setIdentifierInfo(ModuleII);
1855 Tok.setKind(ModuleII->getTokenID());
1856 } else if (II == Ident__identifier) {
1857 SourceLocation Loc = Tok.getLocation();
1858
1859 // We're expecting '__identifier' '(' identifier ')'. Try to recover
1860 // if the parens are missing.
1861 LexNonComment(Tok);
1862 if (Tok.isNot(tok::l_paren)) {
1863 // No '(', use end of last token.
1864 Diag(getLocForEndOfToken(Loc), diag::err_pp_expected_after)
1865 << II << tok::l_paren;
1866 // If the next token isn't valid as our argument, we can't recover.
1867 if (!Tok.isAnnotation() && Tok.getIdentifierInfo())
1868 Tok.setKind(tok::identifier);
1869 return;
1870 }
1871
1872 SourceLocation LParenLoc = Tok.getLocation();
1873 LexNonComment(Tok);
1874
1875 if (!Tok.isAnnotation() && Tok.getIdentifierInfo())
1876 Tok.setKind(tok::identifier);
1877 else if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) {
1878 StringLiteralParser Literal(Tok, *this,
1879 StringLiteralEvalMethod::Unevaluated);
1880 if (Literal.hadError)
1881 return;
1882
1883 Tok.setIdentifierInfo(getIdentifierInfo(Literal.GetString()));
1884 Tok.setKind(tok::identifier);
1885 } else {
1886 Diag(Tok.getLocation(), diag::err_pp_identifier_arg_not_identifier)
1887 << Tok.getKind();
1888 // Don't walk past anything that's not a real token.
1889 if (Tok.isOneOf(tok::eof, tok::eod) || Tok.isAnnotation())
1890 return;
1891 }
1892
1893 // Discard the ')', preserving 'Tok' as our result.
1894 Token RParen;
1895 LexNonComment(RParen);
1896 if (RParen.isNot(tok::r_paren)) {
1897 Diag(getLocForEndOfToken(Tok.getLocation()), diag::err_pp_expected_after)
1898 << Tok.getKind() << tok::r_paren;
1899 Diag(LParenLoc, diag::note_matching) << tok::l_paren;
1900 }
1901 return;
1902 } else if (II == Ident__is_target_arch) {
1903 EvaluateFeatureLikeBuiltinMacro(
1904 OS, Tok, II, *this, false,
1905 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1906 IdentifierInfo *II = ExpectFeatureIdentifierInfo(
1907 Tok, *this, diag::err_feature_check_malformed);
1908 return II && isTargetArch(getTargetInfo(), II);
1909 });
1910 } else if (II == Ident__is_target_vendor) {
1911 EvaluateFeatureLikeBuiltinMacro(
1912 OS, Tok, II, *this, false,
1913 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1914 IdentifierInfo *II = ExpectFeatureIdentifierInfo(
1915 Tok, *this, diag::err_feature_check_malformed);
1916 return II && isTargetVendor(getTargetInfo(), II);
1917 });
1918 } else if (II == Ident__is_target_os) {
1919 EvaluateFeatureLikeBuiltinMacro(
1920 OS, Tok, II, *this, false,
1921 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1922 IdentifierInfo *II = ExpectFeatureIdentifierInfo(
1923 Tok, *this, diag::err_feature_check_malformed);
1924 return II && isTargetOS(getTargetInfo(), II);
1925 });
1926 } else if (II == Ident__is_target_environment) {
1927 EvaluateFeatureLikeBuiltinMacro(
1928 OS, Tok, II, *this, false,
1929 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1930 IdentifierInfo *II = ExpectFeatureIdentifierInfo(
1931 Tok, *this, diag::err_feature_check_malformed);
1932 return II && isTargetEnvironment(getTargetInfo(), II);
1933 });
1934 } else if (II == Ident__is_target_variant_os) {
1935 EvaluateFeatureLikeBuiltinMacro(
1936 OS, Tok, II, *this, false,
1937 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1938 IdentifierInfo *II = ExpectFeatureIdentifierInfo(
1939 Tok, *this, diag::err_feature_check_malformed);
1940 return II && isTargetVariantOS(getTargetInfo(), II);
1941 });
1942 } else if (II == Ident__is_target_variant_environment) {
1943 EvaluateFeatureLikeBuiltinMacro(
1944 OS, Tok, II, *this, false,
1945 [this](Token &Tok, bool &HasLexedNextToken) -> int {
1946 IdentifierInfo *II = ExpectFeatureIdentifierInfo(
1947 Tok, *this, diag::err_feature_check_malformed);
1948 return II && isTargetVariantEnvironment(getTargetInfo(), II);
1949 });
1950 } else {
1951 llvm_unreachable("Unknown identifier!");
1952 }
1953 CreateString(OS.str(), Tok, Tok.getLocation(), Tok.getLocation());
1954 Tok.setFlagValue(Token::StartOfLine, IsAtStartOfLine);
1955 Tok.setFlagValue(Token::LeadingSpace, HasLeadingSpace);
1956 }
1957
markMacroAsUsed(MacroInfo * MI)1958 void Preprocessor::markMacroAsUsed(MacroInfo *MI) {
1959 // If the 'used' status changed, and the macro requires 'unused' warning,
1960 // remove its SourceLocation from the warn-for-unused-macro locations.
1961 if (MI->isWarnIfUnused() && !MI->isUsed())
1962 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
1963 MI->setIsUsed(true);
1964 }
1965
processPathForFileMacro(SmallVectorImpl<char> & Path,const LangOptions & LangOpts,const TargetInfo & TI)1966 void Preprocessor::processPathForFileMacro(SmallVectorImpl<char> &Path,
1967 const LangOptions &LangOpts,
1968 const TargetInfo &TI) {
1969 LangOpts.remapPathPrefix(Path);
1970 if (LangOpts.UseTargetPathSeparator) {
1971 if (TI.getTriple().isOSWindows())
1972 llvm::sys::path::remove_dots(Path, false,
1973 llvm::sys::path::Style::windows_backslash);
1974 else
1975 llvm::sys::path::remove_dots(Path, false, llvm::sys::path::Style::posix);
1976 }
1977 }
1978
processPathToFileName(SmallVectorImpl<char> & FileName,const PresumedLoc & PLoc,const LangOptions & LangOpts,const TargetInfo & TI)1979 void Preprocessor::processPathToFileName(SmallVectorImpl<char> &FileName,
1980 const PresumedLoc &PLoc,
1981 const LangOptions &LangOpts,
1982 const TargetInfo &TI) {
1983 // Try to get the last path component, failing that return the original
1984 // presumed location.
1985 StringRef PLFileName = llvm::sys::path::filename(PLoc.getFilename());
1986 if (PLFileName.empty())
1987 PLFileName = PLoc.getFilename();
1988 FileName.append(PLFileName.begin(), PLFileName.end());
1989 processPathForFileMacro(FileName, LangOpts, TI);
1990 }
1991