brintos / llvm-project-archived public Read only

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-exception6//7//===----------------------------------------------------------------------===//8///9/// \file10/// Implements # directive processing for the Preprocessor.11///12//===----------------------------------------------------------------------===//13 14#include "clang/Basic/AttributeCommonInfo.h"15#include "clang/Basic/Attributes.h"16#include "clang/Basic/CharInfo.h"17#include "clang/Basic/DirectoryEntry.h"18#include "clang/Basic/FileManager.h"19#include "clang/Basic/IdentifierTable.h"20#include "clang/Basic/LangOptions.h"21#include "clang/Basic/Module.h"22#include "clang/Basic/SourceLocation.h"23#include "clang/Basic/SourceManager.h"24#include "clang/Basic/TargetInfo.h"25#include "clang/Basic/TokenKinds.h"26#include "clang/Lex/CodeCompletionHandler.h"27#include "clang/Lex/HeaderSearch.h"28#include "clang/Lex/LexDiagnostic.h"29#include "clang/Lex/LiteralSupport.h"30#include "clang/Lex/MacroInfo.h"31#include "clang/Lex/ModuleLoader.h"32#include "clang/Lex/ModuleMap.h"33#include "clang/Lex/PPCallbacks.h"34#include "clang/Lex/Pragma.h"35#include "clang/Lex/Preprocessor.h"36#include "clang/Lex/PreprocessorOptions.h"37#include "clang/Lex/Token.h"38#include "clang/Lex/VariadicMacroSupport.h"39#include "llvm/ADT/ArrayRef.h"40#include "llvm/ADT/STLExtras.h"41#include "llvm/ADT/ScopeExit.h"42#include "llvm/ADT/SmallVector.h"43#include "llvm/ADT/StringExtras.h"44#include "llvm/ADT/StringRef.h"45#include "llvm/ADT/StringSwitch.h"46#include "llvm/Support/ErrorHandling.h"47#include "llvm/Support/Path.h"48#include "llvm/Support/SaveAndRestore.h"49#include <algorithm>50#include <cassert>51#include <cstring>52#include <optional>53#include <string>54#include <utility>55 56using namespace clang;57 58//===----------------------------------------------------------------------===//59// Utility Methods for Preprocessor Directive Handling.60//===----------------------------------------------------------------------===//61 62MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {63  static_assert(std::is_trivially_destructible_v<MacroInfo>, "");64  return new (BP) MacroInfo(L);65}66 67DefMacroDirective *Preprocessor::AllocateDefMacroDirective(MacroInfo *MI,68                                                           SourceLocation Loc) {69  return new (BP) DefMacroDirective(MI, Loc);70}71 72UndefMacroDirective *73Preprocessor::AllocateUndefMacroDirective(SourceLocation UndefLoc) {74  return new (BP) UndefMacroDirective(UndefLoc);75}76 77VisibilityMacroDirective *78Preprocessor::AllocateVisibilityMacroDirective(SourceLocation Loc,79                                               bool isPublic) {80  return new (BP) VisibilityMacroDirective(Loc, isPublic);81}82 83/// Read and discard all tokens remaining on the current line until84/// the tok::eod token is found.85SourceRange Preprocessor::DiscardUntilEndOfDirective(Token &Tmp) {86  SourceRange Res;87 88  LexUnexpandedToken(Tmp);89  Res.setBegin(Tmp.getLocation());90  while (Tmp.isNot(tok::eod)) {91    assert(Tmp.isNot(tok::eof) && "EOF seen while discarding directive tokens");92    LexUnexpandedToken(Tmp);93  }94  Res.setEnd(Tmp.getLocation());95  return Res;96}97 98/// Enumerates possible cases of #define/#undef a reserved identifier.99enum MacroDiag {100  MD_NoWarn,        //> Not a reserved identifier101  MD_KeywordDef,    //> Macro hides keyword, enabled by default102  MD_ReservedMacro, //> #define of #undef reserved id, disabled by default103  MD_ReservedAttributeIdentifier104};105 106/// Enumerates possible %select values for the pp_err_elif_after_else and107/// pp_err_elif_without_if diagnostics.108enum PPElifDiag {109  PED_Elif,110  PED_Elifdef,111  PED_Elifndef112};113 114static bool isFeatureTestMacro(StringRef MacroName) {115  // list from:116  // * https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_macros.html117  // * https://docs.microsoft.com/en-us/cpp/c-runtime-library/security-features-in-the-crt?view=msvc-160118  // * man 7 feature_test_macros119  // The list must be sorted for correct binary search.120  static constexpr StringRef ReservedMacro[] = {121      "_ATFILE_SOURCE",122      "_BSD_SOURCE",123      "_CRT_NONSTDC_NO_WARNINGS",124      "_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES",125      "_CRT_SECURE_NO_WARNINGS",126      "_FILE_OFFSET_BITS",127      "_FORTIFY_SOURCE",128      "_GLIBCXX_ASSERTIONS",129      "_GLIBCXX_CONCEPT_CHECKS",130      "_GLIBCXX_DEBUG",131      "_GLIBCXX_DEBUG_PEDANTIC",132      "_GLIBCXX_PARALLEL",133      "_GLIBCXX_PARALLEL_ASSERTIONS",134      "_GLIBCXX_SANITIZE_VECTOR",135      "_GLIBCXX_USE_CXX11_ABI",136      "_GLIBCXX_USE_DEPRECATED",137      "_GNU_SOURCE",138      "_ISOC11_SOURCE",139      "_ISOC95_SOURCE",140      "_ISOC99_SOURCE",141      "_LARGEFILE64_SOURCE",142      "_POSIX_C_SOURCE",143      "_REENTRANT",144      "_SVID_SOURCE",145      "_THREAD_SAFE",146      "_XOPEN_SOURCE",147      "_XOPEN_SOURCE_EXTENDED",148      "__STDCPP_WANT_MATH_SPEC_FUNCS__",149      "__STDC_FORMAT_MACROS",150  };151  return llvm::binary_search(ReservedMacro, MacroName);152}153 154static bool isLanguageDefinedBuiltin(const SourceManager &SourceMgr,155                                     const MacroInfo *MI,156                                     const StringRef MacroName) {157  // If this is a macro with special handling (like __LINE__) then it's language158  // defined.159  if (MI->isBuiltinMacro())160    return true;161  // Builtin macros are defined in the builtin file162  if (!SourceMgr.isWrittenInBuiltinFile(MI->getDefinitionLoc()))163    return false;164  // C defines macros starting with __STDC, and C++ defines macros starting with165  // __STDCPP166  if (MacroName.starts_with("__STDC"))167    return true;168  // C++ defines the __cplusplus macro169  if (MacroName == "__cplusplus")170    return true;171  // C++ defines various feature-test macros starting with __cpp172  if (MacroName.starts_with("__cpp"))173    return true;174  // Anything else isn't language-defined175  return false;176}177 178static bool isReservedCXXAttributeName(Preprocessor &PP, IdentifierInfo *II) {179  const LangOptions &Lang = PP.getLangOpts();180  if (Lang.CPlusPlus &&181      hasAttribute(AttributeCommonInfo::AS_CXX11, /* Scope*/ nullptr, II,182                   PP.getTargetInfo(), Lang, /*CheckPlugins*/ false) > 0) {183    AttributeCommonInfo::AttrArgsInfo AttrArgsInfo =184        AttributeCommonInfo::getCXX11AttrArgsInfo(II);185    if (AttrArgsInfo == AttributeCommonInfo::AttrArgsInfo::Required)186      return PP.isNextPPTokenOneOf(tok::l_paren);187 188    return !PP.isNextPPTokenOneOf(tok::l_paren) ||189           AttrArgsInfo == AttributeCommonInfo::AttrArgsInfo::Optional;190  }191  return false;192}193 194static MacroDiag shouldWarnOnMacroDef(Preprocessor &PP, IdentifierInfo *II) {195  const LangOptions &Lang = PP.getLangOpts();196  StringRef Text = II->getName();197  if (isReservedInAllContexts(II->isReserved(Lang)))198    return isFeatureTestMacro(Text) ? MD_NoWarn : MD_ReservedMacro;199  if (II->isKeyword(Lang))200    return MD_KeywordDef;201  if (Lang.CPlusPlus11 && (Text == "override" || Text == "final"))202    return MD_KeywordDef;203  if (isReservedCXXAttributeName(PP, II))204    return MD_ReservedAttributeIdentifier;205  return MD_NoWarn;206}207 208static MacroDiag shouldWarnOnMacroUndef(Preprocessor &PP, IdentifierInfo *II) {209  const LangOptions &Lang = PP.getLangOpts();210  // Do not warn on keyword undef.  It is generally harmless and widely used.211  if (isReservedInAllContexts(II->isReserved(Lang)))212    return MD_ReservedMacro;213  if (isReservedCXXAttributeName(PP, II))214    return MD_ReservedAttributeIdentifier;215  return MD_NoWarn;216}217 218// Return true if we want to issue a diagnostic by default if we219// encounter this name in a #include with the wrong case. For now,220// this includes the standard C and C++ headers, Posix headers,221// and Boost headers. Improper case for these #includes is a222// potential portability issue.223static bool warnByDefaultOnWrongCase(StringRef Include) {224  // If the first component of the path is "boost", treat this like a standard header225  // for the purposes of diagnostics.226  if (::llvm::sys::path::begin(Include)->equals_insensitive("boost"))227    return true;228 229  // "condition_variable" is the longest standard header name at 18 characters.230  // If the include file name is longer than that, it can't be a standard header.231  static const size_t MaxStdHeaderNameLen = 18u;232  if (Include.size() > MaxStdHeaderNameLen)233    return false;234 235  // Lowercase and normalize the search string.236  SmallString<32> LowerInclude{Include};237  for (char &Ch : LowerInclude) {238    // In the ASCII range?239    if (static_cast<unsigned char>(Ch) > 0x7f)240      return false; // Can't be a standard header241    // ASCII lowercase:242    if (Ch >= 'A' && Ch <= 'Z')243      Ch += 'a' - 'A';244    // Normalize path separators for comparison purposes.245    else if (::llvm::sys::path::is_separator(Ch))246      Ch = '/';247  }248 249  // The standard C/C++ and Posix headers250  return llvm::StringSwitch<bool>(LowerInclude)251      // C library headers252      .Cases({"assert.h", "complex.h", "ctype.h", "errno.h", "fenv.h"}, true)253      .Cases({"float.h", "inttypes.h", "iso646.h", "limits.h", "locale.h"},254             true)255      .Cases({"math.h", "setjmp.h", "signal.h", "stdalign.h", "stdarg.h"}, true)256      .Cases({"stdatomic.h", "stdbool.h", "stdckdint.h", "stdcountof.h"}, true)257      .Cases({"stddef.h", "stdint.h", "stdio.h", "stdlib.h", "stdnoreturn.h"},258             true)259      .Cases({"string.h", "tgmath.h", "threads.h", "time.h", "uchar.h"}, true)260      .Cases({"wchar.h", "wctype.h"}, true)261 262      // C++ headers for C library facilities263      .Cases({"cassert", "ccomplex", "cctype", "cerrno", "cfenv"}, true)264      .Cases({"cfloat", "cinttypes", "ciso646", "climits", "clocale"}, true)265      .Cases({"cmath", "csetjmp", "csignal", "cstdalign", "cstdarg"}, true)266      .Cases({"cstdbool", "cstddef", "cstdint", "cstdio", "cstdlib"}, true)267      .Cases({"cstring", "ctgmath", "ctime", "cuchar", "cwchar"}, true)268      .Case("cwctype", true)269 270      // C++ library headers271      .Cases({"algorithm", "fstream", "list", "regex", "thread"}, true)272      .Cases({"array", "functional", "locale", "scoped_allocator", "tuple"},273             true)274      .Cases({"atomic", "future", "map", "set", "type_traits"}, true)275      .Cases(276          {"bitset", "initializer_list", "memory", "shared_mutex", "typeindex"},277          true)278      .Cases({"chrono", "iomanip", "mutex", "sstream", "typeinfo"}, true)279      .Cases({"codecvt", "ios", "new", "stack", "unordered_map"}, true)280      .Cases({"complex", "iosfwd", "numeric", "stdexcept", "unordered_set"},281             true)282      .Cases(283          {"condition_variable", "iostream", "ostream", "streambuf", "utility"},284          true)285      .Cases({"deque", "istream", "queue", "string", "valarray"}, true)286      .Cases({"exception", "iterator", "random", "strstream", "vector"}, true)287      .Cases({"forward_list", "limits", "ratio", "system_error"}, true)288 289      // POSIX headers (which aren't also C headers)290      .Cases({"aio.h", "arpa/inet.h", "cpio.h", "dirent.h", "dlfcn.h"}, true)291      .Cases({"fcntl.h", "fmtmsg.h", "fnmatch.h", "ftw.h", "glob.h"}, true)292      .Cases({"grp.h", "iconv.h", "langinfo.h", "libgen.h", "monetary.h"}, true)293      .Cases({"mqueue.h", "ndbm.h", "net/if.h", "netdb.h", "netinet/in.h"},294             true)295      .Cases({"netinet/tcp.h", "nl_types.h", "poll.h", "pthread.h", "pwd.h"},296             true)297      .Cases({"regex.h", "sched.h", "search.h", "semaphore.h", "spawn.h"}, true)298      .Cases({"strings.h", "stropts.h", "sys/ipc.h", "sys/mman.h", "sys/msg.h"},299             true)300      .Cases({"sys/resource.h", "sys/select.h", "sys/sem.h", "sys/shm.h",301              "sys/socket.h"},302             true)303      .Cases({"sys/stat.h", "sys/statvfs.h", "sys/time.h", "sys/times.h",304              "sys/types.h"},305             true)306      .Cases(307          {"sys/uio.h", "sys/un.h", "sys/utsname.h", "sys/wait.h", "syslog.h"},308          true)309      .Cases({"tar.h", "termios.h", "trace.h", "ulimit.h"}, true)310      .Cases({"unistd.h", "utime.h", "utmpx.h", "wordexp.h"}, true)311      .Default(false);312}313 314/// Find a similar string in `Candidates`.315///316/// \param LHS a string for a similar string in `Candidates`317///318/// \param Candidates the candidates to find a similar string.319///320/// \returns a similar string if exists. If no similar string exists,321/// returns std::nullopt.322static std::optional<StringRef>323findSimilarStr(StringRef LHS, const std::vector<StringRef> &Candidates) {324  // We need to check if `Candidates` has the exact case-insensitive string325  // because the Levenshtein distance match does not care about it.326  for (StringRef C : Candidates) {327    if (LHS.equals_insensitive(C)) {328      return C;329    }330  }331 332  // Keep going with the Levenshtein distance match.333  // If the LHS size is less than 3, use the LHS size minus 1 and if not,334  // use the LHS size divided by 3.335  size_t Length = LHS.size();336  size_t MaxDist = Length < 3 ? Length - 1 : Length / 3;337 338  std::optional<std::pair<StringRef, size_t>> SimilarStr;339  for (StringRef C : Candidates) {340    size_t CurDist = LHS.edit_distance(C, true);341    if (CurDist <= MaxDist) {342      if (!SimilarStr) {343        // The first similar string found.344        SimilarStr = {C, CurDist};345      } else if (CurDist < SimilarStr->second) {346        // More similar string found.347        SimilarStr = {C, CurDist};348      }349    }350  }351 352  if (SimilarStr) {353    return SimilarStr->first;354  } else {355    return std::nullopt;356  }357}358 359bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,360                                  bool *ShadowFlag) {361  // Missing macro name?362  if (MacroNameTok.is(tok::eod))363    return Diag(MacroNameTok, diag::err_pp_missing_macro_name);364 365  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();366  if (!II)367    return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);368 369  if (II->isCPlusPlusOperatorKeyword()) {370    // C++ 2.5p2: Alternative tokens behave the same as its primary token371    // except for their spellings.372    Diag(MacroNameTok, getLangOpts().MicrosoftExt373                           ? diag::ext_pp_operator_used_as_macro_name374                           : diag::err_pp_operator_used_as_macro_name)375        << II << MacroNameTok.getKind();376    // Allow #defining |and| and friends for Microsoft compatibility or377    // recovery when legacy C headers are included in C++.378  }379 380  if ((isDefineUndef != MU_Other) && II->getPPKeywordID() == tok::pp_defined) {381    // Error if defining "defined": C99 6.10.8/4, C++ [cpp.predefined]p4.382    return Diag(MacroNameTok, diag::err_defined_macro_name);383  }384 385  // If defining/undefining reserved identifier or a keyword, we need to issue386  // a warning.387  SourceLocation MacroNameLoc = MacroNameTok.getLocation();388  if (ShadowFlag)389    *ShadowFlag = false;390  // Macro names with reserved identifiers are accepted if built-in or passed391  // through the command line (the later may be present if -dD was used to392  // generate the preprocessed file).393  // NB: isInPredefinedFile() is relatively expensive, so keep it at the end394  // of the condition.395  if (!SourceMgr.isInSystemHeader(MacroNameLoc) &&396      !SourceMgr.isInPredefinedFile(MacroNameLoc)) {397    MacroDiag D = MD_NoWarn;398    if (isDefineUndef == MU_Define) {399      D = shouldWarnOnMacroDef(*this, II);400    }401    else if (isDefineUndef == MU_Undef)402      D = shouldWarnOnMacroUndef(*this, II);403    if (D == MD_KeywordDef) {404      // We do not want to warn on some patterns widely used in configuration405      // scripts.  This requires analyzing next tokens, so do not issue warnings406      // now, only inform caller.407      if (ShadowFlag)408        *ShadowFlag = true;409    }410    if (D == MD_ReservedMacro)411      Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_id);412    if (D == MD_ReservedAttributeIdentifier)413      Diag(MacroNameTok, diag::warn_pp_macro_is_reserved_attribute_id)414          << II->getName();415  }416 417  // Okay, we got a good identifier.418  return false;419}420 421/// Lex and validate a macro name, which occurs after a422/// \#define or \#undef.423///424/// This sets the token kind to eod and discards the rest of the macro line if425/// the macro name is invalid.426///427/// \param MacroNameTok Token that is expected to be a macro name.428/// \param isDefineUndef Context in which macro is used.429/// \param ShadowFlag Points to a flag that is set if macro shadows a keyword.430void Preprocessor::ReadMacroName(Token &MacroNameTok, MacroUse isDefineUndef,431                                 bool *ShadowFlag) {432  // Read the token, don't allow macro expansion on it.433  LexUnexpandedToken(MacroNameTok);434 435  if (MacroNameTok.is(tok::code_completion)) {436    if (CodeComplete)437      CodeComplete->CodeCompleteMacroName(isDefineUndef == MU_Define);438    setCodeCompletionReached();439    LexUnexpandedToken(MacroNameTok);440  }441 442  if (!CheckMacroName(MacroNameTok, isDefineUndef, ShadowFlag))443    return;444 445  // Invalid macro name, read and discard the rest of the line and set the446  // token kind to tok::eod if necessary.447  if (MacroNameTok.isNot(tok::eod)) {448    MacroNameTok.setKind(tok::eod);449    DiscardUntilEndOfDirective();450  }451}452 453/// Ensure that the next token is a tok::eod token.454///455/// If not, emit a diagnostic and consume up until the eod.  If EnableMacros is456/// true, then we consider macros that expand to zero tokens as being ok.457///458/// Returns the location of the end of the directive.459SourceLocation Preprocessor::CheckEndOfDirective(const char *DirType,460                                                 bool EnableMacros) {461  Token Tmp;462  // Lex unexpanded tokens for most directives: macros might expand to zero463  // tokens, causing us to miss diagnosing invalid lines.  Some directives (like464  // #line) allow empty macros.465  if (EnableMacros)466    Lex(Tmp);467  else468    LexUnexpandedToken(Tmp);469 470  // There should be no tokens after the directive, but we allow them as an471  // extension.472  while (Tmp.is(tok::comment))  // Skip comments in -C mode.473    LexUnexpandedToken(Tmp);474 475  if (Tmp.is(tok::eod))476    return Tmp.getLocation();477 478  // Add a fixit in GNU/C99/C++ mode.  Don't offer a fixit for strict-C89,479  // or if this is a macro-style preprocessing directive, because it is more480  // trouble than it is worth to insert /**/ and check that there is no /**/481  // in the range also.482  FixItHint Hint;483  if ((LangOpts.GNUMode || LangOpts.C99 || LangOpts.CPlusPlus) &&484      !CurTokenLexer)485    Hint = FixItHint::CreateInsertion(Tmp.getLocation(),"//");486  Diag(Tmp, diag::ext_pp_extra_tokens_at_eol) << DirType << Hint;487  return DiscardUntilEndOfDirective().getEnd();488}489 490void Preprocessor::SuggestTypoedDirective(const Token &Tok,491                                          StringRef Directive) const {492  // If this is a `.S` file, treat unknown # directives as non-preprocessor493  // directives.494  if (getLangOpts().AsmPreprocessor) return;495 496  std::vector<StringRef> Candidates = {497      "if", "ifdef", "ifndef", "elif", "else", "endif"498  };499  if (LangOpts.C23 || LangOpts.CPlusPlus23)500    Candidates.insert(Candidates.end(), {"elifdef", "elifndef"});501 502  if (std::optional<StringRef> Sugg = findSimilarStr(Directive, Candidates)) {503    // Directive cannot be coming from macro.504    assert(Tok.getLocation().isFileID());505    CharSourceRange DirectiveRange = CharSourceRange::getCharRange(506        Tok.getLocation(),507        Tok.getLocation().getLocWithOffset(Directive.size()));508    StringRef SuggValue = *Sugg;509 510    auto Hint = FixItHint::CreateReplacement(DirectiveRange, SuggValue);511    Diag(Tok, diag::warn_pp_invalid_directive) << 1 << SuggValue << Hint;512  }513}514 515/// SkipExcludedConditionalBlock - We just read a \#if or related directive and516/// decided that the subsequent tokens are in the \#if'd out portion of the517/// file.  Lex the rest of the file, until we see an \#endif.  If518/// FoundNonSkipPortion is true, then we have already emitted code for part of519/// this \#if directive, so \#else/\#elif blocks should never be entered.520/// If ElseOk is true, then \#else directives are ok, if not, then we have521/// already seen one so a \#else directive is a duplicate.  When this returns,522/// the caller can lex the first valid token.523void Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc,524                                                SourceLocation IfTokenLoc,525                                                bool FoundNonSkipPortion,526                                                bool FoundElse,527                                                SourceLocation ElseLoc) {528  // In SkippingRangeStateTy we are depending on SkipExcludedConditionalBlock()529  // not getting called recursively by storing the RecordedSkippedRanges530  // DenseMap lookup pointer (field SkipRangePtr). SkippingRangeStateTy expects531  // that RecordedSkippedRanges won't get modified and SkipRangePtr won't be532  // invalidated. If this changes and there is a need to call533  // SkipExcludedConditionalBlock() recursively, SkippingRangeStateTy should534  // change to do a second lookup in endLexPass function instead of reusing the535  // lookup pointer.536  assert(!SkippingExcludedConditionalBlock &&537         "calling SkipExcludedConditionalBlock recursively");538  llvm::SaveAndRestore SARSkipping(SkippingExcludedConditionalBlock, true);539 540  ++NumSkipped;541  assert(!CurTokenLexer && "Conditional PP block cannot appear in a macro!");542  assert(CurPPLexer && "Conditional PP block must be in a file!");543  assert(CurLexer && "Conditional PP block but no current lexer set!");544 545  if (PreambleConditionalStack.reachedEOFWhileSkipping())546    PreambleConditionalStack.clearSkipInfo();547  else548    CurPPLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/ false,549                                     FoundNonSkipPortion, FoundElse);550 551  // Enter raw mode to disable identifier lookup (and thus macro expansion),552  // disabling warnings, etc.553  CurPPLexer->LexingRawMode = true;554  Token Tok;555  SourceLocation endLoc;556 557  /// Keeps track and caches skipped ranges and also retrieves a prior skipped558  /// range if the same block is re-visited.559  struct SkippingRangeStateTy {560    Preprocessor &PP;561 562    const char *BeginPtr = nullptr;563    unsigned *SkipRangePtr = nullptr;564 565    SkippingRangeStateTy(Preprocessor &PP) : PP(PP) {}566 567    void beginLexPass() {568      if (BeginPtr)569        return; // continue skipping a block.570 571      // Initiate a skipping block and adjust the lexer if we already skipped it572      // before.573      BeginPtr = PP.CurLexer->getBufferLocation();574      SkipRangePtr = &PP.RecordedSkippedRanges[BeginPtr];575      if (*SkipRangePtr) {576        PP.CurLexer->seek(PP.CurLexer->getCurrentBufferOffset() + *SkipRangePtr,577                          /*IsAtStartOfLine*/ true);578      }579    }580 581    void endLexPass(const char *Hashptr) {582      if (!BeginPtr) {583        // Not doing normal lexing.584        assert(PP.CurLexer->isDependencyDirectivesLexer());585        return;586      }587 588      // Finished skipping a block, record the range if it's first time visited.589      if (!*SkipRangePtr) {590        *SkipRangePtr = Hashptr - BeginPtr;591      }592      assert(*SkipRangePtr == unsigned(Hashptr - BeginPtr));593      BeginPtr = nullptr;594      SkipRangePtr = nullptr;595    }596  } SkippingRangeState(*this);597 598  while (true) {599    if (CurLexer->isDependencyDirectivesLexer()) {600      CurLexer->LexDependencyDirectiveTokenWhileSkipping(Tok);601    } else {602      SkippingRangeState.beginLexPass();603      while (true) {604        CurLexer->Lex(Tok);605 606        if (Tok.is(tok::code_completion)) {607          setCodeCompletionReached();608          if (CodeComplete)609            CodeComplete->CodeCompleteInConditionalExclusion();610          continue;611        }612 613        // If this is the end of the buffer, we have an error.614        if (Tok.is(tok::eof)) {615          // We don't emit errors for unterminated conditionals here,616          // Lexer::LexEndOfFile can do that properly.617          // Just return and let the caller lex after this #include.618          if (PreambleConditionalStack.isRecording())619            PreambleConditionalStack.SkipInfo.emplace(HashTokenLoc, IfTokenLoc,620                                                      FoundNonSkipPortion,621                                                      FoundElse, ElseLoc);622          break;623        }624 625        // If this token is not a preprocessor directive, just skip it.626        if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine())627          continue;628 629        break;630      }631    }632    if (Tok.is(tok::eof))633      break;634 635    // We just parsed a # character at the start of a line, so we're in636    // directive mode.  Tell the lexer this so any newlines we see will be637    // converted into an EOD token (this terminates the macro).638    CurPPLexer->ParsingPreprocessorDirective = true;639    if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);640 641    assert(Tok.is(tok::hash));642    const char *Hashptr = CurLexer->getBufferLocation() - Tok.getLength();643    assert(CurLexer->getSourceLocation(Hashptr) == Tok.getLocation());644 645    // Read the next token, the directive flavor.646    LexUnexpandedToken(Tok);647 648    // If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or649    // something bogus), skip it.650    if (Tok.isNot(tok::raw_identifier)) {651      CurPPLexer->ParsingPreprocessorDirective = false;652      // Restore comment saving mode.653      if (CurLexer) CurLexer->resetExtendedTokenMode();654      continue;655    }656 657    // If the first letter isn't i or e, it isn't intesting to us.  We know that658    // this is safe in the face of spelling differences, because there is no way659    // to spell an i/e in a strange way that is another letter.  Skipping this660    // allows us to avoid looking up the identifier info for #define/#undef and661    // other common directives.662    StringRef RI = Tok.getRawIdentifier();663 664    char FirstChar = RI[0];665    if (FirstChar >= 'a' && FirstChar <= 'z' &&666        FirstChar != 'i' && FirstChar != 'e') {667      CurPPLexer->ParsingPreprocessorDirective = false;668      // Restore comment saving mode.669      if (CurLexer) CurLexer->resetExtendedTokenMode();670      continue;671    }672 673    // Get the identifier name without trigraphs or embedded newlines.  Note674    // that we can't use Tok.getIdentifierInfo() because its lookup is disabled675    // when skipping.676    char DirectiveBuf[20];677    StringRef Directive;678    if (!Tok.needsCleaning() && RI.size() < 20) {679      Directive = RI;680    } else {681      std::string DirectiveStr = getSpelling(Tok);682      size_t IdLen = DirectiveStr.size();683      if (IdLen >= 20) {684        CurPPLexer->ParsingPreprocessorDirective = false;685        // Restore comment saving mode.686        if (CurLexer) CurLexer->resetExtendedTokenMode();687        continue;688      }689      memcpy(DirectiveBuf, &DirectiveStr[0], IdLen);690      Directive = StringRef(DirectiveBuf, IdLen);691    }692 693    if (Directive.starts_with("if")) {694      StringRef Sub = Directive.substr(2);695      if (Sub.empty() ||   // "if"696          Sub == "def" ||   // "ifdef"697          Sub == "ndef") {  // "ifndef"698        // We know the entire #if/#ifdef/#ifndef block will be skipped, don't699        // bother parsing the condition.700        DiscardUntilEndOfDirective();701        CurPPLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,702                                       /*foundnonskip*/false,703                                       /*foundelse*/false);704      } else {705        SuggestTypoedDirective(Tok, Directive);706      }707    } else if (Directive[0] == 'e') {708      StringRef Sub = Directive.substr(1);709      if (Sub == "ndif") {  // "endif"710        PPConditionalInfo CondInfo;711        CondInfo.WasSkipping = true; // Silence bogus warning.712        bool InCond = CurPPLexer->popConditionalLevel(CondInfo);713        (void)InCond;  // Silence warning in no-asserts mode.714        assert(!InCond && "Can't be skipping if not in a conditional!");715 716        // If we popped the outermost skipping block, we're done skipping!717        if (!CondInfo.WasSkipping) {718          SkippingRangeState.endLexPass(Hashptr);719          // Restore the value of LexingRawMode so that trailing comments720          // are handled correctly, if we've reached the outermost block.721          CurPPLexer->LexingRawMode = false;722          endLoc = CheckEndOfDirective("endif");723          CurPPLexer->LexingRawMode = true;724          if (Callbacks)725            Callbacks->Endif(Tok.getLocation(), CondInfo.IfLoc);726          break;727        } else {728          DiscardUntilEndOfDirective();729        }730      } else if (Sub == "lse") { // "else".731        // #else directive in a skipping conditional.  If not in some other732        // skipping conditional, and if #else hasn't already been seen, enter it733        // as a non-skipping conditional.734        PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();735 736        if (!CondInfo.WasSkipping)737          SkippingRangeState.endLexPass(Hashptr);738 739        // If this is a #else with a #else before it, report the error.740        if (CondInfo.FoundElse)741          Diag(Tok, diag::pp_err_else_after_else);742 743        // Note that we've seen a #else in this conditional.744        CondInfo.FoundElse = true;745 746        // If the conditional is at the top level, and the #if block wasn't747        // entered, enter the #else block now.748        if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {749          CondInfo.FoundNonSkip = true;750          // Restore the value of LexingRawMode so that trailing comments751          // are handled correctly.752          CurPPLexer->LexingRawMode = false;753          endLoc = CheckEndOfDirective("else");754          CurPPLexer->LexingRawMode = true;755          if (Callbacks)756            Callbacks->Else(Tok.getLocation(), CondInfo.IfLoc);757          break;758        } else {759          DiscardUntilEndOfDirective();  // C99 6.10p4.760        }761      } else if (Sub == "lif") {  // "elif".762        PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();763 764        if (!CondInfo.WasSkipping)765          SkippingRangeState.endLexPass(Hashptr);766 767        // If this is a #elif with a #else before it, report the error.768        if (CondInfo.FoundElse)769          Diag(Tok, diag::pp_err_elif_after_else) << PED_Elif;770 771        // If this is in a skipping block or if we're already handled this #if772        // block, don't bother parsing the condition.773        if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {774          // FIXME: We should probably do at least some minimal parsing of the775          // condition to verify that it is well-formed. The current state776          // allows #elif* directives with completely malformed (or missing)777          // conditions.778          DiscardUntilEndOfDirective();779        } else {780          // Restore the value of LexingRawMode so that identifiers are781          // looked up, etc, inside the #elif expression.782          assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");783          CurPPLexer->LexingRawMode = false;784          IdentifierInfo *IfNDefMacro = nullptr;785          DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);786          // Stop if Lexer became invalid after hitting code completion token.787          if (!CurPPLexer)788            return;789          const bool CondValue = DER.Conditional;790          CurPPLexer->LexingRawMode = true;791          if (Callbacks) {792            Callbacks->Elif(793                Tok.getLocation(), DER.ExprRange,794                (CondValue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False),795                CondInfo.IfLoc);796          }797          // If this condition is true, enter it!798          if (CondValue) {799            CondInfo.FoundNonSkip = true;800            break;801          }802        }803      } else if (Sub == "lifdef" ||  // "elifdef"804                 Sub == "lifndef") { // "elifndef"805        bool IsElifDef = Sub == "lifdef";806        PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();807        Token DirectiveToken = Tok;808 809        if (!CondInfo.WasSkipping)810          SkippingRangeState.endLexPass(Hashptr);811 812        // Warn if using `#elifdef` & `#elifndef` in not C23 & C++23 mode even813        // if this branch is in a skipping block.814        unsigned DiagID;815        if (LangOpts.CPlusPlus)816          DiagID = LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_pp_directive817                                        : diag::ext_cxx23_pp_directive;818        else819          DiagID = LangOpts.C23 ? diag::warn_c23_compat_pp_directive820                                : diag::ext_c23_pp_directive;821        Diag(Tok, DiagID) << (IsElifDef ? PED_Elifdef : PED_Elifndef);822 823        // If this is a #elif with a #else before it, report the error.824        if (CondInfo.FoundElse)825          Diag(Tok, diag::pp_err_elif_after_else)826              << (IsElifDef ? PED_Elifdef : PED_Elifndef);827 828        // If this is in a skipping block or if we're already handled this #if829        // block, don't bother parsing the condition.830        if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {831          // FIXME: We should probably do at least some minimal parsing of the832          // condition to verify that it is well-formed. The current state833          // allows #elif* directives with completely malformed (or missing)834          // conditions.835          DiscardUntilEndOfDirective();836        } else {837          // Restore the value of LexingRawMode so that identifiers are838          // looked up, etc, inside the #elif[n]def expression.839          assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");840          CurPPLexer->LexingRawMode = false;841          Token MacroNameTok;842          ReadMacroName(MacroNameTok);843          CurPPLexer->LexingRawMode = true;844 845          // If the macro name token is tok::eod, there was an error that was846          // already reported.847          if (MacroNameTok.is(tok::eod)) {848            // Skip code until we get to #endif.  This helps with recovery by849            // not emitting an error when the #endif is reached.850            continue;851          }852 853          emitMacroExpansionWarnings(MacroNameTok);854 855          CheckEndOfDirective(IsElifDef ? "elifdef" : "elifndef");856 857          IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();858          auto MD = getMacroDefinition(MII);859          MacroInfo *MI = MD.getMacroInfo();860 861          if (Callbacks) {862            if (IsElifDef) {863              Callbacks->Elifdef(DirectiveToken.getLocation(), MacroNameTok,864                                 MD);865            } else {866              Callbacks->Elifndef(DirectiveToken.getLocation(), MacroNameTok,867                                  MD);868            }869          }870          // If this condition is true, enter it!871          if (static_cast<bool>(MI) == IsElifDef) {872            CondInfo.FoundNonSkip = true;873            break;874          }875        }876      } else {877        SuggestTypoedDirective(Tok, Directive);878      }879    } else {880      SuggestTypoedDirective(Tok, Directive);881    }882 883    CurPPLexer->ParsingPreprocessorDirective = false;884    // Restore comment saving mode.885    if (CurLexer) CurLexer->resetExtendedTokenMode();886  }887 888  // Finally, if we are out of the conditional (saw an #endif or ran off the end889  // of the file, just stop skipping and return to lexing whatever came after890  // the #if block.891  CurPPLexer->LexingRawMode = false;892 893  // The last skipped range isn't actually skipped yet if it's truncated894  // by the end of the preamble; we'll resume parsing after the preamble.895  if (Callbacks && (Tok.isNot(tok::eof) || !isRecordingPreamble()))896    Callbacks->SourceRangeSkipped(897        SourceRange(HashTokenLoc, endLoc.isValid()898                                      ? endLoc899                                      : CurPPLexer->getSourceLocation()),900        Tok.getLocation());901}902 903Module *Preprocessor::getModuleForLocation(SourceLocation Loc,904                                           bool AllowTextual) {905  if (!SourceMgr.isInMainFile(Loc)) {906    // Try to determine the module of the include directive.907    // FIXME: Look into directly passing the FileEntry from LookupFile instead.908    FileID IDOfIncl = SourceMgr.getFileID(SourceMgr.getExpansionLoc(Loc));909    if (auto EntryOfIncl = SourceMgr.getFileEntryRefForID(IDOfIncl)) {910      // The include comes from an included file.911      return HeaderInfo.getModuleMap()912          .findModuleForHeader(*EntryOfIncl, AllowTextual)913          .getModule();914    }915  }916 917  // This is either in the main file or not in a file at all. It belongs918  // to the current module, if there is one.919  return getLangOpts().CurrentModule.empty()920             ? nullptr921             : HeaderInfo.lookupModule(getLangOpts().CurrentModule, Loc);922}923 924OptionalFileEntryRef925Preprocessor::getHeaderToIncludeForDiagnostics(SourceLocation IncLoc,926                                               SourceLocation Loc) {927  Module *IncM = getModuleForLocation(928      IncLoc, LangOpts.ModulesValidateTextualHeaderIncludes);929 930  // Walk up through the include stack, looking through textual headers of M931  // until we hit a non-textual header that we can #include. (We assume textual932  // headers of a module with non-textual headers aren't meant to be used to933  // import entities from the module.)934  auto &SM = getSourceManager();935  while (!Loc.isInvalid() && !SM.isInMainFile(Loc)) {936    auto ID = SM.getFileID(SM.getExpansionLoc(Loc));937    auto FE = SM.getFileEntryRefForID(ID);938    if (!FE)939      break;940 941    // We want to find all possible modules that might contain this header, so942    // search all enclosing directories for module maps and load them.943    HeaderInfo.hasModuleMap(FE->getName(), /*Root*/ nullptr,944                            SourceMgr.isInSystemHeader(Loc));945 946    bool InPrivateHeader = false;947    for (auto Header : HeaderInfo.findAllModulesForHeader(*FE)) {948      if (!Header.isAccessibleFrom(IncM)) {949        // It's in a private header; we can't #include it.950        // FIXME: If there's a public header in some module that re-exports it,951        // then we could suggest including that, but it's not clear that's the952        // expected way to make this entity visible.953        InPrivateHeader = true;954        continue;955      }956 957      // Don't suggest explicitly excluded headers.958      if (Header.getRole() == ModuleMap::ExcludedHeader)959        continue;960 961      // We'll suggest including textual headers below if they're962      // include-guarded.963      if (Header.getRole() & ModuleMap::TextualHeader)964        continue;965 966      // If we have a module import syntax, we shouldn't include a header to967      // make a particular module visible. Let the caller know they should968      // suggest an import instead.969      if (getLangOpts().ObjC || getLangOpts().CPlusPlusModules)970        return std::nullopt;971 972      // If this is an accessible, non-textual header of M's top-level module973      // that transitively includes the given location and makes the974      // corresponding module visible, this is the thing to #include.975      return *FE;976    }977 978    // FIXME: If we're bailing out due to a private header, we shouldn't suggest979    // an import either.980    if (InPrivateHeader)981      return std::nullopt;982 983    // If the header is includable and has an include guard, assume the984    // intended way to expose its contents is by #include, not by importing a985    // module that transitively includes it.986    if (getHeaderSearchInfo().isFileMultipleIncludeGuarded(*FE))987      return *FE;988 989    Loc = SM.getIncludeLoc(ID);990  }991 992  return std::nullopt;993}994 995OptionalFileEntryRef Preprocessor::LookupFile(996    SourceLocation FilenameLoc, StringRef Filename, bool isAngled,997    ConstSearchDirIterator FromDir, const FileEntry *FromFile,998    ConstSearchDirIterator *CurDirArg, SmallVectorImpl<char> *SearchPath,999    SmallVectorImpl<char> *RelativePath,1000    ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped,1001    bool *IsFrameworkFound, bool SkipCache, bool OpenFile, bool CacheFailures) {1002  ConstSearchDirIterator CurDirLocal = nullptr;1003  ConstSearchDirIterator &CurDir = CurDirArg ? *CurDirArg : CurDirLocal;1004 1005  Module *RequestingModule = getModuleForLocation(1006      FilenameLoc, LangOpts.ModulesValidateTextualHeaderIncludes);1007 1008  // If the header lookup mechanism may be relative to the current inclusion1009  // stack, record the parent #includes.1010  SmallVector<std::pair<OptionalFileEntryRef, DirectoryEntryRef>, 16> Includers;1011  bool BuildSystemModule = false;1012  if (!FromDir && !FromFile) {1013    FileID FID = getCurrentFileLexer()->getFileID();1014    OptionalFileEntryRef FileEnt = SourceMgr.getFileEntryRefForID(FID);1015 1016    // If there is no file entry associated with this file, it must be the1017    // predefines buffer or the module includes buffer. Any other file is not1018    // lexed with a normal lexer, so it won't be scanned for preprocessor1019    // directives.1020    //1021    // If we have the predefines buffer, resolve #include references (which come1022    // from the -include command line argument) from the current working1023    // directory instead of relative to the main file.1024    //1025    // If we have the module includes buffer, resolve #include references (which1026    // come from header declarations in the module map) relative to the module1027    // map file.1028    if (!FileEnt) {1029      if (FID == SourceMgr.getMainFileID() && MainFileDir) {1030        auto IncludeDir =1031            HeaderInfo.getModuleMap().shouldImportRelativeToBuiltinIncludeDir(1032                Filename, getCurrentModule())1033                ? HeaderInfo.getModuleMap().getBuiltinDir()1034                : MainFileDir;1035        Includers.push_back(std::make_pair(std::nullopt, *IncludeDir));1036        BuildSystemModule = getCurrentModule()->IsSystem;1037      } else if ((FileEnt = SourceMgr.getFileEntryRefForID(1038                      SourceMgr.getMainFileID()))) {1039        auto CWD = FileMgr.getOptionalDirectoryRef(".");1040        Includers.push_back(std::make_pair(*FileEnt, *CWD));1041      }1042    } else {1043      Includers.push_back(std::make_pair(*FileEnt, FileEnt->getDir()));1044    }1045 1046    // MSVC searches the current include stack from top to bottom for1047    // headers included by quoted include directives.1048    // See: http://msdn.microsoft.com/en-us/library/36k2cdd4.aspx1049    if (LangOpts.MSVCCompat && !isAngled) {1050      for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {1051        if (IsFileLexer(ISEntry))1052          if ((FileEnt = ISEntry.ThePPLexer->getFileEntry()))1053            Includers.push_back(std::make_pair(*FileEnt, FileEnt->getDir()));1054      }1055    }1056  }1057 1058  CurDir = CurDirLookup;1059 1060  if (FromFile) {1061    // We're supposed to start looking from after a particular file. Search1062    // the include path until we find that file or run out of files.1063    ConstSearchDirIterator TmpCurDir = CurDir;1064    ConstSearchDirIterator TmpFromDir = nullptr;1065    while (OptionalFileEntryRef FE = HeaderInfo.LookupFile(1066               Filename, FilenameLoc, isAngled, TmpFromDir, &TmpCurDir,1067               Includers, SearchPath, RelativePath, RequestingModule,1068               SuggestedModule, /*IsMapped=*/nullptr,1069               /*IsFrameworkFound=*/nullptr, SkipCache)) {1070      // Keep looking as if this file did a #include_next.1071      TmpFromDir = TmpCurDir;1072      ++TmpFromDir;1073      if (&FE->getFileEntry() == FromFile) {1074        // Found it.1075        FromDir = TmpFromDir;1076        CurDir = TmpCurDir;1077        break;1078      }1079    }1080  }1081 1082  // Do a standard file entry lookup.1083  OptionalFileEntryRef FE = HeaderInfo.LookupFile(1084      Filename, FilenameLoc, isAngled, FromDir, &CurDir, Includers, SearchPath,1085      RelativePath, RequestingModule, SuggestedModule, IsMapped,1086      IsFrameworkFound, SkipCache, BuildSystemModule, OpenFile, CacheFailures);1087  if (FE)1088    return FE;1089 1090  OptionalFileEntryRef CurFileEnt;1091  // Otherwise, see if this is a subframework header.  If so, this is relative1092  // to one of the headers on the #include stack.  Walk the list of the current1093  // headers on the #include stack and pass them to HeaderInfo.1094  if (IsFileLexer()) {1095    if ((CurFileEnt = CurPPLexer->getFileEntry())) {1096      if (OptionalFileEntryRef FE = HeaderInfo.LookupSubframeworkHeader(1097              Filename, *CurFileEnt, SearchPath, RelativePath, RequestingModule,1098              SuggestedModule)) {1099        return FE;1100      }1101    }1102  }1103 1104  for (IncludeStackInfo &ISEntry : llvm::reverse(IncludeMacroStack)) {1105    if (IsFileLexer(ISEntry)) {1106      if ((CurFileEnt = ISEntry.ThePPLexer->getFileEntry())) {1107        if (OptionalFileEntryRef FE = HeaderInfo.LookupSubframeworkHeader(1108                Filename, *CurFileEnt, SearchPath, RelativePath,1109                RequestingModule, SuggestedModule)) {1110          return FE;1111        }1112      }1113    }1114  }1115 1116  // Otherwise, we really couldn't find the file.1117  return std::nullopt;1118}1119 1120OptionalFileEntryRef1121Preprocessor::LookupEmbedFile(StringRef Filename, bool isAngled, bool OpenFile,1122                              const FileEntry *LookupFromFile) {1123  FileManager &FM = this->getFileManager();1124  if (llvm::sys::path::is_absolute(Filename)) {1125    // lookup path or immediately fail1126    llvm::Expected<FileEntryRef> ShouldBeEntry = FM.getFileRef(1127        Filename, OpenFile, /*CacheFailure=*/true, /*IsText=*/false);1128    return llvm::expectedToOptional(std::move(ShouldBeEntry));1129  }1130 1131  auto SeparateComponents = [](SmallVectorImpl<char> &LookupPath,1132                               StringRef StartingFrom, StringRef FileName,1133                               bool RemoveInitialFileComponentFromLookupPath) {1134    llvm::sys::path::native(StartingFrom, LookupPath);1135    if (RemoveInitialFileComponentFromLookupPath)1136      llvm::sys::path::remove_filename(LookupPath);1137    if (!LookupPath.empty() &&1138        !llvm::sys::path::is_separator(LookupPath.back())) {1139      LookupPath.push_back(llvm::sys::path::get_separator().front());1140    }1141    LookupPath.append(FileName.begin(), FileName.end());1142  };1143 1144  // Otherwise, it's search time!1145  SmallString<512> LookupPath;1146  // Non-angled lookup1147  if (!isAngled) {1148    if (LookupFromFile) {1149      // Use file-based lookup.1150      StringRef FullFileDir = LookupFromFile->tryGetRealPathName();1151      if (!FullFileDir.empty()) {1152        SeparateComponents(LookupPath, FullFileDir, Filename, true);1153        llvm::Expected<FileEntryRef> ShouldBeEntry = FM.getFileRef(1154            LookupPath, OpenFile, /*CacheFailure=*/true, /*IsText=*/false);1155        if (ShouldBeEntry)1156          return llvm::expectedToOptional(std::move(ShouldBeEntry));1157        llvm::consumeError(ShouldBeEntry.takeError());1158      }1159    }1160 1161    // Otherwise, do working directory lookup.1162    LookupPath.clear();1163    auto MaybeWorkingDirEntry = FM.getDirectoryRef(".");1164    if (MaybeWorkingDirEntry) {1165      DirectoryEntryRef WorkingDirEntry = *MaybeWorkingDirEntry;1166      StringRef WorkingDir = WorkingDirEntry.getName();1167      if (!WorkingDir.empty()) {1168        SeparateComponents(LookupPath, WorkingDir, Filename, false);1169        llvm::Expected<FileEntryRef> ShouldBeEntry = FM.getFileRef(1170            LookupPath, OpenFile, /*CacheFailure=*/true, /*IsText=*/false);1171        if (ShouldBeEntry)1172          return llvm::expectedToOptional(std::move(ShouldBeEntry));1173        llvm::consumeError(ShouldBeEntry.takeError());1174      }1175    }1176  }1177 1178  for (const auto &Entry : PPOpts.EmbedEntries) {1179    LookupPath.clear();1180    SeparateComponents(LookupPath, Entry, Filename, false);1181    llvm::Expected<FileEntryRef> ShouldBeEntry = FM.getFileRef(1182        LookupPath, OpenFile, /*CacheFailure=*/true, /*IsText=*/false);1183    if (ShouldBeEntry)1184      return llvm::expectedToOptional(std::move(ShouldBeEntry));1185    llvm::consumeError(ShouldBeEntry.takeError());1186  }1187  return std::nullopt;1188}1189 1190//===----------------------------------------------------------------------===//1191// Preprocessor Directive Handling.1192//===----------------------------------------------------------------------===//1193 1194class Preprocessor::ResetMacroExpansionHelper {1195public:1196  ResetMacroExpansionHelper(Preprocessor *pp)1197    : PP(pp), save(pp->DisableMacroExpansion) {1198    if (pp->MacroExpansionInDirectivesOverride)1199      pp->DisableMacroExpansion = false;1200  }1201 1202  ~ResetMacroExpansionHelper() {1203    PP->DisableMacroExpansion = save;1204  }1205 1206private:1207  Preprocessor *PP;1208  bool save;1209};1210 1211/// Process a directive while looking for the through header or a #pragma1212/// hdrstop. The following directives are handled:1213/// #include (to check if it is the through header)1214/// #define (to warn about macros that don't match the PCH)1215/// #pragma (to check for pragma hdrstop).1216/// All other directives are completely discarded.1217void Preprocessor::HandleSkippedDirectiveWhileUsingPCH(Token &Result,1218                                                       SourceLocation HashLoc) {1219  if (const IdentifierInfo *II = Result.getIdentifierInfo()) {1220    if (II->getPPKeywordID() == tok::pp_define) {1221      return HandleDefineDirective(Result,1222                                   /*ImmediatelyAfterHeaderGuard=*/false);1223    }1224    if (SkippingUntilPCHThroughHeader &&1225        II->getPPKeywordID() == tok::pp_include) {1226      return HandleIncludeDirective(HashLoc, Result);1227    }1228    if (SkippingUntilPragmaHdrStop && II->getPPKeywordID() == tok::pp_pragma) {1229      Lex(Result);1230      auto *II = Result.getIdentifierInfo();1231      if (II && II->getName() == "hdrstop")1232        return HandlePragmaHdrstop(Result);1233    }1234  }1235  DiscardUntilEndOfDirective();1236}1237 1238/// HandleDirective - This callback is invoked when the lexer sees a # token1239/// at the start of a line.  This consumes the directive, modifies the1240/// lexer/preprocessor state, and advances the lexer(s) so that the next token1241/// read is the correct one.1242void Preprocessor::HandleDirective(Token &Result) {1243  // FIXME: Traditional: # with whitespace before it not recognized by K&R?1244 1245  // We just parsed a # character at the start of a line, so we're in directive1246  // mode.  Tell the lexer this so any newlines we see will be converted into an1247  // EOD token (which terminates the directive).1248  CurPPLexer->ParsingPreprocessorDirective = true;1249  if (CurLexer) CurLexer->SetKeepWhitespaceMode(false);1250 1251  bool ImmediatelyAfterTopLevelIfndef =1252      CurPPLexer->MIOpt.getImmediatelyAfterTopLevelIfndef();1253  CurPPLexer->MIOpt.resetImmediatelyAfterTopLevelIfndef();1254 1255  ++NumDirectives;1256 1257  // We are about to read a token.  For the multiple-include optimization FA to1258  // work, we have to remember if we had read any tokens *before* this1259  // pp-directive.1260  bool ReadAnyTokensBeforeDirective =CurPPLexer->MIOpt.getHasReadAnyTokensVal();1261 1262  // Save the '#' token in case we need to return it later.1263  Token SavedHash = Result;1264 1265  // Read the next token, the directive flavor.  This isn't expanded due to1266  // C99 6.10.3p8.1267  LexUnexpandedToken(Result);1268 1269  // C99 6.10.3p11: Is this preprocessor directive in macro invocation?  e.g.:1270  //   #define A(x) #x1271  //   A(abc1272  //     #warning blah1273  //   def)1274  // If so, the user is relying on undefined behavior, emit a diagnostic. Do1275  // not support this for #include-like directives, since that can result in1276  // terrible diagnostics, and does not work in GCC.1277  if (InMacroArgs) {1278    if (IdentifierInfo *II = Result.getIdentifierInfo()) {1279      switch (II->getPPKeywordID()) {1280      case tok::pp_include:1281      case tok::pp_import:1282      case tok::pp_include_next:1283      case tok::pp___include_macros:1284      case tok::pp_pragma:1285      case tok::pp_embed:1286        Diag(Result, diag::err_embedded_directive) << II->getName();1287        Diag(*ArgMacro, diag::note_macro_expansion_here)1288            << ArgMacro->getIdentifierInfo();1289        DiscardUntilEndOfDirective();1290        return;1291      default:1292        break;1293      }1294    }1295    Diag(Result, diag::ext_embedded_directive);1296  }1297 1298  // Temporarily enable macro expansion if set so1299  // and reset to previous state when returning from this function.1300  ResetMacroExpansionHelper helper(this);1301 1302  if (SkippingUntilPCHThroughHeader || SkippingUntilPragmaHdrStop)1303    return HandleSkippedDirectiveWhileUsingPCH(Result, SavedHash.getLocation());1304 1305  switch (Result.getKind()) {1306  case tok::eod:1307    // Ignore the null directive with regards to the multiple-include1308    // optimization, i.e. allow the null directive to appear outside of the1309    // include guard and still enable the multiple-include optimization.1310    CurPPLexer->MIOpt.SetReadToken(ReadAnyTokensBeforeDirective);1311    return;   // null directive.1312  case tok::code_completion:1313    setCodeCompletionReached();1314    if (CodeComplete)1315      CodeComplete->CodeCompleteDirective(1316                                    CurPPLexer->getConditionalStackDepth() > 0);1317    return;1318  case tok::numeric_constant:  // # 7  GNU line marker directive.1319    // In a .S file "# 4" may be a comment so don't treat it as a preprocessor1320    // directive. However do permit it in the predefines file, as we use line1321    // markers to mark the builtin macros as being in a system header.1322    if (getLangOpts().AsmPreprocessor &&1323        SourceMgr.getFileID(SavedHash.getLocation()) != getPredefinesFileID())1324      break;1325    return HandleDigitDirective(Result);1326  default:1327    IdentifierInfo *II = Result.getIdentifierInfo();1328    if (!II) break; // Not an identifier.1329 1330    // Ask what the preprocessor keyword ID is.1331    switch (II->getPPKeywordID()) {1332    default: break;1333    // C99 6.10.1 - Conditional Inclusion.1334    case tok::pp_if:1335      return HandleIfDirective(Result, SavedHash, ReadAnyTokensBeforeDirective);1336    case tok::pp_ifdef:1337      return HandleIfdefDirective(Result, SavedHash, false,1338                                  true /*not valid for miopt*/);1339    case tok::pp_ifndef:1340      return HandleIfdefDirective(Result, SavedHash, true,1341                                  ReadAnyTokensBeforeDirective);1342    case tok::pp_elif:1343    case tok::pp_elifdef:1344    case tok::pp_elifndef:1345      return HandleElifFamilyDirective(Result, SavedHash, II->getPPKeywordID());1346 1347    case tok::pp_else:1348      return HandleElseDirective(Result, SavedHash);1349    case tok::pp_endif:1350      return HandleEndifDirective(Result);1351 1352    // C99 6.10.2 - Source File Inclusion.1353    case tok::pp_include:1354      // Handle #include.1355      return HandleIncludeDirective(SavedHash.getLocation(), Result);1356    case tok::pp___include_macros:1357      // Handle -imacros.1358      return HandleIncludeMacrosDirective(SavedHash.getLocation(), Result);1359 1360    // C99 6.10.3 - Macro Replacement.1361    case tok::pp_define:1362      return HandleDefineDirective(Result, ImmediatelyAfterTopLevelIfndef);1363    case tok::pp_undef:1364      return HandleUndefDirective();1365 1366    // C99 6.10.4 - Line Control.1367    case tok::pp_line:1368      return HandleLineDirective();1369 1370    // C99 6.10.5 - Error Directive.1371    case tok::pp_error:1372      return HandleUserDiagnosticDirective(Result, false);1373 1374    // C99 6.10.6 - Pragma Directive.1375    case tok::pp_pragma:1376      return HandlePragmaDirective({PIK_HashPragma, SavedHash.getLocation()});1377 1378    // GNU Extensions.1379    case tok::pp_import:1380      return HandleImportDirective(SavedHash.getLocation(), Result);1381    case tok::pp_include_next:1382      return HandleIncludeNextDirective(SavedHash.getLocation(), Result);1383 1384    case tok::pp_warning:1385      if (LangOpts.CPlusPlus)1386        Diag(Result, LangOpts.CPlusPlus231387                         ? diag::warn_cxx23_compat_warning_directive1388                         : diag::ext_pp_warning_directive)1389            << /*C++23*/ 1;1390      else1391        Diag(Result, LangOpts.C23 ? diag::warn_c23_compat_warning_directive1392                                  : diag::ext_pp_warning_directive)1393            << /*C23*/ 0;1394 1395      return HandleUserDiagnosticDirective(Result, true);1396    case tok::pp_ident:1397      return HandleIdentSCCSDirective(Result);1398    case tok::pp_sccs:1399      return HandleIdentSCCSDirective(Result);1400    case tok::pp_embed:1401      return HandleEmbedDirective(SavedHash.getLocation(), Result,1402                                  getCurrentFileLexer()1403                                      ? *getCurrentFileLexer()->getFileEntry()1404                                      : static_cast<FileEntry *>(nullptr));1405    case tok::pp_assert:1406      //isExtension = true;  // FIXME: implement #assert1407      break;1408    case tok::pp_unassert:1409      //isExtension = true;  // FIXME: implement #unassert1410      break;1411 1412    case tok::pp___public_macro:1413      if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility)1414        return HandleMacroPublicDirective(Result);1415      break;1416 1417    case tok::pp___private_macro:1418      if (getLangOpts().Modules || getLangOpts().ModulesLocalVisibility)1419        return HandleMacroPrivateDirective();1420      break;1421    }1422    break;1423  }1424 1425  // If this is a .S file, treat unknown # directives as non-preprocessor1426  // directives.  This is important because # may be a comment or introduce1427  // various pseudo-ops.  Just return the # token and push back the following1428  // token to be lexed next time.1429  if (getLangOpts().AsmPreprocessor) {1430    auto Toks = std::make_unique<Token[]>(2);1431    // Return the # and the token after it.1432    Toks[0] = SavedHash;1433    Toks[1] = Result;1434 1435    // If the second token is a hashhash token, then we need to translate it to1436    // unknown so the token lexer doesn't try to perform token pasting.1437    if (Result.is(tok::hashhash))1438      Toks[1].setKind(tok::unknown);1439 1440    // Enter this token stream so that we re-lex the tokens.  Make sure to1441    // enable macro expansion, in case the token after the # is an identifier1442    // that is expanded.1443    EnterTokenStream(std::move(Toks), 2, false, /*IsReinject*/false);1444    return;1445  }1446 1447  // If we reached here, the preprocessing token is not valid!1448  // Start suggesting if a similar directive found.1449  Diag(Result, diag::err_pp_invalid_directive) << 0;1450 1451  // Read the rest of the PP line.1452  DiscardUntilEndOfDirective();1453 1454  // Okay, we're done parsing the directive.1455}1456 1457/// GetLineValue - Convert a numeric token into an unsigned value, emitting1458/// Diagnostic DiagID if it is invalid, and returning the value in Val.1459static bool GetLineValue(Token &DigitTok, unsigned &Val,1460                         unsigned DiagID, Preprocessor &PP,1461                         bool IsGNULineDirective=false) {1462  if (DigitTok.isNot(tok::numeric_constant)) {1463    PP.Diag(DigitTok, DiagID);1464 1465    if (DigitTok.isNot(tok::eod))1466      PP.DiscardUntilEndOfDirective();1467    return true;1468  }1469 1470  SmallString<64> IntegerBuffer;1471  IntegerBuffer.resize(DigitTok.getLength());1472  const char *DigitTokBegin = &IntegerBuffer[0];1473  bool Invalid = false;1474  unsigned ActualLength = PP.getSpelling(DigitTok, DigitTokBegin, &Invalid);1475  if (Invalid)1476    return true;1477 1478  // Verify that we have a simple digit-sequence, and compute the value.  This1479  // is always a simple digit string computed in decimal, so we do this manually1480  // here.1481  Val = 0;1482  for (unsigned i = 0; i != ActualLength; ++i) {1483    // C++1y [lex.fcon]p1:1484    //   Optional separating single quotes in a digit-sequence are ignored1485    if (DigitTokBegin[i] == '\'')1486      continue;1487 1488    if (!isDigit(DigitTokBegin[i])) {1489      PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i),1490              diag::err_pp_line_digit_sequence) << IsGNULineDirective;1491      PP.DiscardUntilEndOfDirective();1492      return true;1493    }1494 1495    unsigned NextVal = Val*10+(DigitTokBegin[i]-'0');1496    if (NextVal < Val) { // overflow.1497      PP.Diag(DigitTok, DiagID);1498      PP.DiscardUntilEndOfDirective();1499      return true;1500    }1501    Val = NextVal;1502  }1503 1504  if (DigitTokBegin[0] == '0' && Val)1505    PP.Diag(DigitTok.getLocation(), diag::warn_pp_line_decimal)1506      << IsGNULineDirective;1507 1508  return false;1509}1510 1511/// Handle a \#line directive: C99 6.10.4.1512///1513/// The two acceptable forms are:1514/// \verbatim1515///   # line digit-sequence1516///   # line digit-sequence "s-char-sequence"1517/// \endverbatim1518void Preprocessor::HandleLineDirective() {1519  // Read the line # and string argument.  Per C99 6.10.4p5, these tokens are1520  // expanded.1521  Token DigitTok;1522  Lex(DigitTok);1523 1524  // Validate the number and convert it to an unsigned.1525  unsigned LineNo;1526  if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer,*this))1527    return;1528 1529  if (LineNo == 0)1530    Diag(DigitTok, diag::ext_pp_line_zero);1531 1532  // Enforce C99 6.10.4p3: "The digit sequence shall not specify ... a1533  // number greater than 2147483647".  C90 requires that the line # be <= 32767.1534  unsigned LineLimit = 32768U;1535  if (LangOpts.C99 || LangOpts.CPlusPlus11)1536    LineLimit = 2147483648U;1537  if (LineNo >= LineLimit)1538    Diag(DigitTok, diag::ext_pp_line_too_big) << LineLimit;1539  else if (LangOpts.CPlusPlus11 && LineNo >= 32768U)1540    Diag(DigitTok, diag::warn_cxx98_compat_pp_line_too_big);1541 1542  int FilenameID = -1;1543  Token StrTok;1544  Lex(StrTok);1545 1546  // If the StrTok is "eod", then it wasn't present.  Otherwise, it must be a1547  // string followed by eod.1548  if (StrTok.is(tok::eod))1549    ; // ok1550  else if (StrTok.isNot(tok::string_literal)) {1551    Diag(StrTok, diag::err_pp_line_invalid_filename);1552    DiscardUntilEndOfDirective();1553    return;1554  } else if (StrTok.hasUDSuffix()) {1555    Diag(StrTok, diag::err_invalid_string_udl);1556    DiscardUntilEndOfDirective();1557    return;1558  } else {1559    // Parse and validate the string, converting it into a unique ID.1560    StringLiteralParser Literal(StrTok, *this);1561    assert(Literal.isOrdinary() && "Didn't allow wide strings in");1562    if (Literal.hadError) {1563      DiscardUntilEndOfDirective();1564      return;1565    }1566    if (Literal.Pascal) {1567      Diag(StrTok, diag::err_pp_linemarker_invalid_filename);1568      DiscardUntilEndOfDirective();1569      return;1570    }1571    FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());1572 1573    // Verify that there is nothing after the string, other than EOD.  Because1574    // of C99 6.10.4p5, macros that expand to empty tokens are ok.1575    CheckEndOfDirective("line", true);1576  }1577 1578  // Take the file kind of the file containing the #line directive. #line1579  // directives are often used for generated sources from the same codebase, so1580  // the new file should generally be classified the same way as the current1581  // file. This is visible in GCC's pre-processed output, which rewrites #line1582  // to GNU line markers.1583  SrcMgr::CharacteristicKind FileKind =1584      SourceMgr.getFileCharacteristic(DigitTok.getLocation());1585 1586  SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, false,1587                        false, FileKind);1588 1589  if (Callbacks)1590    Callbacks->FileChanged(CurPPLexer->getSourceLocation(),1591                           PPCallbacks::RenameFile, FileKind);1592}1593 1594/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line1595/// marker directive.1596static bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit,1597                                SrcMgr::CharacteristicKind &FileKind,1598                                Preprocessor &PP) {1599  unsigned FlagVal;1600  Token FlagTok;1601  PP.Lex(FlagTok);1602  if (FlagTok.is(tok::eod)) return false;1603  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))1604    return true;1605 1606  if (FlagVal == 1) {1607    IsFileEntry = true;1608 1609    PP.Lex(FlagTok);1610    if (FlagTok.is(tok::eod)) return false;1611    if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))1612      return true;1613  } else if (FlagVal == 2) {1614    IsFileExit = true;1615 1616    SourceManager &SM = PP.getSourceManager();1617    // If we are leaving the current presumed file, check to make sure the1618    // presumed include stack isn't empty!1619    FileID CurFileID =1620      SM.getDecomposedExpansionLoc(FlagTok.getLocation()).first;1621    PresumedLoc PLoc = SM.getPresumedLoc(FlagTok.getLocation());1622    if (PLoc.isInvalid())1623      return true;1624 1625    // If there is no include loc (main file) or if the include loc is in a1626    // different physical file, then we aren't in a "1" line marker flag region.1627    SourceLocation IncLoc = PLoc.getIncludeLoc();1628    if (IncLoc.isInvalid() ||1629        SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {1630      PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);1631      PP.DiscardUntilEndOfDirective();1632      return true;1633    }1634 1635    PP.Lex(FlagTok);1636    if (FlagTok.is(tok::eod)) return false;1637    if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag,PP))1638      return true;1639  }1640 1641  // We must have 3 if there are still flags.1642  if (FlagVal != 3) {1643    PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);1644    PP.DiscardUntilEndOfDirective();1645    return true;1646  }1647 1648  FileKind = SrcMgr::C_System;1649 1650  PP.Lex(FlagTok);1651  if (FlagTok.is(tok::eod)) return false;1652  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))1653    return true;1654 1655  // We must have 4 if there is yet another flag.1656  if (FlagVal != 4) {1657    PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);1658    PP.DiscardUntilEndOfDirective();1659    return true;1660  }1661 1662  FileKind = SrcMgr::C_ExternCSystem;1663 1664  PP.Lex(FlagTok);1665  if (FlagTok.is(tok::eod)) return false;1666 1667  // There are no more valid flags here.1668  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);1669  PP.DiscardUntilEndOfDirective();1670  return true;1671}1672 1673/// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is1674/// one of the following forms:1675///1676///     # 421677///     # 42 "file" ('1' | '2')?1678///     # 42 "file" ('1' | '2')? '3' '4'?1679///1680void Preprocessor::HandleDigitDirective(Token &DigitTok) {1681  // Validate the number and convert it to an unsigned.  GNU does not have a1682  // line # limit other than it fit in 32-bits.1683  unsigned LineNo;1684  if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer,1685                   *this, true))1686    return;1687 1688  Token StrTok;1689  Lex(StrTok);1690 1691  bool IsFileEntry = false, IsFileExit = false;1692  int FilenameID = -1;1693  SrcMgr::CharacteristicKind FileKind = SrcMgr::C_User;1694 1695  // If the StrTok is "eod", then it wasn't present.  Otherwise, it must be a1696  // string followed by eod.1697  if (StrTok.is(tok::eod)) {1698    Diag(StrTok, diag::ext_pp_gnu_line_directive);1699    // Treat this like "#line NN", which doesn't change file characteristics.1700    FileKind = SourceMgr.getFileCharacteristic(DigitTok.getLocation());1701  } else if (StrTok.isNot(tok::string_literal)) {1702    Diag(StrTok, diag::err_pp_linemarker_invalid_filename);1703    DiscardUntilEndOfDirective();1704    return;1705  } else if (StrTok.hasUDSuffix()) {1706    Diag(StrTok, diag::err_invalid_string_udl);1707    DiscardUntilEndOfDirective();1708    return;1709  } else {1710    // Parse and validate the string, converting it into a unique ID.1711    StringLiteralParser Literal(StrTok, *this);1712    assert(Literal.isOrdinary() && "Didn't allow wide strings in");1713    if (Literal.hadError) {1714      DiscardUntilEndOfDirective();1715      return;1716    }1717    if (Literal.Pascal) {1718      Diag(StrTok, diag::err_pp_linemarker_invalid_filename);1719      DiscardUntilEndOfDirective();1720      return;1721    }1722 1723    // If a filename was present, read any flags that are present.1724    if (ReadLineMarkerFlags(IsFileEntry, IsFileExit, FileKind, *this))1725      return;1726    if (!SourceMgr.isInPredefinedFile(DigitTok.getLocation()))1727      Diag(StrTok, diag::ext_pp_gnu_line_directive);1728 1729    // Exiting to an empty string means pop to the including file, so leave1730    // FilenameID as -1 in that case.1731    if (!(IsFileExit && Literal.GetString().empty()))1732      FilenameID = SourceMgr.getLineTableFilenameID(Literal.GetString());1733  }1734 1735  // Create a line note with this information.1736  SourceMgr.AddLineNote(DigitTok.getLocation(), LineNo, FilenameID, IsFileEntry,1737                        IsFileExit, FileKind);1738 1739  // If the preprocessor has callbacks installed, notify them of the #line1740  // change.  This is used so that the line marker comes out in -E mode for1741  // example.1742  if (Callbacks) {1743    PPCallbacks::FileChangeReason Reason = PPCallbacks::RenameFile;1744    if (IsFileEntry)1745      Reason = PPCallbacks::EnterFile;1746    else if (IsFileExit)1747      Reason = PPCallbacks::ExitFile;1748 1749    Callbacks->FileChanged(CurPPLexer->getSourceLocation(), Reason, FileKind);1750  }1751}1752 1753/// HandleUserDiagnosticDirective - Handle a #warning or #error directive.1754///1755void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,1756                                                 bool isWarning) {1757  // Read the rest of the line raw.  We do this because we don't want macros1758  // to be expanded and we don't require that the tokens be valid preprocessing1759  // tokens.  For example, this is allowed: "#warning `   'foo".  GCC does1760  // collapse multiple consecutive white space between tokens, but this isn't1761  // specified by the standard.1762  SmallString<128> Message;1763  CurLexer->ReadToEndOfLine(&Message);1764 1765  // Find the first non-whitespace character, so that we can make the1766  // diagnostic more succinct.1767  StringRef Msg = Message.str().ltrim(' ');1768 1769  if (isWarning)1770    Diag(Tok, diag::pp_hash_warning) << Msg;1771  else1772    Diag(Tok, diag::err_pp_hash_error) << Msg;1773}1774 1775/// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.1776///1777void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {1778  // Yes, this directive is an extension.1779  Diag(Tok, diag::ext_pp_ident_directive);1780 1781  // Read the string argument.1782  Token StrTok;1783  Lex(StrTok);1784 1785  // If the token kind isn't a string, it's a malformed directive.1786  if (StrTok.isNot(tok::string_literal) &&1787      StrTok.isNot(tok::wide_string_literal)) {1788    Diag(StrTok, diag::err_pp_malformed_ident);1789    if (StrTok.isNot(tok::eod))1790      DiscardUntilEndOfDirective();1791    return;1792  }1793 1794  if (StrTok.hasUDSuffix()) {1795    Diag(StrTok, diag::err_invalid_string_udl);1796    DiscardUntilEndOfDirective();1797    return;1798  }1799 1800  // Verify that there is nothing after the string, other than EOD.1801  CheckEndOfDirective("ident");1802 1803  if (Callbacks) {1804    bool Invalid = false;1805    std::string Str = getSpelling(StrTok, &Invalid);1806    if (!Invalid)1807      Callbacks->Ident(Tok.getLocation(), Str);1808  }1809}1810 1811/// Handle a #public directive.1812void Preprocessor::HandleMacroPublicDirective(Token &Tok) {1813  Token MacroNameTok;1814  ReadMacroName(MacroNameTok, MU_Undef);1815 1816  // Error reading macro name?  If so, diagnostic already issued.1817  if (MacroNameTok.is(tok::eod))1818    return;1819 1820  // Check to see if this is the last token on the #__public_macro line.1821  CheckEndOfDirective("__public_macro");1822 1823  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();1824  // Okay, we finally have a valid identifier to undef.1825  MacroDirective *MD = getLocalMacroDirective(II);1826 1827  // If the macro is not defined, this is an error.1828  if (!MD) {1829    Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;1830    return;1831  }1832 1833  // Note that this macro has now been exported.1834  appendMacroDirective(II, AllocateVisibilityMacroDirective(1835                                MacroNameTok.getLocation(), /*isPublic=*/true));1836}1837 1838/// Handle a #private directive.1839void Preprocessor::HandleMacroPrivateDirective() {1840  Token MacroNameTok;1841  ReadMacroName(MacroNameTok, MU_Undef);1842 1843  // Error reading macro name?  If so, diagnostic already issued.1844  if (MacroNameTok.is(tok::eod))1845    return;1846 1847  // Check to see if this is the last token on the #__private_macro line.1848  CheckEndOfDirective("__private_macro");1849 1850  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();1851  // Okay, we finally have a valid identifier to undef.1852  MacroDirective *MD = getLocalMacroDirective(II);1853 1854  // If the macro is not defined, this is an error.1855  if (!MD) {1856    Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;1857    return;1858  }1859 1860  // Note that this macro has now been marked private.1861  appendMacroDirective(II, AllocateVisibilityMacroDirective(1862                               MacroNameTok.getLocation(), /*isPublic=*/false));1863}1864 1865//===----------------------------------------------------------------------===//1866// Preprocessor Include Directive Handling.1867//===----------------------------------------------------------------------===//1868 1869/// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully1870/// checked and spelled filename, e.g. as an operand of \#include. This returns1871/// true if the input filename was in <>'s or false if it were in ""'s.  The1872/// caller is expected to provide a buffer that is large enough to hold the1873/// spelling of the filename, but is also expected to handle the case when1874/// this method decides to use a different buffer.1875bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,1876                                              StringRef &Buffer) {1877  // Get the text form of the filename.1878  assert(!Buffer.empty() && "Can't have tokens with empty spellings!");1879 1880  // FIXME: Consider warning on some of the cases described in C11 6.4.7/3 and1881  // C++20 [lex.header]/2:1882  //1883  // If `"`, `'`, `\`, `/*`, or `//` appears in a header-name, then1884  //   in C: behavior is undefined1885  //   in C++: program is conditionally-supported with implementation-defined1886  //           semantics1887 1888  // Make sure the filename is <x> or "x".1889  bool isAngled;1890  if (Buffer[0] == '<') {1891    if (Buffer.back() != '>') {1892      Diag(Loc, diag::err_pp_expects_filename);1893      Buffer = StringRef();1894      return true;1895    }1896    isAngled = true;1897  } else if (Buffer[0] == '"') {1898    if (Buffer.back() != '"') {1899      Diag(Loc, diag::err_pp_expects_filename);1900      Buffer = StringRef();1901      return true;1902    }1903    isAngled = false;1904  } else {1905    Diag(Loc, diag::err_pp_expects_filename);1906    Buffer = StringRef();1907    return true;1908  }1909 1910  // Diagnose #include "" as invalid.1911  if (Buffer.size() <= 2) {1912    Diag(Loc, diag::err_pp_empty_filename);1913    Buffer = StringRef();1914    return true;1915  }1916 1917  // Skip the brackets.1918  Buffer = Buffer.substr(1, Buffer.size()-2);1919  return isAngled;1920}1921 1922/// Push a token onto the token stream containing an annotation.1923void Preprocessor::EnterAnnotationToken(SourceRange Range,1924                                        tok::TokenKind Kind,1925                                        void *AnnotationVal) {1926  // FIXME: Produce this as the current token directly, rather than1927  // allocating a new token for it.1928  auto Tok = std::make_unique<Token[]>(1);1929  Tok[0].startToken();1930  Tok[0].setKind(Kind);1931  Tok[0].setLocation(Range.getBegin());1932  Tok[0].setAnnotationEndLoc(Range.getEnd());1933  Tok[0].setAnnotationValue(AnnotationVal);1934  EnterTokenStream(std::move(Tok), 1, true, /*IsReinject*/ false);1935}1936 1937/// Produce a diagnostic informing the user that a #include or similar1938/// was implicitly treated as a module import.1939static void diagnoseAutoModuleImport(Preprocessor &PP, SourceLocation HashLoc,1940                                     Token &IncludeTok,1941                                     ArrayRef<IdentifierLoc> Path,1942                                     SourceLocation PathEnd) {1943  SmallString<128> PathString;1944  for (size_t I = 0, N = Path.size(); I != N; ++I) {1945    if (I)1946      PathString += '.';1947    PathString += Path[I].getIdentifierInfo()->getName();1948  }1949 1950  int IncludeKind = 0;1951  switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {1952  case tok::pp_include:1953    IncludeKind = 0;1954    break;1955 1956  case tok::pp_import:1957    IncludeKind = 1;1958    break;1959 1960  case tok::pp_include_next:1961    IncludeKind = 2;1962    break;1963 1964  case tok::pp___include_macros:1965    IncludeKind = 3;1966    break;1967 1968  default:1969    llvm_unreachable("unknown include directive kind");1970  }1971 1972  PP.Diag(HashLoc, diag::remark_pp_include_directive_modular_translation)1973      << IncludeKind << PathString;1974}1975 1976// Given a vector of path components and a string containing the real1977// path to the file, build a properly-cased replacement in the vector,1978// and return true if the replacement should be suggested.1979static bool trySimplifyPath(SmallVectorImpl<StringRef> &Components,1980                            StringRef RealPathName,1981                            llvm::sys::path::Style Separator) {1982  auto RealPathComponentIter = llvm::sys::path::rbegin(RealPathName);1983  auto RealPathComponentEnd = llvm::sys::path::rend(RealPathName);1984  int Cnt = 0;1985  bool SuggestReplacement = false;1986 1987  auto IsSep = [Separator](StringRef Component) {1988    return Component.size() == 1 &&1989           llvm::sys::path::is_separator(Component[0], Separator);1990  };1991 1992  // Below is a best-effort to handle ".." in paths. It is admittedly1993  // not 100% correct in the presence of symlinks.1994  for (auto &Component : llvm::reverse(Components)) {1995    if ("." == Component) {1996    } else if (".." == Component) {1997      ++Cnt;1998    } else if (Cnt) {1999      --Cnt;2000    } else if (RealPathComponentIter != RealPathComponentEnd) {2001      if (!IsSep(Component) && !IsSep(*RealPathComponentIter) &&2002          Component != *RealPathComponentIter) {2003        // If these non-separator path components differ by more than just case,2004        // then we may be looking at symlinked paths. Bail on this diagnostic to2005        // avoid noisy false positives.2006        SuggestReplacement =2007            RealPathComponentIter->equals_insensitive(Component);2008        if (!SuggestReplacement)2009          break;2010        Component = *RealPathComponentIter;2011      }2012      ++RealPathComponentIter;2013    }2014  }2015  return SuggestReplacement;2016}2017 2018bool Preprocessor::checkModuleIsAvailable(const LangOptions &LangOpts,2019                                          const TargetInfo &TargetInfo,2020                                          const Module &M,2021                                          DiagnosticsEngine &Diags) {2022  Module::Requirement Requirement;2023  Module::UnresolvedHeaderDirective MissingHeader;2024  Module *ShadowingModule = nullptr;2025  if (M.isAvailable(LangOpts, TargetInfo, Requirement, MissingHeader,2026                    ShadowingModule))2027    return false;2028 2029  if (MissingHeader.FileNameLoc.isValid()) {2030    Diags.Report(MissingHeader.FileNameLoc, diag::err_module_header_missing)2031        << MissingHeader.IsUmbrella << MissingHeader.FileName;2032  } else if (ShadowingModule) {2033    Diags.Report(M.DefinitionLoc, diag::err_module_shadowed) << M.Name;2034    Diags.Report(ShadowingModule->DefinitionLoc,2035                 diag::note_previous_definition);2036  } else {2037    // FIXME: Track the location at which the requirement was specified, and2038    // use it here.2039    Diags.Report(M.DefinitionLoc, diag::err_module_unavailable)2040        << M.getFullModuleName() << Requirement.RequiredState2041        << Requirement.FeatureName;2042  }2043  return true;2044}2045 2046std::pair<ConstSearchDirIterator, const FileEntry *>2047Preprocessor::getIncludeNextStart(const Token &IncludeNextTok) const {2048  // #include_next is like #include, except that we start searching after2049  // the current found directory.  If we can't do this, issue a2050  // diagnostic.2051  ConstSearchDirIterator Lookup = CurDirLookup;2052  const FileEntry *LookupFromFile = nullptr;2053 2054  if (isInPrimaryFile() && LangOpts.IsHeaderFile) {2055    // If the main file is a header, then it's either for PCH/AST generation,2056    // or libclang opened it. Either way, handle it as a normal include below2057    // and do not complain about include_next.2058  } else if (isInPrimaryFile()) {2059    Lookup = nullptr;2060    Diag(IncludeNextTok, diag::pp_include_next_in_primary);2061  } else if (CurLexerSubmodule) {2062    // Start looking up in the directory *after* the one in which the current2063    // file would be found, if any.2064    assert(CurPPLexer && "#include_next directive in macro?");2065    if (auto FE = CurPPLexer->getFileEntry())2066      LookupFromFile = *FE;2067    Lookup = nullptr;2068  } else if (!Lookup) {2069    // The current file was not found by walking the include path. Either it2070    // is the primary file (handled above), or it was found by absolute path,2071    // or it was found relative to such a file.2072    // FIXME: Track enough information so we know which case we're in.2073    Diag(IncludeNextTok, diag::pp_include_next_absolute_path);2074  } else {2075    // Start looking up in the next directory.2076    ++Lookup;2077  }2078 2079  return {Lookup, LookupFromFile};2080}2081 2082/// HandleIncludeDirective - The "\#include" tokens have just been read, read2083/// the file to be included from the lexer, then include it!  This is a common2084/// routine with functionality shared between \#include, \#include_next and2085/// \#import.  LookupFrom is set when this is a \#include_next directive, it2086/// specifies the file to start searching from.2087void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,2088                                          Token &IncludeTok,2089                                          ConstSearchDirIterator LookupFrom,2090                                          const FileEntry *LookupFromFile) {2091  Token FilenameTok;2092  if (LexHeaderName(FilenameTok))2093    return;2094 2095  if (FilenameTok.isNot(tok::header_name)) {2096    if (FilenameTok.is(tok::identifier) && PPOpts.SingleFileParseMode) {2097      // If we saw #include IDENTIFIER and lexing didn't turn in into a header2098      // name, it was undefined. In 'single-file-parse' mode, just skip the2099      // directive without emitting diagnostics - the identifier might be2100      // normally defined in previously-skipped include directive.2101      DiscardUntilEndOfDirective();2102      return;2103    }2104 2105    Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);2106    if (FilenameTok.isNot(tok::eod))2107      DiscardUntilEndOfDirective();2108    return;2109  }2110 2111  // Verify that there is nothing after the filename, other than EOD.  Note2112  // that we allow macros that expand to nothing after the filename, because2113  // this falls into the category of "#include pp-tokens new-line" specified2114  // in C99 6.10.2p4.2115  SourceLocation EndLoc =2116      CheckEndOfDirective(IncludeTok.getIdentifierInfo()->getNameStart(), true);2117 2118  auto Action = HandleHeaderIncludeOrImport(HashLoc, IncludeTok, FilenameTok,2119                                            EndLoc, LookupFrom, LookupFromFile);2120  switch (Action.Kind) {2121  case ImportAction::None:2122  case ImportAction::SkippedModuleImport:2123    break;2124  case ImportAction::ModuleBegin:2125    EnterAnnotationToken(SourceRange(HashLoc, EndLoc),2126                         tok::annot_module_begin, Action.ModuleForHeader);2127    break;2128  case ImportAction::HeaderUnitImport:2129    EnterAnnotationToken(SourceRange(HashLoc, EndLoc), tok::annot_header_unit,2130                         Action.ModuleForHeader);2131    break;2132  case ImportAction::ModuleImport:2133    EnterAnnotationToken(SourceRange(HashLoc, EndLoc),2134                         tok::annot_module_include, Action.ModuleForHeader);2135    break;2136  case ImportAction::Failure:2137    assert(TheModuleLoader.HadFatalFailure &&2138           "This should be an early exit only to a fatal error");2139    TheModuleLoader.HadFatalFailure = true;2140    IncludeTok.setKind(tok::eof);2141    CurLexer->cutOffLexing();2142    return;2143  }2144}2145 2146OptionalFileEntryRef Preprocessor::LookupHeaderIncludeOrImport(2147    ConstSearchDirIterator *CurDir, StringRef &Filename,2148    SourceLocation FilenameLoc, CharSourceRange FilenameRange,2149    const Token &FilenameTok, bool &IsFrameworkFound, bool IsImportDecl,2150    bool &IsMapped, ConstSearchDirIterator LookupFrom,2151    const FileEntry *LookupFromFile, StringRef &LookupFilename,2152    SmallVectorImpl<char> &RelativePath, SmallVectorImpl<char> &SearchPath,2153    ModuleMap::KnownHeader &SuggestedModule, bool isAngled) {2154  auto DiagnoseHeaderInclusion = [&](FileEntryRef FE) {2155    if (LangOpts.AsmPreprocessor)2156      return;2157 2158    Module *RequestingModule = getModuleForLocation(2159        FilenameLoc, LangOpts.ModulesValidateTextualHeaderIncludes);2160    bool RequestingModuleIsModuleInterface =2161        !SourceMgr.isInMainFile(FilenameLoc);2162 2163    HeaderInfo.getModuleMap().diagnoseHeaderInclusion(2164        RequestingModule, RequestingModuleIsModuleInterface, FilenameLoc,2165        Filename, FE);2166  };2167 2168  OptionalFileEntryRef File = LookupFile(2169      FilenameLoc, LookupFilename, isAngled, LookupFrom, LookupFromFile, CurDir,2170      Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,2171      &SuggestedModule, &IsMapped, &IsFrameworkFound);2172  if (File) {2173    DiagnoseHeaderInclusion(*File);2174    return File;2175  }2176 2177  // Give the clients a chance to silently skip this include.2178  if (Callbacks && Callbacks->FileNotFound(Filename))2179    return std::nullopt;2180 2181  if (SuppressIncludeNotFoundError)2182    return std::nullopt;2183 2184  // If the file could not be located and it was included via angle2185  // brackets, we can attempt a lookup as though it were a quoted path to2186  // provide the user with a possible fixit.2187  if (isAngled) {2188    OptionalFileEntryRef File = LookupFile(2189        FilenameLoc, LookupFilename, false, LookupFrom, LookupFromFile, CurDir,2190        Callbacks ? &SearchPath : nullptr, Callbacks ? &RelativePath : nullptr,2191        &SuggestedModule, &IsMapped,2192        /*IsFrameworkFound=*/nullptr);2193    if (File) {2194      DiagnoseHeaderInclusion(*File);2195      Diag(FilenameTok, diag::err_pp_file_not_found_angled_include_not_fatal)2196          << Filename << IsImportDecl2197          << FixItHint::CreateReplacement(FilenameRange,2198                                          "\"" + Filename.str() + "\"");2199      return File;2200    }2201  }2202 2203  // Check for likely typos due to leading or trailing non-isAlphanumeric2204  // characters2205  StringRef OriginalFilename = Filename;2206  if (LangOpts.SpellChecking) {2207    // A heuristic to correct a typo file name by removing leading and2208    // trailing non-isAlphanumeric characters.2209    auto CorrectTypoFilename = [](llvm::StringRef Filename) {2210      Filename = Filename.drop_until(isAlphanumeric);2211      while (!Filename.empty() && !isAlphanumeric(Filename.back())) {2212        Filename = Filename.drop_back();2213      }2214      return Filename;2215    };2216    StringRef TypoCorrectionName = CorrectTypoFilename(Filename);2217    StringRef TypoCorrectionLookupName = CorrectTypoFilename(LookupFilename);2218 2219    OptionalFileEntryRef File = LookupFile(2220        FilenameLoc, TypoCorrectionLookupName, isAngled, LookupFrom,2221        LookupFromFile, CurDir, Callbacks ? &SearchPath : nullptr,2222        Callbacks ? &RelativePath : nullptr, &SuggestedModule, &IsMapped,2223        /*IsFrameworkFound=*/nullptr);2224    if (File) {2225      DiagnoseHeaderInclusion(*File);2226      auto Hint =2227          isAngled ? FixItHint::CreateReplacement(2228                         FilenameRange, "<" + TypoCorrectionName.str() + ">")2229                   : FixItHint::CreateReplacement(2230                         FilenameRange, "\"" + TypoCorrectionName.str() + "\"");2231      Diag(FilenameTok, diag::err_pp_file_not_found_typo_not_fatal)2232          << OriginalFilename << TypoCorrectionName << Hint;2233      // We found the file, so set the Filename to the name after typo2234      // correction.2235      Filename = TypoCorrectionName;2236      LookupFilename = TypoCorrectionLookupName;2237      return File;2238    }2239  }2240 2241  // If the file is still not found, just go with the vanilla diagnostic2242  assert(!File && "expected missing file");2243  Diag(FilenameTok, diag::err_pp_file_not_found)2244      << OriginalFilename << FilenameRange;2245  if (IsFrameworkFound) {2246    size_t SlashPos = OriginalFilename.find('/');2247    assert(SlashPos != StringRef::npos &&2248           "Include with framework name should have '/' in the filename");2249    StringRef FrameworkName = OriginalFilename.substr(0, SlashPos);2250    FrameworkCacheEntry &CacheEntry =2251        HeaderInfo.LookupFrameworkCache(FrameworkName);2252    assert(CacheEntry.Directory && "Found framework should be in cache");2253    Diag(FilenameTok, diag::note_pp_framework_without_header)2254        << OriginalFilename.substr(SlashPos + 1) << FrameworkName2255        << CacheEntry.Directory->getName();2256  }2257 2258  return std::nullopt;2259}2260 2261/// Handle either a #include-like directive or an import declaration that names2262/// a header file.2263///2264/// \param HashLoc The location of the '#' token for an include, or2265///        SourceLocation() for an import declaration.2266/// \param IncludeTok The include / include_next / import token.2267/// \param FilenameTok The header-name token.2268/// \param EndLoc The location at which any imported macros become visible.2269/// \param LookupFrom For #include_next, the starting directory for the2270///        directory lookup.2271/// \param LookupFromFile For #include_next, the starting file for the directory2272///        lookup.2273Preprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(2274    SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok,2275    SourceLocation EndLoc, ConstSearchDirIterator LookupFrom,2276    const FileEntry *LookupFromFile) {2277  SmallString<128> FilenameBuffer;2278  StringRef Filename = getSpelling(FilenameTok, FilenameBuffer);2279  SourceLocation CharEnd = FilenameTok.getEndLoc();2280 2281  CharSourceRange FilenameRange2282    = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);2283  StringRef OriginalFilename = Filename;2284  bool isAngled =2285    GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);2286 2287  // If GetIncludeFilenameSpelling set the start ptr to null, there was an2288  // error.2289  if (Filename.empty())2290    return {ImportAction::None};2291 2292  bool IsImportDecl = HashLoc.isInvalid();2293  SourceLocation StartLoc = IsImportDecl ? IncludeTok.getLocation() : HashLoc;2294 2295  // Complain about attempts to #include files in an audit pragma.2296  if (PragmaARCCFCodeAuditedInfo.getLoc().isValid()) {2297    Diag(StartLoc, diag::err_pp_include_in_arc_cf_code_audited) << IsImportDecl;2298    Diag(PragmaARCCFCodeAuditedInfo.getLoc(), diag::note_pragma_entered_here);2299 2300    // Immediately leave the pragma.2301    PragmaARCCFCodeAuditedInfo = IdentifierLoc();2302  }2303 2304  // Complain about attempts to #include files in an assume-nonnull pragma.2305  if (PragmaAssumeNonNullLoc.isValid()) {2306    Diag(StartLoc, diag::err_pp_include_in_assume_nonnull) << IsImportDecl;2307    Diag(PragmaAssumeNonNullLoc, diag::note_pragma_entered_here);2308 2309    // Immediately leave the pragma.2310    PragmaAssumeNonNullLoc = SourceLocation();2311  }2312 2313  if (HeaderInfo.HasIncludeAliasMap()) {2314    // Map the filename with the brackets still attached.  If the name doesn't2315    // map to anything, fall back on the filename we've already gotten the2316    // spelling for.2317    StringRef NewName = HeaderInfo.MapHeaderToIncludeAlias(OriginalFilename);2318    if (!NewName.empty())2319      Filename = NewName;2320  }2321 2322  // Search include directories.2323  bool IsMapped = false;2324  bool IsFrameworkFound = false;2325  ConstSearchDirIterator CurDir = nullptr;2326  SmallString<1024> SearchPath;2327  SmallString<1024> RelativePath;2328  // We get the raw path only if we have 'Callbacks' to which we later pass2329  // the path.2330  ModuleMap::KnownHeader SuggestedModule;2331  SourceLocation FilenameLoc = FilenameTok.getLocation();2332  StringRef LookupFilename = Filename;2333 2334  // Normalize slashes when compiling with -fms-extensions on non-Windows. This2335  // is unnecessary on Windows since the filesystem there handles backslashes.2336  SmallString<128> NormalizedPath;2337  llvm::sys::path::Style BackslashStyle = llvm::sys::path::Style::native;2338  if (is_style_posix(BackslashStyle) && LangOpts.MicrosoftExt) {2339    NormalizedPath = Filename.str();2340    llvm::sys::path::native(NormalizedPath);2341    LookupFilename = NormalizedPath;2342    BackslashStyle = llvm::sys::path::Style::windows;2343  }2344 2345  OptionalFileEntryRef File = LookupHeaderIncludeOrImport(2346      &CurDir, Filename, FilenameLoc, FilenameRange, FilenameTok,2347      IsFrameworkFound, IsImportDecl, IsMapped, LookupFrom, LookupFromFile,2348      LookupFilename, RelativePath, SearchPath, SuggestedModule, isAngled);2349 2350  if (usingPCHWithThroughHeader() && SkippingUntilPCHThroughHeader) {2351    if (File && isPCHThroughHeader(&File->getFileEntry()))2352      SkippingUntilPCHThroughHeader = false;2353    return {ImportAction::None};2354  }2355 2356  // Should we enter the source file? Set to Skip if either the source file is2357  // known to have no effect beyond its effect on module visibility -- that is,2358  // if it's got an include guard that is already defined, set to Import if it2359  // is a modular header we've already built and should import.2360 2361  // For C++20 Modules2362  // [cpp.include]/7 If the header identified by the header-name denotes an2363  // importable header, it is implementation-defined whether the #include2364  // preprocessing directive is instead replaced by an import directive.2365  // For this implementation, the translation is permitted when we are parsing2366  // the Global Module Fragment, and not otherwise (the cases where it would be2367  // valid to replace an include with an import are highly constrained once in2368  // named module purview; this choice avoids considerable complexity in2369  // determining valid cases).2370 2371  enum { Enter, Import, Skip, IncludeLimitReached } Action = Enter;2372 2373  if (PPOpts.SingleFileParseMode)2374    Action = IncludeLimitReached;2375 2376  // If we've reached the max allowed include depth, it is usually due to an2377  // include cycle. Don't enter already processed files again as it can lead to2378  // reaching the max allowed include depth again.2379  if (Action == Enter && HasReachedMaxIncludeDepth && File &&2380      alreadyIncluded(*File))2381    Action = IncludeLimitReached;2382 2383  // FIXME: We do not have a good way to disambiguate C++ clang modules from2384  // C++ standard modules (other than use/non-use of Header Units).2385 2386  Module *ModuleToImport = SuggestedModule.getModule();2387 2388  bool MaybeTranslateInclude = Action == Enter && File && ModuleToImport &&2389                               !ModuleToImport->isForBuilding(getLangOpts());2390 2391  // Maybe a usable Header Unit2392  bool UsableHeaderUnit = false;2393  if (getLangOpts().CPlusPlusModules && ModuleToImport &&2394      ModuleToImport->isHeaderUnit()) {2395    if (TrackGMFState.inGMF() || IsImportDecl)2396      UsableHeaderUnit = true;2397    else if (!IsImportDecl) {2398      // This is a Header Unit that we do not include-translate2399      ModuleToImport = nullptr;2400    }2401  }2402  // Maybe a usable clang header module.2403  bool UsableClangHeaderModule =2404      (getLangOpts().CPlusPlusModules || getLangOpts().Modules) &&2405      ModuleToImport && !ModuleToImport->isHeaderUnit();2406 2407  // Determine whether we should try to import the module for this #include, if2408  // there is one. Don't do so if precompiled module support is disabled or we2409  // are processing this module textually (because we're building the module).2410  if (MaybeTranslateInclude && (UsableHeaderUnit || UsableClangHeaderModule)) {2411    // If this include corresponds to a module but that module is2412    // unavailable, diagnose the situation and bail out.2413    // FIXME: Remove this; loadModule does the same check (but produces2414    // slightly worse diagnostics).2415    if (checkModuleIsAvailable(getLangOpts(), getTargetInfo(), *ModuleToImport,2416                               getDiagnostics())) {2417      Diag(FilenameTok.getLocation(),2418           diag::note_implicit_top_level_module_import_here)2419          << ModuleToImport->getTopLevelModuleName();2420      return {ImportAction::None};2421    }2422 2423    // Compute the module access path corresponding to this module.2424    // FIXME: Should we have a second loadModule() overload to avoid this2425    // extra lookup step?2426    SmallVector<IdentifierLoc, 2> Path;2427    for (Module *Mod = ModuleToImport; Mod; Mod = Mod->Parent)2428      Path.emplace_back(FilenameTok.getLocation(),2429                        getIdentifierInfo(Mod->Name));2430    std::reverse(Path.begin(), Path.end());2431 2432    // Warn that we're replacing the include/import with a module import.2433    if (!IsImportDecl)2434      diagnoseAutoModuleImport(*this, StartLoc, IncludeTok, Path, CharEnd);2435 2436    // Load the module to import its macros. We'll make the declarations2437    // visible when the parser gets here.2438    // FIXME: Pass ModuleToImport in here rather than converting it to a path2439    // and making the module loader convert it back again.2440    ModuleLoadResult Imported = TheModuleLoader.loadModule(2441        IncludeTok.getLocation(), Path, Module::Hidden,2442        /*IsInclusionDirective=*/true);2443    assert((Imported == nullptr || Imported == ModuleToImport) &&2444           "the imported module is different than the suggested one");2445 2446    if (Imported) {2447      Action = Import;2448    } else if (Imported.isMissingExpected()) {2449      markClangModuleAsAffecting(2450          static_cast<Module *>(Imported)->getTopLevelModule());2451      // We failed to find a submodule that we assumed would exist (because it2452      // was in the directory of an umbrella header, for instance), but no2453      // actual module containing it exists (because the umbrella header is2454      // incomplete).  Treat this as a textual inclusion.2455      ModuleToImport = nullptr;2456    } else if (Imported.isConfigMismatch()) {2457      // On a configuration mismatch, enter the header textually. We still know2458      // that it's part of the corresponding module.2459    } else {2460      // We hit an error processing the import. Bail out.2461      if (hadModuleLoaderFatalFailure()) {2462        // With a fatal failure in the module loader, we abort parsing.2463        Token &Result = IncludeTok;2464        assert(CurLexer && "#include but no current lexer set!");2465        Result.startToken();2466        CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);2467        CurLexer->cutOffLexing();2468      }2469      return {ImportAction::None};2470    }2471  }2472 2473  // The #included file will be considered to be a system header if either it is2474  // in a system include directory, or if the #includer is a system include2475  // header.2476  SrcMgr::CharacteristicKind FileCharacter =2477      SourceMgr.getFileCharacteristic(FilenameTok.getLocation());2478  if (File)2479    FileCharacter = std::max(HeaderInfo.getFileDirFlavor(*File), FileCharacter);2480 2481  // If this is a '#import' or an import-declaration, don't re-enter the file.2482  //2483  // FIXME: If we have a suggested module for a '#include', and we've already2484  // visited this file, don't bother entering it again. We know it has no2485  // further effect.2486  bool EnterOnce =2487      IsImportDecl ||2488      IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import;2489 2490  bool IsFirstIncludeOfFile = false;2491 2492  // Ask HeaderInfo if we should enter this #include file.  If not, #including2493  // this file will have no effect.2494  if (Action == Enter && File &&2495      !HeaderInfo.ShouldEnterIncludeFile(*this, *File, EnterOnce,2496                                         getLangOpts().Modules, ModuleToImport,2497                                         IsFirstIncludeOfFile)) {2498    // C++ standard modules:2499    // If we are not in the GMF, then we textually include only2500    // clang modules:2501    // Even if we've already preprocessed this header once and know that we2502    // don't need to see its contents again, we still need to import it if it's2503    // modular because we might not have imported it from this submodule before.2504    //2505    // FIXME: We don't do this when compiling a PCH because the AST2506    // serialization layer can't cope with it. This means we get local2507    // submodule visibility semantics wrong in that case.2508    if (UsableHeaderUnit && !getLangOpts().CompilingPCH)2509      Action = TrackGMFState.inGMF() ? Import : Skip;2510    else2511      Action = (ModuleToImport && !getLangOpts().CompilingPCH) ? Import : Skip;2512  }2513 2514  // Check for circular inclusion of the main file.2515  // We can't generate a consistent preamble with regard to the conditional2516  // stack if the main file is included again as due to the preamble bounds2517  // some directives (e.g. #endif of a header guard) will never be seen.2518  // Since this will lead to confusing errors, avoid the inclusion.2519  if (Action == Enter && File && PreambleConditionalStack.isRecording() &&2520      SourceMgr.isMainFile(File->getFileEntry())) {2521    Diag(FilenameTok.getLocation(),2522         diag::err_pp_including_mainfile_in_preamble);2523    return {ImportAction::None};2524  }2525 2526  if (Callbacks && !IsImportDecl) {2527    // Notify the callback object that we've seen an inclusion directive.2528    // FIXME: Use a different callback for a pp-import?2529    Callbacks->InclusionDirective(HashLoc, IncludeTok, LookupFilename, isAngled,2530                                  FilenameRange, File, SearchPath, RelativePath,2531                                  SuggestedModule.getModule(), Action == Import,2532                                  FileCharacter);2533    if (Action == Skip && File)2534      Callbacks->FileSkipped(*File, FilenameTok, FileCharacter);2535  }2536 2537  if (!File)2538    return {ImportAction::None};2539 2540  // If this is a C++20 pp-import declaration, diagnose if we didn't find any2541  // module corresponding to the named header.2542  if (IsImportDecl && !ModuleToImport) {2543    Diag(FilenameTok, diag::err_header_import_not_header_unit)2544      << OriginalFilename << File->getName();2545    return {ImportAction::None};2546  }2547 2548  // Issue a diagnostic if the name of the file on disk has a different case2549  // than the one we're about to open.2550  const bool CheckIncludePathPortability =2551      !IsMapped && !File->getFileEntry().tryGetRealPathName().empty();2552 2553  if (CheckIncludePathPortability) {2554    StringRef Name = LookupFilename;2555    StringRef NameWithoriginalSlashes = Filename;2556#if defined(_WIN32)2557    // Skip UNC prefix if present. (tryGetRealPathName() always2558    // returns a path with the prefix skipped.)2559    bool NameWasUNC = Name.consume_front("\\\\?\\");2560    NameWithoriginalSlashes.consume_front("\\\\?\\");2561#endif2562    StringRef RealPathName = File->getFileEntry().tryGetRealPathName();2563    SmallVector<StringRef, 16> Components(llvm::sys::path::begin(Name),2564                                          llvm::sys::path::end(Name));2565#if defined(_WIN32)2566    // -Wnonportable-include-path is designed to diagnose includes using2567    // case even on systems with a case-insensitive file system.2568    // On Windows, RealPathName always starts with an upper-case drive2569    // letter for absolute paths, but Name might start with either2570    // case depending on if `cd c:\foo` or `cd C:\foo` was used in the shell.2571    // ("foo" will always have on-disk case, no matter which case was2572    // used in the cd command). To not emit this warning solely for2573    // the drive letter, whose case is dependent on if `cd` is used2574    // with upper- or lower-case drive letters, always consider the2575    // given drive letter case as correct for the purpose of this warning.2576    SmallString<128> FixedDriveRealPath;2577    if (llvm::sys::path::is_absolute(Name) &&2578        llvm::sys::path::is_absolute(RealPathName) &&2579        toLowercase(Name[0]) == toLowercase(RealPathName[0]) &&2580        isLowercase(Name[0]) != isLowercase(RealPathName[0])) {2581      assert(Components.size() >= 3 && "should have drive, backslash, name");2582      assert(Components[0].size() == 2 && "should start with drive");2583      assert(Components[0][1] == ':' && "should have colon");2584      FixedDriveRealPath = (Name.substr(0, 1) + RealPathName.substr(1)).str();2585      RealPathName = FixedDriveRealPath;2586    }2587#endif2588 2589    if (trySimplifyPath(Components, RealPathName, BackslashStyle)) {2590      SmallString<128> Path;2591      Path.reserve(Name.size()+2);2592      Path.push_back(isAngled ? '<' : '"');2593 2594      const auto IsSep = [BackslashStyle](char c) {2595        return llvm::sys::path::is_separator(c, BackslashStyle);2596      };2597 2598      for (auto Component : Components) {2599        // On POSIX, Components will contain a single '/' as first element2600        // exactly if Name is an absolute path.2601        // On Windows, it will contain "C:" followed by '\' for absolute paths.2602        // The drive letter is optional for absolute paths on Windows, but2603        // clang currently cannot process absolute paths in #include lines that2604        // don't have a drive.2605        // If the first entry in Components is a directory separator,2606        // then the code at the bottom of this loop that keeps the original2607        // directory separator style copies it. If the second entry is2608        // a directory separator (the C:\ case), then that separator already2609        // got copied when the C: was processed and we want to skip that entry.2610        if (!(Component.size() == 1 && IsSep(Component[0])))2611          Path.append(Component);2612        else if (Path.size() != 1)2613          continue;2614 2615        // Append the separator(s) the user used, or the close quote2616        if (Path.size() > NameWithoriginalSlashes.size()) {2617          Path.push_back(isAngled ? '>' : '"');2618          continue;2619        }2620        assert(IsSep(NameWithoriginalSlashes[Path.size()-1]));2621        do2622          Path.push_back(NameWithoriginalSlashes[Path.size()-1]);2623        while (Path.size() <= NameWithoriginalSlashes.size() &&2624               IsSep(NameWithoriginalSlashes[Path.size()-1]));2625      }2626 2627#if defined(_WIN32)2628      // Restore UNC prefix if it was there.2629      if (NameWasUNC)2630        Path = (Path.substr(0, 1) + "\\\\?\\" + Path.substr(1)).str();2631#endif2632 2633      // For user files and known standard headers, issue a diagnostic.2634      // For other system headers, don't. They can be controlled separately.2635      auto DiagId =2636          (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name))2637              ? diag::pp_nonportable_path2638              : diag::pp_nonportable_system_path;2639      Diag(FilenameTok, DiagId) << Path <<2640        FixItHint::CreateReplacement(FilenameRange, Path);2641    }2642  }2643 2644  switch (Action) {2645  case Skip:2646    // If we don't need to enter the file, stop now.2647    if (ModuleToImport)2648      return {ImportAction::SkippedModuleImport, ModuleToImport};2649    return {ImportAction::None};2650 2651  case IncludeLimitReached:2652    // If we reached our include limit and don't want to enter any more files,2653    // don't go any further.2654    return {ImportAction::None};2655 2656  case Import: {2657    // If this is a module import, make it visible if needed.2658    assert(ModuleToImport && "no module to import");2659 2660    makeModuleVisible(ModuleToImport, EndLoc);2661 2662    if (IncludeTok.getIdentifierInfo()->getPPKeywordID() ==2663        tok::pp___include_macros)2664      return {ImportAction::None};2665 2666    return {ImportAction::ModuleImport, ModuleToImport};2667  }2668 2669  case Enter:2670    break;2671  }2672 2673  // Check that we don't have infinite #include recursion.2674  if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1) {2675    Diag(FilenameTok, diag::err_pp_include_too_deep);2676    HasReachedMaxIncludeDepth = true;2677    return {ImportAction::None};2678  }2679 2680  if (isAngled && isInNamedModule())2681    Diag(FilenameTok, diag::warn_pp_include_angled_in_module_purview)2682        << getNamedModuleName();2683 2684  // Look up the file, create a File ID for it.2685  SourceLocation IncludePos = FilenameTok.getLocation();2686  // If the filename string was the result of macro expansions, set the include2687  // position on the file where it will be included and after the expansions.2688  if (IncludePos.isMacroID())2689    IncludePos = SourceMgr.getExpansionRange(IncludePos).getEnd();2690  FileID FID = SourceMgr.createFileID(*File, IncludePos, FileCharacter);2691  if (!FID.isValid()) {2692    TheModuleLoader.HadFatalFailure = true;2693    return ImportAction::Failure;2694  }2695 2696  // If all is good, enter the new file!2697  if (EnterSourceFile(FID, CurDir, FilenameTok.getLocation(),2698                      IsFirstIncludeOfFile))2699    return {ImportAction::None};2700 2701  // Determine if we're switching to building a new submodule, and which one.2702  // This does not apply for C++20 modules header units.2703  if (ModuleToImport && !ModuleToImport->isHeaderUnit()) {2704    if (ModuleToImport->getTopLevelModule()->ShadowingModule) {2705      // We are building a submodule that belongs to a shadowed module. This2706      // means we find header files in the shadowed module.2707      Diag(ModuleToImport->DefinitionLoc,2708           diag::err_module_build_shadowed_submodule)2709          << ModuleToImport->getFullModuleName();2710      Diag(ModuleToImport->getTopLevelModule()->ShadowingModule->DefinitionLoc,2711           diag::note_previous_definition);2712      return {ImportAction::None};2713    }2714    // When building a pch, -fmodule-name tells the compiler to textually2715    // include headers in the specified module. We are not building the2716    // specified module.2717    //2718    // FIXME: This is the wrong way to handle this. We should produce a PCH2719    // that behaves the same as the header would behave in a compilation using2720    // that PCH, which means we should enter the submodule. We need to teach2721    // the AST serialization layer to deal with the resulting AST.2722    if (getLangOpts().CompilingPCH &&2723        ModuleToImport->isForBuilding(getLangOpts()))2724      return {ImportAction::None};2725 2726    assert(!CurLexerSubmodule && "should not have marked this as a module yet");2727    CurLexerSubmodule = ModuleToImport;2728 2729    // Let the macro handling code know that any future macros are within2730    // the new submodule.2731    EnterSubmodule(ModuleToImport, EndLoc, /*ForPragma*/ false);2732 2733    // Let the parser know that any future declarations are within the new2734    // submodule.2735    // FIXME: There's no point doing this if we're handling a #__include_macros2736    // directive.2737    return {ImportAction::ModuleBegin, ModuleToImport};2738  }2739 2740  assert(!IsImportDecl && "failed to diagnose missing module for import decl");2741  return {ImportAction::None};2742}2743 2744/// HandleIncludeNextDirective - Implements \#include_next.2745///2746void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc,2747                                              Token &IncludeNextTok) {2748  Diag(IncludeNextTok, diag::ext_pp_include_next_directive);2749 2750  ConstSearchDirIterator Lookup = nullptr;2751  const FileEntry *LookupFromFile;2752  std::tie(Lookup, LookupFromFile) = getIncludeNextStart(IncludeNextTok);2753 2754  return HandleIncludeDirective(HashLoc, IncludeNextTok, Lookup,2755                                LookupFromFile);2756}2757 2758/// HandleMicrosoftImportDirective - Implements \#import for Microsoft Mode2759void Preprocessor::HandleMicrosoftImportDirective(Token &Tok) {2760  // The Microsoft #import directive takes a type library and generates header2761  // files from it, and includes those.  This is beyond the scope of what clang2762  // does, so we ignore it and error out.  However, #import can optionally have2763  // trailing attributes that span multiple lines.  We're going to eat those2764  // so we can continue processing from there.2765  Diag(Tok, diag::err_pp_import_directive_ms );2766 2767  // Read tokens until we get to the end of the directive.  Note that the2768  // directive can be split over multiple lines using the backslash character.2769  DiscardUntilEndOfDirective();2770}2771 2772/// HandleImportDirective - Implements \#import.2773///2774void Preprocessor::HandleImportDirective(SourceLocation HashLoc,2775                                         Token &ImportTok) {2776  if (!LangOpts.ObjC) {  // #import is standard for ObjC.2777    if (LangOpts.MSVCCompat)2778      return HandleMicrosoftImportDirective(ImportTok);2779    Diag(ImportTok, diag::ext_pp_import_directive);2780  }2781  return HandleIncludeDirective(HashLoc, ImportTok);2782}2783 2784/// HandleIncludeMacrosDirective - The -imacros command line option turns into a2785/// pseudo directive in the predefines buffer.  This handles it by sucking all2786/// tokens through the preprocessor and discarding them (only keeping the side2787/// effects on the preprocessor).2788void Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc,2789                                                Token &IncludeMacrosTok) {2790  // This directive should only occur in the predefines buffer.  If not, emit an2791  // error and reject it.2792  SourceLocation Loc = IncludeMacrosTok.getLocation();2793  if (SourceMgr.getBufferName(Loc) != "<built-in>") {2794    Diag(IncludeMacrosTok.getLocation(),2795         diag::pp_include_macros_out_of_predefines);2796    DiscardUntilEndOfDirective();2797    return;2798  }2799 2800  // Treat this as a normal #include for checking purposes.  If this is2801  // successful, it will push a new lexer onto the include stack.2802  HandleIncludeDirective(HashLoc, IncludeMacrosTok);2803 2804  Token TmpTok;2805  do {2806    Lex(TmpTok);2807    assert(TmpTok.isNot(tok::eof) && "Didn't find end of -imacros!");2808  } while (TmpTok.isNot(tok::hashhash));2809}2810 2811//===----------------------------------------------------------------------===//2812// Preprocessor Macro Directive Handling.2813//===----------------------------------------------------------------------===//2814 2815/// ReadMacroParameterList - The ( starting a parameter list of a macro2816/// definition has just been read.  Lex the rest of the parameters and the2817/// closing ), updating MI with what we learn.  Return true if an error occurs2818/// parsing the param list.2819bool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {2820  SmallVector<IdentifierInfo*, 32> Parameters;2821 2822  while (true) {2823    LexUnexpandedNonComment(Tok);2824    switch (Tok.getKind()) {2825    case tok::r_paren:2826      // Found the end of the parameter list.2827      if (Parameters.empty())  // #define FOO()2828        return false;2829      // Otherwise we have #define FOO(A,)2830      Diag(Tok, diag::err_pp_expected_ident_in_arg_list);2831      return true;2832    case tok::ellipsis:  // #define X(... -> C99 varargs2833      if (!LangOpts.C99)2834        Diag(Tok, LangOpts.CPlusPlus11 ?2835             diag::warn_cxx98_compat_variadic_macro :2836             diag::ext_variadic_macro);2837 2838      // OpenCL v1.2 s6.9.e: variadic macros are not supported.2839      if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus) {2840        Diag(Tok, diag::ext_pp_opencl_variadic_macros);2841      }2842 2843      // Lex the token after the identifier.2844      LexUnexpandedNonComment(Tok);2845      if (Tok.isNot(tok::r_paren)) {2846        Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);2847        return true;2848      }2849      // Add the __VA_ARGS__ identifier as a parameter.2850      Parameters.push_back(Ident__VA_ARGS__);2851      MI->setIsC99Varargs();2852      MI->setParameterList(Parameters, BP);2853      return false;2854    case tok::eod:  // #define X(2855      Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);2856      return true;2857    default:2858      // Handle keywords and identifiers here to accept things like2859      // #define Foo(for) for.2860      IdentifierInfo *II = Tok.getIdentifierInfo();2861      if (!II) {2862        // #define X(12863        Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);2864        return true;2865      }2866 2867      // If this is already used as a parameter, it is used multiple times (e.g.2868      // #define X(A,A.2869      if (llvm::is_contained(Parameters, II)) { // C99 6.10.3p62870        Diag(Tok, diag::err_pp_duplicate_name_in_arg_list) << II;2871        return true;2872      }2873 2874      // Add the parameter to the macro info.2875      Parameters.push_back(II);2876 2877      // Lex the token after the identifier.2878      LexUnexpandedNonComment(Tok);2879 2880      switch (Tok.getKind()) {2881      default:          // #define X(A B2882        Diag(Tok, diag::err_pp_expected_comma_in_arg_list);2883        return true;2884      case tok::r_paren: // #define X(A)2885        MI->setParameterList(Parameters, BP);2886        return false;2887      case tok::comma:  // #define X(A,2888        break;2889      case tok::ellipsis:  // #define X(A... -> GCC extension2890        // Diagnose extension.2891        Diag(Tok, diag::ext_named_variadic_macro);2892 2893        // Lex the token after the identifier.2894        LexUnexpandedNonComment(Tok);2895        if (Tok.isNot(tok::r_paren)) {2896          Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);2897          return true;2898        }2899 2900        MI->setIsGNUVarargs();2901        MI->setParameterList(Parameters, BP);2902        return false;2903      }2904    }2905  }2906}2907 2908static bool isConfigurationPattern(Token &MacroName, MacroInfo *MI,2909                                   const LangOptions &LOptions) {2910  if (MI->getNumTokens() == 1) {2911    const Token &Value = MI->getReplacementToken(0);2912 2913    // Macro that is identity, like '#define inline inline' is a valid pattern.2914    if (MacroName.getKind() == Value.getKind())2915      return true;2916 2917    // Macro that maps a keyword to the same keyword decorated with leading/2918    // trailing underscores is a valid pattern:2919    //    #define inline __inline2920    //    #define inline __inline__2921    //    #define inline _inline (in MS compatibility mode)2922    StringRef MacroText = MacroName.getIdentifierInfo()->getName();2923    if (IdentifierInfo *II = Value.getIdentifierInfo()) {2924      if (!II->isKeyword(LOptions))2925        return false;2926      StringRef ValueText = II->getName();2927      StringRef TrimmedValue = ValueText;2928      if (!ValueText.starts_with("__")) {2929        if (ValueText.starts_with("_"))2930          TrimmedValue = TrimmedValue.drop_front(1);2931        else2932          return false;2933      } else {2934        TrimmedValue = TrimmedValue.drop_front(2);2935        if (TrimmedValue.ends_with("__"))2936          TrimmedValue = TrimmedValue.drop_back(2);2937      }2938      return TrimmedValue == MacroText;2939    } else {2940      return false;2941    }2942  }2943 2944  // #define inline2945  return MacroName.isOneOf(tok::kw_extern, tok::kw_inline, tok::kw_static,2946                           tok::kw_const) &&2947         MI->getNumTokens() == 0;2948}2949 2950// ReadOptionalMacroParameterListAndBody - This consumes all (i.e. the2951// entire line) of the macro's tokens and adds them to MacroInfo, and while2952// doing so performs certain validity checks including (but not limited to):2953//   - # (stringization) is followed by a macro parameter2954//2955//  Returns a nullptr if an invalid sequence of tokens is encountered or returns2956//  a pointer to a MacroInfo object.2957 2958MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(2959    const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {2960 2961  Token LastTok = MacroNameTok;2962  // Create the new macro.2963  MacroInfo *const MI = AllocateMacroInfo(MacroNameTok.getLocation());2964 2965  Token Tok;2966  LexUnexpandedToken(Tok);2967 2968  // Ensure we consume the rest of the macro body if errors occur.2969  auto _ = llvm::make_scope_exit([&]() {2970    // The flag indicates if we are still waiting for 'eod'.2971    if (CurLexer->ParsingPreprocessorDirective)2972      DiscardUntilEndOfDirective();2973  });2974 2975  // Used to un-poison and then re-poison identifiers of the __VA_ARGS__ ilk2976  // within their appropriate context.2977  VariadicMacroScopeGuard VariadicMacroScopeGuard(*this);2978 2979  // If this is a function-like macro definition, parse the argument list,2980  // marking each of the identifiers as being used as macro arguments.  Also,2981  // check other constraints on the first token of the macro body.2982  if (Tok.is(tok::eod)) {2983    if (ImmediatelyAfterHeaderGuard) {2984      // Save this macro information since it may part of a header guard.2985      CurPPLexer->MIOpt.SetDefinedMacro(MacroNameTok.getIdentifierInfo(),2986                                        MacroNameTok.getLocation());2987    }2988    // If there is no body to this macro, we have no special handling here.2989  } else if (Tok.hasLeadingSpace()) {2990    // This is a normal token with leading space.  Clear the leading space2991    // marker on the first token to get proper expansion.2992    Tok.clearFlag(Token::LeadingSpace);2993  } else if (Tok.is(tok::l_paren)) {2994    // This is a function-like macro definition.  Read the argument list.2995    MI->setIsFunctionLike();2996    if (ReadMacroParameterList(MI, LastTok))2997      return nullptr;2998 2999    // If this is a definition of an ISO C/C++ variadic function-like macro (not3000    // using the GNU named varargs extension) inform our variadic scope guard3001    // which un-poisons and re-poisons certain identifiers (e.g. __VA_ARGS__)3002    // allowed only within the definition of a variadic macro.3003 3004    if (MI->isC99Varargs()) {3005      VariadicMacroScopeGuard.enterScope();3006    }3007 3008    // Read the first token after the arg list for down below.3009    LexUnexpandedToken(Tok);3010  } else if (LangOpts.C99 || LangOpts.CPlusPlus11) {3011    // C99 requires whitespace between the macro definition and the body.  Emit3012    // a diagnostic for something like "#define X+".3013    Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);3014  } else {3015    // C90 6.8 TC1 says: "In the definition of an object-like macro, if the3016    // first character of a replacement list is not a character required by3017    // subclause 5.2.1, then there shall be white-space separation between the3018    // identifier and the replacement list.".  5.2.1 lists this set:3019    //   "A-Za-z0-9!"#%&'()*+,_./:;<=>?[\]^_{|}~" as well as whitespace, which3020    // is irrelevant here.3021    bool isInvalid = false;3022    if (Tok.is(tok::at)) // @ is not in the list above.3023      isInvalid = true;3024    else if (Tok.is(tok::unknown)) {3025      // If we have an unknown token, it is something strange like "`".  Since3026      // all of valid characters would have lexed into a single character3027      // token of some sort, we know this is not a valid case.3028      isInvalid = true;3029    }3030    if (isInvalid)3031      Diag(Tok, diag::ext_missing_whitespace_after_macro_name);3032    else3033      Diag(Tok, diag::warn_missing_whitespace_after_macro_name);3034  }3035 3036  if (!Tok.is(tok::eod))3037    LastTok = Tok;3038 3039  SmallVector<Token, 16> Tokens;3040 3041  // Read the rest of the macro body.3042  if (MI->isObjectLike()) {3043    // Object-like macros are very simple, just read their body.3044    while (Tok.isNot(tok::eod)) {3045      LastTok = Tok;3046      Tokens.push_back(Tok);3047      // Get the next token of the macro.3048      LexUnexpandedToken(Tok);3049    }3050  } else {3051    // Otherwise, read the body of a function-like macro.  While we are at it,3052    // check C99 6.10.3.2p1: ensure that # operators are followed by macro3053    // parameters in function-like macro expansions.3054 3055    VAOptDefinitionContext VAOCtx(*this);3056 3057    while (Tok.isNot(tok::eod)) {3058      LastTok = Tok;3059 3060      if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {3061        Tokens.push_back(Tok);3062 3063        if (VAOCtx.isVAOptToken(Tok)) {3064          // If we're already within a VAOPT, emit an error.3065          if (VAOCtx.isInVAOpt()) {3066            Diag(Tok, diag::err_pp_vaopt_nested_use);3067            return nullptr;3068          }3069          // Ensure VAOPT is followed by a '(' .3070          LexUnexpandedToken(Tok);3071          if (Tok.isNot(tok::l_paren)) {3072            Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use);3073            return nullptr;3074          }3075          Tokens.push_back(Tok);3076          VAOCtx.sawVAOptFollowedByOpeningParens(Tok.getLocation());3077          LexUnexpandedToken(Tok);3078          if (Tok.is(tok::hashhash)) {3079            Diag(Tok, diag::err_vaopt_paste_at_start);3080            return nullptr;3081          }3082          continue;3083        } else if (VAOCtx.isInVAOpt()) {3084          if (Tok.is(tok::r_paren)) {3085            if (VAOCtx.sawClosingParen()) {3086              assert(Tokens.size() >= 3 &&3087                     "Must have seen at least __VA_OPT__( "3088                     "and a subsequent tok::r_paren");3089              if (Tokens[Tokens.size() - 2].is(tok::hashhash)) {3090                Diag(Tok, diag::err_vaopt_paste_at_end);3091                return nullptr;3092              }3093            }3094          } else if (Tok.is(tok::l_paren)) {3095            VAOCtx.sawOpeningParen(Tok.getLocation());3096          }3097        }3098        // Get the next token of the macro.3099        LexUnexpandedToken(Tok);3100        continue;3101      }3102 3103      // If we're in -traditional mode, then we should ignore stringification3104      // and token pasting. Mark the tokens as unknown so as not to confuse3105      // things.3106      if (getLangOpts().TraditionalCPP) {3107        Tok.setKind(tok::unknown);3108        Tokens.push_back(Tok);3109 3110        // Get the next token of the macro.3111        LexUnexpandedToken(Tok);3112        continue;3113      }3114 3115      if (Tok.is(tok::hashhash)) {3116        // If we see token pasting, check if it looks like the gcc comma3117        // pasting extension.  We'll use this information to suppress3118        // diagnostics later on.3119 3120        // Get the next token of the macro.3121        LexUnexpandedToken(Tok);3122 3123        if (Tok.is(tok::eod)) {3124          Tokens.push_back(LastTok);3125          break;3126        }3127 3128        if (!Tokens.empty() && Tok.getIdentifierInfo() == Ident__VA_ARGS__ &&3129            Tokens[Tokens.size() - 1].is(tok::comma))3130          MI->setHasCommaPasting();3131 3132        // Things look ok, add the '##' token to the macro.3133        Tokens.push_back(LastTok);3134        continue;3135      }3136 3137      // Our Token is a stringization operator.3138      // Get the next token of the macro.3139      LexUnexpandedToken(Tok);3140 3141      // Check for a valid macro arg identifier or __VA_OPT__.3142      if (!VAOCtx.isVAOptToken(Tok) &&3143          (Tok.getIdentifierInfo() == nullptr ||3144           MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) {3145 3146        // If this is assembler-with-cpp mode, we accept random gibberish after3147        // the '#' because '#' is often a comment character.  However, change3148        // the kind of the token to tok::unknown so that the preprocessor isn't3149        // confused.3150        if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) {3151          LastTok.setKind(tok::unknown);3152          Tokens.push_back(LastTok);3153          continue;3154        } else {3155          Diag(Tok, diag::err_pp_stringize_not_parameter)3156            << LastTok.is(tok::hashat);3157          return nullptr;3158        }3159      }3160 3161      // Things look ok, add the '#' and param name tokens to the macro.3162      Tokens.push_back(LastTok);3163 3164      // If the token following '#' is VAOPT, let the next iteration handle it3165      // and check it for correctness, otherwise add the token and prime the3166      // loop with the next one.3167      if (!VAOCtx.isVAOptToken(Tok)) {3168        Tokens.push_back(Tok);3169        LastTok = Tok;3170 3171        // Get the next token of the macro.3172        LexUnexpandedToken(Tok);3173      }3174    }3175    if (VAOCtx.isInVAOpt()) {3176      assert(Tok.is(tok::eod) && "Must be at End Of preprocessing Directive");3177      Diag(Tok, diag::err_pp_expected_after)3178        << LastTok.getKind() << tok::r_paren;3179      Diag(VAOCtx.getUnmatchedOpeningParenLoc(), diag::note_matching) << tok::l_paren;3180      return nullptr;3181    }3182  }3183  MI->setDefinitionEndLoc(LastTok.getLocation());3184 3185  MI->setTokens(Tokens, BP);3186  return MI;3187}3188 3189static bool isObjCProtectedMacro(const IdentifierInfo *II) {3190  return II->isStr("__strong") || II->isStr("__weak") ||3191         II->isStr("__unsafe_unretained") || II->isStr("__autoreleasing");3192}3193 3194/// HandleDefineDirective - Implements \#define.  This consumes the entire macro3195/// line then lets the caller lex the next real token.3196void Preprocessor::HandleDefineDirective(3197    Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) {3198  ++NumDefined;3199 3200  Token MacroNameTok;3201  bool MacroShadowsKeyword;3202  ReadMacroName(MacroNameTok, MU_Define, &MacroShadowsKeyword);3203 3204  // Error reading macro name?  If so, diagnostic already issued.3205  if (MacroNameTok.is(tok::eod))3206    return;3207 3208  IdentifierInfo *II = MacroNameTok.getIdentifierInfo();3209  // Issue a final pragma warning if we're defining a macro that was has been3210  // undefined and is being redefined.3211  if (!II->hasMacroDefinition() && II->hadMacroDefinition() && II->isFinal())3212    emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/false);3213 3214  // If we are supposed to keep comments in #defines, reenable comment saving3215  // mode.3216  if (CurLexer) CurLexer->SetCommentRetentionState(KeepMacroComments);3217 3218  MacroInfo *const MI = ReadOptionalMacroParameterListAndBody(3219      MacroNameTok, ImmediatelyAfterHeaderGuard);3220 3221  if (!MI) return;3222 3223  if (MacroShadowsKeyword &&3224      !isConfigurationPattern(MacroNameTok, MI, getLangOpts())) {3225    Diag(MacroNameTok, diag::warn_pp_macro_hides_keyword);3226  }3227  // Check that there is no paste (##) operator at the beginning or end of the3228  // replacement list.3229  unsigned NumTokens = MI->getNumTokens();3230  if (NumTokens != 0) {3231    if (MI->getReplacementToken(0).is(tok::hashhash)) {3232      Diag(MI->getReplacementToken(0), diag::err_paste_at_start);3233      return;3234    }3235    if (MI->getReplacementToken(NumTokens-1).is(tok::hashhash)) {3236      Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end);3237      return;3238    }3239  }3240 3241  // When skipping just warn about macros that do not match.3242  if (SkippingUntilPCHThroughHeader) {3243    const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo());3244    if (!OtherMI || !MI->isIdenticalTo(*OtherMI, *this,3245                             /*Syntactic=*/LangOpts.MicrosoftExt))3246      Diag(MI->getDefinitionLoc(), diag::warn_pp_macro_def_mismatch_with_pch)3247          << MacroNameTok.getIdentifierInfo();3248    // Issue the diagnostic but allow the change if msvc extensions are enabled3249    if (!LangOpts.MicrosoftExt)3250      return;3251  }3252 3253  // Finally, if this identifier already had a macro defined for it, verify that3254  // the macro bodies are identical, and issue diagnostics if they are not.3255  if (const MacroInfo *OtherMI=getMacroInfo(MacroNameTok.getIdentifierInfo())) {3256    // Final macros are hard-mode: they always warn. Even if the bodies are3257    // identical. Even if they are in system headers. Even if they are things we3258    // would silently allow in the past.3259    if (MacroNameTok.getIdentifierInfo()->isFinal())3260      emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/false);3261 3262    // In Objective-C, ignore attempts to directly redefine the builtin3263    // definitions of the ownership qualifiers.  It's still possible to3264    // #undef them.3265    if (getLangOpts().ObjC &&3266        SourceMgr.getFileID(OtherMI->getDefinitionLoc()) ==3267            getPredefinesFileID() &&3268        isObjCProtectedMacro(MacroNameTok.getIdentifierInfo())) {3269      // Warn if it changes the tokens.3270      if ((!getDiagnostics().getSuppressSystemWarnings() ||3271           !SourceMgr.isInSystemHeader(DefineTok.getLocation())) &&3272          !MI->isIdenticalTo(*OtherMI, *this,3273                             /*Syntactic=*/LangOpts.MicrosoftExt)) {3274        Diag(MI->getDefinitionLoc(), diag::warn_pp_objc_macro_redef_ignored);3275      }3276      assert(!OtherMI->isWarnIfUnused());3277      return;3278    }3279 3280    // It is very common for system headers to have tons of macro redefinitions3281    // and for warnings to be disabled in system headers.  If this is the case,3282    // then don't bother calling MacroInfo::isIdenticalTo.3283    if (!getDiagnostics().getSuppressSystemWarnings() ||3284        !SourceMgr.isInSystemHeader(DefineTok.getLocation())) {3285 3286      if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())3287        Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);3288 3289      // Warn if defining "__LINE__" and other builtins, per C99 6.10.8/4 and3290      // C++ [cpp.predefined]p4, but allow it as an extension.3291      if (isLanguageDefinedBuiltin(SourceMgr, OtherMI, II->getName()))3292        Diag(MacroNameTok, diag::ext_pp_redef_builtin_macro);3293      // Macros must be identical.  This means all tokens and whitespace3294      // separation must be the same.  C99 6.10.3p2.3295      else if (!OtherMI->isAllowRedefinitionsWithoutWarning() &&3296               !MI->isIdenticalTo(*OtherMI, *this, /*Syntactic=*/LangOpts.MicrosoftExt)) {3297        Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef)3298          << MacroNameTok.getIdentifierInfo();3299        Diag(OtherMI->getDefinitionLoc(), diag::note_previous_definition);3300      }3301    }3302    if (OtherMI->isWarnIfUnused())3303      WarnUnusedMacroLocs.erase(OtherMI->getDefinitionLoc());3304  }3305 3306  DefMacroDirective *MD =3307      appendDefMacroDirective(MacroNameTok.getIdentifierInfo(), MI);3308 3309  assert(!MI->isUsed());3310  // If we need warning for not using the macro, add its location in the3311  // warn-because-unused-macro set. If it gets used it will be removed from set.3312  if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) &&3313      !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc()) &&3314      !MacroExpansionInDirectivesOverride &&3315      getSourceManager().getFileID(MI->getDefinitionLoc()) !=3316          getPredefinesFileID()) {3317    MI->setIsWarnIfUnused(true);3318    WarnUnusedMacroLocs.insert(MI->getDefinitionLoc());3319  }3320 3321  // If the callbacks want to know, tell them about the macro definition.3322  if (Callbacks)3323    Callbacks->MacroDefined(MacroNameTok, MD);3324}3325 3326/// HandleUndefDirective - Implements \#undef.3327///3328void Preprocessor::HandleUndefDirective() {3329  ++NumUndefined;3330 3331  Token MacroNameTok;3332  ReadMacroName(MacroNameTok, MU_Undef);3333 3334  // Error reading macro name?  If so, diagnostic already issued.3335  if (MacroNameTok.is(tok::eod))3336    return;3337 3338  // Check to see if this is the last token on the #undef line.3339  CheckEndOfDirective("undef");3340 3341  // Okay, we have a valid identifier to undef.3342  auto *II = MacroNameTok.getIdentifierInfo();3343  auto MD = getMacroDefinition(II);3344  UndefMacroDirective *Undef = nullptr;3345 3346  if (II->isFinal())3347    emitFinalMacroWarning(MacroNameTok, /*IsUndef=*/true);3348 3349  // If the macro is not defined, this is a noop undef.3350  if (const MacroInfo *MI = MD.getMacroInfo()) {3351    if (!MI->isUsed() && MI->isWarnIfUnused())3352      Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);3353 3354    // Warn if undefining "__LINE__" and other builtins, per C99 6.10.8/4 and3355    // C++ [cpp.predefined]p4, but allow it as an extension.3356    if (isLanguageDefinedBuiltin(SourceMgr, MI, II->getName()))3357      Diag(MacroNameTok, diag::ext_pp_undef_builtin_macro);3358 3359    if (MI->isWarnIfUnused())3360      WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());3361 3362    Undef = AllocateUndefMacroDirective(MacroNameTok.getLocation());3363  }3364 3365  // If the callbacks want to know, tell them about the macro #undef.3366  // Note: no matter if the macro was defined or not.3367  if (Callbacks)3368    Callbacks->MacroUndefined(MacroNameTok, MD, Undef);3369 3370  if (Undef)3371    appendMacroDirective(II, Undef);3372}3373 3374//===----------------------------------------------------------------------===//3375// Preprocessor Conditional Directive Handling.3376//===----------------------------------------------------------------------===//3377 3378/// HandleIfdefDirective - Implements the \#ifdef/\#ifndef directive.  isIfndef3379/// is true when this is a \#ifndef directive.  ReadAnyTokensBeforeDirective is3380/// true if any tokens have been returned or pp-directives activated before this3381/// \#ifndef has been lexed.3382///3383void Preprocessor::HandleIfdefDirective(Token &Result,3384                                        const Token &HashToken,3385                                        bool isIfndef,3386                                        bool ReadAnyTokensBeforeDirective) {3387  ++NumIf;3388  Token DirectiveTok = Result;3389 3390  Token MacroNameTok;3391  ReadMacroName(MacroNameTok);3392 3393  // Error reading macro name?  If so, diagnostic already issued.3394  if (MacroNameTok.is(tok::eod)) {3395    // Skip code until we get to #endif.  This helps with recovery by not3396    // emitting an error when the #endif is reached.3397    SkipExcludedConditionalBlock(HashToken.getLocation(),3398                                 DirectiveTok.getLocation(),3399                                 /*Foundnonskip*/ false, /*FoundElse*/ false);3400    return;3401  }3402 3403  emitMacroExpansionWarnings(MacroNameTok, /*IsIfnDef=*/true);3404 3405  // Check to see if this is the last token on the #if[n]def line.3406  CheckEndOfDirective(isIfndef ? "ifndef" : "ifdef");3407 3408  IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();3409  auto MD = getMacroDefinition(MII);3410  MacroInfo *MI = MD.getMacroInfo();3411 3412  if (CurPPLexer->getConditionalStackDepth() == 0) {3413    // If the start of a top-level #ifdef and if the macro is not defined,3414    // inform MIOpt that this might be the start of a proper include guard.3415    // Otherwise it is some other form of unknown conditional which we can't3416    // handle.3417    if (!ReadAnyTokensBeforeDirective && !MI) {3418      assert(isIfndef && "#ifdef shouldn't reach here");3419      CurPPLexer->MIOpt.EnterTopLevelIfndef(MII, MacroNameTok.getLocation());3420    } else3421      CurPPLexer->MIOpt.EnterTopLevelConditional();3422  }3423 3424  // If there is a macro, process it.3425  if (MI)  // Mark it used.3426    markMacroAsUsed(MI);3427 3428  if (Callbacks) {3429    if (isIfndef)3430      Callbacks->Ifndef(DirectiveTok.getLocation(), MacroNameTok, MD);3431    else3432      Callbacks->Ifdef(DirectiveTok.getLocation(), MacroNameTok, MD);3433  }3434 3435  bool RetainExcludedCB = PPOpts.RetainExcludedConditionalBlocks &&3436    getSourceManager().isInMainFile(DirectiveTok.getLocation());3437 3438  // Should we include the stuff contained by this directive?3439  if (PPOpts.SingleFileParseMode && !MI) {3440    // In 'single-file-parse mode' undefined identifiers trigger parsing of all3441    // the directive blocks.3442    CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),3443                                     /*wasskip*/false, /*foundnonskip*/false,3444                                     /*foundelse*/false);3445  } else if (!MI == isIfndef || RetainExcludedCB) {3446    // Yes, remember that we are inside a conditional, then lex the next token.3447    CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),3448                                     /*wasskip*/false, /*foundnonskip*/true,3449                                     /*foundelse*/false);3450  } else {3451    // No, skip the contents of this block.3452    SkipExcludedConditionalBlock(HashToken.getLocation(),3453                                 DirectiveTok.getLocation(),3454                                 /*Foundnonskip*/ false,3455                                 /*FoundElse*/ false);3456  }3457}3458 3459/// HandleIfDirective - Implements the \#if directive.3460///3461void Preprocessor::HandleIfDirective(Token &IfToken,3462                                     const Token &HashToken,3463                                     bool ReadAnyTokensBeforeDirective) {3464  ++NumIf;3465 3466  // Parse and evaluate the conditional expression.3467  IdentifierInfo *IfNDefMacro = nullptr;3468  const DirectiveEvalResult DER = EvaluateDirectiveExpression(IfNDefMacro);3469  const bool ConditionalTrue = DER.Conditional;3470  // Lexer might become invalid if we hit code completion point while evaluating3471  // expression.3472  if (!CurPPLexer)3473    return;3474 3475  // If this condition is equivalent to #ifndef X, and if this is the first3476  // directive seen, handle it for the multiple-include optimization.3477  if (CurPPLexer->getConditionalStackDepth() == 0) {3478    if (!ReadAnyTokensBeforeDirective && IfNDefMacro && ConditionalTrue)3479      // FIXME: Pass in the location of the macro name, not the 'if' token.3480      CurPPLexer->MIOpt.EnterTopLevelIfndef(IfNDefMacro, IfToken.getLocation());3481    else3482      CurPPLexer->MIOpt.EnterTopLevelConditional();3483  }3484 3485  if (Callbacks)3486    Callbacks->If(3487        IfToken.getLocation(), DER.ExprRange,3488        (ConditionalTrue ? PPCallbacks::CVK_True : PPCallbacks::CVK_False));3489 3490  bool RetainExcludedCB = PPOpts.RetainExcludedConditionalBlocks &&3491    getSourceManager().isInMainFile(IfToken.getLocation());3492 3493  // Should we include the stuff contained by this directive?3494  if (PPOpts.SingleFileParseMode && DER.IncludedUndefinedIds) {3495    // In 'single-file-parse mode' undefined identifiers trigger parsing of all3496    // the directive blocks.3497    CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,3498                                     /*foundnonskip*/false, /*foundelse*/false);3499  } else if (ConditionalTrue || RetainExcludedCB) {3500    // Yes, remember that we are inside a conditional, then lex the next token.3501    CurPPLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,3502                                   /*foundnonskip*/true, /*foundelse*/false);3503  } else {3504    // No, skip the contents of this block.3505    SkipExcludedConditionalBlock(HashToken.getLocation(), IfToken.getLocation(),3506                                 /*Foundnonskip*/ false,3507                                 /*FoundElse*/ false);3508  }3509}3510 3511/// HandleEndifDirective - Implements the \#endif directive.3512///3513void Preprocessor::HandleEndifDirective(Token &EndifToken) {3514  ++NumEndif;3515 3516  // Check that this is the whole directive.3517  CheckEndOfDirective("endif");3518 3519  PPConditionalInfo CondInfo;3520  if (CurPPLexer->popConditionalLevel(CondInfo)) {3521    // No conditionals on the stack: this is an #endif without an #if.3522    Diag(EndifToken, diag::err_pp_endif_without_if);3523    return;3524  }3525 3526  // If this the end of a top-level #endif, inform MIOpt.3527  if (CurPPLexer->getConditionalStackDepth() == 0)3528    CurPPLexer->MIOpt.ExitTopLevelConditional();3529 3530  assert(!CondInfo.WasSkipping && !CurPPLexer->LexingRawMode &&3531         "This code should only be reachable in the non-skipping case!");3532 3533  if (Callbacks)3534    Callbacks->Endif(EndifToken.getLocation(), CondInfo.IfLoc);3535}3536 3537/// HandleElseDirective - Implements the \#else directive.3538///3539void Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) {3540  ++NumElse;3541 3542  // #else directive in a non-skipping conditional... start skipping.3543  CheckEndOfDirective("else");3544 3545  PPConditionalInfo CI;3546  if (CurPPLexer->popConditionalLevel(CI)) {3547    Diag(Result, diag::pp_err_else_without_if);3548    return;3549  }3550 3551  // If this is a top-level #else, inform the MIOpt.3552  if (CurPPLexer->getConditionalStackDepth() == 0)3553    CurPPLexer->MIOpt.EnterTopLevelConditional();3554 3555  // If this is a #else with a #else before it, report the error.3556  if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);3557 3558  if (Callbacks)3559    Callbacks->Else(Result.getLocation(), CI.IfLoc);3560 3561  bool RetainExcludedCB = PPOpts.RetainExcludedConditionalBlocks &&3562    getSourceManager().isInMainFile(Result.getLocation());3563 3564  if ((PPOpts.SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {3565    // In 'single-file-parse mode' undefined identifiers trigger parsing of all3566    // the directive blocks.3567    CurPPLexer->pushConditionalLevel(CI.IfLoc, /*wasskip*/false,3568                                     /*foundnonskip*/false, /*foundelse*/true);3569    return;3570  }3571 3572  // Finally, skip the rest of the contents of this block.3573  SkipExcludedConditionalBlock(HashToken.getLocation(), CI.IfLoc,3574                               /*Foundnonskip*/ true,3575                               /*FoundElse*/ true, Result.getLocation());3576}3577 3578/// Implements the \#elif, \#elifdef, and \#elifndef directives.3579void Preprocessor::HandleElifFamilyDirective(Token &ElifToken,3580                                             const Token &HashToken,3581                                             tok::PPKeywordKind Kind) {3582  PPElifDiag DirKind = Kind == tok::pp_elif      ? PED_Elif3583                       : Kind == tok::pp_elifdef ? PED_Elifdef3584                                                 : PED_Elifndef;3585  ++NumElse;3586 3587  // Warn if using `#elifdef` & `#elifndef` in not C23 & C++23 mode.3588  switch (DirKind) {3589  case PED_Elifdef:3590  case PED_Elifndef:3591    unsigned DiagID;3592    if (LangOpts.CPlusPlus)3593      DiagID = LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_pp_directive3594                                    : diag::ext_cxx23_pp_directive;3595    else3596      DiagID = LangOpts.C23 ? diag::warn_c23_compat_pp_directive3597                            : diag::ext_c23_pp_directive;3598    Diag(ElifToken, DiagID) << DirKind;3599    break;3600  default:3601    break;3602  }3603 3604  // #elif directive in a non-skipping conditional... start skipping.3605  // We don't care what the condition is, because we will always skip it (since3606  // the block immediately before it was included).3607  SourceRange ConditionRange = DiscardUntilEndOfDirective();3608 3609  PPConditionalInfo CI;3610  if (CurPPLexer->popConditionalLevel(CI)) {3611    Diag(ElifToken, diag::pp_err_elif_without_if) << DirKind;3612    return;3613  }3614 3615  // If this is a top-level #elif, inform the MIOpt.3616  if (CurPPLexer->getConditionalStackDepth() == 0)3617    CurPPLexer->MIOpt.EnterTopLevelConditional();3618 3619  // If this is a #elif with a #else before it, report the error.3620  if (CI.FoundElse)3621    Diag(ElifToken, diag::pp_err_elif_after_else) << DirKind;3622 3623  if (Callbacks) {3624    switch (Kind) {3625    case tok::pp_elif:3626      Callbacks->Elif(ElifToken.getLocation(), ConditionRange,3627                      PPCallbacks::CVK_NotEvaluated, CI.IfLoc);3628      break;3629    case tok::pp_elifdef:3630      Callbacks->Elifdef(ElifToken.getLocation(), ConditionRange, CI.IfLoc);3631      break;3632    case tok::pp_elifndef:3633      Callbacks->Elifndef(ElifToken.getLocation(), ConditionRange, CI.IfLoc);3634      break;3635    default:3636      assert(false && "unexpected directive kind");3637      break;3638    }3639  }3640 3641  bool RetainExcludedCB = PPOpts.RetainExcludedConditionalBlocks &&3642    getSourceManager().isInMainFile(ElifToken.getLocation());3643 3644  if ((PPOpts.SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {3645    // In 'single-file-parse mode' undefined identifiers trigger parsing of all3646    // the directive blocks.3647    CurPPLexer->pushConditionalLevel(ElifToken.getLocation(), /*wasskip*/false,3648                                     /*foundnonskip*/false, /*foundelse*/false);3649    return;3650  }3651 3652  // Finally, skip the rest of the contents of this block.3653  SkipExcludedConditionalBlock(3654      HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true,3655      /*FoundElse*/ CI.FoundElse, ElifToken.getLocation());3656}3657 3658std::optional<LexEmbedParametersResult>3659Preprocessor::LexEmbedParameters(Token &CurTok, bool ForHasEmbed) {3660  LexEmbedParametersResult Result{};3661  tok::TokenKind EndTokenKind = ForHasEmbed ? tok::r_paren : tok::eod;3662 3663  auto DiagMismatchedBracesAndSkipToEOD =3664      [&](tok::TokenKind Expected,3665          std::pair<tok::TokenKind, SourceLocation> Matches) {3666        Diag(CurTok, diag::err_expected) << Expected;3667        Diag(Matches.second, diag::note_matching) << Matches.first;3668        if (CurTok.isNot(EndTokenKind))3669          DiscardUntilEndOfDirective(CurTok);3670      };3671 3672  auto ExpectOrDiagAndSkipToEOD = [&](tok::TokenKind Kind) {3673    if (CurTok.isNot(Kind)) {3674      Diag(CurTok, diag::err_expected) << Kind;3675      if (CurTok.isNot(EndTokenKind))3676        DiscardUntilEndOfDirective(CurTok);3677      return false;3678    }3679    return true;3680  };3681 3682  // C23 6.10:3683  // pp-parameter-name:3684  //   pp-standard-parameter3685  //   pp-prefixed-parameter3686  //3687  // pp-standard-parameter:3688  //   identifier3689  //3690  // pp-prefixed-parameter:3691  //   identifier :: identifier3692  auto LexPPParameterName = [&]() -> std::optional<std::string> {3693    // We expect the current token to be an identifier; if it's not, things3694    // have gone wrong.3695    if (!ExpectOrDiagAndSkipToEOD(tok::identifier))3696      return std::nullopt;3697 3698    const IdentifierInfo *Prefix = CurTok.getIdentifierInfo();3699 3700    // Lex another token; it is either a :: or we're done with the parameter3701    // name.3702    LexNonComment(CurTok);3703    if (CurTok.is(tok::coloncolon)) {3704      // We found a ::, so lex another identifier token.3705      LexNonComment(CurTok);3706      if (!ExpectOrDiagAndSkipToEOD(tok::identifier))3707        return std::nullopt;3708 3709      const IdentifierInfo *Suffix = CurTok.getIdentifierInfo();3710 3711      // Lex another token so we're past the name.3712      LexNonComment(CurTok);3713      return (llvm::Twine(Prefix->getName()) + "::" + Suffix->getName()).str();3714    }3715    return Prefix->getName().str();3716  };3717 3718  // C23 6.10p5: In all aspects, a preprocessor standard parameter specified by3719  // this document as an identifier pp_param and an identifier of the form3720  // __pp_param__ shall behave the same when used as a preprocessor parameter,3721  // except for the spelling.3722  auto NormalizeParameterName = [](StringRef Name) {3723    if (Name.size() > 4 && Name.starts_with("__") && Name.ends_with("__"))3724      return Name.substr(2, Name.size() - 4);3725    return Name;3726  };3727 3728  auto LexParenthesizedIntegerExpr = [&]() -> std::optional<size_t> {3729    // we have a limit parameter and its internals are processed using3730    // evaluation rules from #if.3731    if (!ExpectOrDiagAndSkipToEOD(tok::l_paren))3732      return std::nullopt;3733 3734    // We do not consume the ( because EvaluateDirectiveExpression will lex3735    // the next token for us.3736    IdentifierInfo *ParameterIfNDef = nullptr;3737    bool EvaluatedDefined;3738    DirectiveEvalResult LimitEvalResult = EvaluateDirectiveExpression(3739        ParameterIfNDef, CurTok, EvaluatedDefined, /*CheckForEOD=*/false);3740 3741    if (!LimitEvalResult.Value) {3742      // If there was an error evaluating the directive expression, we expect3743      // to be at the end of directive token.3744      assert(CurTok.is(tok::eod) && "expect to be at the end of directive");3745      return std::nullopt;3746    }3747 3748    if (!ExpectOrDiagAndSkipToEOD(tok::r_paren))3749      return std::nullopt;3750 3751    // Eat the ).3752    LexNonComment(CurTok);3753 3754    // C23 6.10.3.2p2: The token defined shall not appear within the constant3755    // expression.3756    if (EvaluatedDefined) {3757      Diag(CurTok, diag::err_defined_in_pp_embed);3758      return std::nullopt;3759    }3760 3761    if (LimitEvalResult.Value) {3762      const llvm::APSInt &Result = *LimitEvalResult.Value;3763      if (Result.isNegative()) {3764        Diag(CurTok, diag::err_requires_positive_value)3765            << toString(Result, 10) << /*positive*/ 0;3766        if (CurTok.isNot(EndTokenKind))3767          DiscardUntilEndOfDirective(CurTok);3768        return std::nullopt;3769      }3770      return Result.getLimitedValue();3771    }3772    return std::nullopt;3773  };3774 3775  auto GetMatchingCloseBracket = [](tok::TokenKind Kind) {3776    switch (Kind) {3777    case tok::l_paren:3778      return tok::r_paren;3779    case tok::l_brace:3780      return tok::r_brace;3781    case tok::l_square:3782      return tok::r_square;3783    default:3784      llvm_unreachable("should not get here");3785    }3786  };3787 3788  auto LexParenthesizedBalancedTokenSoup =3789      [&](llvm::SmallVectorImpl<Token> &Tokens) {3790        std::vector<std::pair<tok::TokenKind, SourceLocation>> BracketStack;3791 3792        // We expect the current token to be a left paren.3793        if (!ExpectOrDiagAndSkipToEOD(tok::l_paren))3794          return false;3795        LexNonComment(CurTok); // Eat the (3796 3797        bool WaitingForInnerCloseParen = false;3798        while (CurTok.isNot(tok::eod) &&3799               (WaitingForInnerCloseParen || CurTok.isNot(tok::r_paren))) {3800          switch (CurTok.getKind()) {3801          default: // Shutting up diagnostics about not fully-covered switch.3802            break;3803          case tok::l_paren:3804            WaitingForInnerCloseParen = true;3805            [[fallthrough]];3806          case tok::l_brace:3807          case tok::l_square:3808            BracketStack.push_back({CurTok.getKind(), CurTok.getLocation()});3809            break;3810          case tok::r_paren:3811            WaitingForInnerCloseParen = false;3812            [[fallthrough]];3813          case tok::r_brace:3814          case tok::r_square: {3815            if (BracketStack.empty()) {3816              ExpectOrDiagAndSkipToEOD(tok::r_paren);3817              return false;3818            }3819            tok::TokenKind Matching =3820                GetMatchingCloseBracket(BracketStack.back().first);3821            if (CurTok.getKind() != Matching) {3822              DiagMismatchedBracesAndSkipToEOD(Matching, BracketStack.back());3823              return false;3824            }3825            BracketStack.pop_back();3826          } break;3827          }3828          Tokens.push_back(CurTok);3829          LexNonComment(CurTok);3830        }3831 3832        // When we're done, we want to eat the closing paren.3833        if (!ExpectOrDiagAndSkipToEOD(tok::r_paren))3834          return false;3835 3836        LexNonComment(CurTok); // Eat the )3837        return true;3838      };3839 3840  LexNonComment(CurTok); // Prime the pump.3841  while (!CurTok.isOneOf(EndTokenKind, tok::eod)) {3842    SourceLocation ParamStartLoc = CurTok.getLocation();3843    std::optional<std::string> ParamName = LexPPParameterName();3844    if (!ParamName)3845      return std::nullopt;3846    StringRef Parameter = NormalizeParameterName(*ParamName);3847 3848    // Lex the parameters (dependent on the parameter type we want!).3849    //3850    // C23 6.10.3.Xp1: The X standard embed parameter may appear zero times or3851    // one time in the embed parameter sequence.3852    if (Parameter == "limit") {3853      if (Result.MaybeLimitParam)3854        Diag(CurTok, diag::err_pp_embed_dup_params) << Parameter;3855 3856      std::optional<size_t> Limit = LexParenthesizedIntegerExpr();3857      if (!Limit)3858        return std::nullopt;3859      Result.MaybeLimitParam =3860          PPEmbedParameterLimit{*Limit, {ParamStartLoc, CurTok.getLocation()}};3861    } else if (Parameter == "clang::offset") {3862      if (Result.MaybeOffsetParam)3863        Diag(CurTok, diag::err_pp_embed_dup_params) << Parameter;3864 3865      std::optional<size_t> Offset = LexParenthesizedIntegerExpr();3866      if (!Offset)3867        return std::nullopt;3868      Result.MaybeOffsetParam = PPEmbedParameterOffset{3869          *Offset, {ParamStartLoc, CurTok.getLocation()}};3870    } else if (Parameter == "prefix") {3871      if (Result.MaybePrefixParam)3872        Diag(CurTok, diag::err_pp_embed_dup_params) << Parameter;3873 3874      SmallVector<Token, 4> Soup;3875      if (!LexParenthesizedBalancedTokenSoup(Soup))3876        return std::nullopt;3877      Result.MaybePrefixParam = PPEmbedParameterPrefix{3878          std::move(Soup), {ParamStartLoc, CurTok.getLocation()}};3879    } else if (Parameter == "suffix") {3880      if (Result.MaybeSuffixParam)3881        Diag(CurTok, diag::err_pp_embed_dup_params) << Parameter;3882 3883      SmallVector<Token, 4> Soup;3884      if (!LexParenthesizedBalancedTokenSoup(Soup))3885        return std::nullopt;3886      Result.MaybeSuffixParam = PPEmbedParameterSuffix{3887          std::move(Soup), {ParamStartLoc, CurTok.getLocation()}};3888    } else if (Parameter == "if_empty") {3889      if (Result.MaybeIfEmptyParam)3890        Diag(CurTok, diag::err_pp_embed_dup_params) << Parameter;3891 3892      SmallVector<Token, 4> Soup;3893      if (!LexParenthesizedBalancedTokenSoup(Soup))3894        return std::nullopt;3895      Result.MaybeIfEmptyParam = PPEmbedParameterIfEmpty{3896          std::move(Soup), {ParamStartLoc, CurTok.getLocation()}};3897    } else {3898      ++Result.UnrecognizedParams;3899 3900      // If there's a left paren, we need to parse a balanced token sequence3901      // and just eat those tokens.3902      if (CurTok.is(tok::l_paren)) {3903        SmallVector<Token, 4> Soup;3904        if (!LexParenthesizedBalancedTokenSoup(Soup))3905          return std::nullopt;3906      }3907      if (!ForHasEmbed) {3908        Diag(ParamStartLoc, diag::err_pp_unknown_parameter) << 1 << Parameter;3909        if (CurTok.isNot(EndTokenKind))3910          DiscardUntilEndOfDirective(CurTok);3911        return std::nullopt;3912      }3913    }3914  }3915  return Result;3916}3917 3918void Preprocessor::HandleEmbedDirectiveImpl(3919    SourceLocation HashLoc, const LexEmbedParametersResult &Params,3920    StringRef BinaryContents, StringRef FileName) {3921  if (BinaryContents.empty()) {3922    // If we have no binary contents, the only thing we need to emit are the3923    // if_empty tokens, if any.3924    // FIXME: this loses AST fidelity; nothing in the compiler will see that3925    // these tokens came from #embed. We have to hack around this when printing3926    // preprocessed output. The same is true for prefix and suffix tokens.3927    if (Params.MaybeIfEmptyParam) {3928      ArrayRef<Token> Toks = Params.MaybeIfEmptyParam->Tokens;3929      size_t TokCount = Toks.size();3930      auto NewToks = std::make_unique<Token[]>(TokCount);3931      llvm::copy(Toks, NewToks.get());3932      EnterTokenStream(std::move(NewToks), TokCount, true, true);3933    }3934    return;3935  }3936 3937  size_t NumPrefixToks = Params.PrefixTokenCount(),3938         NumSuffixToks = Params.SuffixTokenCount();3939  size_t TotalNumToks = 1 + NumPrefixToks + NumSuffixToks;3940  size_t CurIdx = 0;3941  auto Toks = std::make_unique<Token[]>(TotalNumToks);3942 3943  // Add the prefix tokens, if any.3944  if (Params.MaybePrefixParam) {3945    llvm::copy(Params.MaybePrefixParam->Tokens, &Toks[CurIdx]);3946    CurIdx += NumPrefixToks;3947  }3948 3949  EmbedAnnotationData *Data = new (BP) EmbedAnnotationData;3950  Data->BinaryData = BinaryContents;3951  Data->FileName = FileName;3952 3953  Toks[CurIdx].startToken();3954  Toks[CurIdx].setKind(tok::annot_embed);3955  Toks[CurIdx].setAnnotationRange(HashLoc);3956  Toks[CurIdx++].setAnnotationValue(Data);3957 3958  // Now add the suffix tokens, if any.3959  if (Params.MaybeSuffixParam) {3960    llvm::copy(Params.MaybeSuffixParam->Tokens, &Toks[CurIdx]);3961    CurIdx += NumSuffixToks;3962  }3963 3964  assert(CurIdx == TotalNumToks && "Calculated the incorrect number of tokens");3965  EnterTokenStream(std::move(Toks), TotalNumToks, true, true);3966}3967 3968void Preprocessor::HandleEmbedDirective(SourceLocation HashLoc, Token &EmbedTok,3969                                        const FileEntry *LookupFromFile) {3970  // Give the usual extension/compatibility warnings.3971  if (LangOpts.C23)3972    Diag(EmbedTok, diag::warn_compat_pp_embed_directive);3973  else3974    Diag(EmbedTok, diag::ext_pp_embed_directive)3975        << (LangOpts.CPlusPlus ? /*Clang*/ 1 : /*C23*/ 0);3976 3977  // Parse the filename header3978  Token FilenameTok;3979  if (LexHeaderName(FilenameTok))3980    return;3981 3982  if (FilenameTok.isNot(tok::header_name)) {3983    Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);3984    if (FilenameTok.isNot(tok::eod))3985      DiscardUntilEndOfDirective();3986    return;3987  }3988 3989  // Parse the optional sequence of3990  // directive-parameters:3991  //     identifier parameter-name-list[opt] directive-argument-list[opt]3992  // directive-argument-list:3993  //    '(' balanced-token-sequence ')'3994  // parameter-name-list:3995  //    '::' identifier parameter-name-list[opt]3996  Token CurTok;3997  std::optional<LexEmbedParametersResult> Params =3998      LexEmbedParameters(CurTok, /*ForHasEmbed=*/false);3999 4000  assert((Params || CurTok.is(tok::eod)) &&4001         "expected success or to be at the end of the directive");4002  if (!Params)4003    return;4004 4005  // Now, splat the data out!4006  SmallString<128> FilenameBuffer;4007  StringRef Filename = getSpelling(FilenameTok, FilenameBuffer);4008  StringRef OriginalFilename = Filename;4009  bool isAngled =4010      GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);4011 4012  // If GetIncludeFilenameSpelling set the start ptr to null, there was an4013  // error.4014  if (Filename.empty())4015    return;4016 4017  OptionalFileEntryRef MaybeFileRef =4018      this->LookupEmbedFile(Filename, isAngled, true, LookupFromFile);4019  if (!MaybeFileRef) {4020    // could not find file4021    if (Callbacks && Callbacks->EmbedFileNotFound(Filename)) {4022      return;4023    }4024    Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;4025    return;4026  }4027 4028  if (MaybeFileRef->isDeviceFile()) {4029    Diag(FilenameTok, diag::err_pp_embed_device_file) << Filename;4030    return;4031  }4032 4033  std::optional<llvm::MemoryBufferRef> MaybeFile =4034      getSourceManager().getMemoryBufferForFileOrNone(*MaybeFileRef);4035  if (!MaybeFile) {4036    // could not find file4037    Diag(FilenameTok, diag::err_cannot_open_file)4038        << Filename << "a buffer to the contents could not be created";4039    return;4040  }4041  StringRef BinaryContents = MaybeFile->getBuffer();4042 4043  // The order is important between 'offset' and 'limit'; we want to offset4044  // first and then limit second; otherwise we may reduce the notional resource4045  // size to something too small to offset into.4046  if (Params->MaybeOffsetParam) {4047    // FIXME: just like with the limit() and if_empty() parameters, this loses4048    // source fidelity in the AST; it has no idea that there was an offset4049    // involved.4050    // offsets all the way to the end of the file make for an empty file.4051    BinaryContents = BinaryContents.substr(Params->MaybeOffsetParam->Offset);4052  }4053 4054  if (Params->MaybeLimitParam) {4055    // FIXME: just like with the clang::offset() and if_empty() parameters,4056    // this loses source fidelity in the AST; it has no idea there was a limit4057    // involved.4058    BinaryContents = BinaryContents.substr(0, Params->MaybeLimitParam->Limit);4059  }4060 4061  if (Callbacks)4062    Callbacks->EmbedDirective(HashLoc, Filename, isAngled, MaybeFileRef,4063                              *Params);4064  // getSpelling() may return a buffer from the token itself or it may use the4065  // SmallString buffer we provided. getSpelling() may also return a string that4066  // is actually longer than FilenameTok.getLength(), so we first pass a4067  // locally created buffer to getSpelling() to get the string of real length4068  // and then we allocate a long living buffer because the buffer we used4069  // previously will only live till the end of this function and we need4070  // filename info to live longer.4071  void *Mem = BP.Allocate(OriginalFilename.size(), alignof(char *));4072  memcpy(Mem, OriginalFilename.data(), OriginalFilename.size());4073  StringRef FilenameToGo =4074      StringRef(static_cast<char *>(Mem), OriginalFilename.size());4075  HandleEmbedDirectiveImpl(HashLoc, *Params, BinaryContents, FilenameToGo);4076}4077