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