clang  14.0.0git
PPDirectives.cpp
Go to the documentation of this file.
1 //===--- PPDirectives.cpp - Directive Handling for Preprocessor -----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// Implements # directive processing for the Preprocessor.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Basic/CharInfo.h"
18 #include "clang/Basic/Module.h"
21 #include "clang/Basic/TokenKinds.h"
23 #include "clang/Lex/HeaderSearch.h"
26 #include "clang/Lex/MacroInfo.h"
27 #include "clang/Lex/ModuleLoader.h"
28 #include "clang/Lex/ModuleMap.h"
29 #include "clang/Lex/PPCallbacks.h"
30 #include "clang/Lex/Pragma.h"
31 #include "clang/Lex/Preprocessor.h"
33 #include "clang/Lex/Token.h"
35 #include "llvm/ADT/ArrayRef.h"
36 #include "llvm/ADT/ScopeExit.h"
37 #include "llvm/ADT/SmallString.h"
38 #include "llvm/ADT/SmallVector.h"
39 #include "llvm/ADT/STLExtras.h"
40 #include "llvm/ADT/StringSwitch.h"
41 #include "llvm/ADT/StringRef.h"
42 #include "llvm/Support/AlignOf.h"
43 #include "llvm/Support/ErrorHandling.h"
44 #include "llvm/Support/Path.h"
45 #include <algorithm>
46 #include <cassert>
47 #include <cstring>
48 #include <new>
49 #include <string>
50 #include <utility>
51 
52 using namespace clang;
53 
54 //===----------------------------------------------------------------------===//
55 // Utility Methods for Preprocessor Directive Handling.
56 //===----------------------------------------------------------------------===//
57 
59  auto *MIChain = new (BP) MacroInfoChain{L, MIChainHead};
60  MIChainHead = MIChain;
61  return &MIChain->MI;
62 }
63 
64 DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,
65  SourceLocation Loc) {
66  return new (BP) DefMacroDirective(MI, Loc);
67 }
68 
70 Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {
71  return new (BP) UndefMacroDirective(UndefLoc);
72 }
73 
75 Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc,
76  bool isPublic) {
77  return new (BP) VisibilityMacroDirective(Loc, isPublic);
78 }
79 
80 /// Read and discard all tokens remaining on the current line until
81 /// the tok::eod token is found.
83  Token Tmp;
84  SourceRange Res;
85 
86  LexUnexpandedToken(Tmp);
87  Res.setBegin(Tmp.getLocation());
88  while (Tmp.isNot(tok::eod)) {
89  assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens");
90  LexUnexpandedToken(Tmp);
91  }
92  Res.setEnd(Tmp.getLocation());
93  return Res;
94 }
95 
96 /// Enumerates possible cases of #define/#undef a reserved identifier.
97 enum MacroDiag {
98  MD_NoWarn, //> Not a reserved identifier
99  MD_KeywordDef, //> Macro hides keyword, enabled by default
100  MD_ReservedMacro //> #define of #undef reserved id, disabled by default
101 };
102 
103 /// Enumerates possible %select values for the pp_err_elif_after_else and
104 /// pp_err_elif_without_if diagnostics.
109 };
110 
111 // The -fmodule-name option tells the compiler to textually include headers in
112 // the specified module, meaning clang won't build the specified module. This is
113 // useful in a number of situations, for instance, when building a library that
114 // vends a module map, one might want to avoid hitting intermediate build
115 // products containimg the module map or avoid finding the system installed
116 // modulemap for that library.
117 static bool isForModuleBuilding(Module *M, StringRef CurrentModule,
118  StringRef ModuleName) {
119  StringRef TopLevelName = M->getTopLevelModuleName();
120 
121  // When building framework Foo, we wanna make sure that Foo *and* Foo_Private
122  // are textually included and no modules are built for both.
123  if (M->getTopLevelModule()->IsFramework && CurrentModule == ModuleName &&
124  !CurrentModule.endswith("_Private") && TopLevelName.endswith("_Private"))
125  TopLevelName = TopLevelName.drop_back(8);
126 
127  return TopLevelName == CurrentModule;
128 }
129 
131  const LangOptions &Lang = PP.getLangOpts();
132  if (isReservedInAllContexts(II->isReserved(Lang))) {
133  // list from:
134  // - https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_macros.html
135  // - https://docs.microsoft.com/en-us/cpp/c-runtime-library/security-features-in-the-crt?view=msvc-160
136  // - man 7 feature_test_macros
137  // The list must be sorted for correct binary search.
138  static constexpr StringRef ReservedMacro[] = {
139  "_ATFILE_SOURCE",
140  "_BSD_SOURCE",
141  "_CRT_NONSTDC_NO_WARNINGS",
142  "_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES",
143  "_CRT_SECURE_NO_WARNINGS",
144  "_FILE_OFFSET_BITS",
145  "_FORTIFY_SOURCE",
146  "_GLIBCXX_ASSERTIONS",
147  "_GLIBCXX_CONCEPT_CHECKS",
148  "_GLIBCXX_DEBUG",
149  "_GLIBCXX_DEBUG_PEDANTIC",
150  "_GLIBCXX_PARALLEL",
151  "_GLIBCXX_PARALLEL_ASSERTIONS",
152  "_GLIBCXX_SANITIZE_VECTOR",
153  "_GLIBCXX_USE_CXX11_ABI",
154  "_GLIBCXX_USE_DEPRECATED",
155  "_GNU_SOURCE",
156  "_ISOC11_SOURCE",
157  "_ISOC95_SOURCE",
158  "_ISOC99_SOURCE",
159  "_LARGEFILE64_SOURCE",
160  "_POSIX_C_SOURCE",
161  "_REENTRANT",
162  "_SVID_SOURCE",
163  "_THREAD_SAFE",
164  "_XOPEN_SOURCE",
165  "_XOPEN_SOURCE_EXTENDED",
166  "__STDCPP_WANT_MATH_SPEC_FUNCS__",
167  "__STDC_FORMAT_MACROS",
168  };
169  if (std::binary_search(std::begin(ReservedMacro), std::end(ReservedMacro),
170  II->getName()))
171  return MD_NoWarn;
172 
173  return MD_ReservedMacro;
174  }
175  StringRef Text = II->getName();
176  if (II->isKeyword(Lang))
177  return MD_KeywordDef;
178  if (Lang.CPlusPlus11 && (Text.equals("override") || Text.equals("final")))
179  return MD_KeywordDef;
180  return MD_NoWarn;
181 }
182 
184  const LangOptions &Lang = PP.getLangOpts();
185  // Do not warn on keyword undef. It is generally harmless and widely used.
186  if (isReservedInAllContexts(II->isReserved(Lang)))
187  return MD_ReservedMacro;
188  return MD_NoWarn;
189 }
190 
191 // Return true if we want to issue a diagnostic by default if we
192 // encounter this name in a #include with the wrong case. For now,
193 // this includes the standard C and C++ headers, Posix headers,
194 // and Boost headers. Improper case for these #includes is a
195 // potential portability issue.
196 static bool warnByDefaultOnWrongCase(StringRef Include) {
197  // If the first component of the path is "boost", treat this like a standard header
198  // for the purposes of diagnostics.
199  if (::llvm::sys::path::begin(Include)->equals_insensitive("boost"))
200  return true;
201 
202  // "condition_variable" is the longest standard header name at 18 characters.
203  // If the include file name is longer than that, it can't be a standard header.
204  static const size_t MaxStdHeaderNameLen = 18u;
205  if (Include.size() > MaxStdHeaderNameLen)
206  return false;
207 
208  // Lowercase and normalize the search string.
209  SmallString<32> LowerInclude{Include};
210  for (char &Ch : LowerInclude) {
211  // In the ASCII range?
212  if (static_cast<unsigned char>(Ch) > 0x7f)
213  return false; // Can't be a standard header
214  // ASCII lowercase:
215  if (Ch >= 'A' && Ch <= 'Z')
216  Ch += 'a' - 'A';
217  // Normalize path separators for comparison purposes.
218  else if (::llvm::sys::path::is_separator(Ch))
219  Ch = '/';
220  }
221 
222  // The standard C/C++ and Posix headers
223  return llvm::StringSwitch<bool>(LowerInclude)
224  // C library headers
225  .Cases("assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h", true)
226  .Cases("float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h", true)
227  .Cases("math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h", true)
228  .Cases("stdatomic.h", "stdbool.h", "stddef.h", "stdint.h", "stdio.h", true)
229  .Cases("stdlib.h", "stdnoreturn.h", "string.h", "tgmath.h", "threads.h", true)
230  .Cases("time.h", "uchar.h", "wchar.h", "wctype.h", true)
231 
232  // C++ headers for C library facilities
233  .Cases("cassert", "ccomplex", "cctype", "cerrno", "cfenv", true)
234  .Cases("cfloat", "cinttypes", "ciso646", "climits", "clocale", true)
235  .Cases("cmath", "csetjmp", "csignal", "cstdalign", "cstdarg", true)
236  .Cases("cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib", true)
237  .Cases("cstring", "ctgmath", "ctime", "cuchar", "cwchar", true)
238  .Case("cwctype", true)
239 
240  // C++ library headers
241  .Cases("algorithm", "fstream", "list", "regex", "thread", true)
242  .Cases("array", "functional", "locale", "scoped_allocator", "tuple", true)
243  .Cases("atomic", "future", "map", "set", "type_traits", true)
244  .Cases("bitset", "initializer_list", "memory", "shared_mutex", "typeindex", true)
245  .Cases("chrono", "iomanip", "mutex", "sstream", "typeinfo", true)
246  .Cases("codecvt", "ios", "new", "stack", "unordered_map", true)
247  .Cases("complex", "iosfwd", "numeric", "stdexcept", "unordered_set", true)
248  .Cases("condition_variable", "iostream", "ostream", "streambuf", "utility", true)
249  .Cases("deque", "istream", "queue", "string", "valarray", true)
250  .Cases("exception", "iterator", "random", "strstream", "vector", true)
251  .Cases("forward_list", "limits", "ratio", "system_error", true)
252 
253  // POSIX headers (which aren't also C headers)
254  .Cases("aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h", true)
255  .Cases("fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h", true)
256  .Cases("grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h", true)
257  .Cases("mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h", true)
258  .Cases("netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h", true)
259  .Cases("regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h", true)
260  .Cases("strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h", true)
261  .Cases("sys/resource.h", "sys/select.h", "sys/sem.h", "sys/shm.h", "sys/socket.h", true)
262  .Cases("sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h", "sys/types.h", true)
263  .Cases("sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h", true)
264  .Cases("tar.h", "termios.h", "trace.h", "ulimit.h", true)
265  .Cases("unistd.h", "utime.h", "utmpx.h", "wordexp.h", true)
266  .Default(false);
267 }
268 
269 bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
270  bool *ShadowFlag) {
271  // Missing macro name?
272  if (MacroNameTok.is(tok::eod))
273  return Diag(MacroNameTok, diag::err_pp_missing_macro_name);
274 
275  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
276  if (!II)
277  return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
278 
279  if (II->isCPlusPlusOperatorKeyword()) {
280  // C++ 2.5p2: Alternative tokens behave the same as its primary token
281  // except for their spellings.
282  Diag(MacroNameTok, getLangOpts().MicrosoftExt
283  ? diag::ext_pp_operator_used_as_macro_name
284  : diag::err_pp_operator_used_as_macro_name)
285  << II << MacroNameTok.getKind();
286  // Allow #defining |and| and friends for Microsoft compatibility or
287  // recovery when legacy C headers are included in C++.
288  }
289 
290  if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) {
291  // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.
292  return Diag(MacroNameTok, diag::err_defined_macro_name);
293  }
294 
295  if (isDefineUndef == MU_Undef) {
296  auto *MI = getMacroInfo(II);
297  if (MI && MI->isBuiltinMacro()) {
298  // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4
299  // and C++ [cpp.predefined]p4], but allow it as an extension.
300  Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro);
301  }
302  }
303 
304  // If defining/undefining reserved identifier or a keyword, we need to issue
305  // a warning.
306  SourceLocation MacroNameLoc = MacroNameTok.getLocation();
307  if (ShadowFlag)
308  *ShadowFlag = false;
309  if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&
310  (SourceMgr.getBufferName(MacroNameLoc) != "<built-in>")) {
311  MacroDiag D = MD_NoWarn;
312  if (isDefineUndef == MU_Define) {
313  D = shouldWarnOnMacroDef(*this, II);
314  }
315  else if (isDefineUndef == MU_Undef)
316  D = shouldWarnOnMacroUndef(*this, II);
317  if (D == MD_KeywordDef) {
318  // We do not want to warn on some patterns widely used in configuration
319  // scripts. This requires analyzing next tokens, so do not issue warnings
320  // now, only inform caller.
321  if (ShadowFlag)
322  *ShadowFlag = true;
323  }
324  if (D == MD_ReservedMacro)
325  Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);
326  }
327 
328  // Okay, we got a good identifier.
329  return false;
330 }
331 
332 /// Lex and validate a macro name, which occurs after a
333 /// \#define or \#undef.
334 ///
335 /// This sets the token kind to eod and discards the rest of the macro line if
336 /// the macro name is invalid.
337 ///
338 /// \param MacroNameTok Token that is expected to be a macro name.
339 /// \param isDefineUndef Context in which macro is used.
340 /// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.
341 void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
342  bool *ShadowFlag) {
343  // Read the token, don't allow macro expansion on it.
344  LexUnexpandedToken(MacroNameTok);
345 
346  if (MacroNameTok.is(tok::code_completion)) {
347  if (CodeComplete)
348  CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define);
350  LexUnexpandedToken(MacroNameTok);
351  }
352 
353  if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag))
354  return;
355 
356  // Invalid macro name, read and discard the rest of the line and set the
357  // token kind to tok::eod if necessary.
358  if (MacroNameTok.isNot(tok::eod)) {
359  MacroNameTok.setKind(tok::eod);
361  }
362 }
363 
364 /// Ensure that the next token is a tok::eod token.
365 ///
366 /// If not, emit a diagnostic and consume up until the eod. If EnableMacros is
367 /// true, then we consider macros that expand to zero tokens as being ok.
368 ///
369 /// Returns the location of the end of the directive.
371  bool EnableMacros) {
372  Token Tmp;
373  // Lex unexpanded tokens for most directives: macros might expand to zero
374  // tokens, causing us to miss diagnosing invalid lines. Some directives (like
375  // #line) allow empty macros.
376  if (EnableMacros)
377  Lex(Tmp);
378  else
379  LexUnexpandedToken(Tmp);
380 
381  // There should be no tokens after the directive, but we allow them as an
382  // extension.
383  while (Tmp.is(tok::comment)) // Skip comments in -C mode.
384  LexUnexpandedToken(Tmp);
385 
386  if (Tmp.is(tok::eod))
387  return Tmp.getLocation();
388 
389  // Add a fixit in GNU/C99/C++ mode. Don't offer a fixit for strict-C89,
390  // or if this is a macro-style preprocessing directive, because it is more
391  // trouble than it is worth to insert /**/ and check that there is no /**/
392  // in the range also.
393  FixItHint Hint;
394  if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&
395  !CurTokenLexer)
396  Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");
397  Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;
399 }
400 
401 Optional<unsigned> Preprocessor::getSkippedRangeForExcludedConditionalBlock(
402  SourceLocation HashLoc) {
403  if (!ExcludedConditionalDirectiveSkipMappings)
404  return None;
405  if (!HashLoc.isFileID())
406  return None;
407 
408  std::pair<FileID, unsigned> HashFileOffset =
409  SourceMgr.getDecomposedLoc(HashLoc);
411  SourceMgr.getBufferOrNone(HashFileOffset.first);
412  if (!Buf)
413  return None;
414  auto It =
415  ExcludedConditionalDirectiveSkipMappings->find(Buf->getBufferStart());
416  if (It == ExcludedConditionalDirectiveSkipMappings->end())
417  return None;
418 
419  const PreprocessorSkippedRangeMapping &SkippedRanges = *It->getSecond();
420  // Check if the offset of '#' is mapped in the skipped ranges.
421  auto MappingIt = SkippedRanges.find(HashFileOffset.second);
422  if (MappingIt == SkippedRanges.end())
423  return None;
424 
425  unsigned BytesToSkip = MappingIt->getSecond();
426  unsigned CurLexerBufferOffset = CurLexer->getCurrentBufferOffset();
427  assert(CurLexerBufferOffset >= HashFileOffset.second &&
428  "lexer is before the hash?");
429  // Take into account the fact that the lexer has already advanced, so the
430  // number of bytes to skip must be adjusted.
431  unsigned LengthDiff = CurLexerBufferOffset - HashFileOffset.second;
432  assert(BytesToSkip >= LengthDiff && "lexer is after the skipped range?");
433  return BytesToSkip - LengthDiff;
434 }
435 
436 /// SkipExcludedConditionalBlock - We just read a \#if or related directive and
437 /// decided that the subsequent tokens are in the \#if'd out portion of the
438 /// file. Lex the rest of the file, until we see an \#endif. If
439 /// FoundNonSkipPortion is true, then we have already emitted code for part of
440 /// this \#if directive, so \#else/\#elif blocks should never be entered.
441 /// If ElseOk is true, then \#else directives are ok, if not, then we have
442 /// already seen one so a \#else directive is a duplicate. When this returns,
443 /// the caller can lex the first valid token.
444 void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc,
445  SourceLocation IfTokenLoc,
446  bool FoundNonSkipPortion,
447  bool FoundElse,
448  SourceLocation ElseLoc) {
449  ++NumSkipped;
450  assert(!CurTokenLexer && CurPPLexer && "Lexing a macro, not a file?");
451 
452  if (PreambleConditionalStack.reachedEOFWhileSkipping())
453  PreambleConditionalStack.clearSkipInfo();
454  else
455  CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false,
456  FoundNonSkipPortion, FoundElse);
457 
458  // Enter raw mode to disable identifier lookup (and thus macro expansion),
459  // disabling warnings, etc.
460  CurPPLexer->LexingRawMode = true;
461  Token Tok;
462  if (auto SkipLength =
463  getSkippedRangeForExcludedConditionalBlock(HashTokenLoc)) {
464  // Skip to the next '#endif' / '#else' / '#elif'.
465  CurLexer->skipOver(*SkipLength);
466  }
467  SourceLocation endLoc;
468  while (true) {
469  CurLexer->Lex(Tok);
470 
471  if (Tok.is(tok::code_completion)) {
473  if (CodeComplete)
474  CodeComplete->CodeCompleteInConditionalExclusion();
475  continue;
476  }
477 
478  // If this is the end of the buffer, we have an error.
479  if (Tok.is(tok::eof)) {
480  // We don't emit errors for unterminated conditionals here,
481  // Lexer::LexEndOfFile can do that properly.
482  // Just return and let the caller lex after this #include.
483  if (PreambleConditionalStack.isRecording())
484  PreambleConditionalStack.SkipInfo.emplace(
485  HashTokenLoc, IfTokenLoc, FoundNonSkipPortion, FoundElse, ElseLoc);
486  break;
487  }
488 
489  // If this token is not a preprocessor directive, just skip it.
490  if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine())
491  continue;
492 
493  // We just parsed a # character at the start of a line, so we're in
494  // directive mode. Tell the lexer this so any newlines we see will be
495  // converted into an EOD token (this terminates the macro).
496  CurPPLexer->ParsingPreprocessorDirective = true;
497  if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
498 
499 
500  // Read the next token, the directive flavor.
501  LexUnexpandedToken(Tok);
502 
503  // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
504  // something bogus), skip it.
505  if (Tok.isNot(tok::raw_identifier)) {
506  CurPPLexer->ParsingPreprocessorDirective = false;
507  // Restore comment saving mode.
508  if (CurLexer) CurLexer->resetExtendedTokenMode();
509  continue;
510  }
511 
512  // If the first letter isn't i or e, it isn't intesting to us. We know that
513  // this is safe in the face of spelling differences, because there is no way
514  // to spell an i/e in a strange way that is another letter. Skipping this
515  // allows us to avoid looking up the identifier info for #define/#undef and
516  // other common directives.
517  StringRef RI = Tok.getRawIdentifier();
518 
519  char FirstChar = RI[0];
520  if (FirstChar >= 'a' && FirstChar <= 'z' &&
521  FirstChar != 'i' && FirstChar != 'e') {
522  CurPPLexer->ParsingPreprocessorDirective = false;
523  // Restore comment saving mode.
524  if (CurLexer) CurLexer->resetExtendedTokenMode();
525  continue;
526  }
527 
528  // Get the identifier name without trigraphs or embedded newlines. Note
529  // that we can't use Tok.getIdentifierInfo() because its lookup is disabled
530  // when skipping.
531  char DirectiveBuf[20];
532  StringRef Directive;
533  if (!Tok.needsCleaning() && RI.size() < 20) {
534  Directive = RI;
535  } else {
536  std::string DirectiveStr = getSpelling(Tok);
537  size_t IdLen = DirectiveStr.size();
538  if (IdLen >= 20) {
539  CurPPLexer->ParsingPreprocessorDirective = false;
540  // Restore comment saving mode.
541  if (CurLexer) CurLexer->resetExtendedTokenMode();
542  continue;
543  }
544  memcpy(DirectiveBuf, &DirectiveStr[0], IdLen);
545  Directive = StringRef(DirectiveBuf, IdLen);
546  }
547 
548  if (Directive.startswith("if")) {
549  StringRef Sub = Directive.substr(2);
550  if (Sub.empty() || // "if"
551  Sub == "def" || // "ifdef"
552  Sub == "ndef") { // "ifndef"
553  // We know the entire #if/#ifdef/#ifndef block will be skipped, don't
554  // bother parsing the condition.
556  CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,
557  /*foundnonskip*/false,
558  /*foundelse*/false);
559  }
560  } else if (Directive[0] == 'e') {
561  StringRef Sub = Directive.substr(1);
562  if (Sub == "ndif") { // "endif"
563  PPConditionalInfo CondInfo;
564  CondInfo.WasSkipping = true; // Silence bogus warning.
565  bool InCond = CurPPLexer->popConditionalLevel(CondInfo);
566  (void)InCond; // Silence warning in no-asserts mode.
567  assert(!InCond && "Can't be skipping if not in a conditional!");
568 
569  // If we popped the outermost skipping block, we're done skipping!
570  if (!CondInfo.WasSkipping) {
571  // Restore the value of LexingRawMode so that trailing comments
572  // are handled correctly, if we've reached the outermost block.
573  CurPPLexer->LexingRawMode = false;
574  endLoc = CheckEndOfDirective("endif");
575  CurPPLexer->LexingRawMode = true;
576  if (Callbacks)
577  Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);
578  break;
579  } else {
581  }
582  } else if (Sub == "lse") { // "else".
583  // #else directive in a skipping conditional. If not in some other
584  // skipping conditional, and if #else hasn't already been seen, enter it
585  // as a non-skipping conditional.
586  PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
587 
588  // If this is a #else with a #else before it, report the error.
589  if (CondInfo.FoundElse)
590  Diag(Tok, diag::pp_err_else_after_else);
591 
592  // Note that we've seen a #else in this conditional.
593  CondInfo.FoundElse = true;
594 
595  // If the conditional is at the top level, and the #if block wasn't
596  // entered, enter the #else block now.
597  if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {
598  CondInfo.FoundNonSkip = true;
599  // Restore the value of LexingRawMode so that trailing comments
600  // are handled correctly.
601  CurPPLexer->LexingRawMode = false;
602  endLoc = CheckEndOfDirective("else");
603  CurPPLexer->LexingRawMode = true;
604  if (Callbacks)
605  Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);
606  break;
607  } else {
608  DiscardUntilEndOfDirective(); // C99 6.10p4.
609  }
610  } else if (Sub == "lif") { // "elif".
611  PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
612 
613  // If this is a #elif with a #else before it, report the error.
614  if (CondInfo.FoundElse)
615  Diag(Tok, diag::pp_err_elif_after_else) << PED_Elif;
616 
617  // If this is in a skipping block or if we're already handled this #if
618  // block, don't bother parsing the condition.
619  if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
620  // FIXME: We should probably do at least some minimal parsing of the
621  // condition to verify that it is well-formed. The current state
622  // allows #elif* directives with completely malformed (or missing)
623  // conditions.
625  } else {
626  // Restore the value of LexingRawMode so that identifiers are
627  // looked up, etc, inside the #elif expression.
628  assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
629  CurPPLexer->LexingRawMode = false;
630  IdentifierInfo *IfNDefMacro = nullptr;
631  DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
632  // Stop if Lexer became invalid after hitting code completion token.
633  if (!CurPPLexer)
634  return;
635  const bool CondValue = DER.Conditional;
636  CurPPLexer->LexingRawMode = true;
637  if (Callbacks) {
638  Callbacks->Elif(
639  Tok.getLocation(), DER.ExprRange,
641  CondInfo.IfLoc);
642  }
643  // If this condition is true, enter it!
644  if (CondValue) {
645  CondInfo.FoundNonSkip = true;
646  break;
647  }
648  }
649  } else if (Sub == "lifdef" || // "elifdef"
650  Sub == "lifndef") { // "elifndef"
651  bool IsElifDef = Sub == "lifdef";
652  PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
653  Token DirectiveToken = Tok;
654 
655  // If this is a #elif with a #else before it, report the error.
656  if (CondInfo.FoundElse)
657  Diag(Tok, diag::pp_err_elif_after_else)
658  << (IsElifDef ? PED_Elifdef : PED_Elifndef);
659 
660  // If this is in a skipping block or if we're already handled this #if
661  // block, don't bother parsing the condition.
662  if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
663  // FIXME: We should probably do at least some minimal parsing of the
664  // condition to verify that it is well-formed. The current state
665  // allows #elif* directives with completely malformed (or missing)
666  // conditions.
668  } else {
669  // Restore the value of LexingRawMode so that identifiers are
670  // looked up, etc, inside the #elif[n]def expression.
671  assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
672  CurPPLexer->LexingRawMode = false;
673  Token MacroNameTok;
674  ReadMacroName(MacroNameTok);
675  CurPPLexer->LexingRawMode = true;
676 
677  // If the macro name token is tok::eod, there was an error that was
678  // already reported.
679  if (MacroNameTok.is(tok::eod)) {
680  // Skip code until we get to #endif. This helps with recovery by
681  // not emitting an error when the #endif is reached.
682  continue;
683  }
684 
685  emitMacroExpansionWarnings(MacroNameTok);
686 
687  CheckEndOfDirective(IsElifDef ? "elifdef" : "elifndef");
688 
689  IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
690  auto MD = getMacroDefinition(MII);
691  MacroInfo *MI = MD.getMacroInfo();
692 
693  if (Callbacks) {
694  if (IsElifDef) {
695  Callbacks->Elifdef(DirectiveToken.getLocation(), MacroNameTok,
696  MD);
697  } else {
698  Callbacks->Elifndef(DirectiveToken.getLocation(), MacroNameTok,
699  MD);
700  }
701  }
702  // If this condition is true, enter it!
703  if (static_cast<bool>(MI) == IsElifDef) {
704  CondInfo.FoundNonSkip = true;
705  break;
706  }
707  }
708  }
709  }
710 
711  CurPPLexer->ParsingPreprocessorDirective = false;
712  // Restore comment saving mode.
713  if (CurLexer) CurLexer->resetExtendedTokenMode();
714  }
715 
716  // Finally, if we are out of the conditional (saw an #endif or ran off the end
717  // of the file, just stop skipping and return to lexing whatever came after
718  // the #if block.
719  CurPPLexer->LexingRawMode = false;
720 
721  // The last skipped range isn't actually skipped yet if it's truncated
722  // by the end of the preamble; we'll resume parsing after the preamble.
723  if (Callbacks && (Tok.isNot(tok::eof) || !isRecordingPreamble()))
724  Callbacks->SourceRangeSkipped(
725  SourceRange(HashTokenLoc, endLoc.isValid()
726  ? endLoc
727  : CurPPLexer->getSourceLocation()),
728  Tok.getLocation());
729 }
730 
732  if (!SourceMgr.isInMainFile(Loc)) {
733  // Try to determine the module of the include directive.
734  // FIXME: Look into directly passing the FileEntry from LookupFile instead.
735  FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc));
736  if (const FileEntry *EntryOfIncl = SourceMgr.getFileEntryForID(IDOfIncl)) {
737  // The include comes from an included file.
738  return HeaderInfo.getModuleMap()
739  .findModuleForHeader(EntryOfIncl)
740  .getModule();
741  }
742  }
743 
744  // This is either in the main file or not in a file at all. It belongs
745  // to the current module, if there is one.
746  return getLangOpts().CurrentModule.empty()
747  ? nullptr
748  : HeaderInfo.lookupModule(getLangOpts().CurrentModule, Loc);
749 }
750 
751 const FileEntry *
753  SourceLocation Loc) {
754  Module *IncM = getModuleForLocation(IncLoc);
755 
756  // Walk up through the include stack, looking through textual headers of M
757  // until we hit a non-textual header that we can #include. (We assume textual
758  // headers of a module with non-textual headers aren't meant to be used to
759  // import entities from the module.)
760  auto &SM = getSourceManager();
761  while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) {
762  auto ID = SM.getFileID(SM.getExpansionLoc(Loc));
763  auto *FE = SM.getFileEntryForID(ID);
764  if (!FE)
765  break;
766 
767  // We want to find all possible modules that might contain this header, so
768  // search all enclosing directories for module maps and load them.
769  HeaderInfo.hasModuleMap(FE->getName(), /*Root*/ nullptr,
770  SourceMgr.isInSystemHeader(Loc));
771 
772  bool InPrivateHeader = false;
773  for (auto Header : HeaderInfo.findAllModulesForHeader(FE)) {
774  if (!Header.isAccessibleFrom(IncM)) {
775  // It's in a private header; we can't #include it.
776  // FIXME: If there's a public header in some module that re-exports it,
777  // then we could suggest including that, but it's not clear that's the
778  // expected way to make this entity visible.
779  InPrivateHeader = true;
780  continue;
781  }
782 
783  // We'll suggest including textual headers below if they're
784  // include-guarded.
785  if (Header.getRole() & ModuleMap::TextualHeader)
786  continue;
787 
788  // If we have a module import syntax, we shouldn't include a header to
789  // make a particular module visible. Let the caller know they should
790  // suggest an import instead.
791  if (getLangOpts().ObjC || getLangOpts().CPlusPlusModules ||
792  getLangOpts().ModulesTS)
793  return nullptr;
794 
795  // If this is an accessible, non-textual header of M's top-level module
796  // that transitively includes the given location and makes the
797  // corresponding module visible, this is the thing to #include.
798  return FE;
799  }
800 
801  // FIXME: If we're bailing out due to a private header, we shouldn't suggest
802  // an import either.
803  if (InPrivateHeader)
804  return nullptr;
805 
806  // If the header is includable and has an include guard, assume the
807  // intended way to expose its contents is by #include, not by importing a
808  // module that transitively includes it.
809  if (getHeaderSearchInfo().isFileMultipleIncludeGuarded(FE))
810  return FE;
811 
812  Loc = SM.getIncludeLoc(ID);
813  }
814 
815  return nullptr;
816 }
817 
819  SourceLocation FilenameLoc, StringRef Filename, bool isAngled,
820  const DirectoryLookup *FromDir, const FileEntry *FromFile,
821  const DirectoryLookup *&CurDir, SmallVectorImpl<char> *SearchPath,
822  SmallVectorImpl<char> *RelativePath,
823  ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped,
824  bool *IsFrameworkFound, bool SkipCache) {
825  Module *RequestingModule = getModuleForLocation(FilenameLoc);
826  bool RequestingModuleIsModuleInterface = !SourceMgr.isInMainFile(FilenameLoc);
827 
828  // If the header lookup mechanism may be relative to the current inclusion
829  // stack, record the parent #includes.
831  Includers;
832  bool BuildSystemModule = false;
833  if (!FromDir && !FromFile) {
835  const FileEntry *FileEnt = SourceMgr.getFileEntryForID(FID);
836 
837  // If there is no file entry associated with this file, it must be the
838  // predefines buffer or the module includes buffer. Any other file is not
839  // lexed with a normal lexer, so it won't be scanned for preprocessor
840  // directives.
841  //
842  // If we have the predefines buffer, resolve #include references (which come
843  // from the -include command line argument) from the current working
844  // directory instead of relative to the main file.
845  //
846  // If we have the module includes buffer, resolve #include references (which
847  // come from header declarations in the module map) relative to the module
848  // map file.
849  if (!FileEnt) {
850  if (FID == SourceMgr.getMainFileID() && MainFileDir) {
851  Includers.push_back(std::make_pair(nullptr, MainFileDir));
852  BuildSystemModule = getCurrentModule()->IsSystem;
853  } else if ((FileEnt =
854  SourceMgr.getFileEntryForID(SourceMgr.getMainFileID())))
855  Includers.push_back(std::make_pair(FileEnt, *FileMgr.getDirectory(".")));
856  } else {
857  Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
858  }
859 
860  // MSVC searches the current include stack from top to bottom for
861  // headers included by quoted include directives.
862  // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx
863  if (LangOpts.MSVCCompat && !isAngled) {
864  for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
865  if (IsFileLexer(ISEntry))
866  if ((FileEnt = ISEntry.ThePPLexer->getFileEntry()))
867  Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
868  }
869  }
870  }
871 
872  CurDir = CurDirLookup;
873 
874  if (FromFile) {
875  // We're supposed to start looking from after a particular file. Search
876  // the include path until we find that file or run out of files.
877  const DirectoryLookup *TmpCurDir = CurDir;
878  const DirectoryLookup *TmpFromDir = nullptr;
879  while (Optional<FileEntryRef> FE = HeaderInfo.LookupFile(
880  Filename, FilenameLoc, isAngled, TmpFromDir, TmpCurDir,
881  Includers, SearchPath, RelativePath, RequestingModule,
882  SuggestedModule, /*IsMapped=*/nullptr,
883  /*IsFrameworkFound=*/nullptr, SkipCache)) {
884  // Keep looking as if this file did a #include_next.
885  TmpFromDir = TmpCurDir;
886  ++TmpFromDir;
887  if (&FE->getFileEntry() == FromFile) {
888  // Found it.
889  FromDir = TmpFromDir;
890  CurDir = TmpCurDir;
891  break;
892  }
893  }
894  }
895 
896  // Do a standard file entry lookup.
897  Optional<FileEntryRef> FE = HeaderInfo.LookupFile(
898  Filename, FilenameLoc, isAngled, FromDir, CurDir, Includers, SearchPath,
899  RelativePath, RequestingModule, SuggestedModule, IsMapped,
900  IsFrameworkFound, SkipCache, BuildSystemModule);
901  if (FE) {
902  if (SuggestedModule && !LangOpts.AsmPreprocessor)
904  RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
905  Filename, &FE->getFileEntry());
906  return FE;
907  }
908 
909  const FileEntry *CurFileEnt;
910  // Otherwise, see if this is a subframework header. If so, this is relative
911  // to one of the headers on the #include stack. Walk the list of the current
912  // headers on the #include stack and pass them to HeaderInfo.
913  if (IsFileLexer()) {
914  if ((CurFileEnt = CurPPLexer->getFileEntry())) {
916  Filename, CurFileEnt, SearchPath, RelativePath, RequestingModule,
917  SuggestedModule)) {
918  if (SuggestedModule && !LangOpts.AsmPreprocessor)
920  RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,
921  Filename, &FE->getFileEntry());
922  return FE;
923  }
924  }
925  }
926 
927  for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {
928  if (IsFileLexer(ISEntry)) {
929  if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) {
931  Filename, CurFileEnt, SearchPath, RelativePath,
932  RequestingModule, SuggestedModule)) {
933  if (SuggestedModule && !LangOpts.AsmPreprocessor)
935  RequestingModule, RequestingModuleIsModuleInterface,
936  FilenameLoc, Filename, &FE->getFileEntry());
937  return FE;
938  }
939  }
940  }
941  }
942 
943  // Otherwise, we really couldn't find the file.
944  return None;
945 }
946 
947 //===----------------------------------------------------------------------===//
948 // Preprocessor Directive Handling.
949 //===----------------------------------------------------------------------===//
950 
952 public:
954  : PP(pp), save(pp->DisableMacroExpansion) {
955  if (pp->MacroExpansionInDirectivesOverride)
956  pp->DisableMacroExpansion = false;
957  }
958 
960  PP->DisableMacroExpansion = save;
961  }
962 
963 private:
964  Preprocessor *PP;
965  bool save;
966 };
967 
968 /// Process a directive while looking for the through header or a #pragma
969 /// hdrstop. The following directives are handled:
970 /// #include (to check if it is the through header)
971 /// #define (to warn about macros that don't match the PCH)
972 /// #pragma (to check for pragma hdrstop).
973 /// All other directives are completely discarded.
975  SourceLocation HashLoc) {
976  if (const IdentifierInfo *II = Result.getIdentifierInfo()) {
977  if (II->getPPKeywordID() == tok::pp_define) {
978  return HandleDefineDirective(Result,
979  /*ImmediatelyAfterHeaderGuard=*/false);
980  }
981  if (SkippingUntilPCHThroughHeader &&
982  II->getPPKeywordID() == tok::pp_include) {
983  return HandleIncludeDirective(HashLoc, Result);
984  }
985  if (SkippingUntilPragmaHdrStop && II->getPPKeywordID() == tok::pp_pragma) {
986  Lex(Result);
987  auto *II = Result.getIdentifierInfo();
988  if (II && II->getName() == "hdrstop")
989  return HandlePragmaHdrstop(Result);
990  }
991  }
993 }
994 
995 /// HandleDirective - This callback is invoked when the lexer sees a # token
996 /// at the start of a line. This consumes the directive, modifies the
997 /// lexer/preprocessor state, and advances the lexer(s) so that the next token
998 /// read is the correct one.
1000  // FIXME: Traditional: # with whitespace before it not recognized by K&R?
1001 
1002  // We just parsed a # character at the start of a line, so we're in directive
1003  // mode. Tell the lexer this so any newlines we see will be converted into an
1004  // EOD token (which terminates the directive).
1005  CurPPLexer->ParsingPreprocessorDirective = true;
1006  if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);
1007 
1008  bool ImmediatelyAfterTopLevelIfndef =
1011 
1012  ++NumDirectives;
1013 
1014  // We are about to read a token. For the multiple-include optimization FA to
1015  // work, we have to remember if we had read any tokens *before* this
1016  // pp-directive.
1017  bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal();
1018 
1019  // Save the '#' token in case we need to return it later.
1020  Token SavedHash = Result;
1021 
1022  // Read the next token, the directive flavor. This isn't expanded due to
1023  // C99 6.10.3p8.
1024  LexUnexpandedToken(Result);
1025 
1026  // C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.:
1027  // #define A(x) #x
1028  // A(abc
1029  // #warning blah
1030  // def)
1031  // If so, the user is relying on undefined behavior, emit a diagnostic. Do
1032  // not support this for #include-like directives, since that can result in
1033  // terrible diagnostics, and does not work in GCC.
1034  if (InMacroArgs) {
1035  if (IdentifierInfo *II = Result.getIdentifierInfo()) {
1036  switch (II->getPPKeywordID()) {
1037  case tok::pp_include:
1038  case tok::pp_import:
1039  case tok::pp_include_next:
1041  case tok::pp_pragma:
1042  Diag(Result, diag::err_embedded_directive) << II->getName();
1043  Diag(*ArgMacro, diag::note_macro_expansion_here)
1044  << ArgMacro->getIdentifierInfo();
1046  return;
1047  default:
1048  break;
1049  }
1050  }
1051  Diag(Result, diag::ext_embedded_directive);
1052  }
1053 
1054  // Temporarily enable macro expansion if set so
1055  // and reset to previous state when returning from this function.
1056  ResetMacroExpansionHelper helper(this);
1057 
1058  if (SkippingUntilPCHThroughHeader || SkippingUntilPragmaHdrStop)
1059  return HandleSkippedDirectiveWhileUsingPCH(Result, SavedHash.getLocation());
1060 
1061  switch (Result.getKind()) {
1062  case tok::eod:
1063  return; // null directive.
1064  case tok::code_completion:
1066  if (CodeComplete)
1067  CodeComplete->CodeCompleteDirective(
1068  CurPPLexer->getConditionalStackDepth() > 0);
1069  return;
1070  case tok::numeric_constant: // # 7 GNU line marker directive.
1071  if (getLangOpts().AsmPreprocessor)
1072  break; // # 4 is not a preprocessor directive in .S files.
1073  return HandleDigitDirective(Result);
1074  default:
1075  IdentifierInfo *II = Result.getIdentifierInfo();
1076  if (!II) break; // Not an identifier.
1077 
1078  // Ask what the preprocessor keyword ID is.
1079  switch (II->getPPKeywordID()) {
1080  default: break;
1081  // C99 6.10.1 - Conditional Inclusion.
1082  case tok::pp_if:
1083  return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective);
1084  case tok::pp_ifdef:
1085  return HandleIfdefDirective(Result, SavedHash, false,
1086  true /*not valid for miopt*/);
1087  case tok::pp_ifndef:
1088  return HandleIfdefDirective(Result, SavedHash, true,
1089  ReadAnyTokensBeforeDirective);
1090  case tok::pp_elif:
1091  case tok::pp_elifdef:
1092  case tok::pp_elifndef:
1093  return HandleElifFamilyDirective(Result, SavedHash, II->getPPKeywordID());
1094 
1095  case tok::pp_else:
1096  return HandleElseDirective(Result, SavedHash);
1097  case tok::pp_endif:
1098  return HandleEndifDirective(Result);
1099 
1100  // C99 6.10.2 - Source File Inclusion.
1101  case tok::pp_include:
1102  // Handle #include.
1103  return HandleIncludeDirective(SavedHash.getLocation(), Result);
1105  // Handle -imacros.
1106  return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result);
1107 
1108  // C99 6.10.3 - Macro Replacement.
1109  case tok::pp_define:
1110  return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef);
1111  case tok::pp_undef:
1112  return HandleUndefDirective();
1113 
1114  // C99 6.10.4 - Line Control.
1115  case tok::pp_line:
1116  return HandleLineDirective();
1117 
1118  // C99 6.10.5 - Error Directive.
1119  case tok::pp_error:
1120  return HandleUserDiagnosticDirective(Result, false);
1121 
1122  // C99 6.10.6 - Pragma Directive.
1123  case tok::pp_pragma:
1124  return HandlePragmaDirective({PIK_HashPragma, SavedHash.getLocation()});
1125 
1126  // GNU Extensions.
1127  case tok::pp_import:
1128  return HandleImportDirective(SavedHash.getLocation(), Result);
1129  case tok::pp_include_next:
1130  return HandleIncludeNextDirective(SavedHash.getLocation(), Result);
1131 
1132  case tok::pp_warning:
1133  Diag(Result, diag::ext_pp_warning_directive);
1134  return HandleUserDiagnosticDirective(Result, true);
1135  case tok::pp_ident:
1136  return HandleIdentSCCSDirective(Result);
1137  case tok::pp_sccs:
1138  return HandleIdentSCCSDirective(Result);
1139  case tok::pp_assert:
1140  //isExtension = true; // FIXME: implement #assert
1141  break;
1142  case tok::pp_unassert:
1143  //isExtension = true; // FIXME: implement #unassert
1144  break;
1145 
1146  case tok::pp___public_macro:
1147  if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility)
1148  return HandleMacroPublicDirective(Result);
1149  break;
1150 
1151  case tok::pp___private_macro:
1152  if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility)
1153  return HandleMacroPrivateDirective();
1154  break;
1155  }
1156  break;
1157  }
1158 
1159  // If this is a .S file, treat unknown # directives as non-preprocessor
1160  // directives. This is important because # may be a comment or introduce
1161  // various pseudo-ops. Just return the # token and push back the following
1162  // token to be lexed next time.
1163  if (getLangOpts().AsmPreprocessor) {
1164  auto Toks = std::make_unique<Token[]>(2);
1165  // Return the # and the token after it.
1166  Toks[0] = SavedHash;
1167  Toks[1] = Result;
1168 
1169  // If the second token is a hashhash token, then we need to translate it to
1170  // unknown so the token lexer doesn't try to perform token pasting.
1171  if (Result.is(tok::hashhash))
1172  Toks[1].setKind(tok::unknown);
1173 
1174  // Enter this token stream so that we re-lex the tokens. Make sure to
1175  // enable macro expansion, in case the token after the # is an identifier
1176  // that is expanded.
1177  EnterTokenStream(std::move(Toks), 2, false, /*IsReinject*/false);
1178  return;
1179  }
1180 
1181  // If we reached here, the preprocessing token is not valid!
1182  Diag(Result, diag::err_pp_invalid_directive);
1183 
1184  // Read the rest of the PP line.
1186 
1187  // Okay, we're done parsing the directive.
1188 }
1189 
1190 /// GetLineValue - Convert a numeric token into an unsigned value, emitting
1191 /// Diagnostic DiagID if it is invalid, and returning the value in Val.
1192 static bool GetLineValue(Token &DigitTok, unsigned &Val,
1193  unsigned DiagID, Preprocessor &PP,
1194  bool IsGNULineDirective=false) {
1195  if (DigitTok.isNot(tok::numeric_constant)) {
1196  PP.Diag(DigitTok, DiagID);
1197 
1198  if (DigitTok.isNot(tok::eod))
1200  return true;
1201  }
1202 
1203  SmallString<64> IntegerBuffer;
1204  IntegerBuffer.resize(DigitTok.getLength());
1205  const char *DigitTokBegin = &IntegerBuffer[0];
1206  bool Invalid = false;
1207  unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid);
1208  if (Invalid)
1209  return true;
1210 
1211  // Verify that we have a simple digit-sequence, and compute the value. This
1212  // is always a simple digit string computed in decimal, so we do this manually
1213  // here.
1214  Val = 0;
1215  for (unsigned i = 0; i != ActualLength; ++i) {
1216  // C++1y [lex.fcon]p1:
1217  // Optional separating single quotes in a digit-sequence are ignored
1218  if (DigitTokBegin[i] == '\'')
1219  continue;
1220 
1221  if (!isDigit(DigitTokBegin[i])) {
1222  PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i),
1223  diag::err_pp_line_digit_sequence) << IsGNULineDirective;
1225  return true;
1226  }
1227 
1228  unsigned NextVal = Val*10+(DigitTokBegin[i]-'0');
1229  if (NextVal < Val) { // overflow.
1230  PP.Diag(DigitTok, DiagID);
1232  return true;
1233  }
1234  Val = NextVal;
1235  }
1236 
1237  if (DigitTokBegin[0] == '0' && Val)
1238  PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal)
1239  << IsGNULineDirective;
1240 
1241  return false;
1242 }
1243 
1244 /// Handle a \#line directive: C99 6.10.4.
1245 ///
1246 /// The two acceptable forms are:
1247 /// \verbatim
1248 /// # line digit-sequence
1249 /// # line digit-sequence "s-char-sequence"
1250 /// \endverbatim
1251 void Preprocessor::HandleLineDirective() {
1252  // Read the line # and string argument. Per C99 6.10.4p5, these tokens are
1253  // expanded.
1254  Token DigitTok;
1255  Lex(DigitTok);
1256 
1257  // Validate the number and convert it to an unsigned.
1258  unsigned LineNo;
1259  if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this))
1260  return;
1261 
1262  if (LineNo == 0)
1263  Diag(DigitTok, diag::ext_pp_line_zero);
1264 
1265  // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a
1266  // number greater than 2147483647". C90 requires that the line # be <= 32767.
1267  unsigned LineLimit = 32768U;
1268  if (LangOpts.C99 || LangOpts.CPlusPlus11)
1269  LineLimit = 2147483648U;
1270  if (LineNo >= LineLimit)
1271  Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit;
1272  else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)
1273  Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);
1274 
1275  int FilenameID = -1;
1276  Token StrTok;
1277  Lex(StrTok);
1278 
1279  // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1280  // string followed by eod.
1281  if (StrTok.is(tok::eod))
1282  ; // ok
1283  else if (StrTok.isNot(tok::string_literal)) {
1284  Diag(StrTok, diag::err_pp_line_invalid_filename);
1286  return;
1287  } else if (StrTok.hasUDSuffix()) {
1288  Diag(StrTok, diag::err_invalid_string_udl);
1290  return;
1291  } else {
1292  // Parse and validate the string, converting it into a unique ID.
1293  StringLiteralParser Literal(StrTok, *this);
1294  assert(Literal.isAscii() && "Didn't allow wide strings in");
1295  if (Literal.hadError) {
1297  return;
1298  }
1299  if (Literal.Pascal) {
1300  Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1302  return;
1303  }
1304  FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
1305 
1306  // Verify that there is nothing after the string, other than EOD. Because
1307  // of C99 6.10.4p5, macros that expand to empty tokens are ok.
1308  CheckEndOfDirective("line", true);
1309  }
1310 
1311  // Take the file kind of the file containing the #line directive. #line
1312  // directives are often used for generated sources from the same codebase, so
1313  // the new file should generally be classified the same way as the current
1314  // file. This is visible in GCC's pre-processed output, which rewrites #line
1315  // to GNU line markers.
1316  SrcMgr::CharacteristicKind FileKind =
1317  SourceMgr.getFileCharacteristic(DigitTok.getLocation());
1318 
1319  SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, false,
1320  false, FileKind);
1321 
1322  if (Callbacks)
1323  Callbacks->FileChanged(CurPPLexer->getSourceLocation(),
1324  PPCallbacks::RenameFile, FileKind);
1325 }
1326 
1327 /// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line
1328 /// marker directive.
1329 static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit,
1330  SrcMgr::CharacteristicKind &FileKind,
1331  Preprocessor &PP) {
1332  unsigned FlagVal;
1333  Token FlagTok;
1334  PP.Lex(FlagTok);
1335  if (FlagTok.is(tok::eod)) return false;
1336  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
1337  return true;
1338 
1339  if (FlagVal == 1) {
1340  IsFileEntry = true;
1341 
1342  PP.Lex(FlagTok);
1343  if (FlagTok.is(tok::eod)) return false;
1344  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
1345  return true;
1346  } else if (FlagVal == 2) {
1347  IsFileExit = true;
1348 
1350  // If we are leaving the current presumed file, check to make sure the
1351  // presumed include stack isn't empty!
1352  FileID CurFileID =
1353  SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first;
1354  PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation());
1355  if (PLoc.isInvalid())
1356  return true;
1357 
1358  // If there is no include loc (main file) or if the include loc is in a
1359  // different physical file, then we aren't in a "1" line marker flag region.
1360  SourceLocation IncLoc = PLoc.getIncludeLoc();
1361  if (IncLoc.isInvalid() ||
1362  SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {
1363  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);
1365  return true;
1366  }
1367 
1368  PP.Lex(FlagTok);
1369  if (FlagTok.is(tok::eod)) return false;
1370  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))
1371  return true;
1372  }
1373 
1374  // We must have 3 if there are still flags.
1375  if (FlagVal != 3) {
1376  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1378  return true;
1379  }
1380 
1381  FileKind = SrcMgr::C_System;
1382 
1383  PP.Lex(FlagTok);
1384  if (FlagTok.is(tok::eod)) return false;
1385  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))
1386  return true;
1387 
1388  // We must have 4 if there is yet another flag.
1389  if (FlagVal != 4) {
1390  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1392  return true;
1393  }
1394 
1395  FileKind = SrcMgr::C_ExternCSystem;
1396 
1397  PP.Lex(FlagTok);
1398  if (FlagTok.is(tok::eod)) return false;
1399 
1400  // There are no more valid flags here.
1401  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);
1403  return true;
1404 }
1405 
1406 /// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is
1407 /// one of the following forms:
1408 ///
1409 /// # 42
1410 /// # 42 "file" ('1' | '2')?
1411 /// # 42 "file" ('1' | '2')? '3' '4'?
1412 ///
1413 void Preprocessor::HandleDigitDirective(Token &DigitTok) {
1414  // Validate the number and convert it to an unsigned. GNU does not have a
1415  // line # limit other than it fit in 32-bits.
1416  unsigned LineNo;
1417  if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer,
1418  *this, true))
1419  return;
1420 
1421  Token StrTok;
1422  Lex(StrTok);
1423 
1424  bool IsFileEntry = false, IsFileExit = false;
1425  int FilenameID = -1;
1427 
1428  // If the StrTok is "eod", then it wasn't present. Otherwise, it must be a
1429  // string followed by eod.
1430  if (StrTok.is(tok::eod)) {
1431  // Treat this like "#line NN", which doesn't change file characteristics.
1432  FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation());
1433  } else if (StrTok.isNot(tok::string_literal)) {
1434  Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1436  return;
1437  } else if (StrTok.hasUDSuffix()) {
1438  Diag(StrTok, diag::err_invalid_string_udl);
1440  return;
1441  } else {
1442  // Parse and validate the string, converting it into a unique ID.
1443  StringLiteralParser Literal(StrTok, *this);
1444  assert(Literal.isAscii() && "Didn't allow wide strings in");
1445  if (Literal.hadError) {
1447  return;
1448  }
1449  if (Literal.Pascal) {
1450  Diag(StrTok, diag::err_pp_linemarker_invalid_filename);
1452  return;
1453  }
1454 
1455  // If a filename was present, read any flags that are present.
1456  if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, FileKind, *this))
1457  return;
1458 
1459  // Exiting to an empty string means pop to the including file, so leave
1460  // FilenameID as -1 in that case.
1461  if (!(IsFileExit && Literal.GetString().empty()))
1462  FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());
1463  }
1464 
1465  // Create a line note with this information.
1466  SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry,
1467  IsFileExit, FileKind);
1468 
1469  // If the preprocessor has callbacks installed, notify them of the #line
1470  // change. This is used so that the line marker comes out in -E mode for
1471  // example.
1472  if (Callbacks) {
1474  if (IsFileEntry)
1475  Reason = PPCallbacks::EnterFile;
1476  else if (IsFileExit)
1477  Reason = PPCallbacks::ExitFile;
1478 
1479  Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind);
1480  }
1481 }
1482 
1483 /// HandleUserDiagnosticDirective - Handle a #warning or #error directive.
1484 ///
1485 void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
1486  bool isWarning) {
1487  // Read the rest of the line raw. We do this because we don't want macros
1488  // to be expanded and we don't require that the tokens be valid preprocessing
1489  // tokens. For example, this is allowed: "#warning ` 'foo". GCC does
1490  // collapse multiple consecutive white space between tokens, but this isn't
1491  // specified by the standard.
1493  CurLexer->ReadToEndOfLine(&Message);
1494 
1495  // Find the first non-whitespace character, so that we can make the
1496  // diagnostic more succinct.
1497  StringRef Msg = Message.str().ltrim(' ');
1498 
1499  if (isWarning)
1500  Diag(Tok, diag::pp_hash_warning) << Msg;
1501  else
1502  Diag(Tok, diag::err_pp_hash_error) << Msg;
1503 }
1504 
1505 /// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
1506 ///
1507 void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {
1508  // Yes, this directive is an extension.
1509  Diag(Tok, diag::ext_pp_ident_directive);
1510 
1511  // Read the string argument.
1512  Token StrTok;
1513  Lex(StrTok);
1514 
1515  // If the token kind isn't a string, it's a malformed directive.
1516  if (StrTok.isNot(tok::string_literal) &&
1517  StrTok.isNot(tok::wide_string_literal)) {
1518  Diag(StrTok, diag::err_pp_malformed_ident);
1519  if (StrTok.isNot(tok::eod))
1521  return;
1522  }
1523 
1524  if (StrTok.hasUDSuffix()) {
1525  Diag(StrTok, diag::err_invalid_string_udl);
1527  return;
1528  }
1529 
1530  // Verify that there is nothing after the string, other than EOD.
1531  CheckEndOfDirective("ident");
1532 
1533  if (Callbacks) {
1534  bool Invalid = false;
1535  std::string Str = getSpelling(StrTok, &Invalid);
1536  if (!Invalid)
1537  Callbacks->Ident(Tok.getLocation(), Str);
1538  }
1539 }
1540 
1541 /// Handle a #public directive.
1542 void Preprocessor::HandleMacroPublicDirective(Token &Tok) {
1543  Token MacroNameTok;
1544  ReadMacroName(MacroNameTok, MU_Undef);
1545 
1546  // Error reading macro name? If so, diagnostic already issued.
1547  if (MacroNameTok.is(tok::eod))
1548  return;
1549 
1550  // Check to see if this is the last token on the #__public_macro line.
1551  CheckEndOfDirective("__public_macro");
1552 
1553  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
1554  // Okay, we finally have a valid identifier to undef.
1556 
1557  // If the macro is not defined, this is an error.
1558  if (!MD) {
1559  Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
1560  return;
1561  }
1562 
1563  // Note that this macro has now been exported.
1564  appendMacroDirective(II, AllocateVisibilityMacroDirective(
1565  MacroNameTok.getLocation(), /*isPublic=*/true));
1566 }
1567 
1568 /// Handle a #private directive.
1569 void Preprocessor::HandleMacroPrivateDirective() {
1570  Token MacroNameTok;
1571  ReadMacroName(MacroNameTok, MU_Undef);
1572 
1573  // Error reading macro name? If so, diagnostic already issued.
1574  if (MacroNameTok.is(tok::eod))
1575  return;
1576 
1577  // Check to see if this is the last token on the #__private_macro line.
1578  CheckEndOfDirective("__private_macro");
1579 
1580  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
1581  // Okay, we finally have a valid identifier to undef.
1583 
1584  // If the macro is not defined, this is an error.
1585  if (!MD) {
1586  Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;
1587  return;
1588  }
1589 
1590  // Note that this macro has now been marked private.
1591  appendMacroDirective(II, AllocateVisibilityMacroDirective(
1592  MacroNameTok.getLocation(), /*isPublic=*/false));
1593 }
1594 
1595 //===----------------------------------------------------------------------===//
1596 // Preprocessor Include Directive Handling.
1597 //===----------------------------------------------------------------------===//
1598 
1599 /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully
1600 /// checked and spelled filename, e.g. as an operand of \#include. This returns
1601 /// true if the input filename was in <>'s or false if it were in ""'s. The
1602 /// caller is expected to provide a buffer that is large enough to hold the
1603 /// spelling of the filename, but is also expected to handle the case when
1604 /// this method decides to use a different buffer.
1606  StringRef &Buffer) {
1607  // Get the text form of the filename.
1608  assert(!Buffer.empty() && "Can't have tokens with empty spellings!");
1609 
1610  // FIXME: Consider warning on some of the cases described in C11 6.4.7/3 and
1611  // C++20 [lex.header]/2:
1612  //
1613  // If `"`, `'`, `\`, `/*`, or `//` appears in a header-name, then
1614  // in C: behavior is undefined
1615  // in C++: program is conditionally-supported with implementation-defined
1616  // semantics
1617 
1618  // Make sure the filename is <x> or "x".
1619  bool isAngled;
1620  if (Buffer[0] == '<') {
1621  if (Buffer.back() != '>') {
1622  Diag(Loc, diag::err_pp_expects_filename);
1623  Buffer = StringRef();
1624  return true;
1625  }
1626  isAngled = true;
1627  } else if (Buffer[0] == '"') {
1628  if (Buffer.back() != '"') {
1629  Diag(Loc, diag::err_pp_expects_filename);
1630  Buffer = StringRef();
1631  return true;
1632  }
1633  isAngled = false;
1634  } else {
1635  Diag(Loc, diag::err_pp_expects_filename);
1636  Buffer = StringRef();
1637  return true;
1638  }
1639 
1640  // Diagnose #include "" as invalid.
1641  if (Buffer.size() <= 2) {
1642  Diag(Loc, diag::err_pp_empty_filename);
1643  Buffer = StringRef();
1644  return true;
1645  }
1646 
1647  // Skip the brackets.
1648  Buffer = Buffer.substr(1, Buffer.size()-2);
1649  return isAngled;
1650 }
1651 
1652 /// Push a token onto the token stream containing an annotation.
1655  void *AnnotationVal) {
1656  // FIXME: Produce this as the current token directly, rather than
1657  // allocating a new token for it.
1658  auto Tok = std::make_unique<Token[]>(1);
1659  Tok[0].startToken();
1660  Tok[0].setKind(Kind);
1661  Tok[0].setLocation(Range.getBegin());
1662  Tok[0].setAnnotationEndLoc(Range.getEnd());
1663  Tok[0].setAnnotationValue(AnnotationVal);
1664  EnterTokenStream(std::move(Tok), 1, true, /*IsReinject*/ false);
1665 }
1666 
1667 /// Produce a diagnostic informing the user that a #include or similar
1668 /// was implicitly treated as a module import.
1670  Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok,
1671  ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path,
1672  SourceLocation PathEnd) {
1673  StringRef ImportKeyword;
1674  if (PP.getLangOpts().ObjC)
1675  ImportKeyword = "@import";
1676  else if (PP.getLangOpts().ModulesTS || PP.getLangOpts().CPlusPlusModules)
1677  ImportKeyword = "import";
1678  else
1679  return; // no import syntax available
1680 
1681  SmallString<128> PathString;
1682  for (size_t I = 0, N = Path.size(); I != N; ++I) {
1683  if (I)
1684  PathString += '.';
1685  PathString += Path[I].first->getName();
1686  }
1687  int IncludeKind = 0;
1688 
1689  switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {
1690  case tok::pp_include:
1691  IncludeKind = 0;
1692  break;
1693 
1694  case tok::pp_import:
1695  IncludeKind = 1;
1696  break;
1697 
1698  case tok::pp_include_next:
1699  IncludeKind = 2;
1700  break;
1701 
1703  IncludeKind = 3;
1704  break;
1705 
1706  default:
1707  llvm_unreachable("unknown include directive kind");
1708  }
1709 
1710  CharSourceRange ReplaceRange(SourceRange(HashLoc, PathEnd),
1711  /*IsTokenRange=*/false);
1712  PP.Diag(HashLoc, diag::warn_auto_module_import)
1713  << IncludeKind << PathString
1715  ReplaceRange, (ImportKeyword + " " + PathString + ";").str());
1716 }
1717 
1718 // Given a vector of path components and a string containing the real
1719 // path to the file, build a properly-cased replacement in the vector,
1720 // and return true if the replacement should be suggested.
1722  StringRef RealPathName) {
1723  auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);
1724  auto RealPathComponentEnd = llvm::sys::path::rend(RealPathName);
1725  int Cnt = 0;
1726  bool SuggestReplacement = false;
1727  // Below is a best-effort to handle ".." in paths. It is admittedly
1728  // not 100% correct in the presence of symlinks.
1729  for (auto &Component : llvm::reverse(Components)) {
1730  if ("." == Component) {
1731  } else if (".." == Component) {
1732  ++Cnt;
1733  } else if (Cnt) {
1734  --Cnt;
1735  } else if (RealPathComponentIter != RealPathComponentEnd) {
1736  if (Component != *RealPathComponentIter) {
1737  // If these path components differ by more than just case, then we
1738  // may be looking at symlinked paths. Bail on this diagnostic to avoid
1739  // noisy false positives.
1740  SuggestReplacement =
1741  RealPathComponentIter->equals_insensitive(Component);
1742  if (!SuggestReplacement)
1743  break;
1744  Component = *RealPathComponentIter;
1745  }
1746  ++RealPathComponentIter;
1747  }
1748  }
1749  return SuggestReplacement;
1750 }
1751 
1753  const TargetInfo &TargetInfo,
1754  DiagnosticsEngine &Diags, Module *M) {
1755  Module::Requirement Requirement;
1756  Module::UnresolvedHeaderDirective MissingHeader;
1757  Module *ShadowingModule = nullptr;
1758  if (M->isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader,
1759  ShadowingModule))
1760  return false;
1761 
1762  if (MissingHeader.FileNameLoc.isValid()) {
1763  Diags.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)
1764  << MissingHeader.IsUmbrella << MissingHeader.FileName;
1765  } else if (ShadowingModule) {
1766  Diags.Report(M->DefinitionLoc, diag::err_module_shadowed) << M->Name;
1767  Diags.Report(ShadowingModule->DefinitionLoc,
1768  diag::note_previous_definition);
1769  } else {
1770  // FIXME: Track the location at which the requirement was specified, and
1771  // use it here.
1772  Diags.Report(M->DefinitionLoc, diag::err_module_unavailable)
1773  << M->getFullModuleName() << Requirement.second << Requirement.first;
1774  }
1775  return true;
1776 }
1777 
1778 /// HandleIncludeDirective - The "\#include" tokens have just been read, read
1779 /// the file to be included from the lexer, then include it! This is a common
1780 /// routine with functionality shared between \#include, \#include_next and
1781 /// \#import. LookupFrom is set when this is a \#include_next directive, it
1782 /// specifies the file to start searching from.
1783 void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
1784  Token &IncludeTok,
1785  const DirectoryLookup *LookupFrom,
1786  const FileEntry *LookupFromFile) {
1787  Token FilenameTok;
1788  if (LexHeaderName(FilenameTok))
1789  return;
1790 
1791  if (FilenameTok.isNot(tok::header_name)) {
1792  Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
1793  if (FilenameTok.isNot(tok::eod))
1795  return;
1796  }
1797 
1798  // Verify that there is nothing after the filename, other than EOD. Note
1799  // that we allow macros that expand to nothing after the filename, because
1800  // this falls into the category of "#include pp-tokens new-line" specified
1801  // in C99 6.10.2p4.
1802  SourceLocation EndLoc =
1803  CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true);
1804 
1805  auto Action = HandleHeaderIncludeOrImport(HashLoc, IncludeTok, FilenameTok,
1806  EndLoc, LookupFrom, LookupFromFile);
1807  switch (Action.Kind) {
1808  case ImportAction::None:
1809  case ImportAction::SkippedModuleImport:
1810  break;
1811  case ImportAction::ModuleBegin:
1812  EnterAnnotationToken(SourceRange(HashLoc, EndLoc),
1813  tok::annot_module_begin, Action.ModuleForHeader);
1814  break;
1815  case ImportAction::ModuleImport:
1816  EnterAnnotationToken(SourceRange(HashLoc, EndLoc),
1817  tok::annot_module_include, Action.ModuleForHeader);
1818  break;
1819  case ImportAction::Failure:
1820  assert(TheModuleLoader.HadFatalFailure &&
1821  "This should be an early exit only to a fatal error");
1822  TheModuleLoader.HadFatalFailure = true;
1823  IncludeTok.setKind(tok::eof);
1824  CurLexer->cutOffLexing();
1825  return;
1826  }
1827 }
1828 
1829 Optional<FileEntryRef> Preprocessor::LookupHeaderIncludeOrImport(
1830  const DirectoryLookup *&CurDir, StringRef& Filename,
1831  SourceLocation FilenameLoc, CharSourceRange FilenameRange,
1832  const Token &FilenameTok, bool &IsFrameworkFound, bool IsImportDecl,
1833  bool &IsMapped, const DirectoryLookup *LookupFrom,
1834  const FileEntry *LookupFromFile, StringRef& LookupFilename,
1835  SmallVectorImpl<char> &RelativePath, SmallVectorImpl<char> &SearchPath,
1836  ModuleMap::KnownHeader &SuggestedModule, bool isAngled) {
1838  FilenameLoc, LookupFilename,
1839  isAngled, LookupFrom, LookupFromFile, CurDir,
1840  Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,
1841  &SuggestedModule, &IsMapped, &IsFrameworkFound);
1842  if (File)
1843  return File;
1844 
1845  if (Callbacks) {
1846  // Give the clients a chance to recover.
1847  SmallString<128> RecoveryPath;
1848  if (Callbacks->FileNotFound(Filename, RecoveryPath)) {
1849  if (auto DE = FileMgr.getOptionalDirectoryRef(RecoveryPath)) {
1850  // Add the recovery path to the list of search paths.
1851  DirectoryLookup DL(*DE, SrcMgr::C_User, false);
1852  HeaderInfo.AddSearchPath(DL, isAngled);
1853 
1854  // Try the lookup again, skipping the cache.
1856  FilenameLoc,
1857  LookupFilename, isAngled,
1858  LookupFrom, LookupFromFile, CurDir, nullptr, nullptr,
1859  &SuggestedModule, &IsMapped, /*IsFrameworkFound=*/nullptr,
1860  /*SkipCache*/ true);
1861  if (File)
1862  return File;
1863  }
1864  }
1865  }
1866 
1867  if (SuppressIncludeNotFoundError)
1868  return None;
1869 
1870  // If the file could not be located and it was included via angle
1871  // brackets, we can attempt a lookup as though it were a quoted path to
1872  // provide the user with a possible fixit.
1873  if (isAngled) {
1875  FilenameLoc, LookupFilename,
1876  false, LookupFrom, LookupFromFile, CurDir,
1877  Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,
1878  &SuggestedModule, &IsMapped,
1879  /*IsFrameworkFound=*/nullptr);
1880  if (File) {
1881  Diag(FilenameTok, diag::err_pp_file_not_found_angled_include_not_fatal)
1882  << Filename << IsImportDecl
1883  << FixItHint::CreateReplacement(FilenameRange,
1884  "\"" + Filename.str() + "\"");
1885  return File;
1886  }
1887  }
1888 
1889  // Check for likely typos due to leading or trailing non-isAlphanumeric
1890  // characters
1891  StringRef OriginalFilename = Filename;
1892  if (LangOpts.SpellChecking) {
1893  // A heuristic to correct a typo file name by removing leading and
1894  // trailing non-isAlphanumeric characters.
1895  auto CorrectTypoFilename = [](llvm::StringRef Filename) {
1896  Filename = Filename.drop_until(isAlphanumeric);
1897  while (!Filename.empty() && !isAlphanumeric(Filename.back())) {
1898  Filename = Filename.drop_back();
1899  }
1900  return Filename;
1901  };
1902  StringRef TypoCorrectionName = CorrectTypoFilename(Filename);
1903  StringRef TypoCorrectionLookupName = CorrectTypoFilename(LookupFilename);
1904 
1906  FilenameLoc, TypoCorrectionLookupName, isAngled, LookupFrom, LookupFromFile,
1907  CurDir, Callbacks ? &SearchPath : nullptr,
1908  Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped,
1909  /*IsFrameworkFound=*/nullptr);
1910  if (File) {
1911  auto Hint =
1912  isAngled ? FixItHint::CreateReplacement(
1913  FilenameRange, "<" + TypoCorrectionName.str() + ">")
1914  : FixItHint::CreateReplacement(
1915  FilenameRange, "\"" + TypoCorrectionName.str() + "\"");
1916  Diag(FilenameTok, diag::err_pp_file_not_found_typo_not_fatal)
1917  << OriginalFilename << TypoCorrectionName << Hint;
1918  // We found the file, so set the Filename to the name after typo
1919  // correction.
1920  Filename = TypoCorrectionName;
1921  LookupFilename = TypoCorrectionLookupName;
1922  return File;
1923  }
1924  }
1925 
1926  // If the file is still not found, just go with the vanilla diagnostic
1927  assert(!File.hasValue() && "expected missing file");
1928  Diag(FilenameTok, diag::err_pp_file_not_found)
1929  << OriginalFilename << FilenameRange;
1930  if (IsFrameworkFound) {
1931  size_t SlashPos = OriginalFilename.find('/');
1932  assert(SlashPos != StringRef::npos &&
1933  "Include with framework name should have '/' in the filename");
1934  StringRef FrameworkName = OriginalFilename.substr(0, SlashPos);
1935  FrameworkCacheEntry &CacheEntry =
1936  HeaderInfo.LookupFrameworkCache(FrameworkName);
1937  assert(CacheEntry.Directory && "Found framework should be in cache");
1938  Diag(FilenameTok, diag::note_pp_framework_without_header)
1939  << OriginalFilename.substr(SlashPos + 1) << FrameworkName
1940  << CacheEntry.Directory->getName();
1941  }
1942 
1943  return None;
1944 }
1945 
1946 /// Handle either a #include-like directive or an import declaration that names
1947 /// a header file.
1948 ///
1949 /// \param HashLoc The location of the '#' token for an include, or
1950 /// SourceLocation() for an import declaration.
1951 /// \param IncludeTok The include / include_next / import token.
1952 /// \param FilenameTok The header-name token.
1953 /// \param EndLoc The location at which any imported macros become visible.
1954 /// \param LookupFrom For #include_next, the starting directory for the
1955 /// directory lookup.
1956 /// \param LookupFromFile For #include_next, the starting file for the directory
1957 /// lookup.
1958 Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(
1959  SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok,
1960  SourceLocation EndLoc, const DirectoryLookup *LookupFrom,
1961  const FileEntry *LookupFromFile) {
1962  SmallString<128> FilenameBuffer;
1963  StringRef Filename = getSpelling(FilenameTok, FilenameBuffer);
1964  SourceLocation CharEnd = FilenameTok.getEndLoc();
1965 
1966  CharSourceRange FilenameRange
1967  = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);
1968  StringRef OriginalFilename = Filename;
1969  bool isAngled =
1971 
1972  // If GetIncludeFilenameSpelling set the start ptr to null, there was an
1973  // error.
1974  if (Filename.empty())
1975  return {ImportAction::None};
1976 
1977  bool IsImportDecl = HashLoc.isInvalid();
1978  SourceLocation StartLoc = IsImportDecl ? IncludeTok.getLocation() : HashLoc;
1979 
1980  // Complain about attempts to #include files in an audit pragma.
1981  if (PragmaARCCFCodeAuditedInfo.second.isValid()) {
1982  Diag(StartLoc, diag::err_pp_include_in_arc_cf_code_audited) << IsImportDecl;
1983  Diag(PragmaARCCFCodeAuditedInfo.second, diag::note_pragma_entered_here);
1984 
1985  // Immediately leave the pragma.
1986  PragmaARCCFCodeAuditedInfo = {nullptr, SourceLocation()};
1987  }
1988 
1989  // Complain about attempts to #include files in an assume-nonnull pragma.
1990  if (PragmaAssumeNonNullLoc.isValid()) {
1991  Diag(StartLoc, diag::err_pp_include_in_assume_nonnull) << IsImportDecl;
1992  Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);
1993 
1994  // Immediately leave the pragma.
1995  PragmaAssumeNonNullLoc = SourceLocation();
1996  }
1997 
1998  if (HeaderInfo.HasIncludeAliasMap()) {
1999  // Map the filename with the brackets still attached. If the name doesn't
2000  // map to anything, fall back on the filename we've already gotten the
2001  // spelling for.
2002  StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename);
2003  if (!NewName.empty())
2004  Filename = NewName;
2005  }
2006 
2007  // Search include directories.
2008  bool IsMapped = false;
2009  bool IsFrameworkFound = false;
2010  const DirectoryLookup *CurDir;
2011  SmallString<1024> SearchPath;
2012  SmallString<1024> RelativePath;
2013  // We get the raw path only if we have 'Callbacks' to which we later pass
2014  // the path.
2015  ModuleMap::KnownHeader SuggestedModule;
2016  SourceLocation FilenameLoc = FilenameTok.getLocation();
2017  StringRef LookupFilename = Filename;
2018 
2019  // Normalize slashes when compiling with -fms-extensions on non-Windows. This
2020  // is unnecessary on Windows since the filesystem there handles backslashes.
2021  SmallString<128> NormalizedPath;
2022  llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::native;
2023  if (is_style_posix(BackslashStyle) && LangOpts.MicrosoftExt) {
2024  NormalizedPath = Filename.str();
2025  llvm::sys::path::native(NormalizedPath);
2026  LookupFilename = NormalizedPath;
2027  BackslashStyle = llvm::sys::path::Style::windows;
2028  }
2029 
2030  Optional<FileEntryRef> File = LookupHeaderIncludeOrImport(
2031  CurDir, Filename, FilenameLoc, FilenameRange, FilenameTok,
2032  IsFrameworkFound, IsImportDecl, IsMapped, LookupFrom, LookupFromFile,
2033  LookupFilename, RelativePath, SearchPath, SuggestedModule, isAngled);
2034 
2035  // Record the header's filename for later use.
2036  if (File)
2037  CurLexer->addInclude(OriginalFilename, File->getFileEntry(), FilenameLoc);
2038 
2039  if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) {
2040  if (File && isPCHThroughHeader(&File->getFileEntry()))
2041  SkippingUntilPCHThroughHeader = false;
2042  return {ImportAction::None};
2043  }
2044 
2045  // Should we enter the source file? Set to Skip if either the source file is
2046  // known to have no effect beyond its effect on module visibility -- that is,
2047  // if it's got an include guard that is already defined, set to Import if it
2048  // is a modular header we've already built and should import.
2049  enum { Enter, Import, Skip, IncludeLimitReached } Action = Enter;
2050 
2051  if (PPOpts->SingleFileParseMode)
2052  Action = IncludeLimitReached;
2053 
2054  // If we've reached the max allowed include depth, it is usually due to an
2055  // include cycle. Don't enter already processed files again as it can lead to
2056  // reaching the max allowed include depth again.
2057  if (Action == Enter && HasReachedMaxIncludeDepth && File &&
2058  HeaderInfo.getFileInfo(&File->getFileEntry()).NumIncludes)
2059  Action = IncludeLimitReached;
2060 
2061  // Determine whether we should try to import the module for this #include, if
2062  // there is one. Don't do so if precompiled module support is disabled or we
2063  // are processing this module textually (because we're building the module).
2064  if (Action == Enter && File && SuggestedModule && getLangOpts().Modules &&
2065  !isForModuleBuilding(SuggestedModule.getModule(),
2066  getLangOpts().CurrentModule,
2067  getLangOpts().ModuleName)) {
2068  // If this include corresponds to a module but that module is
2069  // unavailable, diagnose the situation and bail out.
2070  // FIXME: Remove this; loadModule does the same check (but produces
2071  // slightly worse diagnostics).
2073  SuggestedModule.getModule())) {
2074  Diag(FilenameTok.getLocation(),
2075  diag::note_implicit_top_level_module_import_here)
2076  << SuggestedModule.getModule()->getTopLevelModuleName();
2077  return {ImportAction::None};
2078  }
2079 
2080  // Compute the module access path corresponding to this module.
2081  // FIXME: Should we have a second loadModule() overload to avoid this
2082  // extra lookup step?
2084  for (Module *Mod = SuggestedModule.getModule(); Mod; Mod = Mod->Parent)
2085  Path.push_back(std::make_pair(getIdentifierInfo(Mod->Name),
2086  FilenameTok.getLocation()));
2087  std::reverse(Path.begin(), Path.end());
2088 
2089  // Warn that we're replacing the include/import with a module import.
2090  if (!IsImportDecl)
2091  diagnoseAutoModuleImport(*this, StartLoc, IncludeTok, Path, CharEnd);
2092 
2093  // Load the module to import its macros. We'll make the declarations
2094  // visible when the parser gets here.
2095  // FIXME: Pass SuggestedModule in here rather than converting it to a path
2096  // and making the module loader convert it back again.
2097  ModuleLoadResult Imported = TheModuleLoader.loadModule(
2098  IncludeTok.getLocation(), Path, Module::Hidden,
2099  /*IsInclusionDirective=*/true);
2100  assert((Imported == nullptr || Imported == SuggestedModule.getModule()) &&
2101  "the imported module is different than the suggested one");
2102 
2103  if (Imported) {
2104  Action = Import;
2105  } else if (Imported.isMissingExpected()) {
2106  // We failed to find a submodule that we assumed would exist (because it
2107  // was in the directory of an umbrella header, for instance), but no
2108  // actual module containing it exists (because the umbrella header is
2109  // incomplete). Treat this as a textual inclusion.
2110  SuggestedModule = ModuleMap::KnownHeader();
2111  } else if (Imported.isConfigMismatch()) {
2112  // On a configuration mismatch, enter the header textually. We still know
2113  // that it's part of the corresponding module.
2114  } else {
2115  // We hit an error processing the import. Bail out.
2117  // With a fatal failure in the module loader, we abort parsing.
2118  Token &Result = IncludeTok;
2119  assert(CurLexer && "#include but no current lexer set!");
2120  Result.startToken();
2121  CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
2122  CurLexer->cutOffLexing();
2123  }
2124  return {ImportAction::None};
2125  }
2126  }
2127 
2128  // The #included file will be considered to be a system header if either it is
2129  // in a system include directory, or if the #includer is a system include
2130  // header.
2131  SrcMgr::CharacteristicKind FileCharacter =
2132  SourceMgr.getFileCharacteristic(FilenameTok.getLocation());
2133  if (File)
2134  FileCharacter = std::max(HeaderInfo.getFileDirFlavor(&File->getFileEntry()),
2135  FileCharacter);
2136 
2137  // If this is a '#import' or an import-declaration, don't re-enter the file.
2138  //
2139  // FIXME: If we have a suggested module for a '#include', and we've already
2140  // visited this file, don't bother entering it again. We know it has no
2141  // further effect.
2142  bool EnterOnce =
2143  IsImportDecl ||
2144  IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import;
2145 
2146  bool IsFirstIncludeOfFile = false;
2147 
2148  // Ask HeaderInfo if we should enter this #include file. If not, #including
2149  // this file will have no effect.
2150  if (Action == Enter && File &&
2151  !HeaderInfo.ShouldEnterIncludeFile(
2152  *this, &File->getFileEntry(), EnterOnce, getLangOpts().Modules,
2153  SuggestedModule.getModule(), IsFirstIncludeOfFile)) {
2154  // Even if we've already preprocessed this header once and know that we
2155  // don't need to see its contents again, we still need to import it if it's
2156  // modular because we might not have imported it from this submodule before.
2157  //
2158  // FIXME: We don't do this when compiling a PCH because the AST
2159  // serialization layer can't cope with it. This means we get local
2160  // submodule visibility semantics wrong in that case.
2161  Action = (SuggestedModule && !getLangOpts().CompilingPCH) ? Import : Skip;
2162  }
2163 
2164  // Check for circular inclusion of the main file.
2165  // We can't generate a consistent preamble with regard to the conditional
2166  // stack if the main file is included again as due to the preamble bounds
2167  // some directives (e.g. #endif of a header guard) will never be seen.
2168  // Since this will lead to confusing errors, avoid the inclusion.
2169  if (Action == Enter && File && PreambleConditionalStack.isRecording() &&
2170  SourceMgr.isMainFile(File->getFileEntry())) {
2171  Diag(FilenameTok.getLocation(),
2172  diag::err_pp_including_mainfile_in_preamble);
2173  return {ImportAction::None};
2174  }
2175 
2176  if (Callbacks && !IsImportDecl) {
2177  // Notify the callback object that we've seen an inclusion directive.
2178  // FIXME: Use a different callback for a pp-import?
2179  Callbacks->InclusionDirective(
2180  HashLoc, IncludeTok, LookupFilename, isAngled, FilenameRange,
2181  File ? &File->getFileEntry() : nullptr, SearchPath, RelativePath,
2182  Action == Import ? SuggestedModule.getModule() : nullptr,
2183  FileCharacter);
2184  if (Action == Skip && File)
2185  Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);
2186  }
2187 
2188  if (!File)
2189  return {ImportAction::None};
2190 
2191  // If this is a C++20 pp-import declaration, diagnose if we didn't find any
2192  // module corresponding to the named header.
2193  if (IsImportDecl && !SuggestedModule) {
2194  Diag(FilenameTok, diag::err_header_import_not_header_unit)
2195  << OriginalFilename << File->getName();
2196  return {ImportAction::None};
2197  }
2198 
2199  // Issue a diagnostic if the name of the file on disk has a different case
2200  // than the one we're about to open.
2201  const bool CheckIncludePathPortability =
2202  !IsMapped && !File->getFileEntry().tryGetRealPathName().empty();
2203 
2204  if (CheckIncludePathPortability) {
2205  StringRef Name = LookupFilename;
2206  StringRef NameWithoriginalSlashes = Filename;
2207 #if defined(_WIN32)
2208  // Skip UNC prefix if present. (tryGetRealPathName() always
2209  // returns a path with the prefix skipped.)
2210  bool NameWasUNC = Name.consume_front("\\\\?\\");
2211  NameWithoriginalSlashes.consume_front("\\\\?\\");
2212 #endif
2213  StringRef RealPathName = File->getFileEntry().tryGetRealPathName();
2214  SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name),
2215  llvm::sys::path::end(Name));
2216 #if defined(_WIN32)
2217  // -Wnonportable-include-path is designed to diagnose includes using
2218  // case even on systems with a case-insensitive file system.
2219  // On Windows, RealPathName always starts with an upper-case drive
2220  // letter for absolute paths, but Name might start with either
2221  // case depending on if `cd c:\foo` or `cd C:\foo` was used in the shell.
2222  // ("foo" will always have on-disk case, no matter which case was
2223  // used in the cd command). To not emit this warning solely for
2224  // the drive letter, whose case is dependent on if `cd` is used
2225  // with upper- or lower-case drive letters, always consider the
2226  // given drive letter case as correct for the purpose of this warning.
2227  SmallString<128> FixedDriveRealPath;
2228  if (llvm::sys::path::is_absolute(Name) &&
2229  llvm::sys::path::is_absolute(RealPathName) &&
2230  toLowercase(Name[0]) == toLowercase(RealPathName[0]) &&
2231  isLowercase(Name[0]) != isLowercase(RealPathName[0])) {
2232  assert(Components.size() >= 3 && "should have drive, backslash, name");
2233  assert(Components[0].size() == 2 && "should start with drive");
2234  assert(Components[0][1] == ':' && "should have colon");
2235  FixedDriveRealPath = (Name.substr(0, 1) + RealPathName.substr(1)).str();
2236  RealPathName = FixedDriveRealPath;
2237  }
2238 #endif
2239 
2240  if (trySimplifyPath(Components, RealPathName)) {
2241  SmallString<128> Path;
2242  Path.reserve(Name.size()+2);
2243  Path.push_back(isAngled ? '<' : '"');
2244 
2245  const auto IsSep = [BackslashStyle](char c) {
2246  return llvm::sys::path::is_separator(c, BackslashStyle);
2247  };
2248 
2249  for (auto Component : Components) {
2250  // On POSIX, Components will contain a single '/' as first element
2251  // exactly if Name is an absolute path.
2252  // On Windows, it will contain "C:" followed by '\' for absolute paths.
2253  // The drive letter is optional for absolute paths on Windows, but
2254  // clang currently cannot process absolute paths in #include lines that
2255  // don't have a drive.
2256  // If the first entry in Components is a directory separator,
2257  // then the code at the bottom of this loop that keeps the original
2258  // directory separator style copies it. If the second entry is
2259  // a directory separator (the C:\ case), then that separator already
2260  // got copied when the C: was processed and we want to skip that entry.
2261  if (!(Component.size() == 1 && IsSep(Component[0])))
2262  Path.append(Component);
2263  else if (!Path.empty())
2264  continue;
2265 
2266  // Append the separator(s) the user used, or the close quote
2267  if (Path.size() > NameWithoriginalSlashes.size()) {
2268  Path.push_back(isAngled ? '>' : '"');
2269  continue;
2270  }
2271  assert(IsSep(NameWithoriginalSlashes[Path.size()-1]));
2272  do
2273  Path.push_back(NameWithoriginalSlashes[Path.size()-1]);
2274  while (Path.size() <= NameWithoriginalSlashes.size() &&
2275  IsSep(NameWithoriginalSlashes[Path.size()-1]));
2276  }
2277 
2278 #if defined(_WIN32)
2279  // Restore UNC prefix if it was there.
2280  if (NameWasUNC)
2281  Path = (Path.substr(0, 1) + "\\\\?\\" + Path.substr(1)).str();
2282 #endif
2283 
2284  // For user files and known standard headers, issue a diagnostic.
2285  // For other system headers, don't. They can be controlled separately.
2286  auto DiagId =
2287  (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name))
2288  ? diag::pp_nonportable_path
2289  : diag::pp_nonportable_system_path;
2290  Diag(FilenameTok, DiagId) << Path <<
2291  FixItHint::CreateReplacement(FilenameRange, Path);
2292  }
2293  }
2294 
2295  switch (Action) {
2296  case Skip:
2297  // If we don't need to enter the file, stop now.
2298  if (Module *M = SuggestedModule.getModule())
2299  return {ImportAction::SkippedModuleImport, M};
2300  return {ImportAction::None};
2301 
2302  case IncludeLimitReached:
2303  // If we reached our include limit and don't want to enter any more files,
2304  // don't go any further.
2305  return {ImportAction::None};
2306 
2307  case Import: {
2308  // If this is a module import, make it visible if needed.
2309  Module *M = SuggestedModule.getModule();
2310  assert(M && "no module to import");
2311 
2312  makeModuleVisible(M, EndLoc);
2313 
2314  if (IncludeTok.getIdentifierInfo()->getPPKeywordID() ==
2316  return {ImportAction::None};
2317 
2318  return {ImportAction::ModuleImport, M};
2319  }
2320 
2321  case Enter:
2322  break;
2323  }
2324 
2325  // Check that we don't have infinite #include recursion.
2326  if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {
2327  Diag(FilenameTok, diag::err_pp_include_too_deep);
2328  HasReachedMaxIncludeDepth = true;
2329  return {ImportAction::None};
2330  }
2331 
2332  // Look up the file, create a File ID for it.
2333  SourceLocation IncludePos = FilenameTok.getLocation();
2334  // If the filename string was the result of macro expansions, set the include
2335  // position on the file where it will be included and after the expansions.
2336  if (IncludePos.isMacroID())
2337  IncludePos = SourceMgr.getExpansionRange(IncludePos).getEnd();
2338  FileID FID = SourceMgr.createFileID(*File, IncludePos, FileCharacter);
2339  if (!FID.isValid()) {
2340  TheModuleLoader.HadFatalFailure = true;
2341  return ImportAction::Failure;
2342  }
2343 
2344  // If all is good, enter the new file!
2345  if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation(),
2346  IsFirstIncludeOfFile))
2347  return {ImportAction::None};
2348 
2349  // Determine if we're switching to building a new submodule, and which one.
2350  if (auto *M = SuggestedModule.getModule()) {
2351  if (M->getTopLevelModule()->ShadowingModule) {
2352  // We are building a submodule that belongs to a shadowed module. This
2353  // means we find header files in the shadowed module.
2354  Diag(M->DefinitionLoc, diag::err_module_build_shadowed_submodule)
2355  << M->getFullModuleName();
2357  diag::note_previous_definition);
2358  return {ImportAction::None};
2359  }
2360  // When building a pch, -fmodule-name tells the compiler to textually
2361  // include headers in the specified module. We are not building the
2362  // specified module.
2363  //
2364  // FIXME: This is the wrong way to handle this. We should produce a PCH
2365  // that behaves the same as the header would behave in a compilation using
2366  // that PCH, which means we should enter the submodule. We need to teach
2367  // the AST serialization layer to deal with the resulting AST.
2368  if (getLangOpts().CompilingPCH &&
2369  isForModuleBuilding(M, getLangOpts().CurrentModule,
2370  getLangOpts().ModuleName))
2371  return {ImportAction::None};
2372 
2373  assert(!CurLexerSubmodule && "should not have marked this as a module yet");
2374  CurLexerSubmodule = M;
2375 
2376  // Let the macro handling code know that any future macros are within
2377  // the new submodule.
2378  EnterSubmodule(M, EndLoc, /*ForPragma*/false);
2379 
2380  // Let the parser know that any future declarations are within the new
2381  // submodule.
2382  // FIXME: There's no point doing this if we're handling a #__include_macros
2383  // directive.
2384  return {ImportAction::ModuleBegin, M};
2385  }
2386 
2387  assert(!IsImportDecl && "failed to diagnose missing module for import decl");
2388  return {ImportAction::None};
2389 }
2390 
2391 /// HandleIncludeNextDirective - Implements \#include_next.
2392 ///
2393 void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc,
2394  Token &IncludeNextTok) {
2395  Diag(IncludeNextTok, diag::ext_pp_include_next_directive);
2396 
2397  // #include_next is like #include, except that we start searching after
2398  // the current found directory. If we can't do this, issue a
2399  // diagnostic.
2400  const DirectoryLookup *Lookup = CurDirLookup;
2401  const FileEntry *LookupFromFile = nullptr;
2402  if (isInPrimaryFile() && LangOpts.IsHeaderFile) {
2403  // If the main file is a header, then it's either for PCH/AST generation,
2404  // or libclang opened it. Either way, handle it as a normal include below
2405  // and do not complain about include_next.
2406  } else if (isInPrimaryFile()) {
2407  Lookup = nullptr;
2408  Diag(IncludeNextTok, diag::pp_include_next_in_primary);
2409  } else if (CurLexerSubmodule) {
2410  // Start looking up in the directory *after* the one in which the current
2411  // file would be found, if any.
2412  assert(CurPPLexer && "#include_next directive in macro?");
2413  LookupFromFile = CurPPLexer->getFileEntry();
2414  Lookup = nullptr;
2415  } else if (!Lookup) {
2416  // The current file was not found by walking the include path. Either it
2417  // is the primary file (handled above), or it was found by absolute path,
2418  // or it was found relative to such a file.
2419  // FIXME: Track enough information so we know which case we're in.
2420  Diag(IncludeNextTok, diag::pp_include_next_absolute_path);
2421  } else {
2422  // Start looking up in the next directory.
2423  ++Lookup;
2424  }
2425 
2426  return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup,
2427  LookupFromFile);
2428 }
2429 
2430 /// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode
2431 void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) {
2432  // The Microsoft #import directive takes a type library and generates header
2433  // files from it, and includes those. This is beyond the scope of what clang
2434  // does, so we ignore it and error out. However, #import can optionally have
2435  // trailing attributes that span multiple lines. We're going to eat those
2436  // so we can continue processing from there.
2437  Diag(Tok, diag::err_pp_import_directive_ms );
2438 
2439  // Read tokens until we get to the end of the directive. Note that the
2440  // directive can be split over multiple lines using the backslash character.
2442 }
2443 
2444 /// HandleImportDirective - Implements \#import.
2445 ///
2446 void Preprocessor::HandleImportDirective(SourceLocation HashLoc,
2447  Token &ImportTok) {
2448  if (!LangOpts.ObjC) { // #import is standard for ObjC.
2449  if (LangOpts.MSVCCompat)
2450  return HandleMicrosoftImportDirective(ImportTok);
2451  Diag(ImportTok, diag::ext_pp_import_directive);
2452  }
2453  return HandleIncludeDirective(HashLoc, ImportTok);
2454 }
2455 
2456 /// HandleIncludeMacrosDirective - The -imacros command line option turns into a
2457 /// pseudo directive in the predefines buffer. This handles it by sucking all
2458 /// tokens through the preprocessor and discarding them (only keeping the side
2459 /// effects on the preprocessor).
2460 void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc,
2461  Token &IncludeMacrosTok) {
2462  // This directive should only occur in the predefines buffer. If not, emit an
2463  // error and reject it.
2464  SourceLocation Loc = IncludeMacrosTok.getLocation();
2465  if (SourceMgr.getBufferName(Loc) != "<built-in>") {
2466  Diag(IncludeMacrosTok.getLocation(),
2467  diag::pp_include_macros_out_of_predefines);
2469  return;
2470  }
2471 
2472  // Treat this as a normal #include for checking purposes. If this is
2473  // successful, it will push a new lexer onto the include stack.
2474  HandleIncludeDirective(HashLoc, IncludeMacrosTok);
2475 
2476  Token TmpTok;
2477  do {
2478  Lex(TmpTok);
2479  assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!");
2480  } while (TmpTok.isNot(tok::hashhash));
2481 }
2482 
2483 //===----------------------------------------------------------------------===//
2484 // Preprocessor Macro Directive Handling.
2485 //===----------------------------------------------------------------------===//
2486 
2487 /// ReadMacroParameterList - The ( starting a parameter list of a macro
2488 /// definition has just been read. Lex the rest of the parameters and the
2489 /// closing ), updating MI with what we learn. Return true if an error occurs
2490 /// parsing the param list.
2491 bool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {
2493 
2494  while (true) {
2495  LexUnexpandedToken(Tok);
2496  switch (Tok.getKind()) {
2497  case tok::r_paren:
2498  // Found the end of the parameter list.
2499  if (Parameters.empty()) // #define FOO()
2500  return false;
2501  // Otherwise we have #define FOO(A,)
2502  Diag(Tok, diag::err_pp_expected_ident_in_arg_list);
2503  return true;
2504  case tok::ellipsis: // #define X(... -> C99 varargs
2505  if (!LangOpts.C99)
2506  Diag(Tok, LangOpts.CPlusPlus11 ?
2507  diag::warn_cxx98_compat_variadic_macro :
2508  diag::ext_variadic_macro);
2509 
2510  // OpenCL v1.2 s6.9.e: variadic macros are not supported.
2511  if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus) {
2512  Diag(Tok, diag::ext_pp_opencl_variadic_macros);
2513  }
2514 
2515  // Lex the token after the identifier.
2516  LexUnexpandedToken(Tok);
2517  if (Tok.isNot(tok::r_paren)) {
2518  Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2519  return true;
2520  }
2521  // Add the __VA_ARGS__ identifier as a parameter.
2522  Parameters.push_back(Ident__VA_ARGS__);
2523  MI->setIsC99Varargs();
2524  MI->setParameterList(Parameters, BP);
2525  return false;
2526  case tok::eod: // #define X(
2527  Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2528  return true;
2529  default:
2530  // Handle keywords and identifiers here to accept things like
2531  // #define Foo(for) for.
2532  IdentifierInfo *II = Tok.getIdentifierInfo();
2533  if (!II) {
2534  // #define X(1
2535  Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);
2536  return true;
2537  }
2538 
2539  // If this is already used as a parameter, it is used multiple times (e.g.
2540  // #define X(A,A.
2541  if (llvm::is_contained(Parameters, II)) { // C99 6.10.3p6
2542  Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II;
2543  return true;
2544  }
2545 
2546  // Add the parameter to the macro info.
2547  Parameters.push_back(II);
2548 
2549  // Lex the token after the identifier.
2550  LexUnexpandedToken(Tok);
2551 
2552  switch (Tok.getKind()) {
2553  default: // #define X(A B
2554  Diag(Tok, diag::err_pp_expected_comma_in_arg_list);
2555  return true;
2556  case tok::r_paren: // #define X(A)
2557  MI->setParameterList(Parameters, BP);
2558  return false;
2559  case tok::comma: // #define X(A,
2560  break;
2561  case tok::ellipsis: // #define X(A... -> GCC extension
2562  // Diagnose extension.
2563  Diag(Tok, diag::ext_named_variadic_macro);
2564 
2565  // Lex the token after the identifier.
2566  LexUnexpandedToken(Tok);
2567  if (Tok.isNot(tok::r_paren)) {
2568  Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
2569  return true;
2570  }
2571 
2572  MI->setIsGNUVarargs();
2573  MI->setParameterList(Parameters, BP);
2574  return false;
2575  }
2576  }
2577  }
2578 }
2579 
2580 static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI,
2581  const LangOptions &LOptions) {
2582  if (MI->getNumTokens() == 1) {
2583  const Token &Value = MI->getReplacementToken(0);
2584 
2585  // Macro that is identity, like '#define inline inline' is a valid pattern.
2586  if (MacroName.getKind() == Value.getKind())
2587  return true;
2588 
2589  // Macro that maps a keyword to the same keyword decorated with leading/
2590  // trailing underscores is a valid pattern:
2591  // #define inline __inline
2592  // #define inline __inline__
2593  // #define inline _inline (in MS compatibility mode)
2594  StringRef MacroText = MacroName.getIdentifierInfo()->getName();
2595  if (IdentifierInfo *II = Value.getIdentifierInfo()) {
2596  if (!II->isKeyword(LOptions))
2597  return false;
2598  StringRef ValueText = II->getName();
2599  StringRef TrimmedValue = ValueText;
2600  if (!ValueText.startswith("__")) {
2601  if (ValueText.startswith("_"))
2602  TrimmedValue = TrimmedValue.drop_front(1);
2603  else
2604  return false;
2605  } else {
2606  TrimmedValue = TrimmedValue.drop_front(2);
2607  if (TrimmedValue.endswith("__"))
2608  TrimmedValue = TrimmedValue.drop_back(2);
2609  }
2610  return TrimmedValue.equals(MacroText);
2611  } else {
2612  return false;
2613  }
2614  }
2615 
2616  // #define inline
2617  return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static,
2618  tok::kw_const) &&
2619  MI->getNumTokens() == 0;
2620 }
2621 
2622 // ReadOptionalMacroParameterListAndBody - This consumes all (i.e. the
2623 // entire line) of the macro's tokens and adds them to MacroInfo, and while
2624 // doing so performs certain validity checks including (but not limited to):
2625 // - # (stringization) is followed by a macro parameter
2626 //
2627 // Returns a nullptr if an invalid sequence of tokens is encountered or returns
2628 // a pointer to a MacroInfo object.
2629 
2630 MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(
2631  const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {
2632 
2633  Token LastTok = MacroNameTok;
2634  // Create the new macro.
2635  MacroInfo *const MI = AllocateMacroInfo(MacroNameTok.getLocation());
2636 
2637  Token Tok;
2638  LexUnexpandedToken(Tok);
2639 
2640  // Ensure we consume the rest of the macro body if errors occur.
2641  auto _ = llvm::make_scope_exit([&]() {
2642  // The flag indicates if we are still waiting for 'eod'.
2643  if (CurLexer->ParsingPreprocessorDirective)
2645  });
2646 
2647  // Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk
2648  // within their appropriate context.
2650 
2651  // If this is a function-like macro definition, parse the argument list,
2652  // marking each of the identifiers as being used as macro arguments. Also,
2653  // check other constraints on the first token of the macro body.
2654  if (Tok.is(tok::eod)) {
2655  if (ImmediatelyAfterHeaderGuard) {
2656  // Save this macro information since it may part of a header guard.
2657  CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(),
2658  MacroNameTok.getLocation());
2659  }
2660  // If there is no body to this macro, we have no special handling here.
2661  } else if (Tok.hasLeadingSpace()) {
2662  // This is a normal token with leading space. Clear the leading space
2663  // marker on the first token to get proper expansion.
2665  } else if (Tok.is(tok::l_paren)) {
2666  // This is a function-like macro definition. Read the argument list.
2667  MI->setIsFunctionLike();
2668  if (ReadMacroParameterList(MI, LastTok))
2669  return nullptr;
2670 
2671  // If this is a definition of an ISO C/C++ variadic function-like macro (not
2672  // using the GNU named varargs extension) inform our variadic scope guard
2673  // which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__)
2674  // allowed only within the definition of a variadic macro.
2675 
2676  if (MI->isC99Varargs()) {
2678  }
2679 
2680  // Read the first token after the arg list for down below.
2681  LexUnexpandedToken(Tok);
2682  } else if (LangOpts.C99 || LangOpts.CPlusPlus11) {
2683  // C99 requires whitespace between the macro definition and the body. Emit
2684  // a diagnostic for something like "#define X+".
2685  Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);
2686  } else {
2687  // C90 6.8 TC1 says: "In the definition of an object-like macro, if the
2688  // first character of a replacement list is not a character required by
2689  // subclause 5.2.1, then there shall be white-space separation between the
2690  // identifier and the replacement list.". 5.2.1 lists this set:
2691  // "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which
2692  // is irrelevant here.
2693  bool isInvalid = false;
2694  if (Tok.is(tok::at)) // @ is not in the list above.
2695  isInvalid = true;
2696  else if (Tok.is(tok::unknown)) {
2697  // If we have an unknown token, it is something strange like "`". Since
2698  // all of valid characters would have lexed into a single character
2699  // token of some sort, we know this is not a valid case.
2700  isInvalid = true;
2701  }
2702  if (isInvalid)
2703  Diag(Tok, diag::ext_missing_whitespace_after_macro_name);
2704  else
2705  Diag(Tok, diag::warn_missing_whitespace_after_macro_name);
2706  }
2707 
2708  if (!Tok.is(tok::eod))
2709  LastTok = Tok;
2710 
2711  // Read the rest of the macro body.
2712  if (MI->isObjectLike()) {
2713  // Object-like macros are very simple, just read their body.
2714  while (Tok.isNot(tok::eod)) {
2715  LastTok = Tok;
2716  MI->AddTokenToBody(Tok);
2717  // Get the next token of the macro.
2718  LexUnexpandedToken(Tok);
2719  }
2720  } else {
2721  // Otherwise, read the body of a function-like macro. While we are at it,
2722  // check C99 6.10.3.2p1: ensure that # operators are followed by macro
2723  // parameters in function-like macro expansions.
2724 
2725  VAOptDefinitionContext VAOCtx(*this);
2726 
2727  while (Tok.isNot(tok::eod)) {
2728  LastTok = Tok;
2729 
2730  if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {
2731  MI->AddTokenToBody(Tok);
2732 
2733  if (VAOCtx.isVAOptToken(Tok)) {
2734  // If we're already within a VAOPT, emit an error.
2735  if (VAOCtx.isInVAOpt()) {
2736  Diag(Tok, diag::err_pp_vaopt_nested_use);
2737  return nullptr;
2738  }
2739  // Ensure VAOPT is followed by a '(' .
2740  LexUnexpandedToken(Tok);
2741  if (Tok.isNot(tok::l_paren)) {
2742  Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use);
2743  return nullptr;
2744  }
2745  MI->AddTokenToBody(Tok);
2746  VAOCtx.sawVAOptFollowedByOpeningParens(Tok.getLocation());
2747  LexUnexpandedToken(Tok);
2748  if (Tok.is(tok::hashhash)) {
2749  Diag(Tok, diag::err_vaopt_paste_at_start);
2750  return nullptr;
2751  }
2752  continue;
2753  } else if (VAOCtx.isInVAOpt()) {
2754  if (Tok.is(tok::r_paren)) {
2755  if (VAOCtx.sawClosingParen()) {
2756  const unsigned NumTokens = MI->getNumTokens();
2757  assert(NumTokens >= 3 && "Must have seen at least __VA_OPT__( "
2758  "and a subsequent tok::r_paren");
2759  if (MI->getReplacementToken(NumTokens - 2).is(tok::hashhash)) {
2760  Diag(Tok, diag::err_vaopt_paste_at_end);
2761  return nullptr;
2762  }
2763  }
2764  } else if (Tok.is(tok::l_paren)) {
2765  VAOCtx.sawOpeningParen(Tok.getLocation());
2766  }
2767  }
2768  // Get the next token of the macro.
2769  LexUnexpandedToken(Tok);
2770  continue;
2771  }
2772 
2773  // If we're in -traditional mode, then we should ignore stringification
2774  // and token pasting. Mark the tokens as unknown so as not to confuse
2775  // things.
2776  if (getLangOpts().TraditionalCPP) {
2777  Tok.setKind(tok::unknown);
2778  MI->AddTokenToBody(Tok);
2779 
2780  // Get the next token of the macro.
2781  LexUnexpandedToken(Tok);
2782  continue;
2783  }
2784 
2785  if (Tok.is(tok::hashhash)) {
2786  // If we see token pasting, check if it looks like the gcc comma
2787  // pasting extension. We'll use this information to suppress
2788  // diagnostics later on.
2789 
2790  // Get the next token of the macro.
2791  LexUnexpandedToken(Tok);
2792 
2793  if (Tok.is(tok::eod)) {
2794  MI->AddTokenToBody(LastTok);
2795  break;
2796  }
2797 
2798  unsigned NumTokens = MI->getNumTokens();
2799  if (NumTokens && Tok.getIdentifierInfo() == Ident__VA_ARGS__ &&
2800  MI->getReplacementToken(NumTokens-1).is(tok::comma))
2801  MI->setHasCommaPasting();
2802 
2803  // Things look ok, add the '##' token to the macro.
2804  MI->AddTokenToBody(LastTok);
2805  continue;
2806  }
2807 
2808  // Our Token is a stringization operator.
2809  // Get the next token of the macro.
2810  LexUnexpandedToken(Tok);
2811 
2812  // Check for a valid macro arg identifier or __VA_OPT__.
2813  if (!VAOCtx.isVAOptToken(Tok) &&
2814  (Tok.getIdentifierInfo() == nullptr ||
2815  MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) {
2816 
2817  // If this is assembler-with-cpp mode, we accept random gibberish after
2818  // the '#' because '#' is often a comment character. However, change
2819  // the kind of the token to tok::unknown so that the preprocessor isn't
2820  // confused.
2821  if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) {
2822  LastTok.setKind(tok::unknown);
2823  MI->AddTokenToBody(LastTok);
2824  continue;
2825  } else {
2826  Diag(Tok, diag::err_pp_stringize_not_parameter)
2827  << LastTok.is(tok::hashat);
2828  return nullptr;
2829  }
2830  }
2831 
2832  // Things look ok, add the '#' and param name tokens to the macro.
2833  MI->AddTokenToBody(LastTok);
2834 
2835  // If the token following '#' is VAOPT, let the next iteration handle it
2836  // and check it for correctness, otherwise add the token and prime the
2837  // loop with the next one.
2838  if (!VAOCtx.isVAOptToken(Tok)) {
2839  MI->AddTokenToBody(Tok);
2840  LastTok = Tok;
2841 
2842  // Get the next token of the macro.
2843  LexUnexpandedToken(Tok);
2844  }
2845  }
2846  if (VAOCtx.isInVAOpt()) {
2847  assert(Tok.is(tok::eod) && "Must be at End Of preprocessing Directive");
2848  Diag(Tok, diag::err_pp_expected_after)
2849  << LastTok.getKind() << tok::r_paren;
2850  Diag(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren;
2851  return nullptr;
2852  }
2853  }
2854  MI->setDefinitionEndLoc(LastTok.getLocation());
2855  return MI;
2856 }
2857 /// HandleDefineDirective - Implements \#define. This consumes the entire macro
2858 /// line then lets the caller lex the next real token.
2859 void Preprocessor::HandleDefineDirective(
2860  Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) {
2861  ++NumDefined;
2862 
2863  Token MacroNameTok;
2864  bool MacroShadowsKeyword;
2865  ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);
2866 
2867  // Error reading macro name? If so, diagnostic already issued.
2868  if (MacroNameTok.is(tok::eod))
2869  return;
2870 
2871  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
2872  // Issue a final pragma warning if we're defining a macro that was has been
2873  // undefined and is being redefined.
2874  if (!II->hasMacroDefinition() && II->hadMacroDefinition() && II->isFinal())
2875  emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/false);
2876 
2877  // If we are supposed to keep comments in #defines, reenable comment saving
2878  // mode.
2879  if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);
2880 
2881  MacroInfo *const MI = ReadOptionalMacroParameterListAndBody(
2882  MacroNameTok, ImmediatelyAfterHeaderGuard);
2883 
2884  if (!MI) return;
2885 
2886  if (MacroShadowsKeyword &&
2887  !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) {
2888  Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword);
2889  }
2890  // Check that there is no paste (##) operator at the beginning or end of the
2891  // replacement list.
2892  unsigned NumTokens = MI->getNumTokens();
2893  if (NumTokens != 0) {
2894  if (MI->getReplacementToken(0).is(tok::hashhash)) {
2895  Diag(MI->getReplacementToken(0), diag::err_paste_at_start);
2896  return;
2897  }
2898  if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) {
2899  Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end);
2900  return;
2901  }
2902  }
2903 
2904  // When skipping just warn about macros that do not match.
2905  if (SkippingUntilPCHThroughHeader) {
2906  const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo());
2907  if (!OtherMI || !MI->isIdenticalTo(*OtherMI, *this,
2908  /*Syntactic=*/LangOpts.MicrosoftExt))
2909  Diag(MI->getDefinitionLoc(), diag::warn_pp_macro_def_mismatch_with_pch)
2910  << MacroNameTok.getIdentifierInfo();
2911  // Issue the diagnostic but allow the change if msvc extensions are enabled
2912  if (!LangOpts.MicrosoftExt)
2913  return;
2914  }
2915 
2916  // Finally, if this identifier already had a macro defined for it, verify that
2917  // the macro bodies are identical, and issue diagnostics if they are not.
2918  if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) {
2919  // Final macros are hard-mode: they always warn. Even if the bodies are
2920  // identical. Even if they are in system headers. Even if they are things we
2921  // would silently allow in the past.
2922  if (MacroNameTok.getIdentifierInfo()->isFinal())
2923  emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/false);
2924 
2925  // In Objective-C, ignore attempts to directly redefine the builtin
2926  // definitions of the ownership qualifiers. It's still possible to
2927  // #undef them.
2928  auto isObjCProtectedMacro = [](const IdentifierInfo *II) -> bool {
2929  return II->isStr("__strong") ||
2930  II->isStr("__weak") ||
2931  II->isStr("__unsafe_unretained") ||
2932  II->isStr("__autoreleasing");
2933  };
2934  if (getLangOpts().ObjC &&
2935  SourceMgr.getFileID(OtherMI->getDefinitionLoc())
2936  == getPredefinesFileID() &&
2937  isObjCProtectedMacro(MacroNameTok.getIdentifierInfo())) {
2938  // Warn if it changes the tokens.
2939  if ((!getDiagnostics().getSuppressSystemWarnings() ||
2940  !SourceMgr.isInSystemHeader(DefineTok.getLocation())) &&
2941  !MI->isIdenticalTo(*OtherMI, *this,
2942  /*Syntactic=*/LangOpts.MicrosoftExt)) {
2943  Diag(MI->getDefinitionLoc(), diag::warn_pp_objc_macro_redef_ignored);
2944  }
2945  assert(!OtherMI->isWarnIfUnused());
2946  return;
2947  }
2948 
2949  // It is very common for system headers to have tons of macro redefinitions
2950  // and for warnings to be disabled in system headers. If this is the case,
2951  // then don't bother calling MacroInfo::isIdenticalTo.
2952  if (!getDiagnostics().getSuppressSystemWarnings() ||
2953  !SourceMgr.isInSystemHeader(DefineTok.getLocation())) {
2954 
2955  if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())
2956  Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);
2957 
2958  // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and
2959  // C++ [cpp.predefined]p4, but allow it as an extension.
2960  if (OtherMI->isBuiltinMacro())
2961  Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro);
2962  // Macros must be identical. This means all tokens and whitespace
2963  // separation must be the same. C99 6.10.3p2.
2964  else if (!OtherMI->isAllowRedefinitionsWithoutWarning() &&
2965  !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) {
2966  Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef)
2967  << MacroNameTok.getIdentifierInfo();
2968  Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition);
2969  }
2970  }
2971  if (OtherMI->isWarnIfUnused())
2972  WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc());
2973  }
2974 
2975  DefMacroDirective *MD =
2976  appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI);
2977 
2978  assert(!MI->isUsed());
2979  // If we need warning for not using the macro, add its location in the
2980  // warn-because-unused-macro set. If it gets used it will be removed from set.
2982  !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc()) &&
2983  !MacroExpansionInDirectivesOverride &&
2984  getSourceManager().getFileID(MI->getDefinitionLoc()) !=
2985  getPredefinesFileID()) {
2986  MI->setIsWarnIfUnused(true);
2987  WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());
2988  }
2989 
2990  // If the callbacks want to know, tell them about the macro definition.
2991  if (Callbacks)
2992  Callbacks->MacroDefined(MacroNameTok, MD);
2993 
2994  // If we're in MS compatibility mode and the macro being defined is the
2995  // assert macro, implicitly add a macro definition for static_assert to work
2996  // around their broken assert.h header file in C. Only do so if there isn't
2997  // already a static_assert macro defined.
2998  if (!getLangOpts().CPlusPlus && getLangOpts().MSVCCompat &&
2999  MacroNameTok.getIdentifierInfo()->isStr("assert") &&
3000  !isMacroDefined("static_assert")) {
3002 
3003  Token Tok;
3004  Tok.startToken();
3005  Tok.setKind(tok::kw__Static_assert);
3006  Tok.setIdentifierInfo(getIdentifierInfo("_Static_assert"));
3007  MI->AddTokenToBody(Tok);
3008  (void)appendDefMacroDirective(getIdentifierInfo("static_assert"), MI);
3009  }
3010 }
3011 
3012 /// HandleUndefDirective - Implements \#undef.
3013 ///
3014 void Preprocessor::HandleUndefDirective() {
3015  ++NumUndefined;
3016 
3017  Token MacroNameTok;
3018  ReadMacroName(MacroNameTok, MU_Undef);
3019 
3020  // Error reading macro name? If so, diagnostic already issued.
3021  if (MacroNameTok.is(tok::eod))
3022  return;
3023 
3024  // Check to see if this is the last token on the #undef line.
3025  CheckEndOfDirective("undef");
3026 
3027  // Okay, we have a valid identifier to undef.
3028  auto *II = MacroNameTok.getIdentifierInfo();
3029  auto MD = getMacroDefinition(II);
3030  UndefMacroDirective *Undef = nullptr;
3031 
3032  if (II->isFinal())
3033  emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/true);
3034 
3035  // If the macro is not defined, this is a noop undef.
3036  if (const MacroInfo *MI = MD.getMacroInfo()) {
3037  if (!MI->isUsed() && MI->isWarnIfUnused())
3038  Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
3039 
3040  if (MI->isWarnIfUnused())
3041  WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
3042 
3043  Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation());
3044  }
3045 
3046  // If the callbacks want to know, tell them about the macro #undef.
3047  // Note: no matter if the macro was defined or not.
3048  if (Callbacks)
3049  Callbacks->MacroUndefined(MacroNameTok, MD, Undef);
3050 
3051  if (Undef)
3052  appendMacroDirective(II, Undef);
3053 }
3054 
3055 //===----------------------------------------------------------------------===//
3056 // Preprocessor Conditional Directive Handling.
3057 //===----------------------------------------------------------------------===//
3058 
3059 /// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive. isIfndef
3060 /// is true when this is a \#ifndef directive. ReadAnyTokensBeforeDirective is
3061 /// true if any tokens have been returned or pp-directives activated before this
3062 /// \#ifndef has been lexed.
3063 ///
3064 void Preprocessor::HandleIfdefDirective(Token &Result,
3065  const Token &HashToken,
3066  bool isIfndef,
3067  bool ReadAnyTokensBeforeDirective) {
3068  ++NumIf;
3069  Token DirectiveTok = Result;
3070 
3071  Token MacroNameTok;
3072  ReadMacroName(MacroNameTok);
3073 
3074  // Error reading macro name? If so, diagnostic already issued.
3075  if (MacroNameTok.is(tok::eod)) {
3076  // Skip code until we get to #endif. This helps with recovery by not
3077  // emitting an error when the #endif is reached.
3078  SkipExcludedConditionalBlock(HashToken.getLocation(),
3079  DirectiveTok.getLocation(),
3080  /*Foundnonskip*/ false, /*FoundElse*/ false);
3081  return;
3082  }
3083 
3084  emitMacroExpansionWarnings(MacroNameTok);
3085 
3086  // Check to see if this is the last token on the #if[n]def line.
3087  CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef");
3088 
3089  IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
3090  auto MD = getMacroDefinition(MII);
3091  MacroInfo *MI = MD.getMacroInfo();
3092 
3093  if (CurPPLexer->getConditionalStackDepth() == 0) {
3094  // If the start of a top-level #ifdef and if the macro is not defined,
3095  // inform MIOpt that this might be the start of a proper include guard.
3096  // Otherwise it is some other form of unknown conditional which we can't
3097  // handle.
3098  if (!ReadAnyTokensBeforeDirective && !MI) {
3099  assert(isIfndef && "#ifdef shouldn't reach here");
3100  CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation());
3101  } else
3102  CurPPLexer->MIOpt.EnterTopLevelConditional();
3103  }
3104 
3105  // If there is a macro, process it.
3106  if (MI) // Mark it used.
3107  markMacroAsUsed(MI);
3108 
3109  if (Callbacks) {
3110  if (isIfndef)
3111  Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD);
3112  else
3113  Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD);
3114  }
3115 
3116  bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
3117  getSourceManager().isInMainFile(DirectiveTok.getLocation());
3118 
3119  // Should we include the stuff contained by this directive?
3120  if (PPOpts->SingleFileParseMode && !MI) {
3121  // In 'single-file-parse mode' undefined identifiers trigger parsing of all
3122  // the directive blocks.
3123  CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
3124  /*wasskip*/false, /*foundnonskip*/false,
3125  /*foundelse*/false);
3126  } else if (!MI == isIfndef || RetainExcludedCB) {
3127  // Yes, remember that we are inside a conditional, then lex the next token.
3128  CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
3129  /*wasskip*/false, /*foundnonskip*/true,
3130  /*foundelse*/false);
3131  } else {
3132  // No, skip the contents of this block.
3133  SkipExcludedConditionalBlock(HashToken.getLocation(),
3134  DirectiveTok.getLocation(),
3135  /*Foundnonskip*/ false,
3136  /*FoundElse*/ false);
3137  }
3138 }
3139 
3140 /// HandleIfDirective - Implements the \#if directive.
3141 ///
3142 void Preprocessor::HandleIfDirective(Token &IfToken,
3143  const Token &HashToken,
3144  bool ReadAnyTokensBeforeDirective) {
3145  ++NumIf;
3146 
3147  // Parse and evaluate the conditional expression.
3148  IdentifierInfo *IfNDefMacro = nullptr;
3149  const DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);
3150  const bool ConditionalTrue = DER.Conditional;
3151  // Lexer might become invalid if we hit code completion point while evaluating
3152  // expression.
3153  if (!CurPPLexer)
3154  return;
3155 
3156  // If this condition is equivalent to #ifndef X, and if this is the first
3157  // directive seen, handle it for the multiple-include optimization.
3158  if (CurPPLexer->getConditionalStackDepth() == 0) {
3159  if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)
3160  // FIXME: Pass in the location of the macro name, not the 'if' token.
3161  CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation());
3162  else
3163  CurPPLexer->MIOpt.EnterTopLevelConditional();
3164  }
3165 
3166  if (Callbacks)
3167  Callbacks->If(
3168  IfToken.getLocation(), DER.ExprRange,
3169  (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));
3170 
3171  bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
3173 
3174  // Should we include the stuff contained by this directive?
3175  if (PPOpts->SingleFileParseMode && DER.IncludedUndefinedIds) {
3176  // In 'single-file-parse mode' undefined identifiers trigger parsing of all
3177  // the directive blocks.
3178  CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
3179  /*foundnonskip*/false, /*foundelse*/false);
3180  } else if (ConditionalTrue || RetainExcludedCB) {
3181  // Yes, remember that we are inside a conditional, then lex the next token.
3182  CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
3183  /*foundnonskip*/true, /*foundelse*/false);
3184  } else {
3185  // No, skip the contents of this block.
3186  SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(),
3187  /*Foundnonskip*/ false,
3188  /*FoundElse*/ false);
3189  }
3190 }
3191 
3192 /// HandleEndifDirective - Implements the \#endif directive.
3193 ///
3194 void Preprocessor::HandleEndifDirective(Token &EndifToken) {
3195  ++NumEndif;
3196 
3197  // Check that this is the whole directive.
3198  CheckEndOfDirective("endif");
3199 
3200  PPConditionalInfo CondInfo;
3201  if (CurPPLexer->popConditionalLevel(CondInfo)) {
3202  // No conditionals on the stack: this is an #endif without an #if.
3203  Diag(EndifToken, diag::err_pp_endif_without_if);
3204  return;
3205  }
3206 
3207  // If this the end of a top-level #endif, inform MIOpt.
3208  if (CurPPLexer->getConditionalStackDepth() == 0)
3209  CurPPLexer->MIOpt.ExitTopLevelConditional();
3210 
3211  assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode &&
3212  "This code should only be reachable in the non-skipping case!");
3213 
3214  if (Callbacks)
3215  Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc);
3216 }
3217 
3218 /// HandleElseDirective - Implements the \#else directive.
3219 ///
3220 void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) {
3221  ++NumElse;
3222 
3223  // #else directive in a non-skipping conditional... start skipping.
3224  CheckEndOfDirective("else");
3225 
3226  PPConditionalInfo CI;
3227  if (CurPPLexer->popConditionalLevel(CI)) {
3228  Diag(Result, diag::pp_err_else_without_if);
3229  return;
3230  }
3231 
3232  // If this is a top-level #else, inform the MIOpt.
3233  if (CurPPLexer->getConditionalStackDepth() == 0)
3234  CurPPLexer->MIOpt.EnterTopLevelConditional();
3235 
3236  // If this is a #else with a #else before it, report the error.
3237  if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);
3238 
3239  if (Callbacks)
3240  Callbacks->Else(Result.getLocation(), CI.IfLoc);
3241 
3242  bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
3244 
3245  if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {
3246  // In 'single-file-parse mode' undefined identifiers trigger parsing of all
3247  // the directive blocks.
3248  CurPPLexer->pushConditionalLevel(CI.IfLoc, /*wasskip*/false,
3249  /*foundnonskip*/false, /*foundelse*/true);
3250  return;
3251  }
3252 
3253  // Finally, skip the rest of the contents of this block.
3254  SkipExcludedConditionalBlock(HashToken.getLocation(), CI.IfLoc,
3255  /*Foundnonskip*/ true,
3256  /*FoundElse*/ true, Result.getLocation());
3257 }
3258 
3259 /// Implements the \#elif, \#elifdef, and \#elifndef directives.
3260 void Preprocessor::HandleElifFamilyDirective(Token &ElifToken,
3261  const Token &HashToken,
3263  PPElifDiag DirKind = Kind == tok::pp_elif ? PED_Elif
3265  : PED_Elifndef;
3266  ++NumElse;
3267 
3268  // #elif directive in a non-skipping conditional... start skipping.
3269  // We don't care what the condition is, because we will always skip it (since
3270  // the block immediately before it was included).
3271  SourceRange ConditionRange = DiscardUntilEndOfDirective();
3272 
3273  PPConditionalInfo CI;
3274  if (CurPPLexer->popConditionalLevel(CI)) {
3275  Diag(ElifToken, diag::pp_err_elif_without_if) << DirKind;
3276  return;
3277  }
3278 
3279  // If this is a top-level #elif, inform the MIOpt.
3280  if (CurPPLexer->getConditionalStackDepth() == 0)
3281  CurPPLexer->MIOpt.EnterTopLevelConditional();
3282 
3283  // If this is a #elif with a #else before it, report the error.
3284  if (CI.FoundElse)
3285  Diag(ElifToken, diag::pp_err_elif_after_else) << DirKind;
3286 
3287  if (Callbacks) {
3288  switch (Kind) {
3289  case tok::pp_elif:
3290  Callbacks->Elif(ElifToken.getLocation(), ConditionRange,
3292  break;
3293  case tok::pp_elifdef:
3294  Callbacks->Elifdef(ElifToken.getLocation(), ConditionRange, CI.IfLoc);
3295  break;
3296  case tok::pp_elifndef:
3297  Callbacks->Elifndef(ElifToken.getLocation(), ConditionRange, CI.IfLoc);
3298  break;
3299  default:
3300  assert(false && "unexpected directive kind");
3301  break;
3302  }
3303  }
3304 
3305  bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
3306  getSourceManager().isInMainFile(ElifToken.getLocation());
3307 
3308  if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {
3309  // In 'single-file-parse mode' undefined identifiers trigger parsing of all
3310  // the directive blocks.
3311  CurPPLexer->pushConditionalLevel(ElifToken.getLocation(), /*wasskip*/false,
3312  /*foundnonskip*/false, /*foundelse*/false);
3313  return;
3314  }
3315 
3316  // Finally, skip the rest of the contents of this block.
3317  SkipExcludedConditionalBlock(
3318  HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true,
3319  /*FoundElse*/ CI.FoundElse, ElifToken.getLocation());
3320 }
isInMainFile
static bool isInMainFile(const clang::Diagnostic &D)
Definition: ASTUnit.cpp:679
clang::SourceRange::setBegin
void setBegin(SourceLocation b)
Definition: SourceLocation.h:222
clang::HeaderSearch::AddSearchPath
void AddSearchPath(const DirectoryLookup &dir, bool isAngled)
Add an additional search path.
Definition: HeaderSearch.h:297
clang::Token::startToken
void startToken()
Reset all flags to cleared.
Definition: Token.h:171
clang::VariadicMacroScopeGuard
An RAII class that tracks when the Preprocessor starts and stops lexing the definition of a (ISO C/C+...
Definition: VariadicMacroSupport.h:30
clang::MacroInfo::getNumTokens
unsigned getNumTokens() const
Return the number of tokens that this macro expands to.
Definition: MacroInfo.h:233
clang::PPCallbacks::CVK_True
@ CVK_True
Definition: PPCallbacks.h:338
clang::MacroInfo::setHasCommaPasting
void setHasCommaPasting()
Definition: MacroInfo.h:218
clang::Module::Requirement
std::pair< std::string, bool > Requirement
An individual requirement: a feature name and a flag indicating the required state of that feature.
Definition: Module.h:235
clang::minimize_source_to_dependency_directives::pp_ifdef
@ pp_ifdef
Definition: DependencyDirectivesSourceMinimizer.h:47
clang::MultipleIncludeOpt::getImmediatelyAfterTopLevelIfndef
bool getImmediatelyAfterTopLevelIfndef() const
getImmediatelyAfterTopLevelIfndef - returns true if the last directive was an #ifndef at the beginnin...
Definition: MultipleIncludeOpt.h:101
clang::LangOptions::CurrentModule
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:343
PED_Elifdef
@ PED_Elifdef
Definition: PPDirectives.cpp:107
clang::IdentifierInfo::hasMacroDefinition
bool hasMacroDefinition() const
Return true if this identifier is #defined to some other value.
Definition: IdentifierTable.h:201
clang::SourceManager::isMainFile
bool isMainFile(const FileEntry &SourceFile)
Returns true when the given FileEntry corresponds to the main file.
Definition: SourceManager.cpp:354
clang::MacroInfo::setIsFunctionLike
void setIsFunctionLike()
Function/Object-likeness.
Definition: MacroInfo.h:198
clang::MacroInfo::getReplacementToken
const Token & getReplacementToken(unsigned Tok) const
Definition: MacroInfo.h:235
clang::Module::getTopLevelModule
Module * getTopLevelModule()
Retrieve the top-level module for this (sub)module, which may be this module.
Definition: Module.h:519
max
__DEVICE__ int max(int __a, int __b)
Definition: __clang_cuda_math.h:196
clang::CodeCompletionHandler::CodeCompleteMacroName
virtual void CodeCompleteMacroName(bool IsDefinition)
Callback invoked when performing code completion in a context where the name of a macro is expected.
Definition: CodeCompletionHandler.h:48
clang::HeaderSearch::getFileInfo
HeaderFileInfo & getFileInfo(const FileEntry *FE)
Return the HeaderFileInfo structure for the specified FileEntry, in preparation for updating it in so...
Definition: HeaderSearch.cpp:1224
clang::Preprocessor::AdvanceToTokenCharacter
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...
Definition: Preprocessor.h:1901
clang::Preprocessor::CheckMacroName
bool CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, bool *ShadowFlag=nullptr)
Definition: PPDirectives.cpp:269
clang::PreprocessorLexer::getConditionalStackDepth
unsigned getConditionalStackDepth() const
Definition: PreprocessorLexer.h:131
clang::SourceManager::getFileCharacteristic
SrcMgr::CharacteristicKind getFileCharacteristic(SourceLocation Loc) const
Return the file characteristic of the specified source location, indicating whether this is a normal ...
Definition: SourceManager.cpp:1469
clang::MultipleIncludeOpt::EnterTopLevelConditional
void EnterTopLevelConditional()
Invoked when a top level conditional (except #ifndef) is found.
Definition: MultipleIncludeOpt.h:142
clang::ModuleLoadResult
Describes the result of attempting to load a module.
Definition: ModuleLoader.h:35
clang::minimize_source_to_dependency_directives::pp_elifdef
@ pp_elifdef
Definition: DependencyDirectivesSourceMinimizer.h:50
warnByDefaultOnWrongCase
static bool warnByDefaultOnWrongCase(StringRef Include)
Definition: PPDirectives.cpp:196
clang::Token::hasLeadingSpace
bool hasLeadingSpace() const
Return true if this token has whitespace before it.
Definition: Token.h:272
clang::FileEntry::getDir
const DirectoryEntry * getDir() const
Return the directory the file lives in.
Definition: FileEntry.h:375
clang::Preprocessor::setCodeCompletionReached
void setCodeCompletionReached()
Note that we hit the code-completion point.
Definition: Preprocessor.h:1687
clang::ModuleMap::KnownHeader
A header that is known to reside within a given module, whether it was included or excluded.
Definition: ModuleMap.h:155
clang::Preprocessor::getMacroDefinition
MacroDefinition getMacroDefinition(const IdentifierInfo *II)
Definition: Preprocessor.h:1112
clang::DeclaratorContext::File
@ File
clang::IdentifierInfo::isFinal
bool isFinal() const
Definition: IdentifierTable.h:254
clang::HeaderSearch::HasIncludeAliasMap
bool HasIncludeAliasMap() const
Checks whether the map exists or not.
Definition: HeaderSearch.h:312
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::PIK_HashPragma
@ PIK_HashPragma
The pragma was introduced via #pragma.
Definition: Pragma.h:36
clang::MacroInfo::setDefinitionEndLoc
void setDefinitionEndLoc(SourceLocation EndLoc)
Set the location of the last token in the macro.
Definition: MacroInfo.h:126
clang::FixItHint::CreateInsertion
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:96
clang::Preprocessor::Lex
void Lex(Token &Result)
Lex the next token for this preprocessor.
Definition: Preprocessor.cpp:888
ModuleMap.h
clang::MacroInfo::isObjectLike
bool isObjectLike() const
Definition: MacroInfo.h:200
clang::SourceManager::isInMainFile
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
Definition: SourceManager.cpp:1591
PPElifDiag
PPElifDiag
Enumerates possible select values for the pp_err_elif_after_else and pp_err_elif_without_if diagnosti...
Definition: PPDirectives.cpp:105
clang::HeaderSearch::getFileDirFlavor
SrcMgr::CharacteristicKind getFileDirFlavor(const FileEntry *File)
Return whether the specified file is a normal header, a system header, or a C++ friendly system heade...
Definition: HeaderSearch.h:451
clang::Preprocessor::LookupFile
Optional< FileEntryRef > 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 *IsFrameworkFound, bool SkipCache=false)
Given a "foo" or <foo> reference, look up the indicated file.
Definition: PPDirectives.cpp:818
clang::Preprocessor::emitMacroExpansionWarnings
void emitMacroExpansionWarnings(const Token &Identifier) const
Definition: Preprocessor.h:2465
clang::Preprocessor::LexHeaderName
bool LexHeaderName(Token &Result, bool AllowMacroExpansion=true)
Lex a token, forming a header-name token if possible.
Definition: Preprocessor.cpp:988
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::DiagnosticsEngine::isIgnored
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:909
clang::Module::getFullModuleName
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:219
ReadLineMarkerFlags
static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP)
ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line marker directive.
Definition: PPDirectives.cpp:1329
clang::DirectoryEntry::getName
StringRef getName() const
Definition: DirectoryEntry.h:40
clang::HeaderSearch::hasModuleMap
bool hasModuleMap(StringRef Filename, const DirectoryEntry *Root, bool IsSystem)
Determine whether there is a module map that may map the header with the given file name to a (sub)mo...
Definition: HeaderSearch.cpp:1417
clang::Token::getEndLoc
SourceLocation getEndLoc() const
Definition: Token.h:153
clang::Preprocessor::getModuleForLocation
Module * getModuleForLocation(SourceLocation Loc)
Find the module that owns the source or header file that Loc points to.
Definition: PPDirectives.cpp:731
clang::Preprocessor::ResetMacroExpansionHelper::~ResetMacroExpansionHelper
~ResetMacroExpansionHelper()
Definition: PPDirectives.cpp:959
clang::MacroInfo::AddTokenToBody
void AddTokenToBody(const Token &Tok)
Add the specified token to the replacement text for the macro.
Definition: MacroInfo.h:248
clang::SourceManager::getBufferOrNone
llvm::Optional< llvm::MemoryBufferRef > getBufferOrNone(FileID FID, SourceLocation Loc=SourceLocation()) const
Return the buffer for the specified FileID.
Definition: SourceManager.h:1011
clang::Token::getIdentifierInfo
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:179
clang::MacroInfo::isIdenticalTo
bool isIdenticalTo(const MacroInfo &Other, Preprocessor &PP, bool Syntactically) const
Return true if the specified macro definition is equal to this macro in spelling, arguments,...
Definition: MacroInfo.cpp:74
clang::IdentifierInfo::isReserved
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine whether this is a name reserved for the implementation (C99 7.1.3, C++ [lib....
Definition: IdentifierTable.cpp:280
clang::HeaderSearch::LookupFrameworkCache
FrameworkCacheEntry & LookupFrameworkCache(StringRef FWName)
Look up the specified framework name in our framework cache.
Definition: HeaderSearch.h:436
Filename
StringRef Filename
Definition: Format.cpp:2379
clang::PreprocessorLexer::MIOpt
MultipleIncludeOpt MIOpt
A state machine that detects the #ifndef-wrapping a file idiom for the multiple-include optimization.
Definition: PreprocessorLexer.h:73
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:191
clang::TargetInfo
Exposes information about the current target.
Definition: TargetInfo.h:189
clang::MacroInfo::setParameterList
void setParameterList(ArrayRef< IdentifierInfo * > List, llvm::BumpPtrAllocator &PPAllocator)
Set the specified list of identifiers as the parameter list for this macro.
Definition: MacroInfo.h:164
memcpy
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Definition: __clang_cuda_device_functions.h:1549
Module.h
clang::Token::setAnnotationEndLoc
void setAnnotationEndLoc(SourceLocation L)
Definition: Token.h:144
clang::Token::isAtStartOfLine
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:268
clang::isLowercase
LLVM_READONLY bool isLowercase(unsigned char c)
Return true if this character is a lowercase ASCII letter: [a-z].
Definition: CharInfo.h:104
clang::Module::Name
std::string Name
The name of this module.
Definition: Module.h:99
clang::minimize_source_to_dependency_directives::pp_ifndef
@ pp_ifndef
Definition: DependencyDirectivesSourceMinimizer.h:48
clang::MultipleIncludeOpt::SetDefinedMacro
void SetDefinedMacro(IdentifierInfo *M, SourceLocation Loc)
Definition: MultipleIncludeOpt.h:78
clang::SourceManager::getExpansionRange
CharSourceRange getExpansionRange(SourceLocation Loc) const
Given a SourceLocation object, return the range of tokens covered by the expansion in the ultimate fi...
Definition: SourceManager.cpp:1038
clang::PPCallbacks::EnterFile
@ EnterFile
Definition: PPCallbacks.h:40
clang::PreprocessorLexer::pushConditionalLevel
void pushConditionalLevel(SourceLocation DirectiveStart, bool WasSkipping, bool FoundNonSkip, bool FoundElse)
pushConditionalLevel - When we enter a #if directive, this keeps track of what we are currently in fo...
Definition: PreprocessorLexer.h:101
llvm::Optional< unsigned >
clang::PresumedLoc::getIncludeLoc
SourceLocation getIncludeLoc() const
Return the presumed include location of this location.
Definition: SourceLocation.h:353
clang::minimize_source_to_dependency_directives::pp_import
@ pp_import
Definition: DependencyDirectivesSourceMinimizer.h:39
clang::ModuleLoader::HadFatalFailure
bool HadFatalFailure
Definition: ModuleLoader.h:157
clang::MacroInfo
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
SourceManager.h
clang::Token::setIdentifierInfo
void setIdentifierInfo(IdentifierInfo *II)
Definition: Token.h:188
clang::SrcMgr::CharacteristicKind
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:78
clang::minimize_source_to_dependency_directives::pp_define
@ pp_define
Definition: DependencyDirectivesSourceMinimizer.h:37
clang::PreprocessorLexer::LexingRawMode
bool LexingRawMode
True if in raw mode.
Definition: PreprocessorLexer.h:69
clang::SourceManager::AddLineNote
void AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID, bool IsFileEntry, bool IsFileExit, SrcMgr::CharacteristicKind FileKind)
Add a line note to the line table for the FileID and offset specified by Loc.
Definition: SourceManager.cpp:272
clang::toLowercase
LLVM_READONLY char toLowercase(char c)
Converts the given ASCII character to its lowercase equivalent.
Definition: CharInfo.h:169
clang::Preprocessor::getCurrentFileLexer
PreprocessorLexer * getCurrentFileLexer() const
Return the current file lexer being lexed from.
Definition: PPLexerChange.cpp:50
clang::Token
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
clang::IdentifierInfo::isCPlusPlusOperatorKeyword
bool isCPlusPlusOperatorKeyword() const
Definition: IdentifierTable.h:361
clang::PPConditionalInfo::FoundElse
bool FoundElse
True if we've seen a #else in this block.
Definition: Token.h:329
clang::FileManager::getOptionalDirectoryRef
llvm::Optional< DirectoryEntryRef > getOptionalDirectoryRef(StringRef DirName, bool CacheFailure=true)
Get a DirectoryEntryRef if it exists, without doing anything on error.
Definition: FileManager.h:168
LiteralSupport.h
clang::VisibilityMacroDirective
A directive for setting the module visibility of a macro.
Definition: MacroInfo.h:444
clang::ModuleMap::diagnoseHeaderInclusion
void diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, const FileEntry *File)
Reports errors if a module must not include a specific file.
Definition: ModuleMap.cpp:473
clang::Module::isAvailable
bool isAvailable() const
Determine whether this module is available for use within the current translation unit.
Definition: Module.h:443
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:626
clang::Preprocessor::getLangOpts
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:960
Preprocessor.h
clang::ModuleLoader::loadModule
virtual ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective)=0
Attempt to load the given module.
clang::driver::tools::arm::ReadTPMode::Invalid
@ Invalid
clang::PPCallbacks::CVK_False
@ CVK_False
Definition: PPCallbacks.h:338
clang::ModuleMap::KnownHeader::getModule
Module * getModule() const
Retrieve the module the header is stored in.
Definition: ModuleMap.h:170
clang::FixItHint
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:70
clang::Preprocessor::usingPCHWithThroughHeader
bool usingPCHWithThroughHeader()
True if using a PCH with a through header.
Definition: Preprocessor.cpp:608
clang::MacroInfo::isUsed
bool isUsed() const
Return false if this macro is defined in the main file and has not yet been used.
Definition: MacroInfo.h:222
clang::minimize_source_to_dependency_directives::pp_if
@ pp_if
Definition: DependencyDirectivesSourceMinimizer.h:46
TokenKinds.h
clang::Preprocessor::GetIncludeFilenameSpelling
bool GetIncludeFilenameSpelling(SourceLocation Loc, StringRef &Buffer)
Turn the specified lexer token into a fully checked and spelled filename, e.g.
Definition: PPDirectives.cpp:1605
U
clang::CharSourceRange::getCharRange
static CharSourceRange getCharRange(SourceRange R)
Definition: SourceLocation.h:265
clang::IdentifierInfo::isStr
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Definition: IdentifierTable.h:176
shouldWarnOnMacroDef
static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II)
Definition: PPDirectives.cpp:130
clang::syntax::NodeRole::Parameters
@ Parameters
PED_Elif
@ PED_Elif
Definition: PPDirectives.cpp:106
clang::Preprocessor::AllocateMacroInfo
MacroInfo * AllocateMacroInfo(SourceLocation L)
Allocate a new MacroInfo object with the provided SourceLocation.
Definition: PPDirectives.cpp:58
clang::MultipleIncludeOpt::getHasReadAnyTokensVal
bool getHasReadAnyTokensVal() const
getHasReadAnyTokensVal - This is used for the #ifndef handshake at the top of the file when reading p...
Definition: MultipleIncludeOpt.h:97
clang::Module
Describes a module or submodule.
Definition: Module.h:96
clang::HeaderSearch::ShouldEnterIncludeFile
bool ShouldEnterIncludeFile(Preprocessor &PP, const FileEntry *File, bool isImport, bool ModulesEnabled, Module *M, bool &IsFirstIncludeOfFile)
Mark the specified file as a target of a #include, #include_next, or #import directive.
Definition: HeaderSearch.cpp:1311
clang::Module::Hidden
@ Hidden
All of the names in this module are hidden.
Definition: Module.h:314
diagnoseAutoModuleImport
static void diagnoseAutoModuleImport(Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok, ArrayRef< std::pair< IdentifierInfo *, SourceLocation >> Path, SourceLocation PathEnd)
Produce a diagnostic informing the user that a include or similar was implicitly treated as a module ...
Definition: PPDirectives.cpp:1669
clang::Decl::getKind
Kind getKind() const
Definition: DeclBase.h:433
clang::minimize_source_to_dependency_directives::pp_include_next
@ pp_include_next
Definition: DependencyDirectivesSourceMinimizer.h:45
clang::XRayInstrKind::None
constexpr XRayInstrMask None
Definition: XRayInstr.h:38
Pragma.h
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:220
clang::SourceManager::getLineTableFilenameID
unsigned getLineTableFilenameID(StringRef Str)
Return the uniqued ID for the specified filename.
Definition: SourceManager.cpp:265
clang::Module::getTopLevelModuleName
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:529
clang::Token::getKind
tok::TokenKind getKind() const
Definition: Token.h:92
clang::Module::IsFramework
unsigned IsFramework
Whether this is a framework module.
Definition: Module.h:264
clang::SourceManager::getMainFileID
FileID getMainFileID() const
Returns the FileID of the main source file.
Definition: SourceManager.h:840
clang::CPlusPlus
@ CPlusPlus
Definition: LangStandard.h:48
clang::FileID::isValid
bool isValid() const
Definition: SourceLocation.h:44
clang::HeaderSearch::findAllModulesForHeader
ArrayRef< ModuleMap::KnownHeader > findAllModulesForHeader(const FileEntry *File) const
Retrieve all the modules corresponding to the given file.
Definition: HeaderSearch.cpp:1476
LangOptions.h
clang::Preprocessor::isPCHThroughHeader
bool isPCHThroughHeader(const FileEntry *FE)
Returns true if the FileEntry is the PCH through header.
Definition: Preprocessor.cpp:597
clang::DirectoryLookup
DirectoryLookup - This class represents one entry in the search list that specifies the search order ...
Definition: DirectoryLookup.h:30
LexDiagnostic.h
clang::FrameworkCacheEntry::Directory
const DirectoryEntry * Directory
The directory entry which should be used for the cached framework.
Definition: HeaderSearch.h:152
clang::PreprocessorLexer::peekConditionalLevel
PPConditionalInfo & peekConditionalLevel()
Return the top of the conditional stack.
Definition: PreprocessorLexer.h:126
clang::Module::DefinitionLoc
SourceLocation DefinitionLoc
The location of the module definition.
Definition: Module.h:102
clang::Preprocessor::Diag
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
Definition: Preprocessor.h:1744
ModuleLoader.h
clang::Token::is
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:97
clang::PPCallbacks::RenameFile
@ RenameFile
Definition: PPCallbacks.h:40
clang::HeaderSearch::lookupModule
Module * lookupModule(StringRef ModuleName, SourceLocation ImportLoc=SourceLocation(), bool AllowSearch=true, bool AllowExtraModuleMapSearch=false)
Lookup a module Search for a module with the given name.
Definition: HeaderSearch.cpp:246
clang::Preprocessor::getTargetInfo
const TargetInfo & getTargetInfo() const
Definition: Preprocessor.h:961
clang::SourceManager::getBufferName
StringRef getBufferName(SourceLocation Loc, bool *Invalid=nullptr) const
Return the filename or buffer identifier of the buffer the location is in.
Definition: SourceManager.cpp:1498
clang::Preprocessor::isMacroDefined
bool isMacroDefined(StringRef Id)
Definition: Preprocessor.h:1088
IdentifierTable.h
clang::Preprocessor::EnterSubmodule
void EnterSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)
Definition: PPLexerChange.cpp:689
clang::ModuleMap::findModuleForHeader
KnownHeader findModuleForHeader(const FileEntry *File, bool AllowTextual=false)
Retrieve the module that owns the given header file, if any.
Definition: ModuleMap.cpp:572
clang::SourceManager::getFileID
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
Definition: SourceManager.h:1103
clang::Token::setAnnotationValue
void setAnnotationValue(void *val)
Definition: Token.h:230
clang::PPConditionalInfo
Information about the conditional stack (#if directives) currently active.
Definition: Token.h:315
llvm::SmallString< 32 >
clang::Token::needsCleaning
bool needsCleaning() const
Return true if this token has trigraphs or escaped newlines in it.
Definition: Token.h:285
clang::FrameworkCacheEntry
This structure is used to record entries in our framework cache.
Definition: HeaderSearch.h:150
clang::PreprocessorLexer::ParsingPreprocessorDirective
bool ParsingPreprocessorDirective
True when parsing #XXX; turns '\n' into a tok::eod token.
Definition: PreprocessorLexer.h:51
clang::HeaderSearch::LookupFile
Optional< FileEntryRef > LookupFile(StringRef Filename, SourceLocation IncludeLoc, bool isAngled, const DirectoryLookup *FromDir, const DirectoryLookup *&CurDir, ArrayRef< std::pair< const FileEntry *, const DirectoryEntry * >> Includers, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool *IsFrameworkFound, bool SkipCache=false, bool BuildSystemModule=false)
Given a "foo" or <foo> reference, look up the indicated file, return null on failure.
Definition: HeaderSearch.cpp:795
clang::SourceRange::setEnd
void setEnd(SourceLocation e)
Definition: SourceLocation.h:223
isInvalid
static bool isInvalid(LocType Loc, bool *Invalid)
Definition: SourceManager.cpp:1227
clang::Preprocessor::HandleSkippedDirectiveWhileUsingPCH
void HandleSkippedDirectiveWhileUsingPCH(Token &Result, SourceLocation HashLoc)
Process directives while skipping until the through header or #pragma hdrstop is found.
Definition: PPDirectives.cpp:974
clang::SourceLocation::isFileID
bool isFileID() const
Definition: SourceLocation.h:102
clang::Module::UnresolvedHeaderDirective::FileName
std::string FileName
Definition: Module.h:218
clang::Preprocessor::getMacroInfo
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:1153
clang::ModuleLoadResult::isConfigMismatch
bool isConfigMismatch() const
Determines whether the module failed to load due to a configuration mismatch with an explicitly-named...
Definition: ModuleLoader.h:69
clang::minimize_source_to_dependency_directives::pp_include
@ pp_include
Definition: DependencyDirectivesSourceMinimizer.h:35
clang::SrcMgr::C_User
@ C_User
Definition: SourceManager.h:79
clang::minimize_source_to_dependency_directives::pp_elifndef
@ pp_elifndef
Definition: DependencyDirectivesSourceMinimizer.h:51
clang::HeaderSearch::MapHeaderToIncludeAlias
StringRef MapHeaderToIncludeAlias(StringRef Source)
Maps one header file name to a different header file name, for use with the include_alias pragma.
Definition: HeaderSearch.h:328
clang::LangOptions::IsHeaderFile
bool IsHeaderFile
Indicates whether the front-end is explicitly told that the input is a header file (i....
Definition: LangOptions.h:380
clang::Token::isNot
bool isNot(tok::TokenKind K) const
Definition: Token.h:98
clang::PreprocessorLexer::popConditionalLevel
bool popConditionalLevel(PPConditionalInfo &CI)
popConditionalLevel - Remove an entry off the top of the conditional stack, returning information abo...
Definition: PreprocessorLexer.h:117
clang::VariadicMacroScopeGuard::enterScope
void enterScope()
Client code should call this function just before the Preprocessor is about to Lex tokens from the de...
Definition: VariadicMacroSupport.h:47
clang::FileEntry
Cached information about one file (either on disk or in the virtual file system).
Definition: FileEntry.h:331
clang::ModuleLoadResult::isMissingExpected
bool isMissingExpected() const
Determines whether the module, which failed to load, was actually a submodule that we expected to see...
Definition: ModuleLoader.h:65
clang::SourceManager::getDecomposedLoc
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
Definition: SourceManager.h:1236
clang::MU_Define
@ MU_Define
Definition: Preprocessor.h:118
clang::Preprocessor::getLocalMacroDirective
MacroDirective * getLocalMacroDirective(const IdentifierInfo *II) const
Given an identifier, return its latest non-imported MacroDirective if it is #define'd and not #undef'...
Definition: Preprocessor.h:1142
clang::minimize_source_to_dependency_directives::pp_else
@ pp_else
Definition: DependencyDirectivesSourceMinimizer.h:52
clang::Token::getRawIdentifier
StringRef getRawIdentifier() const
getRawIdentifier - For a raw identifier token (i.e., an identifier lexed in raw mode),...
Definition: Token.h:205
clang::Module::Parent
Module * Parent
The parent of this module.
Definition: Module.h:124
clang::Token::getLength
unsigned getLength() const
Definition: Token.h:129
clang::Token::LeadingSpace
@ LeadingSpace
Definition: Token.h:75
clang::IdentifierInfo::isKeyword
bool isKeyword(const LangOptions &LangOpts) const
Return true if this token is a keyword in the specified language.
Definition: IdentifierTable.cpp:255
clang::DefMacroDirective
A directive for a defined macro or a macro imported from a module.
Definition: MacroInfo.h:406
clang::MU_Undef
@ MU_Undef
Definition: Preprocessor.h:121
clang::Preprocessor::getSourceManager
SourceManager & getSourceManager() const
Definition: Preprocessor.h:964
clang::UndefMacroDirective
A directive for an undefined macro.
Definition: MacroInfo.h:429
clang::PresumedLoc::isInvalid
bool isInvalid() const
Return true if this object is invalid or uninitialized.
Definition: SourceLocation.h:318
clang::Preprocessor::getSpelling
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
Definition: Preprocessor.h:1759
MD_ReservedMacro
@ MD_ReservedMacro
Definition: PPDirectives.cpp:100
clang::PPCallbacks::ExitFile
@ ExitFile
Definition: PPCallbacks.h:40
clang::MultipleIncludeOpt::EnterTopLevelIfndef
void EnterTopLevelIfndef(const IdentifierInfo *M, SourceLocation Loc)
Called when entering a top-level #ifndef directive (or the "\#if !defined" equivalent) without any pr...
Definition: MultipleIncludeOpt.h:122
SourceLocation.h
clang::ModuleMap::TextualHeader
@ TextualHeader
This header is part of the module (for layering purposes) but should be textually included.
Definition: ModuleMap.h:137
clang::PreprocessorLexer::getFileID
FileID getFileID() const
Definition: PreprocessorLexer.h:155
clang::tok::TokenKind
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
clang::Preprocessor::HandleDirective
void HandleDirective(Token &Result)
Callback invoked when the lexer sees a # token at the start of a line.
Definition: PPDirectives.cpp:999
clang::PPCallbacks::FileChangeReason
FileChangeReason
Definition: PPCallbacks.h:39
CharInfo.h
clang::HeaderSearch::LookupSubframeworkHeader
Optional< FileEntryRef > LookupSubframeworkHeader(StringRef Filename, const FileEntry *ContextFileEnt, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule)
Look up a subframework for the specified #include file.
Definition: HeaderSearch.cpp:1085
Directive
VerifyDiagnosticConsumer::Directive Directive
Definition: VerifyDiagnosticConsumer.cpp:49
clang::Preprocessor::hadModuleLoaderFatalFailure
bool hadModuleLoaderFatalFailure() const
Definition: Preprocessor.h:984
clang::MacroInfo::isC99Varargs
bool isC99Varargs() const
Definition: MacroInfo.h:205
clang::minimize_source_to_dependency_directives::pp_undef
@ pp_undef
Definition: DependencyDirectivesSourceMinimizer.h:38
clang::Preprocessor::VariadicMacroScopeGuard
friend class VariadicMacroScopeGuard
Definition: Preprocessor.h:132
clang::Preprocessor::ResetMacroExpansionHelper::ResetMacroExpansionHelper
ResetMacroExpansionHelper(Preprocessor *pp)
Definition: PPDirectives.cpp:953
clang::CodeCompletionHandler::CodeCompleteDirective
virtual void CodeCompleteDirective(bool InConditional)
Callback invoked when performing code completion for a preprocessor directive.
Definition: CodeCompletionHandler.h:37
clang::Module::IsSystem
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers).
Definition: Module.h:271
clang::HeaderFileInfo::NumIncludes
unsigned short NumIncludes
The number of times the file has been included already.
Definition: HeaderSearch.h:93
MD_NoWarn
@ MD_NoWarn
Definition: PPDirectives.cpp:98
llvm::ArrayRef
Definition: LLVM.h:34
clang::isAlphanumeric
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
Definition: CharInfo.h:122
Value
Value
Definition: UninitializedValues.cpp:102
clang::tok::PPKeywordKind
PPKeywordKind
Provides a namespace for preprocessor keywords which start with a '#' at the beginning of the line.
Definition: TokenKinds.h:33
HeaderSearch.h
clang::CharSourceRange
Represents a character-granular source range.
Definition: SourceLocation.h:253
clang::syntax::NodeRole::Message
@ Message
clang::Preprocessor::appendDefMacroDirective
DefMacroDirective * appendDefMacroDirective(IdentifierInfo *II, MacroInfo *MI, SourceLocation Loc)
Definition: Preprocessor.h:1174
clang::Preprocessor::markMacroAsUsed
void markMacroAsUsed(MacroInfo *MI)
A macro is used, update information about macros that need unused warnings.
Definition: PPMacroExpansion.cpp:1879
clang::IdentifierInfo::getPPKeywordID
tok::PPKeywordKind getPPKeywordID() const
Return the preprocessor keyword ID for this identifier.
Definition: IdentifierTable.cpp:312
clang::isReservedInAllContexts
bool isReservedInAllContexts(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved in all contexts.
Definition: IdentifierTable.h:62
isForModuleBuilding
static bool isForModuleBuilding(Module *M, StringRef CurrentModule, StringRef ModuleName)
Definition: PPDirectives.cpp:117
clang::PPConditionalInfo::WasSkipping
bool WasSkipping
True if this was contained in a skipping directive, e.g., in a "\#if 0" block.
Definition: Token.h:321
clang::VAOptDefinitionContext
A class for tracking whether we're inside a VA_OPT during a traversal of the tokens of a variadic mac...
Definition: VariadicMacroSupport.h:66
clang::Preprocessor::getCurrentModule
Module * getCurrentModule()
Retrieves the module that we're currently building, if any.
Definition: Preprocessor.cpp:517
clang::CharSourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:284
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::Token::clearFlag
void clearFlag(TokenFlags Flag)
Unset the specified flag.
Definition: Token.h:246
clang::Token::getLocation
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:126
clang::PreprocessorSkippedRangeMapping
llvm::DenseMap< unsigned, unsigned > PreprocessorSkippedRangeMapping
A mapping from an offset into a buffer to the number of bytes that can be skipped by the preprocessor...
Definition: PreprocessorExcludedConditionalDirectiveSkipMapping.h:21
clang::Preprocessor::EnterSourceFile
bool EnterSourceFile(FileID FID, const DirectoryLookup *Dir, SourceLocation Loc, bool IsFirstIncludeOfFile=true)
Add a source file to the top of the include stack and start lexing tokens from it instead of the curr...
Definition: PPLexerChange.cpp:69
clang::SourceLocation::isMacroID
bool isMacroID() const
Definition: SourceLocation.h:103
clang::Module::UnresolvedHeaderDirective::IsUmbrella
bool IsUmbrella
Definition: Module.h:219
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:58
CodeCompletionHandler.h
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::IdentifierInfo::getNameStart
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
Definition: IdentifierTable.h:189
clang::MacroInfo::getParameterNum
int getParameterNum(const IdentifierInfo *Arg) const
Return the parameter number of the specified identifier, or -1 if the identifier is not a formal para...
Definition: MacroInfo.h:189
clang::MacroInfo::setIsWarnIfUnused
void setIsWarnIfUnused(bool val)
Set the value of the IsWarnIfUnused flag.
Definition: MacroInfo.h:160
trySimplifyPath
static bool trySimplifyPath(SmallVectorImpl< StringRef > &Components, StringRef RealPathName)
Definition: PPDirectives.cpp:1721
clang::Token::setLocation
void setLocation(SourceLocation L)
Definition: Token.h:134
clang::Module::UnresolvedHeaderDirective
Stored information about a header directive that was found in the module map file but has not been re...
Definition: Module.h:215
clang::Preprocessor::ResetMacroExpansionHelper
Definition: PPDirectives.cpp:951
clang::PreprocessorLexer::getSourceLocation
virtual SourceLocation getSourceLocation()=0
Return the source location for the next observable location.
clang::MacroInfo::isAllowRedefinitionsWithoutWarning
bool isAllowRedefinitionsWithoutWarning() const
Return true if this macro can be redefined without warning.
Definition: MacroInfo.h:225
clang::IdentifierInfo::getName
StringRef getName() const
Return the actual identifier string.
Definition: IdentifierTable.h:195
clang::Builtin::ID
ID
Definition: Builtins.h:48
clang::SourceLocation::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:111
clang::MacroInfo::isBuiltinMacro
bool isBuiltinMacro() const
Return true if this macro requires processing before expansion.
Definition: MacroInfo.h:215
clang::Preprocessor::CheckEndOfDirective
SourceLocation CheckEndOfDirective(const char *DirType, bool EnableMacros=false)
Ensure that the next token is a tok::eod token.
Definition: PPDirectives.cpp:370
clang
Definition: CalledOnceCheck.h:17
clang::SrcMgr::C_ExternCSystem
@ C_ExternCSystem
Definition: SourceManager.h:81
Text
StringRef Text
Definition: Format.cpp:2380
clang::minimize_source_to_dependency_directives::pp___include_macros
@ pp___include_macros
Definition: DependencyDirectivesSourceMinimizer.h:36
clang::SourceManager::createFileID
FileID createFileID(const FileEntry *SourceFile, SourceLocation IncludePos, SrcMgr::CharacteristicKind FileCharacter, int LoadedID=0, SourceLocation::UIntTy LoadedOffset=0)
Create a new FileID that represents the specified file being #included from the specified IncludePosi...
Definition: SourceManager.cpp:532
PPCallbacks.h
clang::IdentifierInfo::hadMacroDefinition
bool hadMacroDefinition() const
Returns true if this identifier was #defined to some value at any moment.
Definition: IdentifierTable.h:226
MacroInfo.h
clang::MacroDirective
Encapsulates changes to the "macros namespace" (the location where the macro name became active,...
Definition: MacroInfo.h:290
clang::MacroDirective::getMacroInfo
const MacroInfo * getMacroInfo() const
Definition: MacroInfo.h:390
clang::Preprocessor::HandlePragmaHdrstop
void HandlePragmaHdrstop(Token &Tok)
Definition: Pragma.cpp:913
clang::Preprocessor::getDiagnostics
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:957
clang::PPConditionalInfo::IfLoc
SourceLocation IfLoc
Location where the conditional started.
Definition: Token.h:317
isConfigurationPattern
static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI, const LangOptions &LOptions)
Definition: PPDirectives.cpp:2580
clang::SourceManager::isInSystemHeader
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
Definition: SourceManager.h:1488
clang::isDigit
LLVM_READONLY bool isDigit(unsigned char c)
Return true if this character is an ASCII digit: [0-9].
Definition: CharInfo.h:98
clang::Preprocessor::DiscardUntilEndOfDirective
SourceRange DiscardUntilEndOfDirective()
Read and discard all tokens remaining on the current line until the tok::eod token is found.
Definition: PPDirectives.cpp:82
clang::MacroInfo::setIsGNUVarargs
void setIsGNUVarargs()
Definition: MacroInfo.h:204
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:38
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:110
clang::SourceManager::getFileEntryForID
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
Definition: SourceManager.h:1030
clang::Preprocessor::isInPrimaryFile
bool isInPrimaryFile() const
Return true if we're in the top-level file, not in a #include.
Definition: PPLexerChange.cpp:35
clang::CodeCompletionHandler::CodeCompleteInConditionalExclusion
virtual void CodeCompleteInConditionalExclusion()
Callback invoked when performing code completion within a block of code that was excluded due to prep...
Definition: CodeCompletionHandler.h:41
VariadicMacroSupport.h
clang::PPConditionalInfo::FoundNonSkip
bool FoundNonSkip
True if we have emitted tokens already, and now we're in an #else block or something.
Definition: Token.h:325
clang::Token::setKind
void setKind(tok::TokenKind K)
Definition: Token.h:93
clang::Preprocessor::makeModuleVisible
void makeModuleVisible(Module *M, SourceLocation Loc)
Definition: Preprocessor.cpp:1306
clang::MacroInfo::isWarnIfUnused
bool isWarnIfUnused() const
Return true if we should emit a warning if the macro is unused.
Definition: MacroInfo.h:230
clang::FileManager::getDirectory
llvm::ErrorOr< const DirectoryEntry * > getDirectory(StringRef DirName, bool CacheFailure=true)
Lookup, cache, and verify the specified directory (real or virtual).
Definition: FileManager.cpp:188
clang::minimize_source_to_dependency_directives::pp_endif
@ pp_endif
Definition: DependencyDirectivesSourceMinimizer.h:53
clang::MultipleIncludeOpt::ExitTopLevelConditional
void ExitTopLevelConditional()
Called when the lexer exits the top-level conditional.
Definition: MultipleIncludeOpt.h:149
clang::PPCallbacks::CVK_NotEvaluated
@ CVK_NotEvaluated
Definition: PPCallbacks.h:338
clang::VerifyDiagnosticConsumer::Directive
Directive - Abstract class representing a parsed verify directive.
Definition: VerifyDiagnosticConsumer.h:191
clang::Token::isOneOf
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const
Definition: Token.h:99
c
__device__ __2f16 float c
Definition: __clang_hip_libdevice_declares.h:315
clang::MU_Other
@ MU_Other
Definition: Preprocessor.h:115
MD_KeywordDef
@ MD_KeywordDef
Definition: PPDirectives.cpp:99
clang::SourceManager::getExpansionLoc
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID.
Definition: SourceManager.h:1158
clang::comments::tok::eof
@ eof
Definition: CommentLexer.h:33
clang::PresumedLoc
Represents an unpacked "presumed" location which can be presented to the user.
Definition: SourceLocation.h:302
clang::Preprocessor::checkModuleIsAvailable
static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, DiagnosticsEngine &Diags, Module *M)
Check that the given module is available, producing a diagnostic if not.
Definition: PPDirectives.cpp:1752
llvm::SmallVectorImpl< char >
FileManager.h
clang::SrcMgr::C_System
@ C_System
Definition: SourceManager.h:80
shouldWarnOnMacroUndef
static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II)
Definition: PPDirectives.cpp:183
clang::Preprocessor::LexUnexpandedToken
void LexUnexpandedToken(Token &Result)
Just like Lex, but disables macro expansion of identifier tokens.
Definition: Preprocessor.h:1492
PreprocessorOptions.h
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:130
clang::Preprocessor::isRecordingPreamble
bool isRecordingPreamble() const
Definition: Preprocessor.h:2356
SM
#define SM(sm)
Definition: Cuda.cpp:81
clang::Preprocessor::appendMacroDirective
void appendMacroDirective(IdentifierInfo *II, MacroDirective *MD)
Add a directive to the macro directive history for this identifier.
Definition: PPMacroExpansion.cpp:71
clang::MacroInfo::setIsC99Varargs
void setIsC99Varargs()
Varargs querying methods. This can only be set for function-like macros.
Definition: MacroInfo.h:203
clang::Preprocessor::getHeaderSearchInfo
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:965
Token.h
clang::StringLiteralParser
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
Definition: LiteralSupport.h:210
PED_Elifndef
@ PED_Elifndef
Definition: PPDirectives.cpp:108
clang::PreprocessorLexer::getFileEntry
const FileEntry * getFileEntry() const
getFileEntry - Return the FileEntry corresponding to this FileID.
Definition: PreprocessorLexer.cpp:50
clang::Preprocessor::EnterAnnotationToken
void EnterAnnotationToken(SourceRange Range, tok::TokenKind Kind, void *AnnotationVal)
Enter an annotation token into the token stream.
Definition: PPDirectives.cpp:1653
clang::Module::ShadowingModule
Module * ShadowingModule
A module with the same name that shadows this module.
Definition: Module.h:244
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:430
clang::Preprocessor::getPredefinesFileID
FileID getPredefinesFileID() const
Returns the FileID for the preprocessor predefines.
Definition: Preprocessor.h:1050
clang::MultipleIncludeOpt::resetImmediatelyAfterTopLevelIfndef
void resetImmediatelyAfterTopLevelIfndef()
Definition: MultipleIncludeOpt.h:74
clang::HeaderSearch::getModuleMap
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:728
clang::interp::Sub
bool Sub(InterpState &S, CodePtr OpPC)
Definition: Interp.h:142
clang::MacroUse
MacroUse
Context in which macro name is used.
Definition: Preprocessor.h:113
MacroDiag
MacroDiag
Enumerates possible cases of #define/#undef a reserved identifier.
Definition: PPDirectives.cpp:97
clang::minimize_source_to_dependency_directives::pp_elif
@ pp_elif
Definition: DependencyDirectivesSourceMinimizer.h:49
GetLineValue
static bool GetLineValue(Token &DigitTok, unsigned &Val, unsigned DiagID, Preprocessor &PP, bool IsGNULineDirective=false)
GetLineValue - Convert a numeric token into an unsigned value, emitting Diagnostic DiagID if it is in...
Definition: PPDirectives.cpp:1192
clang::Preprocessor::getIdentifierInfo
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
Definition: Preprocessor.h:1243
clang::FixItHint::CreateReplacement
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition: Diagnostic.h:133
clang::Module::UnresolvedHeaderDirective::FileNameLoc
SourceLocation FileNameLoc
Definition: Module.h:217
clang::Preprocessor::getHeaderToIncludeForDiagnostics
const FileEntry * getHeaderToIncludeForDiagnostics(SourceLocation IncLoc, SourceLocation MLoc)
We want to produce a diagnostic at location IncLoc concerning an unreachable effect at location MLoc ...
Definition: PPDirectives.cpp:752
clang::Token::hasUDSuffix
bool hasUDSuffix() const
Return true if this token is a string or character literal which has a ud-suffix.
Definition: Token.h:293
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1523
clang::MacroInfo::getDefinitionLoc
SourceLocation getDefinitionLoc() const
Return the location that the macro was defined at.
Definition: MacroInfo.h:123