/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/lib/Lex/Pragma.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/lib/Lex/Pragma.cpp
Warning:	line 1182, column 7 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name Pragma.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangLex/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangLex/../include -I /usr/src/gnu/usr.bin/clang/libclangLex/obj -I /usr/src/gnu/usr.bin/clang/libclangLex/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangLex/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/lib/Lex/Pragma.cpp

/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/lib/Lex/Pragma.cpp

→

1//===- Pragma.cpp - Pragma registration and handling ----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the PragmaHandler/PragmaTable interfaces and implements
10// pragma related methods of the Preprocessor class.
11//
12//===----------------------------------------------------------------------===//

14#include "clang/Lex/Pragma.h"
15#include "clang/Basic/Diagnostic.h"
16#include "clang/Basic/DiagnosticLex.h"
17#include "clang/Basic/FileManager.h"
18#include "clang/Basic/IdentifierTable.h"
19#include "clang/Basic/LLVM.h"
20#include "clang/Basic/LangOptions.h"
21#include "clang/Basic/Module.h"
22#include "clang/Basic/SourceLocation.h"
23#include "clang/Basic/SourceManager.h"
24#include "clang/Basic/TokenKinds.h"
25#include "clang/Lex/HeaderSearch.h"
26#include "clang/Lex/LexDiagnostic.h"
27#include "clang/Lex/Lexer.h"
28#include "clang/Lex/LiteralSupport.h"
29#include "clang/Lex/MacroInfo.h"
30#include "clang/Lex/ModuleLoader.h"
31#include "clang/Lex/PPCallbacks.h"
32#include "clang/Lex/Preprocessor.h"
33#include "clang/Lex/PreprocessorLexer.h"
34#include "clang/Lex/PreprocessorOptions.h"
35#include "clang/Lex/Token.h"
36#include "clang/Lex/TokenLexer.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/DenseMap.h"
39#include "llvm/ADT/Optional.h"
40#include "llvm/ADT/STLExtras.h"
41#include "llvm/ADT/SmallString.h"
42#include "llvm/ADT/SmallVector.h"
43#include "llvm/ADT/StringRef.h"
44#include "llvm/ADT/StringSwitch.h"
45#include "llvm/Support/Compiler.h"
46#include "llvm/Support/ErrorHandling.h"
47#include "llvm/Support/Timer.h"
48#include <algorithm>
49#include <cassert>
50#include <cstddef>
51#include <cstdint>
52#include <limits>
53#include <string>
54#include <utility>
55#include <vector>

57using namespace clang;

59// Out-of-line destructor to provide a home for the class.
60PragmaHandler::~PragmaHandler() = default;

62//===----------------------------------------------------------------------===//
63// EmptyPragmaHandler Implementation.
64//===----------------------------------------------------------------------===//

66EmptyPragmaHandler::EmptyPragmaHandler(StringRef Name) : PragmaHandler(Name) {}

68void EmptyPragmaHandler::HandlePragma(Preprocessor &PP,
                                    PragmaIntroducer Introducer,
                                    Token &FirstToken) {}

72//===----------------------------------------------------------------------===//
73// PragmaNamespace Implementation.
74//===----------------------------------------------------------------------===//

76/// FindHandler - Check to see if there is already a handler for the
77/// specified name.  If not, return the handler for the null identifier if it
78/// exists, otherwise return null.  If IgnoreNull is true (the default) then
79/// the null handler isn't returned on failure to match.
80PragmaHandler *PragmaNamespace::FindHandler(StringRef Name,
                                          bool IgnoreNull) const {
auto I = Handlers.find(Name);
if (I != Handlers.end())
  return I->getValue().get();
if (IgnoreNull)
  return nullptr;
I = Handlers.find(StringRef());
if (I != Handlers.end())
  return I->getValue().get();
return nullptr;
91}

93void PragmaNamespace::AddPragma(PragmaHandler *Handler) {
assert(!Handlers.count(Handler->getName()) &&((void)0)
       "A handler with this name is already registered in this namespace")((void)0);
Handlers[Handler->getName()].reset(Handler);
97}

99void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) {
auto I = Handlers.find(Handler->getName());
assert(I != Handlers.end() &&((void)0)
       "Handler not registered in this namespace")((void)0);
// Release ownership back to the caller.
I->getValue().release();
Handlers.erase(I);
106}

108void PragmaNamespace::HandlePragma(Preprocessor &PP,
                                 PragmaIntroducer Introducer, Token &Tok) {
// Read the 'namespace' that the directive is in, e.g. STDC.  Do not macro
// expand it, the user can have a STDC #define, that should not affect this.
PP.LexUnexpandedToken(Tok);

// Get the handler for this token.  If there is no handler, ignore the pragma.
PragmaHandler *Handler
  = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName()
                                        : StringRef(),
                /*IgnoreNull=*/false);
if (!Handler) {
  PP.Diag(Tok, diag::warn_pragma_ignored);
  return;
}

// Otherwise, pass it down.
Handler->HandlePragma(PP, Introducer, Tok);
126}

128//===----------------------------------------------------------------------===//
129// Preprocessor Pragma Directive Handling.
130//===----------------------------------------------------------------------===//

132namespace {
133// TokenCollector provides the option to collect tokens that were "read"
134// and return them to the stream to be read later.
135// Currently used when reading _Pragma/__pragma directives.
136struct TokenCollector {
Preprocessor &Self;
bool Collect;
SmallVector<Token, 3> Tokens;
Token &Tok;

void lex() {
  if (Collect)
    Tokens.push_back(Tok);
  Self.Lex(Tok);
}

void revert() {
  assert(Collect && "did not collect tokens")((void)0);
  assert(!Tokens.empty() && "collected unexpected number of tokens")((void)0);

  // Push the ( "string" ) tokens into the token stream.
  auto Toks = std::make_unique<Token[]>(Tokens.size());
  std::copy(Tokens.begin() + 1, Tokens.end(), Toks.get());
  Toks[Tokens.size() - 1] = Tok;
  Self.EnterTokenStream(std::move(Toks), Tokens.size(),
                        /*DisableMacroExpansion*/ true,
                        /*IsReinject*/ true);

  // ... and return the pragma token unchanged.
  Tok = *Tokens.begin();
}
163};
164} // namespace

166/// HandlePragmaDirective - The "\#pragma" directive has been parsed.  Lex the
167/// rest of the pragma, passing it to the registered pragma handlers.
168void Preprocessor::HandlePragmaDirective(PragmaIntroducer Introducer) {
if (Callbacks)
  Callbacks->PragmaDirective(Introducer.Loc, Introducer.Kind);

if (!PragmasEnabled)
  return;

++NumPragma;

// Invoke the first level of pragma handlers which reads the namespace id.
Token Tok;
PragmaHandlers->HandlePragma(*this, Introducer, Tok);

// If the pragma handler didn't read the rest of the line, consume it now.
if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())
 || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
  DiscardUntilEndOfDirective();
185}

187/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then
188/// return the first token after the directive.  The _Pragma token has just
189/// been read into 'Tok'.
190void Preprocessor::Handle_Pragma(Token &Tok) {
// C11 6.10.3.4/3:
//   all pragma unary operator expressions within [a completely
//   macro-replaced preprocessing token sequence] are [...] processed [after
//   rescanning is complete]
//
// This means that we execute _Pragma operators in two cases:
//
//  1) on token sequences that would otherwise be produced as the output of
//     phase 4 of preprocessing, and
//  2) on token sequences formed as the macro-replaced token sequence of a
//     macro argument
//
// Case #2 appears to be a wording bug: only _Pragmas that would survive to
// the end of phase 4 should actually be executed. Discussion on the WG14
// mailing list suggests that a _Pragma operator is notionally checked early,
// but only pragmas that survive to the end of phase 4 should be executed.
//
// In Case #2, we check the syntax now, but then put the tokens back into the
// token stream for later consumption.

TokenCollector Toks = {*this, InMacroArgPreExpansion, {}, Tok};

// Remember the pragma token location.
SourceLocation PragmaLoc = Tok.getLocation();

// Read the '('.
Toks.lex();
if (Tok.isNot(tok::l_paren)) {
  Diag(PragmaLoc, diag::err__Pragma_malformed);
  return;
}

// Read the '"..."'.
Toks.lex();
if (!tok::isStringLiteral(Tok.getKind())) {
  Diag(PragmaLoc, diag::err__Pragma_malformed);
  // Skip bad tokens, and the ')', if present.
  if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof))
    Lex(Tok);
  while (Tok.isNot(tok::r_paren) &&
         !Tok.isAtStartOfLine() &&
         Tok.isNot(tok::eof))
    Lex(Tok);
  if (Tok.is(tok::r_paren))
    Lex(Tok);
  return;
}

if (Tok.hasUDSuffix()) {
  Diag(Tok, diag::err_invalid_string_udl);
  // Skip this token, and the ')', if present.
  Lex(Tok);
  if (Tok.is(tok::r_paren))
    Lex(Tok);
  return;
}

// Remember the string.
Token StrTok = Tok;

// Read the ')'.
Toks.lex();
if (Tok.isNot(tok::r_paren)) {
  Diag(PragmaLoc, diag::err__Pragma_malformed);
  return;
}

// If we're expanding a macro argument, put the tokens back.
if (InMacroArgPreExpansion) {
  Toks.revert();
  return;
}

SourceLocation RParenLoc = Tok.getLocation();
std::string StrVal = getSpelling(StrTok);

// The _Pragma is lexically sound.  Destringize according to C11 6.10.9.1:
// "The string literal is destringized by deleting any encoding prefix,
// deleting the leading and trailing double-quotes, replacing each escape
// sequence \" by a double-quote, and replacing each escape sequence \\ by a
// single backslash."
if (StrVal[0] == 'L' || StrVal[0] == 'U' ||
    (StrVal[0] == 'u' && StrVal[1] != '8'))
  StrVal.erase(StrVal.begin());
else if (StrVal[0] == 'u')
  StrVal.erase(StrVal.begin(), StrVal.begin() + 2);

if (StrVal[0] == 'R') {
  // FIXME: C++11 does not specify how to handle raw-string-literals here.
  // We strip off the 'R', the quotes, the d-char-sequences, and the parens.
  assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' &&((void)0)
         "Invalid raw string token!")((void)0);

  // Measure the length of the d-char-sequence.
  unsigned NumDChars = 0;
  while (StrVal[2 + NumDChars] != '(') {
    assert(NumDChars < (StrVal.size() - 5) / 2 &&((void)0)
           "Invalid raw string token!")((void)0);
    ++NumDChars;
  }
  assert(StrVal[StrVal.size() - 2 - NumDChars] == ')')((void)0);

  // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the
  // parens below.
  StrVal.erase(0, 2 + NumDChars);
  StrVal.erase(StrVal.size() - 1 - NumDChars);
} else {
  assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&((void)0)
         "Invalid string token!")((void)0);

  // Remove escaped quotes and escapes.
  unsigned ResultPos = 1;
  for (size_t i = 1, e = StrVal.size() - 1; i != e; ++i) {
    // Skip escapes.  \\ -> '\' and \" -> '"'.
    if (StrVal[i] == '\\' && i + 1 < e &&
        (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"'))
      ++i;
    StrVal[ResultPos++] = StrVal[i];
  }
  StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);
}

// Remove the front quote, replacing it with a space, so that the pragma
// contents appear to have a space before them.
StrVal[0] = ' ';

// Replace the terminating quote with a \n.
StrVal[StrVal.size()-1] = '\n';

// Plop the string (including the newline and trailing null) into a buffer
// where we can lex it.
Token TmpTok;
TmpTok.startToken();
CreateString(StrVal, TmpTok);
SourceLocation TokLoc = TmpTok.getLocation();

// Make and enter a lexer object so that we lex and expand the tokens just
// like any others.
Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
                                      StrVal.size(), *this);

EnterSourceFileWithLexer(TL, nullptr);

// With everything set up, lex this as a #pragma directive.
HandlePragmaDirective({PIK__Pragma, PragmaLoc});

// Finally, return whatever came after the pragma directive.
return Lex(Tok);
339}

341/// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
342/// is not enclosed within a string literal.
343void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
// During macro pre-expansion, check the syntax now but put the tokens back
// into the token stream for later consumption. Same as Handle_Pragma.
TokenCollector Toks = {*this, InMacroArgPreExpansion, {}, Tok};

// Remember the pragma token location.
SourceLocation PragmaLoc = Tok.getLocation();

// Read the '('.
Toks.lex();
if (Tok.isNot(tok::l_paren)) {
  Diag(PragmaLoc, diag::err__Pragma_malformed);
  return;
}

// Get the tokens enclosed within the __pragma(), as well as the final ')'.
SmallVector<Token, 32> PragmaToks;
int NumParens = 0;
Toks.lex();
while (Tok.isNot(tok::eof)) {
  PragmaToks.push_back(Tok);
  if (Tok.is(tok::l_paren))
    NumParens++;
  else if (Tok.is(tok::r_paren) && NumParens-- == 0)
    break;
  Toks.lex();
}

if (Tok.is(tok::eof)) {
  Diag(PragmaLoc, diag::err_unterminated___pragma);
  return;
}

// If we're expanding a macro argument, put the tokens back.
if (InMacroArgPreExpansion) {
  Toks.revert();
  return;
}

PragmaToks.front().setFlag(Token::LeadingSpace);

// Replace the ')' with an EOD to mark the end of the pragma.
PragmaToks.back().setKind(tok::eod);

Token *TokArray = new Token[PragmaToks.size()];
std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);

// Push the tokens onto the stack.
EnterTokenStream(TokArray, PragmaToks.size(), true, true,
                 /*IsReinject*/ false);

// With everything set up, lex this as a #pragma directive.
HandlePragmaDirective({PIK___pragma, PragmaLoc});

// Finally, return whatever came after the pragma directive.
return Lex(Tok);
399}

401/// HandlePragmaOnce - Handle \#pragma once.  OnceTok is the 'once'.
402void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
// Don't honor the 'once' when handling the primary source file, unless
// this is a prefix to a TU, which indicates we're generating a PCH file, or
// when the main file is a header (e.g. when -xc-header is provided on the
// commandline).
if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) {
  Diag(OnceTok, diag::pp_pragma_once_in_main_file);
  return;
}

// Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
// Mark the file as a once-only file now.
HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
415}

417void Preprocessor::HandlePragmaMark(Token &MarkTok) {
assert(CurPPLexer && "No current lexer?")((void)0);

SmallString<64> Buffer;
CurLexer->ReadToEndOfLine(&Buffer);
if (Callbacks)
  Callbacks->PragmaMark(MarkTok.getLocation(), Buffer);
424}

426/// HandlePragmaPoison - Handle \#pragma GCC poison.  PoisonTok is the 'poison'.
427void Preprocessor::HandlePragmaPoison() {
Token Tok;

while (true) {
  // Read the next token to poison.  While doing this, pretend that we are
  // skipping while reading the identifier to poison.
  // This avoids errors on code like:
  //   #pragma GCC poison X
  //   #pragma GCC poison X
  if (CurPPLexer) CurPPLexer->LexingRawMode = true;
  LexUnexpandedToken(Tok);
  if (CurPPLexer) CurPPLexer->LexingRawMode = false;

  // If we reached the end of line, we're done.
  if (Tok.is(tok::eod)) return;

  // Can only poison identifiers.
  if (Tok.isNot(tok::raw_identifier)) {
    Diag(Tok, diag::err_pp_invalid_poison);
    return;
  }

  // Look up the identifier info for the token.  We disabled identifier lookup
  // by saying we're skipping contents, so we need to do this manually.
  IdentifierInfo *II = LookUpIdentifierInfo(Tok);

  // Already poisoned.
  if (II->isPoisoned()) continue;

  // If this is a macro identifier, emit a warning.
  if (isMacroDefined(II))
    Diag(Tok, diag::pp_poisoning_existing_macro);

  // Finally, poison it!
  II->setIsPoisoned();
  if (II->isFromAST())
    II->setChangedSinceDeserialization();
}
465}

467/// HandlePragmaSystemHeader - Implement \#pragma GCC system_header.  We know
468/// that the whole directive has been parsed.
469void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) {
if (isInPrimaryFile()) {
  Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
  return;
}

// Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
PreprocessorLexer *TheLexer = getCurrentFileLexer();

// Mark the file as a system header.
HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry());

PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
if (PLoc.isInvalid())
  return;

unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename());

// Notify the client, if desired, that we are in a new source file.
if (Callbacks)
  Callbacks->FileChanged(SysHeaderTok.getLocation(),
                         PPCallbacks::SystemHeaderPragma, SrcMgr::C_System);

// Emit a line marker.  This will change any source locations from this point
// forward to realize they are in a system header.
// Create a line note with this information.
SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine() + 1,
                      FilenameID, /*IsEntry=*/false, /*IsExit=*/false,
                      SrcMgr::C_System);
498}

500static llvm::Optional<Token> LexHeader(Preprocessor &PP,
                                     Optional<FileEntryRef> &File,
                                     bool SuppressIncludeNotFoundError) {
Token FilenameTok;
if (PP.LexHeaderName(FilenameTok, /*AllowConcatenation*/ false))
  return llvm::None;

// If the next token wasn't a header-name, diagnose the error.
if (FilenameTok.isNot(tok::header_name)) {
  PP.Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
  return llvm::None;
}

// Reserve a buffer to get the spelling.
SmallString<128> FilenameBuffer;
bool Invalid = false;
StringRef Filename = PP.getSpelling(FilenameTok, FilenameBuffer, &Invalid);
if (Invalid)
  return llvm::None;

bool isAngled =
    PP.GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
// If GetIncludeFilenameSpelling set the start ptr to null, there was an
// error.
if (Filename.empty())
  return llvm::None;

// Search include directories for this file.
const DirectoryLookup *CurDir;
File = PP.LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
                     nullptr, CurDir, nullptr, nullptr, nullptr, nullptr,
                     nullptr);
if (!File) {
  if (!SuppressIncludeNotFoundError)
    PP.Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
  return llvm::None;
}

return FilenameTok;
539}

541/// HandlePragmaIncludeInstead - Handle \#pragma clang include_instead(header).
542void Preprocessor::HandlePragmaIncludeInstead(Token &Tok) {
// Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
PreprocessorLexer *TheLexer = getCurrentFileLexer();

if (!SourceMgr.isInSystemHeader(Tok.getLocation())) {
  Diag(Tok, diag::err_pragma_include_instead_not_sysheader);
  return;
}

Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  Diag(Tok, diag::err_expected) << "(";
  return;
}

Optional<FileEntryRef> File;
llvm::Optional<Token> FilenameTok =
    LexHeader(*this, File, SuppressIncludeNotFoundError);
if (!FilenameTok)
  return;

Lex(Tok);
if (Tok.isNot(tok::r_paren)) {
  Diag(Tok, diag::err_expected) << ")";
  return;
}

SmallString<128> FilenameBuffer;
StringRef Filename = getSpelling(*FilenameTok, FilenameBuffer);
HeaderInfo.AddFileAlias(TheLexer->getFileEntry(), Filename);
572}

574/// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah.
575void Preprocessor::HandlePragmaDependency(Token &DependencyTok) {
Optional<FileEntryRef> File;
llvm::Optional<Token> FilenameTok =
    LexHeader(*this, File, SuppressIncludeNotFoundError);
if (!FilenameTok)
  return;

const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();

// If this file is older than the file it depends on, emit a diagnostic.
if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
  // Lex tokens at the end of the message and include them in the message.
  std::string Message;
  Lex(DependencyTok);
  while (DependencyTok.isNot(tok::eod)) {
    Message += getSpelling(DependencyTok) + " ";
    Lex(DependencyTok);
  }

  // Remove the trailing ' ' if present.
  if (!Message.empty())
    Message.erase(Message.end()-1);
  Diag(*FilenameTok, diag::pp_out_of_date_dependency) << Message;
}
599}

601/// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
602/// Return the IdentifierInfo* associated with the macro to push or pop.
603IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) {
// Remember the pragma token location.
Token PragmaTok = Tok;

// Read the '('.
Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
    << getSpelling(PragmaTok);
  return nullptr;
}

// Read the macro name string.
Lex(Tok);
if (Tok.isNot(tok::string_literal)) {
  Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
    << getSpelling(PragmaTok);
  return nullptr;
}

if (Tok.hasUDSuffix()) {
  Diag(Tok, diag::err_invalid_string_udl);
  return nullptr;
}

// Remember the macro string.
std::string StrVal = getSpelling(Tok);

// Read the ')'.
Lex(Tok);
if (Tok.isNot(tok::r_paren)) {
  Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
    << getSpelling(PragmaTok);
  return nullptr;
}

assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&((void)0)
       "Invalid string token!")((void)0);

// Create a Token from the string.
Token MacroTok;
MacroTok.startToken();
MacroTok.setKind(tok::raw_identifier);
CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);

// Get the IdentifierInfo of MacroToPushTok.
return LookUpIdentifierInfo(MacroTok);
650}

652/// Handle \#pragma push_macro.
653///
654/// The syntax is:
655/// \code
656///   #pragma push_macro("macro")
657/// \endcode
658void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) {
// Parse the pragma directive and get the macro IdentifierInfo*.
IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok);
if (!IdentInfo) return;

// Get the MacroInfo associated with IdentInfo.
MacroInfo *MI = getMacroInfo(IdentInfo);

if (MI) {
  // Allow the original MacroInfo to be redefined later.
  MI->setIsAllowRedefinitionsWithoutWarning(true);
}

// Push the cloned MacroInfo so we can retrieve it later.
PragmaPushMacroInfo[IdentInfo].push_back(MI);
673}

675/// Handle \#pragma pop_macro.
676///
677/// The syntax is:
678/// \code
679///   #pragma pop_macro("macro")
680/// \endcode
681void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) {
SourceLocation MessageLoc = PopMacroTok.getLocation();

// Parse the pragma directive and get the macro IdentifierInfo*.
IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok);
if (!IdentInfo) return;

// Find the vector<MacroInfo*> associated with the macro.
llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>::iterator iter =
  PragmaPushMacroInfo.find(IdentInfo);
if (iter != PragmaPushMacroInfo.end()) {
  // Forget the MacroInfo currently associated with IdentInfo.
  if (MacroInfo *MI = getMacroInfo(IdentInfo)) {
    if (MI->isWarnIfUnused())
      WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
    appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc));
  }

  // Get the MacroInfo we want to reinstall.
  MacroInfo *MacroToReInstall = iter->second.back();

  if (MacroToReInstall)
    // Reinstall the previously pushed macro.
    appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc);

  // Pop PragmaPushMacroInfo stack.
  iter->second.pop_back();
  if (iter->second.empty())
    PragmaPushMacroInfo.erase(iter);
} else {
  Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push)
    << IdentInfo->getName();
}
714}

716void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) {
// We will either get a quoted filename or a bracketed filename, and we
// have to track which we got.  The first filename is the source name,
// and the second name is the mapped filename.  If the first is quoted,
// the second must be as well (cannot mix and match quotes and brackets).

// Get the open paren
Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  Diag(Tok, diag::warn_pragma_include_alias_expected) << "(";
  return;
}

// We expect either a quoted string literal, or a bracketed name
Token SourceFilenameTok;
if (LexHeaderName(SourceFilenameTok))
  return;

StringRef SourceFileName;
SmallString<128> FileNameBuffer;
if (SourceFilenameTok.is(tok::header_name)) {
  SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer);
} else {
  Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
  return;
}
FileNameBuffer.clear();

// Now we expect a comma, followed by another include name
Lex(Tok);
if (Tok.isNot(tok::comma)) {
  Diag(Tok, diag::warn_pragma_include_alias_expected) << ",";
  return;
}

Token ReplaceFilenameTok;
if (LexHeaderName(ReplaceFilenameTok))
  return;

StringRef ReplaceFileName;
if (ReplaceFilenameTok.is(tok::header_name)) {
  ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer);
} else {
  Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
  return;
}

// Finally, we expect the closing paren
Lex(Tok);
if (Tok.isNot(tok::r_paren)) {
  Diag(Tok, diag::warn_pragma_include_alias_expected) << ")";
  return;
}

// Now that we have the source and target filenames, we need to make sure
// they're both of the same type (angled vs non-angled)
StringRef OriginalSource = SourceFileName;

bool SourceIsAngled =
  GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(),
                              SourceFileName);
bool ReplaceIsAngled =
  GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(),
                              ReplaceFileName);
if (!SourceFileName.empty() && !ReplaceFileName.empty() &&
    (SourceIsAngled != ReplaceIsAngled)) {
  unsigned int DiagID;
  if (SourceIsAngled)
    DiagID = diag::warn_pragma_include_alias_mismatch_angle;
  else
    DiagID = diag::warn_pragma_include_alias_mismatch_quote;

  Diag(SourceFilenameTok.getLocation(), DiagID)
    << SourceFileName
    << ReplaceFileName;

  return;
}

// Now we can let the include handler know about this mapping
getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName);
797}

799// Lex a component of a module name: either an identifier or a string literal;
800// for components that can be expressed both ways, the two forms are equivalent.
801static bool LexModuleNameComponent(
  Preprocessor &PP, Token &Tok,
  std::pair<IdentifierInfo *, SourceLocation> &ModuleNameComponent,
  bool First) {
PP.LexUnexpandedToken(Tok);
if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) {
  StringLiteralParser Literal(Tok, PP);
  if (Literal.hadError)
    return true;
  ModuleNameComponent = std::make_pair(
      PP.getIdentifierInfo(Literal.GetString()), Tok.getLocation());
} else if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) {
  ModuleNameComponent =
      std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation());
} else {
  PP.Diag(Tok.getLocation(), diag::err_pp_expected_module_name) << First;
  return true;
}
return false;
820}

822static bool LexModuleName(
  Preprocessor &PP, Token &Tok,
  llvm::SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>>
      &ModuleName) {
while (true) {
  std::pair<IdentifierInfo*, SourceLocation> NameComponent;
  if (LexModuleNameComponent(PP, Tok, NameComponent, ModuleName.empty()))
    return true;
  ModuleName.push_back(NameComponent);

  PP.LexUnexpandedToken(Tok);
  if (Tok.isNot(tok::period))
    return false;
}
836}

838void Preprocessor::HandlePragmaModuleBuild(Token &Tok) {
SourceLocation Loc = Tok.getLocation();

std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
if (LexModuleNameComponent(*this, Tok, ModuleNameLoc, true))
  return;
IdentifierInfo *ModuleName = ModuleNameLoc.first;

LexUnexpandedToken(Tok);
if (Tok.isNot(tok::eod)) {
  Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
  DiscardUntilEndOfDirective();
}

CurLexer->LexingRawMode = true;

auto TryConsumeIdentifier = [&](StringRef Ident) -> bool {
  if (Tok.getKind() != tok::raw_identifier ||
      Tok.getRawIdentifier() != Ident)
    return false;
  CurLexer->Lex(Tok);
  return true;
};

// Scan forward looking for the end of the module.
const char *Start = CurLexer->getBufferLocation();
const char *End = nullptr;
unsigned NestingLevel = 1;
while (true) {
  End = CurLexer->getBufferLocation();
  CurLexer->Lex(Tok);

  if (Tok.is(tok::eof)) {
    Diag(Loc, diag::err_pp_module_build_missing_end);
    break;
  }

  if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) {
    // Token was part of module; keep going.
    continue;
  }

  // We hit something directive-shaped; check to see if this is the end
  // of the module build.
  CurLexer->ParsingPreprocessorDirective = true;
  CurLexer->Lex(Tok);
  if (TryConsumeIdentifier("pragma") && TryConsumeIdentifier("clang") &&
      TryConsumeIdentifier("module")) {
    if (TryConsumeIdentifier("build"))
      // #pragma clang module build -> entering a nested module build.
      ++NestingLevel;
    else if (TryConsumeIdentifier("endbuild")) {
      // #pragma clang module endbuild -> leaving a module build.
      if (--NestingLevel == 0)
        break;
    }
    // We should either be looking at the EOD or more of the current directive
    // preceding the EOD. Either way we can ignore this token and keep going.
    assert(Tok.getKind() != tok::eof && "missing EOD before EOF")((void)0);
  }
}

CurLexer->LexingRawMode = false;

// Load the extracted text as a preprocessed module.
assert(CurLexer->getBuffer().begin() <= Start &&((void)0)
       Start <= CurLexer->getBuffer().end() &&((void)0)
       CurLexer->getBuffer().begin() <= End &&((void)0)
       End <= CurLexer->getBuffer().end() &&((void)0)
       "module source range not contained within same file buffer")((void)0);
TheModuleLoader.createModuleFromSource(Loc, ModuleName->getName(),
                                       StringRef(Start, End - Start));
910}

912void Preprocessor::HandlePragmaHdrstop(Token &Tok) {
Lex(Tok);
if (Tok.is(tok::l_paren)) {
  Diag(Tok.getLocation(), diag::warn_pp_hdrstop_filename_ignored);

  std::string FileName;
  if (!LexStringLiteral(Tok, FileName, "pragma hdrstop", false))
    return;

  if (Tok.isNot(tok::r_paren)) {
    Diag(Tok, diag::err_expected) << tok::r_paren;
    return;
  }
  Lex(Tok);
}
if (Tok.isNot(tok::eod))
  Diag(Tok.getLocation(), diag::ext_pp_extra_tokens_at_eol)
      << "pragma hdrstop";

if (creatingPCHWithPragmaHdrStop() &&
    SourceMgr.isInMainFile(Tok.getLocation())) {
  assert(CurLexer && "no lexer for #pragma hdrstop processing")((void)0);
  Token &Result = Tok;
  Result.startToken();
  CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
  CurLexer->cutOffLexing();
}
if (usingPCHWithPragmaHdrStop())
  SkippingUntilPragmaHdrStop = false;
941}

943/// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
944/// If 'Namespace' is non-null, then it is a token required to exist on the
945/// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
946void Preprocessor::AddPragmaHandler(StringRef Namespace,
                                  PragmaHandler *Handler) {
PragmaNamespace *InsertNS = PragmaHandlers.get();

// If this is specified to be in a namespace, step down into it.
if (!Namespace.empty()) {
  // If there is already a pragma handler with the name of this namespace,
  // we either have an error (directive with the same name as a namespace) or
  // we already have the namespace to insert into.
  if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
    InsertNS = Existing->getIfNamespace();
    assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"((void)0)
           " handler with the same name!")((void)0);
  } else {
    // Otherwise, this namespace doesn't exist yet, create and insert the
    // handler for it.
    InsertNS = new PragmaNamespace(Namespace);
    PragmaHandlers->AddPragma(InsertNS);
  }
}

// Check to make sure we don't already have a pragma for this identifier.
assert(!InsertNS->FindHandler(Handler->getName()) &&((void)0)
       "Pragma handler already exists for this identifier!")((void)0);
InsertNS->AddPragma(Handler);
971}

973/// RemovePragmaHandler - Remove the specific pragma handler from the
974/// preprocessor. If \arg Namespace is non-null, then it should be the
975/// namespace that \arg Handler was added to. It is an error to remove
976/// a handler that has not been registered.
977void Preprocessor::RemovePragmaHandler(StringRef Namespace,
                                     PragmaHandler *Handler) {
PragmaNamespace *NS = PragmaHandlers.get();

// If this is specified to be in a namespace, step down into it.
if (!Namespace.empty()) {
  PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
  assert(Existing && "Namespace containing handler does not exist!")((void)0);

  NS = Existing->getIfNamespace();
  assert(NS && "Invalid namespace, registered as a regular pragma handler!")((void)0);
}

NS->RemovePragmaHandler(Handler);

// If this is a non-default namespace and it is now empty, remove it.
if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
  PragmaHandlers->RemovePragmaHandler(NS);
  delete NS;
}
997}

999bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) {
Token Tok;
LexUnexpandedToken(Tok);

if (Tok.isNot(tok::identifier)) {
  Diag(Tok, diag::ext_on_off_switch_syntax);
  return true;
}
IdentifierInfo *II = Tok.getIdentifierInfo();
if (II->isStr("ON"))
  Result = tok::OOS_ON;
else if (II->isStr("OFF"))
  Result = tok::OOS_OFF;
else if (II->isStr("DEFAULT"))
  Result = tok::OOS_DEFAULT;
else {
  Diag(Tok, diag::ext_on_off_switch_syntax);
  return true;
}

// Verify that this is followed by EOD.
LexUnexpandedToken(Tok);
if (Tok.isNot(tok::eod))
  Diag(Tok, diag::ext_pragma_syntax_eod);
return false;
1024}

1026namespace {

1028/// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
1029struct PragmaOnceHandler : public PragmaHandler {
PragmaOnceHandler() : PragmaHandler("once") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &OnceTok) override {
  PP.CheckEndOfDirective("pragma once");
  PP.HandlePragmaOnce(OnceTok);
}
1037};

1039/// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
1040/// rest of the line is not lexed.
1041struct PragmaMarkHandler : public PragmaHandler {
PragmaMarkHandler() : PragmaHandler("mark") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &MarkTok) override {
  PP.HandlePragmaMark(MarkTok);
}
1048};

1050/// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
1051struct PragmaPoisonHandler : public PragmaHandler {
PragmaPoisonHandler() : PragmaHandler("poison") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &PoisonTok) override {
  PP.HandlePragmaPoison();
}
1058};

1060/// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
1061/// as a system header, which silences warnings in it.
1062struct PragmaSystemHeaderHandler : public PragmaHandler {
PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &SHToken) override {
  PP.HandlePragmaSystemHeader(SHToken);
  PP.CheckEndOfDirective("pragma");
}
1070};

1072/// PragmaIncludeInsteadHandler - "\#pragma clang include_instead(header)" marks
1073/// the current file as non-includable if the including header is not a system
1074/// header.
1075struct PragmaIncludeInsteadHandler : public PragmaHandler {
PragmaIncludeInsteadHandler() : PragmaHandler("include_instead") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &IIToken) override {
  PP.HandlePragmaIncludeInstead(IIToken);
}
1082};

1084struct PragmaDependencyHandler : public PragmaHandler {
PragmaDependencyHandler() : PragmaHandler("dependency") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &DepToken) override {
  PP.HandlePragmaDependency(DepToken);
}
1091};

1093struct PragmaDebugHandler : public PragmaHandler {
PragmaDebugHandler() : PragmaHandler("__debug") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &DebugToken) override {
  Token Tok;
  PP.LexUnexpandedToken(Tok);
  if (Tok.isNot(tok::identifier)) {
1
Calling 'Token::isNot'→
4
←
Returning from 'Token::isNot'→
5
←
Taking false branch→
    PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
    return;
  }
  IdentifierInfo *II = Tok.getIdentifierInfo();

  if (II->isStr("assert")) {
6
←
Calling 'IdentifierInfo::isStr'→
9
←
Returning from 'IdentifierInfo::isStr'→
10
←
Taking false branch→
    if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
      llvm_unreachable("This is an assertion!")__builtin_unreachable();
  } else if (II->isStr("crash")) {
11
←
Calling 'IdentifierInfo::isStr'→
14
←
Returning from 'IdentifierInfo::isStr'→
15
←
Taking false branch→
    llvm::Timer T("crash", "pragma crash");
    llvm::TimeRegion R(&T);
    if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
      LLVM_BUILTIN_TRAP__builtin_trap();
  } else if (II->isStr("parser_crash")) {
16
←
Calling 'IdentifierInfo::isStr'→
19
←
Returning from 'IdentifierInfo::isStr'→
20
←
Taking false branch→
    if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash) {
      Token Crasher;
      Crasher.startToken();
      Crasher.setKind(tok::annot_pragma_parser_crash);
      Crasher.setAnnotationRange(SourceRange(Tok.getLocation()));
      PP.EnterToken(Crasher, /*IsReinject*/ false);
    }
  } else if (II->isStr("dump")) {
21
←
Calling 'IdentifierInfo::isStr'→
24
←
Returning from 'IdentifierInfo::isStr'→
25
←
Taking false branch→
    Token Identifier;
    PP.LexUnexpandedToken(Identifier);
    if (auto *DumpII = Identifier.getIdentifierInfo()) {
      Token DumpAnnot;
      DumpAnnot.startToken();
      DumpAnnot.setKind(tok::annot_pragma_dump);
      DumpAnnot.setAnnotationRange(
          SourceRange(Tok.getLocation(), Identifier.getLocation()));
      DumpAnnot.setAnnotationValue(DumpII);
      PP.DiscardUntilEndOfDirective();
      PP.EnterToken(DumpAnnot, /*IsReinject*/false);
    } else {
      PP.Diag(Identifier, diag::warn_pragma_debug_missing_argument)
          << II->getName();
    }
  } else if (II->isStr("diag_mapping")) {
26
←
Calling 'IdentifierInfo::isStr'→
28
←
Returning from 'IdentifierInfo::isStr'→
29
←
Taking false branch→
    Token DiagName;
    PP.LexUnexpandedToken(DiagName);
    if (DiagName.is(tok::eod))
      PP.getDiagnostics().dump();
    else if (DiagName.is(tok::string_literal) && !DiagName.hasUDSuffix()) {
      StringLiteralParser Literal(DiagName, PP);
      if (Literal.hadError)
        return;
      PP.getDiagnostics().dump(Literal.GetString());
    } else {
      PP.Diag(DiagName, diag::warn_pragma_debug_missing_argument)
          << II->getName();
    }
  } else if (II->isStr("llvm_fatal_error")) {
30
←
Calling 'IdentifierInfo::isStr'→
33
←
Returning from 'IdentifierInfo::isStr'→
34
←
Taking false branch→
    if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
      llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
  } else if (II->isStr("llvm_unreachable")) {
35
←
Calling 'IdentifierInfo::isStr'→
37
←
Returning from 'IdentifierInfo::isStr'→
38
←
Taking false branch→
    if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
      llvm_unreachable("#pragma clang __debug llvm_unreachable")__builtin_unreachable();
  } else if (II->isStr("macro")) {
39
←
Calling 'IdentifierInfo::isStr'→
41
←
Returning from 'IdentifierInfo::isStr'→
42
←
Taking false branch→
    Token MacroName;
    PP.LexUnexpandedToken(MacroName);
    auto *MacroII = MacroName.getIdentifierInfo();
    if (MacroII)
      PP.dumpMacroInfo(MacroII);
    else
      PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
          << II->getName();
  } else if (II->isStr("module_map")) {
43
←
Calling 'IdentifierInfo::isStr'→
47
←
Returning from 'IdentifierInfo::isStr'→
48
←
Taking true branch→
    llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
        ModuleName;
    if (LexModuleName(PP, Tok, ModuleName))
49
←
Assuming the condition is false→
50
←
Taking false branch→
      return;
    ModuleMap &MM = PP.getHeaderSearchInfo().getModuleMap();
    Module *M = nullptr;
51
←
'M' initialized to a null pointer value→
    for (auto IIAndLoc : ModuleName) {
52
←
Assuming '__begin11' is equal to '__end11'→
      M = MM.lookupModuleQualified(IIAndLoc.first->getName(), M);
      if (!M) {
        PP.Diag(IIAndLoc.second, diag::warn_pragma_debug_unknown_module)
            << IIAndLoc.first;
        return;
      }
    }
    M->dump();
53
←
Called C++ object pointer is null
  } else if (II->isStr("overflow_stack")) {
    if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
      DebugOverflowStack();
  } else if (II->isStr("captured")) {
    HandleCaptured(PP);
  } else if (II->isStr("modules")) {
    struct ModuleVisitor {
      Preprocessor &PP;
      void visit(Module *M, bool VisibleOnly) {
        SourceLocation ImportLoc = PP.getModuleImportLoc(M);
        if (!VisibleOnly || ImportLoc.isValid()) {
          llvm::errs() << M->getFullModuleName() << " ";
          if (ImportLoc.isValid()) {
            llvm::errs() << M << " visible ";
            ImportLoc.print(llvm::errs(), PP.getSourceManager());
          }
          llvm::errs() << "\n";
        }
        for (Module *Sub : M->submodules()) {
          if (!VisibleOnly || ImportLoc.isInvalid() || Sub->IsExplicit)
            visit(Sub, VisibleOnly);
        }
      }
      void visitAll(bool VisibleOnly) {
        for (auto &NameAndMod :
             PP.getHeaderSearchInfo().getModuleMap().modules())
          visit(NameAndMod.second, VisibleOnly);
      }
    } Visitor{PP};

    Token Kind;
    PP.LexUnexpandedToken(Kind);
    auto *DumpII = Kind.getIdentifierInfo();
    if (!DumpII) {
      PP.Diag(Kind, diag::warn_pragma_debug_missing_argument)
          << II->getName();
    } else if (DumpII->isStr("all")) {
      Visitor.visitAll(false);
    } else if (DumpII->isStr("visible")) {
      Visitor.visitAll(true);
    } else if (DumpII->isStr("building")) {
      for (auto &Building : PP.getBuildingSubmodules()) {
        llvm::errs() << "in " << Building.M->getFullModuleName();
        if (Building.ImportLoc.isValid()) {
          llvm::errs() << " imported ";
          if (Building.IsPragma)
            llvm::errs() << "via pragma ";
          llvm::errs() << "at ";
          Building.ImportLoc.print(llvm::errs(), PP.getSourceManager());
          llvm::errs() << "\n";
        }
      }
    } else {
      PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
        << DumpII->getName();
    }
  } else {
    PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
      << II->getName();
  }

  PPCallbacks *Callbacks = PP.getPPCallbacks();
  if (Callbacks)
    Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
}

void HandleCaptured(Preprocessor &PP) {
  Token Tok;
  PP.LexUnexpandedToken(Tok);

  if (Tok.isNot(tok::eod)) {
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
      << "pragma clang __debug captured";
    return;
  }

  SourceLocation NameLoc = Tok.getLocation();
  MutableArrayRef<Token> Toks(
      PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
  Toks[0].startToken();
  Toks[0].setKind(tok::annot_pragma_captured);
  Toks[0].setLocation(NameLoc);

  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
                      /*IsReinject=*/false);
}

1270// Disable MSVC warning about runtime stack overflow.
1271#ifdef _MSC_VER
  #pragma warning(disable : 4717)
1273#endif
static void DebugOverflowStack(void (*P)() = nullptr) {
  void (*volatile Self)(void(*P)()) = DebugOverflowStack;
  Self(reinterpret_cast<void(*)()>(Self));
}
1278#ifdef _MSC_VER
  #pragma warning(default : 4717)
1280#endif
1281};

1283/// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
1284struct PragmaDiagnosticHandler : public PragmaHandler {
1285private:
const char *Namespace;

1288public:
explicit PragmaDiagnosticHandler(const char *NS)
    : PragmaHandler("diagnostic"), Namespace(NS) {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &DiagToken) override {
  SourceLocation DiagLoc = DiagToken.getLocation();
  Token Tok;
  PP.LexUnexpandedToken(Tok);
  if (Tok.isNot(tok::identifier)) {
    PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
    return;
  }
  IdentifierInfo *II = Tok.getIdentifierInfo();
  PPCallbacks *Callbacks = PP.getPPCallbacks();

  if (II->isStr("pop")) {
    if (!PP.getDiagnostics().popMappings(DiagLoc))
      PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
    else if (Callbacks)
      Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
    return;
  } else if (II->isStr("push")) {
    PP.getDiagnostics().pushMappings(DiagLoc);
    if (Callbacks)
      Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
    return;
  }

  diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
                          .Case("ignored", diag::Severity::Ignored)
                          .Case("warning", diag::Severity::Warning)
                          .Case("error", diag::Severity::Error)
                          .Case("fatal", diag::Severity::Fatal)
                          .Default(diag::Severity());

  if (SV == diag::Severity()) {
    PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
    return;
  }

  PP.LexUnexpandedToken(Tok);
  SourceLocation StringLoc = Tok.getLocation();

  std::string WarningName;
  if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
                                 /*AllowMacroExpansion=*/false))
    return;

  if (Tok.isNot(tok::eod)) {
    PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
    return;
  }

  if (WarningName.size() < 3 || WarningName[0] != '-' ||
      (WarningName[1] != 'W' && WarningName[1] != 'R')) {
    PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
    return;
  }

  diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
                                              : diag::Flavor::Remark;
  StringRef Group = StringRef(WarningName).substr(2);
  bool unknownDiag = false;
  if (Group == "everything") {
    // Special handling for pragma clang diagnostic ... "-Weverything".
    // There is no formal group named "everything", so there has to be a
    // special case for it.
    PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
  } else
    unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
                                                          DiagLoc);
  if (unknownDiag)
    PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
      << WarningName;
  else if (Callbacks)
    Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
}
1366};

1368/// "\#pragma hdrstop [<header-name-string>]"
1369struct PragmaHdrstopHandler : public PragmaHandler {
PragmaHdrstopHandler() : PragmaHandler("hdrstop") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &DepToken) override {
  PP.HandlePragmaHdrstop(DepToken);
}
1375};

1377/// "\#pragma warning(...)".  MSVC's diagnostics do not map cleanly to clang's
1378/// diagnostics, so we don't really implement this pragma.  We parse it and
1379/// ignore it to avoid -Wunknown-pragma warnings.
1380struct PragmaWarningHandler : public PragmaHandler {
PragmaWarningHandler() : PragmaHandler("warning") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &Tok) override {
  // Parse things like:
  // warning(push, 1)
  // warning(pop)
  // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
  SourceLocation DiagLoc = Tok.getLocation();
  PPCallbacks *Callbacks = PP.getPPCallbacks();

  PP.Lex(Tok);
  if (Tok.isNot(tok::l_paren)) {
    PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
    return;
  }

  PP.Lex(Tok);
  IdentifierInfo *II = Tok.getIdentifierInfo();

  if (II && II->isStr("push")) {
    // #pragma warning( push[ ,n ] )
    int Level = -1;
    PP.Lex(Tok);
    if (Tok.is(tok::comma)) {
      PP.Lex(Tok);
      uint64_t Value;
      if (Tok.is(tok::numeric_constant) &&
          PP.parseSimpleIntegerLiteral(Tok, Value))
        Level = int(Value);
      if (Level < 0 || Level > 4) {
        PP.Diag(Tok, diag::warn_pragma_warning_push_level);
        return;
      }
    }
    if (Callbacks)
      Callbacks->PragmaWarningPush(DiagLoc, Level);
  } else if (II && II->isStr("pop")) {
    // #pragma warning( pop )
    PP.Lex(Tok);
    if (Callbacks)
      Callbacks->PragmaWarningPop(DiagLoc);
  } else {
    // #pragma warning( warning-specifier : warning-number-list
    //                  [; warning-specifier : warning-number-list...] )
    while (true) {
      II = Tok.getIdentifierInfo();
      if (!II && !Tok.is(tok::numeric_constant)) {
        PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
        return;
      }

      // Figure out which warning specifier this is.
      bool SpecifierValid;
      StringRef Specifier;
      llvm::SmallString<1> SpecifierBuf;
      if (II) {
        Specifier = II->getName();
        SpecifierValid = llvm::StringSwitch<bool>(Specifier)
                             .Cases("default", "disable", "error", "once",
                                    "suppress", true)
                             .Default(false);
        // If we read a correct specifier, snatch next token (that should be
        // ":", checked later).
        if (SpecifierValid)
          PP.Lex(Tok);
      } else {
        // Token is a numeric constant. It should be either 1, 2, 3 or 4.
        uint64_t Value;
        Specifier = PP.getSpelling(Tok, SpecifierBuf);
        if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
          SpecifierValid = (Value >= 1) && (Value <= 4);
        } else
          SpecifierValid = false;
        // Next token already snatched by parseSimpleIntegerLiteral.
      }

      if (!SpecifierValid) {
        PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
        return;
      }
      if (Tok.isNot(tok::colon)) {
        PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
        return;
      }

      // Collect the warning ids.
      SmallVector<int, 4> Ids;
      PP.Lex(Tok);
      while (Tok.is(tok::numeric_constant)) {
        uint64_t Value;
        if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
            Value > INT_MAX2147483647) {
          PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
          return;
        }
        Ids.push_back(int(Value));
      }
      if (Callbacks)
        Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);

      // Parse the next specifier if there is a semicolon.
      if (Tok.isNot(tok::semi))
        break;
      PP.Lex(Tok);
    }
  }

  if (Tok.isNot(tok::r_paren)) {
    PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
    return;
  }

  PP.Lex(Tok);
  if (Tok.isNot(tok::eod))
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
}
1498};

1500/// "\#pragma execution_character_set(...)". MSVC supports this pragma only
1501/// for "UTF-8". We parse it and ignore it if UTF-8 is provided and warn
1502/// otherwise to avoid -Wunknown-pragma warnings.
1503struct PragmaExecCharsetHandler : public PragmaHandler {
PragmaExecCharsetHandler() : PragmaHandler("execution_character_set") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &Tok) override {
  // Parse things like:
  // execution_character_set(push, "UTF-8")
  // execution_character_set(pop)
  SourceLocation DiagLoc = Tok.getLocation();
  PPCallbacks *Callbacks = PP.getPPCallbacks();

  PP.Lex(Tok);
  if (Tok.isNot(tok::l_paren)) {
    PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << "(";
    return;
  }

  PP.Lex(Tok);
  IdentifierInfo *II = Tok.getIdentifierInfo();

  if (II && II->isStr("push")) {
    // #pragma execution_character_set( push[ , string ] )
    PP.Lex(Tok);
    if (Tok.is(tok::comma)) {
      PP.Lex(Tok);

      std::string ExecCharset;
      if (!PP.FinishLexStringLiteral(Tok, ExecCharset,
                                     "pragma execution_character_set",
                                     /*AllowMacroExpansion=*/false))
        return;

      // MSVC supports either of these, but nothing else.
      if (ExecCharset != "UTF-8" && ExecCharset != "utf-8") {
        PP.Diag(Tok, diag::warn_pragma_exec_charset_push_invalid) << ExecCharset;
        return;
      }
    }
    if (Callbacks)
      Callbacks->PragmaExecCharsetPush(DiagLoc, "UTF-8");
  } else if (II && II->isStr("pop")) {
    // #pragma execution_character_set( pop )
    PP.Lex(Tok);
    if (Callbacks)
      Callbacks->PragmaExecCharsetPop(DiagLoc);
  } else {
    PP.Diag(Tok, diag::warn_pragma_exec_charset_spec_invalid);
    return;
  }

  if (Tok.isNot(tok::r_paren)) {
    PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << ")";
    return;
  }

  PP.Lex(Tok);
  if (Tok.isNot(tok::eod))
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma execution_character_set";
}
1562};

1564/// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1565struct PragmaIncludeAliasHandler : public PragmaHandler {
PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &IncludeAliasTok) override {
  PP.HandlePragmaIncludeAlias(IncludeAliasTok);
}
1572};

1574/// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message
1575/// extension.  The syntax is:
1576/// \code
1577///   #pragma message(string)
1578/// \endcode
1579/// OR, in GCC mode:
1580/// \code
1581///   #pragma message string
1582/// \endcode
1583/// string is a string, which is fully macro expanded, and permits string
1584/// concatenation, embedded escape characters, etc... See MSDN for more details.
1585/// Also handles \#pragma GCC warning and \#pragma GCC error which take the same
1586/// form as \#pragma message.
1587struct PragmaMessageHandler : public PragmaHandler {
1588private:
const PPCallbacks::PragmaMessageKind Kind;
const StringRef Namespace;

static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
                              bool PragmaNameOnly = false) {
  switch (Kind) {
    case PPCallbacks::PMK_Message:
      return PragmaNameOnly ? "message" : "pragma message";
    case PPCallbacks::PMK_Warning:
      return PragmaNameOnly ? "warning" : "pragma warning";
    case PPCallbacks::PMK_Error:
      return PragmaNameOnly ? "error" : "pragma error";
  }
  llvm_unreachable("Unknown PragmaMessageKind!")__builtin_unreachable();
}

1605public:
PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
                     StringRef Namespace = StringRef())
    : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind),
      Namespace(Namespace) {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &Tok) override {
  SourceLocation MessageLoc = Tok.getLocation();
  PP.Lex(Tok);
  bool ExpectClosingParen = false;
  switch (Tok.getKind()) {
  case tok::l_paren:
    // We have a MSVC style pragma message.
    ExpectClosingParen = true;
    // Read the string.
    PP.Lex(Tok);
    break;
  case tok::string_literal:
    // We have a GCC style pragma message, and we just read the string.
    break;
  default:
    PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
    return;
  }

  std::string MessageString;
  if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
                                 /*AllowMacroExpansion=*/true))
    return;

  if (ExpectClosingParen) {
    if (Tok.isNot(tok::r_paren)) {
      PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
      return;
    }
    PP.Lex(Tok);  // eat the r_paren.
  }

  if (Tok.isNot(tok::eod)) {
    PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
    return;
  }

  // Output the message.
  PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
                        ? diag::err_pragma_message
                        : diag::warn_pragma_message) << MessageString;

  // If the pragma is lexically sound, notify any interested PPCallbacks.
  if (PPCallbacks *Callbacks = PP.getPPCallbacks())
    Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
}
1658};

1660/// Handle the clang \#pragma module import extension. The syntax is:
1661/// \code
1662///   #pragma clang module import some.module.name
1663/// \endcode
1664struct PragmaModuleImportHandler : public PragmaHandler {
PragmaModuleImportHandler() : PragmaHandler("import") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &Tok) override {
  SourceLocation ImportLoc = Tok.getLocation();

  // Read the module name.
  llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
      ModuleName;
  if (LexModuleName(PP, Tok, ModuleName))
    return;

  if (Tok.isNot(tok::eod))
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";

  // If we have a non-empty module path, load the named module.
  Module *Imported =
      PP.getModuleLoader().loadModule(ImportLoc, ModuleName, Module::Hidden,
                                    /*IsInclusionDirective=*/false);
  if (!Imported)
    return;

  PP.makeModuleVisible(Imported, ImportLoc);
  PP.EnterAnnotationToken(SourceRange(ImportLoc, ModuleName.back().second),
                          tok::annot_module_include, Imported);
  if (auto *CB = PP.getPPCallbacks())
    CB->moduleImport(ImportLoc, ModuleName, Imported);
}
1693};

1695/// Handle the clang \#pragma module begin extension. The syntax is:
1696/// \code
1697///   #pragma clang module begin some.module.name
1698///   ...
1699///   #pragma clang module end
1700/// \endcode
1701struct PragmaModuleBeginHandler : public PragmaHandler {
PragmaModuleBeginHandler() : PragmaHandler("begin") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &Tok) override {
  SourceLocation BeginLoc = Tok.getLocation();

  // Read the module name.
  llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
      ModuleName;
  if (LexModuleName(PP, Tok, ModuleName))
    return;

  if (Tok.isNot(tok::eod))
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";

  // We can only enter submodules of the current module.
  StringRef Current = PP.getLangOpts().CurrentModule;
  if (ModuleName.front().first->getName() != Current) {
    PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module)
      << ModuleName.front().first << (ModuleName.size() > 1)
      << Current.empty() << Current;
    return;
  }

  // Find the module we're entering. We require that a module map for it
  // be loaded or implicitly loadable.
  auto &HSI = PP.getHeaderSearchInfo();
  Module *M = HSI.lookupModule(Current);
  if (!M) {
    PP.Diag(ModuleName.front().second,
            diag::err_pp_module_begin_no_module_map) << Current;
    return;
  }
  for (unsigned I = 1; I != ModuleName.size(); ++I) {
    auto *NewM = M->findOrInferSubmodule(ModuleName[I].first->getName());
    if (!NewM) {
      PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule)
        << M->getFullModuleName() << ModuleName[I].first;
      return;
    }
    M = NewM;
  }

  // If the module isn't available, it doesn't make sense to enter it.
  if (Preprocessor::checkModuleIsAvailable(
          PP.getLangOpts(), PP.getTargetInfo(), PP.getDiagnostics(), M)) {
    PP.Diag(BeginLoc, diag::note_pp_module_begin_here)
      << M->getTopLevelModuleName();
    return;
  }

  // Enter the scope of the submodule.
  PP.EnterSubmodule(M, BeginLoc, /*ForPragma*/true);
  PP.EnterAnnotationToken(SourceRange(BeginLoc, ModuleName.back().second),
                          tok::annot_module_begin, M);
}
1758};

1760/// Handle the clang \#pragma module end extension.
1761struct PragmaModuleEndHandler : public PragmaHandler {
PragmaModuleEndHandler() : PragmaHandler("end") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &Tok) override {
  SourceLocation Loc = Tok.getLocation();

  PP.LexUnexpandedToken(Tok);
  if (Tok.isNot(tok::eod))
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";

  Module *M = PP.LeaveSubmodule(/*ForPragma*/true);
  if (M)
    PP.EnterAnnotationToken(SourceRange(Loc), tok::annot_module_end, M);
  else
    PP.Diag(Loc, diag::err_pp_module_end_without_module_begin);
}
1778};

1780/// Handle the clang \#pragma module build extension.
1781struct PragmaModuleBuildHandler : public PragmaHandler {
PragmaModuleBuildHandler() : PragmaHandler("build") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &Tok) override {
  PP.HandlePragmaModuleBuild(Tok);
}
1788};

1790/// Handle the clang \#pragma module load extension.
1791struct PragmaModuleLoadHandler : public PragmaHandler {
PragmaModuleLoadHandler() : PragmaHandler("load") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &Tok) override {
  SourceLocation Loc = Tok.getLocation();

  // Read the module name.
  llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
      ModuleName;
  if (LexModuleName(PP, Tok, ModuleName))
    return;

  if (Tok.isNot(tok::eod))
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";

  // Load the module, don't make it visible.
  PP.getModuleLoader().loadModule(Loc, ModuleName, Module::Hidden,
                                  /*IsInclusionDirective=*/false);
}
1811};

1813/// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1814/// macro on the top of the stack.
1815struct PragmaPushMacroHandler : public PragmaHandler {
PragmaPushMacroHandler() : PragmaHandler("push_macro") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &PushMacroTok) override {
  PP.HandlePragmaPushMacro(PushMacroTok);
}
1822};

1824/// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the
1825/// macro to the value on the top of the stack.
1826struct PragmaPopMacroHandler : public PragmaHandler {
PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &PopMacroTok) override {
  PP.HandlePragmaPopMacro(PopMacroTok);
}
1833};

1835/// PragmaARCCFCodeAuditedHandler -
1836///   \#pragma clang arc_cf_code_audited begin/end
1837struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &NameTok) override {
  SourceLocation Loc = NameTok.getLocation();
  bool IsBegin;

  Token Tok;

  // Lex the 'begin' or 'end'.
  PP.LexUnexpandedToken(Tok);
  const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
  if (BeginEnd && BeginEnd->isStr("begin")) {
    IsBegin = true;
  } else if (BeginEnd && BeginEnd->isStr("end")) {
    IsBegin = false;
  } else {
    PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
    return;
  }

  // Verify that this is followed by EOD.
  PP.LexUnexpandedToken(Tok);
  if (Tok.isNot(tok::eod))
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";

  // The start location of the active audit.
  SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedInfo().second;

  // The start location we want after processing this.
  SourceLocation NewLoc;

  if (IsBegin) {
    // Complain about attempts to re-enter an audit.
    if (BeginLoc.isValid()) {
      PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
      PP.Diag(BeginLoc, diag::note_pragma_entered_here);
    }
    NewLoc = Loc;
  } else {
    // Complain about attempts to leave an audit that doesn't exist.
    if (!BeginLoc.isValid()) {
      PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
      return;
    }
    NewLoc = SourceLocation();
  }

  PP.setPragmaARCCFCodeAuditedInfo(NameTok.getIdentifierInfo(), NewLoc);
}
1888};

1890/// PragmaAssumeNonNullHandler -
1891///   \#pragma clang assume_nonnull begin/end
1892struct PragmaAssumeNonNullHandler : public PragmaHandler {
PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &NameTok) override {
  SourceLocation Loc = NameTok.getLocation();
  bool IsBegin;

  Token Tok;

  // Lex the 'begin' or 'end'.
  PP.LexUnexpandedToken(Tok);
  const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
  if (BeginEnd && BeginEnd->isStr("begin")) {
    IsBegin = true;
  } else if (BeginEnd && BeginEnd->isStr("end")) {
    IsBegin = false;
  } else {
    PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
    return;
  }

  // Verify that this is followed by EOD.
  PP.LexUnexpandedToken(Tok);
  if (Tok.isNot(tok::eod))
    PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";

  // The start location of the active audit.
  SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc();

  // The start location we want after processing this.
  SourceLocation NewLoc;
  PPCallbacks *Callbacks = PP.getPPCallbacks();

  if (IsBegin) {
    // Complain about attempts to re-enter an audit.
    if (BeginLoc.isValid()) {
      PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
      PP.Diag(BeginLoc, diag::note_pragma_entered_here);
    }
    NewLoc = Loc;
    if (Callbacks)
      Callbacks->PragmaAssumeNonNullBegin(NewLoc);
  } else {
    // Complain about attempts to leave an audit that doesn't exist.
    if (!BeginLoc.isValid()) {
      PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
      return;
    }
    NewLoc = SourceLocation();
    if (Callbacks)
      Callbacks->PragmaAssumeNonNullEnd(NewLoc);
  }

  PP.setPragmaAssumeNonNullLoc(NewLoc);
}
1948};

1950/// Handle "\#pragma region [...]"
1951///
1952/// The syntax is
1953/// \code
1954///   #pragma region [optional name]
1955///   #pragma endregion [optional comment]
1956/// \endcode
1957///
1958/// \note This is
1959/// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a>
1960/// pragma, just skipped by compiler.
1961struct PragmaRegionHandler : public PragmaHandler {
PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {}

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                  Token &NameTok) override {
  // #pragma region: endregion matches can be verified
  // __pragma(region): no sense, but ignored by msvc
  // _Pragma is not valid for MSVC, but there isn't any point
  // to handle a _Pragma differently.
}
1971};

1973} // namespace

1975/// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
1976/// \#pragma GCC poison/system_header/dependency and \#pragma once.
1977void Preprocessor::RegisterBuiltinPragmas() {
AddPragmaHandler(new PragmaOnceHandler());
AddPragmaHandler(new PragmaMarkHandler());
AddPragmaHandler(new PragmaPushMacroHandler());
AddPragmaHandler(new PragmaPopMacroHandler());
AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));

// #pragma GCC ...
AddPragmaHandler("GCC", new PragmaPoisonHandler());
AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
AddPragmaHandler("GCC", new PragmaDependencyHandler());
AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
                                                 "GCC"));
AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
                                                 "GCC"));
// #pragma clang ...
AddPragmaHandler("clang", new PragmaPoisonHandler());
AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
AddPragmaHandler("clang", new PragmaIncludeInsteadHandler());
AddPragmaHandler("clang", new PragmaDebugHandler());
AddPragmaHandler("clang", new PragmaDependencyHandler());
AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());

// #pragma clang module ...
auto *ModuleHandler = new PragmaNamespace("module");
AddPragmaHandler("clang", ModuleHandler);
ModuleHandler->AddPragma(new PragmaModuleImportHandler());
ModuleHandler->AddPragma(new PragmaModuleBeginHandler());
ModuleHandler->AddPragma(new PragmaModuleEndHandler());
ModuleHandler->AddPragma(new PragmaModuleBuildHandler());
ModuleHandler->AddPragma(new PragmaModuleLoadHandler());

// Add region pragmas.
AddPragmaHandler(new PragmaRegionHandler("region"));
AddPragmaHandler(new PragmaRegionHandler("endregion"));

// MS extensions.
if (LangOpts.MicrosoftExt) {
  AddPragmaHandler(new PragmaWarningHandler());
  AddPragmaHandler(new PragmaExecCharsetHandler());
  AddPragmaHandler(new PragmaIncludeAliasHandler());
  AddPragmaHandler(new PragmaHdrstopHandler());
  AddPragmaHandler(new PragmaSystemHeaderHandler());
}

// Pragmas added by plugins
for (const PragmaHandlerRegistry::entry &handler :
     PragmaHandlerRegistry::entries()) {
  AddPragmaHandler(handler.instantiate().release());
}
2030}

2032/// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
2033/// warn about those pragmas being unknown.
2034void Preprocessor::IgnorePragmas() {
AddPragmaHandler(new EmptyPragmaHandler());
// Also ignore all pragmas in all namespaces created
// in Preprocessor::RegisterBuiltinPragmas().
AddPragmaHandler("GCC", new EmptyPragmaHandler());
AddPragmaHandler("clang", new EmptyPragmaHandler());
2040}

←

/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/include/clang/Lex/Token.h

→

1//===--- Token.h - Token interface ------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file defines the Token interface.
10//
11//===----------------------------------------------------------------------===//

13#ifndef LLVM_CLANG_LEX_TOKEN_H
14#define LLVM_CLANG_LEX_TOKEN_H

16#include "clang/Basic/SourceLocation.h"
17#include "clang/Basic/TokenKinds.h"
18#include "llvm/ADT/StringRef.h"
19#include <cassert>

21namespace clang {

23class IdentifierInfo;

25/// Token - This structure provides full information about a lexed token.
26/// It is not intended to be space efficient, it is intended to return as much
27/// information as possible about each returned token.  This is expected to be
28/// compressed into a smaller form if memory footprint is important.
29///
30/// The parser can create a special "annotation token" representing a stream of
31/// tokens that were parsed and semantically resolved, e.g.: "foo::MyClass<int>"
32/// can be represented by a single typename annotation token that carries
33/// information about the SourceRange of the tokens and the type object.
34class Token {
/// The location of the token. This is actually a SourceLocation.
SourceLocation::UIntTy Loc;

// Conceptually these next two fields could be in a union.  However, this
// causes gcc 4.2 to pessimize LexTokenInternal, a very performance critical
// routine. Keeping as separate members with casts until a more beautiful fix
// presents itself.

/// UintData - This holds either the length of the token text, when
/// a normal token, or the end of the SourceRange when an annotation
/// token.
SourceLocation::UIntTy UintData;

/// PtrData - This is a union of four different pointer types, which depends
/// on what type of token this is:
///  Identifiers, keywords, etc:
///    This is an IdentifierInfo*, which contains the uniqued identifier
///    spelling.
///  Literals:  isLiteral() returns true.
///    This is a pointer to the start of the token in a text buffer, which
///    may be dirty (have trigraphs / escaped newlines).
///  Annotations (resolved type names, C++ scopes, etc): isAnnotation().
///    This is a pointer to sema-specific data for the annotation token.
///  Eof:
//     This is a pointer to a Decl.
///  Other:
///    This is null.
void *PtrData;

/// Kind - The actual flavor of token this is.
tok::TokenKind Kind;

/// Flags - Bits we track about this token, members of the TokenFlags enum.
unsigned short Flags;

70public:
// Various flags set per token:
enum TokenFlags {
  StartOfLine = 0x01,   // At start of line or only after whitespace
                        // (considering the line after macro expansion).
  LeadingSpace = 0x02,  // Whitespace exists before this token (considering
                        // whitespace after macro expansion).
  DisableExpand = 0x04, // This identifier may never be macro expanded.
  NeedsCleaning = 0x08, // Contained an escaped newline or trigraph.
  LeadingEmptyMacro = 0x10, // Empty macro exists before this token.
  HasUDSuffix = 0x20,  // This string or character literal has a ud-suffix.
  HasUCN = 0x40,       // This identifier contains a UCN.
  IgnoredComma = 0x80, // This comma is not a macro argument separator (MS).
  StringifiedInMacro = 0x100, // This string or character literal is formed by
                              // macro stringizing or charizing operator.
  CommaAfterElided = 0x200, // The comma following this token was elided (MS).
  IsEditorPlaceholder = 0x400, // This identifier is a placeholder.
  IsReinjected = 0x800, // A phase 4 token that was produced before and
                        // re-added, e.g. via EnterTokenStream. Annotation
                        // tokens are *not* reinjected.
};

tok::TokenKind getKind() const { return Kind; }
void setKind(tok::TokenKind K) { Kind = K; }

/// is/isNot - Predicates to check if this token is a specific kind, as in
/// "if (Tok.is(tok::l_brace)) {...}".
bool is(tok::TokenKind K) const { return Kind == K; }
bool isNot(tok::TokenKind K) const { return Kind != K; }
2
←
Assuming 'K' is equal to field 'Kind'→
3
←
Returning zero, which participates in a condition later→
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const {
  return is(K1) || is(K2);
}
template <typename... Ts>
bool isOneOf(tok::TokenKind K1, tok::TokenKind K2, Ts... Ks) const {
  return is(K1) || isOneOf(K2, Ks...);
}

/// Return true if this is a raw identifier (when lexing
/// in raw mode) or a non-keyword identifier (when lexing in non-raw mode).
bool isAnyIdentifier() const {
  return tok::isAnyIdentifier(getKind());
}

/// Return true if this is a "literal", like a numeric
/// constant, string, etc.
bool isLiteral() const {
  return tok::isLiteral(getKind());
}

/// Return true if this is any of tok::annot_* kind tokens.
bool isAnnotation() const {
  return tok::isAnnotation(getKind());
}

/// Return a source location identifier for the specified
/// offset in the current file.
SourceLocation getLocation() const {
  return SourceLocation::getFromRawEncoding(Loc);
}
unsigned getLength() const {
  assert(!isAnnotation() && "Annotation tokens have no length field")((void)0);
  return UintData;
}

void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
void setLength(unsigned Len) {
  assert(!isAnnotation() && "Annotation tokens have no length field")((void)0);
  UintData = Len;
}

SourceLocation getAnnotationEndLoc() const {
  assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")((void)0);
  return SourceLocation::getFromRawEncoding(UintData ? UintData : Loc);
}
void setAnnotationEndLoc(SourceLocation L) {
  assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")((void)0);
  UintData = L.getRawEncoding();
}

SourceLocation getLastLoc() const {
  return isAnnotation() ? getAnnotationEndLoc() : getLocation();
}

SourceLocation getEndLoc() const {
  return isAnnotation() ? getAnnotationEndLoc()
                        : getLocation().getLocWithOffset(getLength());
}

/// SourceRange of the group of tokens that this annotation token
/// represents.
SourceRange getAnnotationRange() const {
  return SourceRange(getLocation(), getAnnotationEndLoc());
}
void setAnnotationRange(SourceRange R) {
  setLocation(R.getBegin());
  setAnnotationEndLoc(R.getEnd());
}

const char *getName() const { return tok::getTokenName(Kind); }

/// Reset all flags to cleared.
void startToken() {
  Kind = tok::unknown;
  Flags = 0;
  PtrData = nullptr;
  UintData = 0;
  Loc = SourceLocation().getRawEncoding();
}

IdentifierInfo *getIdentifierInfo() const {
  assert(isNot(tok::raw_identifier) &&((void)0)
         "getIdentifierInfo() on a tok::raw_identifier token!")((void)0);
  assert(!isAnnotation() &&((void)0)
         "getIdentifierInfo() on an annotation token!")((void)0);
  if (isLiteral()) return nullptr;
  if (is(tok::eof)) return nullptr;
  return (IdentifierInfo*) PtrData;
}
void setIdentifierInfo(IdentifierInfo *II) {
  PtrData = (void*) II;
}

const void *getEofData() const {
  assert(is(tok::eof))((void)0);
  return reinterpret_cast<const void *>(PtrData);
}
void setEofData(const void *D) {
  assert(is(tok::eof))((void)0);
  assert(!PtrData)((void)0);
  PtrData = const_cast<void *>(D);
}

/// getRawIdentifier - For a raw identifier token (i.e., an identifier
/// lexed in raw mode), returns a reference to the text substring in the
/// buffer if known.
StringRef getRawIdentifier() const {
  assert(is(tok::raw_identifier))((void)0);
  return StringRef(reinterpret_cast<const char *>(PtrData), getLength());
}
void setRawIdentifierData(const char *Ptr) {
  assert(is(tok::raw_identifier))((void)0);
  PtrData = const_cast<char*>(Ptr);
}

/// getLiteralData - For a literal token (numeric constant, string, etc), this
/// returns a pointer to the start of it in the text buffer if known, null
/// otherwise.
const char *getLiteralData() const {
  assert(isLiteral() && "Cannot get literal data of non-literal")((void)0);
  return reinterpret_cast<const char*>(PtrData);
}
void setLiteralData(const char *Ptr) {
  assert(isLiteral() && "Cannot set literal data of non-literal")((void)0);
  PtrData = const_cast<char*>(Ptr);
}

void *getAnnotationValue() const {
  assert(isAnnotation() && "Used AnnotVal on non-annotation token")((void)0);
  return PtrData;
}
void setAnnotationValue(void *val) {
  assert(isAnnotation() && "Used AnnotVal on non-annotation token")((void)0);
  PtrData = val;
}

/// Set the specified flag.
void setFlag(TokenFlags Flag) {
  Flags |= Flag;
}

/// Get the specified flag.
bool getFlag(TokenFlags Flag) const {
  return (Flags & Flag) != 0;
}

/// Unset the specified flag.
void clearFlag(TokenFlags Flag) {
  Flags &= ~Flag;
}

/// Return the internal represtation of the flags.
///
/// This is only intended for low-level operations such as writing tokens to
/// disk.
unsigned getFlags() const {
  return Flags;
}

/// Set a flag to either true or false.
void setFlagValue(TokenFlags Flag, bool Val) {
  if (Val)
    setFlag(Flag);
  else
    clearFlag(Flag);
}

/// isAtStartOfLine - Return true if this token is at the start of a line.
///
bool isAtStartOfLine() const { return getFlag(StartOfLine); }

/// Return true if this token has whitespace before it.
///
bool hasLeadingSpace() const { return getFlag(LeadingSpace); }

/// Return true if this identifier token should never
/// be expanded in the future, due to C99 6.10.3.4p2.
bool isExpandDisabled() const { return getFlag(DisableExpand); }

/// Return true if we have an ObjC keyword identifier.
bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const;

/// Return the ObjC keyword kind.
tok::ObjCKeywordKind getObjCKeywordID() const;

/// Return true if this token has trigraphs or escaped newlines in it.
bool needsCleaning() const { return getFlag(NeedsCleaning); }

/// Return true if this token has an empty macro before it.
///
bool hasLeadingEmptyMacro() const { return getFlag(LeadingEmptyMacro); }

/// Return true if this token is a string or character literal which
/// has a ud-suffix.
bool hasUDSuffix() const { return getFlag(HasUDSuffix); }

/// Returns true if this token contains a universal character name.
bool hasUCN() const { return getFlag(HasUCN); }

/// Returns true if this token is formed by macro by stringizing or charizing
/// operator.
bool stringifiedInMacro() const { return getFlag(StringifiedInMacro); }

/// Returns true if the comma after this token was elided.
bool commaAfterElided() const { return getFlag(CommaAfterElided); }

/// Returns true if this token is an editor placeholder.
///
/// Editor placeholders are produced by the code-completion engine and are
/// represented as characters between '<#' and '#>' in the source code. The
/// lexer uses identifier tokens to represent placeholders.
bool isEditorPlaceholder() const { return getFlag(IsEditorPlaceholder); }
311};

313/// Information about the conditional stack (\#if directives)
314/// currently active.
315struct PPConditionalInfo {
/// Location where the conditional started.
SourceLocation IfLoc;

/// True if this was contained in a skipping directive, e.g.,
/// in a "\#if 0" block.
bool WasSkipping;

/// True if we have emitted tokens already, and now we're in
/// an \#else block or something.  Only useful in Skipping blocks.
bool FoundNonSkip;

/// True if we've seen a \#else in this block.  If so,
/// \#elif/\#else directives are not allowed.
bool FoundElse;
330};

332} // end namespace clang

334#endif // LLVM_CLANG_LEX_TOKEN_H

←

/usr/src/gnu/usr.bin/clang/libclangLex/../../../llvm/clang/include/clang/Basic/IdentifierTable.h

1//===- IdentifierTable.h - Hash table for identifier lookup -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// Defines the clang::IdentifierInfo, clang::IdentifierTable, and
11/// clang::Selector interfaces.
12//
13//===----------------------------------------------------------------------===//

15#ifndef LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
16#define LLVM_CLANG_BASIC_IDENTIFIERTABLE_H

18#include "clang/Basic/LLVM.h"
19#include "clang/Basic/TokenKinds.h"
20#include "llvm/ADT/DenseMapInfo.h"
21#include "llvm/ADT/SmallString.h"
22#include "llvm/ADT/StringMap.h"
23#include "llvm/ADT/StringRef.h"
24#include "llvm/Support/Allocator.h"
25#include "llvm/Support/PointerLikeTypeTraits.h"
26#include "llvm/Support/type_traits.h"
27#include <cassert>
28#include <cstddef>
29#include <cstdint>
30#include <cstring>
31#include <string>
32#include <utility>

34namespace clang {

36class DeclarationName;
37class DeclarationNameTable;
38class IdentifierInfo;
39class LangOptions;
40class MultiKeywordSelector;
41class SourceLocation;

43enum class ReservedIdentifierStatus {
NotReserved = 0,
StartsWithUnderscoreAtGlobalScope,
StartsWithDoubleUnderscore,
StartsWithUnderscoreFollowedByCapitalLetter,
ContainsDoubleUnderscore,
49};

51/// A simple pair of identifier info and location.
52using IdentifierLocPair = std::pair<IdentifierInfo *, SourceLocation>;

54/// IdentifierInfo and other related classes are aligned to
55/// 8 bytes so that DeclarationName can use the lower 3 bits
56/// of a pointer to one of these classes.
57enum { IdentifierInfoAlignment = 8 };

59static constexpr int ObjCOrBuiltinIDBits = 16;

61/// One of these records is kept for each identifier that
62/// is lexed.  This contains information about whether the token was \#define'd,
63/// is a language keyword, or if it is a front-end token of some sort (e.g. a
64/// variable or function name).  The preprocessor keeps this information in a
65/// set, and all tok::identifier tokens have a pointer to one of these.
66/// It is aligned to 8 bytes because DeclarationName needs the lower 3 bits.
67class alignas(IdentifierInfoAlignment) IdentifierInfo {
friend class IdentifierTable;

// Front-end token ID or tok::identifier.
unsigned TokenID : 9;

// ObjC keyword ('protocol' in '@protocol') or builtin (__builtin_inf).
// First NUM_OBJC_KEYWORDS values are for Objective-C,
// the remaining values are for builtins.
unsigned ObjCOrBuiltinID : ObjCOrBuiltinIDBits;

// True if there is a #define for this.
unsigned HasMacro : 1;

// True if there was a #define for this.
unsigned HadMacro : 1;

// True if the identifier is a language extension.
unsigned IsExtension : 1;

// True if the identifier is a keyword in a newer or proposed Standard.
unsigned IsFutureCompatKeyword : 1;

// True if the identifier is poisoned.
unsigned IsPoisoned : 1;

// True if the identifier is a C++ operator keyword.
unsigned IsCPPOperatorKeyword : 1;

// Internal bit set by the member function RecomputeNeedsHandleIdentifier.
// See comment about RecomputeNeedsHandleIdentifier for more info.
unsigned NeedsHandleIdentifier : 1;

// True if the identifier was loaded (at least partially) from an AST file.
unsigned IsFromAST : 1;

// True if the identifier has changed from the definition
// loaded from an AST file.
unsigned ChangedAfterLoad : 1;

// True if the identifier's frontend information has changed from the
// definition loaded from an AST file.
unsigned FEChangedAfterLoad : 1;

// True if revertTokenIDToIdentifier was called.
unsigned RevertedTokenID : 1;

// True if there may be additional information about
// this identifier stored externally.
unsigned OutOfDate : 1;

// True if this is the 'import' contextual keyword.
unsigned IsModulesImport : 1;

// True if this is a mangled OpenMP variant name.
unsigned IsMangledOpenMPVariantName : 1;

// 28 bits left in a 64-bit word.

// Managed by the language front-end.
void *FETokenInfo = nullptr;

llvm::StringMapEntry<IdentifierInfo *> *Entry = nullptr;

IdentifierInfo()
    : TokenID(tok::identifier), ObjCOrBuiltinID(0), HasMacro(false),
      HadMacro(false), IsExtension(false), IsFutureCompatKeyword(false),
      IsPoisoned(false), IsCPPOperatorKeyword(false),
      NeedsHandleIdentifier(false), IsFromAST(false), ChangedAfterLoad(false),
      FEChangedAfterLoad(false), RevertedTokenID(false), OutOfDate(false),
      IsModulesImport(false), IsMangledOpenMPVariantName(false) {}

139public:
IdentifierInfo(const IdentifierInfo &) = delete;
IdentifierInfo &operator=(const IdentifierInfo &) = delete;
IdentifierInfo(IdentifierInfo &&) = delete;
IdentifierInfo &operator=(IdentifierInfo &&) = delete;

/// Return true if this is the identifier for the specified string.
///
/// This is intended to be used for string literals only: II->isStr("foo").
template <std::size_t StrLen>
bool isStr(const char (&Str)[StrLen]) const {
  return getLength() == StrLen-1 &&
7
←
Assuming the condition is false→
8
←
Returning zero, which participates in a condition later→
12
←
Assuming the condition is false→
13
←
Returning zero, which participates in a condition later→
17
←
Assuming the condition is false→
18
←
Returning zero, which participates in a condition later→
22
←
Assuming the condition is false→
23
←
Returning zero, which participates in a condition later→
27
←
Returning zero, which participates in a condition later→
31
←
Assuming the condition is false→
32
←
Returning zero, which participates in a condition later→
36
←
Returning zero, which participates in a condition later→
40
←
Returning zero, which participates in a condition later→
44
←
Assuming the condition is true→
46
←
Returning the value 1, which participates in a condition later→
         memcmp(getNameStart(), Str, StrLen-1) == 0;
45
←
Assuming the condition is true→
}

/// Return true if this is the identifier for the specified StringRef.
bool isStr(llvm::StringRef Str) const {
  llvm::StringRef ThisStr(getNameStart(), getLength());
  return ThisStr == Str;
}

/// Return the beginning of the actual null-terminated string for this
/// identifier.
const char *getNameStart() const { return Entry->getKeyData(); }

/// Efficiently return the length of this identifier info.
unsigned getLength() const { return Entry->getKeyLength(); }

/// Return the actual identifier string.
StringRef getName() const {
  return StringRef(getNameStart(), getLength());
}

/// Return true if this identifier is \#defined to some other value.
/// \note The current definition may be in a module and not currently visible.
bool hasMacroDefinition() const {
  return HasMacro;
}
void setHasMacroDefinition(bool Val) {
  if (HasMacro == Val) return;

  HasMacro = Val;
  if (Val) {
    NeedsHandleIdentifier = true;
    HadMacro = true;
  } else {
    RecomputeNeedsHandleIdentifier();
  }
}
/// Returns true if this identifier was \#defined to some value at any
/// moment. In this case there should be an entry for the identifier in the
/// macro history table in Preprocessor.
bool hadMacroDefinition() const {
  return HadMacro;
}

/// If this is a source-language token (e.g. 'for'), this API
/// can be used to cause the lexer to map identifiers to source-language
/// tokens.
tok::TokenKind getTokenID() const { return (tok::TokenKind)TokenID; }

/// True if revertTokenIDToIdentifier() was called.
bool hasRevertedTokenIDToIdentifier() const { return RevertedTokenID; }

/// Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2
/// compatibility.
///
/// TokenID is normally read-only but there are 2 instances where we revert it
/// to tok::identifier for libstdc++ 4.2. Keep track of when this happens
/// using this method so we can inform serialization about it.
void revertTokenIDToIdentifier() {
  assert(TokenID != tok::identifier && "Already at tok::identifier")((void)0);
  TokenID = tok::identifier;
  RevertedTokenID = true;
}
void revertIdentifierToTokenID(tok::TokenKind TK) {
  assert(TokenID == tok::identifier && "Should be at tok::identifier")((void)0);
  TokenID = TK;
  RevertedTokenID = false;
}

/// Return the preprocessor keyword ID for this identifier.
///
/// For example, "define" will return tok::pp_define.
tok::PPKeywordKind getPPKeywordID() const;

/// Return the Objective-C keyword ID for the this identifier.
///
/// For example, 'class' will return tok::objc_class if ObjC is enabled.
tok::ObjCKeywordKind getObjCKeywordID() const {
  if (ObjCOrBuiltinID < tok::NUM_OBJC_KEYWORDS)
    return tok::ObjCKeywordKind(ObjCOrBuiltinID);
  else
    return tok::objc_not_keyword;
}
void setObjCKeywordID(tok::ObjCKeywordKind ID) { ObjCOrBuiltinID = ID; }

/// Return a value indicating whether this is a builtin function.
///
/// 0 is not-built-in. 1+ are specific builtin functions.
unsigned getBuiltinID() const {
  if (ObjCOrBuiltinID >= tok::NUM_OBJC_KEYWORDS)
    return ObjCOrBuiltinID - tok::NUM_OBJC_KEYWORDS;
  else
    return 0;
}
void setBuiltinID(unsigned ID) {
  ObjCOrBuiltinID = ID + tok::NUM_OBJC_KEYWORDS;
  assert(ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS) == ID((void)0)
         && "ID too large for field!")((void)0);
}

unsigned getObjCOrBuiltinID() const { return ObjCOrBuiltinID; }
void setObjCOrBuiltinID(unsigned ID) { ObjCOrBuiltinID = ID; }

/// get/setExtension - Initialize information about whether or not this
/// language token is an extension.  This controls extension warnings, and is
/// only valid if a custom token ID is set.
bool isExtensionToken() const { return IsExtension; }
void setIsExtensionToken(bool Val) {
  IsExtension = Val;
  if (Val)
    NeedsHandleIdentifier = true;
  else
    RecomputeNeedsHandleIdentifier();
}

/// is/setIsFutureCompatKeyword - Initialize information about whether or not
/// this language token is a keyword in a newer or proposed Standard. This
/// controls compatibility warnings, and is only true when not parsing the
/// corresponding Standard. Once a compatibility problem has been diagnosed
/// with this keyword, the flag will be cleared.
bool isFutureCompatKeyword() const { return IsFutureCompatKeyword; }
void setIsFutureCompatKeyword(bool Val) {
  IsFutureCompatKeyword = Val;
  if (Val)
    NeedsHandleIdentifier = true;
  else
    RecomputeNeedsHandleIdentifier();
}

/// setIsPoisoned - Mark this identifier as poisoned.  After poisoning, the
/// Preprocessor will emit an error every time this token is used.
void setIsPoisoned(bool Value = true) {
  IsPoisoned = Value;
  if (Value)
    NeedsHandleIdentifier = true;
  else
    RecomputeNeedsHandleIdentifier();
}

/// Return true if this token has been poisoned.
bool isPoisoned() const { return IsPoisoned; }

/// isCPlusPlusOperatorKeyword/setIsCPlusPlusOperatorKeyword controls whether
/// this identifier is a C++ alternate representation of an operator.
void setIsCPlusPlusOperatorKeyword(bool Val = true) {
  IsCPPOperatorKeyword = Val;
}
bool isCPlusPlusOperatorKeyword() const { return IsCPPOperatorKeyword; }

/// Return true if this token is a keyword in the specified language.
bool isKeyword(const LangOptions &LangOpts) const;

/// Return true if this token is a C++ keyword in the specified
/// language.
bool isCPlusPlusKeyword(const LangOptions &LangOpts) const;

/// Get and set FETokenInfo. The language front-end is allowed to associate
/// arbitrary metadata with this token.
void *getFETokenInfo() const { return FETokenInfo; }
void setFETokenInfo(void *T) { FETokenInfo = T; }

/// Return true if the Preprocessor::HandleIdentifier must be called
/// on a token of this identifier.
///
/// If this returns false, we know that HandleIdentifier will not affect
/// the token.
bool isHandleIdentifierCase() const { return NeedsHandleIdentifier; }

/// Return true if the identifier in its current state was loaded
/// from an AST file.
bool isFromAST() const { return IsFromAST; }

void setIsFromAST() { IsFromAST = true; }

/// Determine whether this identifier has changed since it was loaded
/// from an AST file.
bool hasChangedSinceDeserialization() const {
  return ChangedAfterLoad;
}

/// Note that this identifier has changed since it was loaded from
/// an AST file.
void setChangedSinceDeserialization() {
  ChangedAfterLoad = true;
}

/// Determine whether the frontend token information for this
/// identifier has changed since it was loaded from an AST file.
bool hasFETokenInfoChangedSinceDeserialization() const {
  return FEChangedAfterLoad;
}

/// Note that the frontend token information for this identifier has
/// changed since it was loaded from an AST file.
void setFETokenInfoChangedSinceDeserialization() {
  FEChangedAfterLoad = true;
}

/// Determine whether the information for this identifier is out of
/// date with respect to the external source.
bool isOutOfDate() const { return OutOfDate; }

/// Set whether the information for this identifier is out of
/// date with respect to the external source.
void setOutOfDate(bool OOD) {
  OutOfDate = OOD;
  if (OOD)
    NeedsHandleIdentifier = true;
  else
    RecomputeNeedsHandleIdentifier();
}

/// Determine whether this is the contextual keyword \c import.
bool isModulesImport() const { return IsModulesImport; }

/// Set whether this identifier is the contextual keyword \c import.
void setModulesImport(bool I) {
  IsModulesImport = I;
  if (I)
    NeedsHandleIdentifier = true;
  else
    RecomputeNeedsHandleIdentifier();
}

/// Determine whether this is the mangled name of an OpenMP variant.
bool isMangledOpenMPVariantName() const { return IsMangledOpenMPVariantName; }

/// Set whether this is the mangled name of an OpenMP variant.
void setMangledOpenMPVariantName(bool I) { IsMangledOpenMPVariantName = I; }

/// Return true if this identifier is an editor placeholder.
///
/// Editor placeholders are produced by the code-completion engine and are
/// represented as characters between '<#' and '#>' in the source code. An
/// example of auto-completed call with a placeholder parameter is shown
/// below:
/// \code
///   function(<#int x#>);
/// \endcode
bool isEditorPlaceholder() const {
  return getName().startswith("<#") && getName().endswith("#>");
}

/// Determine whether \p this is a name reserved for the implementation (C99
/// 7.1.3, C++ [lib.global.names]).
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;

/// Provide less than operator for lexicographical sorting.
bool operator<(const IdentifierInfo &RHS) const {
  return getName() < RHS.getName();
}

403private:
/// The Preprocessor::HandleIdentifier does several special (but rare)
/// things to identifiers of various sorts.  For example, it changes the
/// \c for keyword token from tok::identifier to tok::for.
///
/// This method is very tied to the definition of HandleIdentifier.  Any
/// change to it should be reflected here.
void RecomputeNeedsHandleIdentifier() {
  NeedsHandleIdentifier = isPoisoned() || hasMacroDefinition() ||
                          isExtensionToken() || isFutureCompatKeyword() ||
                          isOutOfDate() || isModulesImport();
}
415};

417/// An RAII object for [un]poisoning an identifier within a scope.
418///
419/// \p II is allowed to be null, in which case objects of this type have
420/// no effect.
421class PoisonIdentifierRAIIObject {
IdentifierInfo *const II;
const bool OldValue;

425public:
PoisonIdentifierRAIIObject(IdentifierInfo *II, bool NewValue)
  : II(II), OldValue(II ? II->isPoisoned() : false) {
  if(II)
    II->setIsPoisoned(NewValue);
}

~PoisonIdentifierRAIIObject() {
  if(II)
    II->setIsPoisoned(OldValue);
}
436};

438/// An iterator that walks over all of the known identifiers
439/// in the lookup table.
440///
441/// Since this iterator uses an abstract interface via virtual
442/// functions, it uses an object-oriented interface rather than the
443/// more standard C++ STL iterator interface. In this OO-style
444/// iteration, the single function \c Next() provides dereference,
445/// advance, and end-of-sequence checking in a single
446/// operation. Subclasses of this iterator type will provide the
447/// actual functionality.
448class IdentifierIterator {
449protected:
IdentifierIterator() = default;

452public:
IdentifierIterator(const IdentifierIterator &) = delete;
IdentifierIterator &operator=(const IdentifierIterator &) = delete;

virtual ~IdentifierIterator();

/// Retrieve the next string in the identifier table and
/// advances the iterator for the following string.
///
/// \returns The next string in the identifier table. If there is
/// no such string, returns an empty \c StringRef.
virtual StringRef Next() = 0;
464};

466/// Provides lookups to, and iteration over, IdentiferInfo objects.
467class IdentifierInfoLookup {
468public:
virtual ~IdentifierInfoLookup();

/// Return the IdentifierInfo for the specified named identifier.
///
/// Unlike the version in IdentifierTable, this returns a pointer instead
/// of a reference.  If the pointer is null then the IdentifierInfo cannot
/// be found.
virtual IdentifierInfo* get(StringRef Name) = 0;

/// Retrieve an iterator into the set of all identifiers
/// known to this identifier lookup source.
///
/// This routine provides access to all of the identifiers known to
/// the identifier lookup, allowing access to the contents of the
/// identifiers without introducing the overhead of constructing
/// IdentifierInfo objects for each.
///
/// \returns A new iterator into the set of known identifiers. The
/// caller is responsible for deleting this iterator.
virtual IdentifierIterator *getIdentifiers();
489};

491/// Implements an efficient mapping from strings to IdentifierInfo nodes.
492///
493/// This has no other purpose, but this is an extremely performance-critical
494/// piece of the code, as each occurrence of every identifier goes through
495/// here when lexed.
496class IdentifierTable {
// Shark shows that using MallocAllocator is *much* slower than using this
// BumpPtrAllocator!
using HashTableTy = llvm::StringMap<IdentifierInfo *, llvm::BumpPtrAllocator>;
HashTableTy HashTable;

IdentifierInfoLookup* ExternalLookup;

504public:
/// Create the identifier table.
explicit IdentifierTable(IdentifierInfoLookup *ExternalLookup = nullptr);

/// Create the identifier table, populating it with info about the
/// language keywords for the language specified by \p LangOpts.
explicit IdentifierTable(const LangOptions &LangOpts,
                         IdentifierInfoLookup *ExternalLookup = nullptr);

/// Set the external identifier lookup mechanism.
void setExternalIdentifierLookup(IdentifierInfoLookup *IILookup) {
  ExternalLookup = IILookup;
}

/// Retrieve the external identifier lookup object, if any.
IdentifierInfoLookup *getExternalIdentifierLookup() const {
  return ExternalLookup;
}

llvm::BumpPtrAllocator& getAllocator() {
  return HashTable.getAllocator();
}

/// Return the identifier token info for the specified named
/// identifier.
IdentifierInfo &get(StringRef Name) {
  auto &Entry = *HashTable.insert(std::make_pair(Name, nullptr)).first;

  IdentifierInfo *&II = Entry.second;
  if (II) return *II;

  // No entry; if we have an external lookup, look there first.
  if (ExternalLookup) {
    II = ExternalLookup->get(Name);
    if (II)
      return *II;
  }

  // Lookups failed, make a new IdentifierInfo.
  void *Mem = getAllocator().Allocate<IdentifierInfo>();
  II = new (Mem) IdentifierInfo();

  // Make sure getName() knows how to find the IdentifierInfo
  // contents.
  II->Entry = &Entry;

  return *II;
}

IdentifierInfo &get(StringRef Name, tok::TokenKind TokenCode) {
  IdentifierInfo &II = get(Name);
  II.TokenID = TokenCode;
  assert(II.TokenID == (unsigned) TokenCode && "TokenCode too large")((void)0);
  return II;
}

/// Gets an IdentifierInfo for the given name without consulting
///        external sources.
///
/// This is a version of get() meant for external sources that want to
/// introduce or modify an identifier. If they called get(), they would
/// likely end up in a recursion.
IdentifierInfo &getOwn(StringRef Name) {
  auto &Entry = *HashTable.insert(std::make_pair(Name, nullptr)).first;

  IdentifierInfo *&II = Entry.second;
  if (II)
    return *II;

  // Lookups failed, make a new IdentifierInfo.
  void *Mem = getAllocator().Allocate<IdentifierInfo>();
  II = new (Mem) IdentifierInfo();

  // Make sure getName() knows how to find the IdentifierInfo
  // contents.
  II->Entry = &Entry;

  // If this is the 'import' contextual keyword, mark it as such.
  if (Name.equals("import"))
    II->setModulesImport(true);

  return *II;
}

using iterator = HashTableTy::const_iterator;
using const_iterator = HashTableTy::const_iterator;

iterator begin() const { return HashTable.begin(); }
iterator end() const   { return HashTable.end(); }
unsigned size() const  { return HashTable.size(); }

iterator find(StringRef Name) const { return HashTable.find(Name); }

/// Print some statistics to stderr that indicate how well the
/// hashing is doing.
void PrintStats() const;

/// Populate the identifier table with info about the language keywords
/// for the language specified by \p LangOpts.
void AddKeywords(const LangOptions &LangOpts);
604};

606/// A family of Objective-C methods.
607///
608/// These families have no inherent meaning in the language, but are
609/// nonetheless central enough in the existing implementations to
610/// merit direct AST support.  While, in theory, arbitrary methods can
611/// be considered to form families, we focus here on the methods
612/// involving allocation and retain-count management, as these are the
613/// most "core" and the most likely to be useful to diverse clients
614/// without extra information.
615///
616/// Both selectors and actual method declarations may be classified
617/// into families.  Method families may impose additional restrictions
618/// beyond their selector name; for example, a method called '_init'
619/// that returns void is not considered to be in the 'init' family
620/// (but would be if it returned 'id').  It is also possible to
621/// explicitly change or remove a method's family.  Therefore the
622/// method's family should be considered the single source of truth.
623enum ObjCMethodFamily {
/// No particular method family.
OMF_None,

// Selectors in these families may have arbitrary arity, may be
// written with arbitrary leading underscores, and may have
// additional CamelCase "words" in their first selector chunk
// following the family name.
OMF_alloc,
OMF_copy,
OMF_init,
OMF_mutableCopy,
OMF_new,

// These families are singletons consisting only of the nullary
// selector with the given name.
OMF_autorelease,
OMF_dealloc,
OMF_finalize,
OMF_release,
OMF_retain,
OMF_retainCount,
OMF_self,
OMF_initialize,

// performSelector families
OMF_performSelector
650};

652/// Enough bits to store any enumerator in ObjCMethodFamily or
653/// InvalidObjCMethodFamily.
654enum { ObjCMethodFamilyBitWidth = 4 };

656/// An invalid value of ObjCMethodFamily.
657enum { InvalidObjCMethodFamily = (1 << ObjCMethodFamilyBitWidth) - 1 };

659/// A family of Objective-C methods.
660///
661/// These are family of methods whose result type is initially 'id', but
662/// but are candidate for the result type to be changed to 'instancetype'.
663enum ObjCInstanceTypeFamily {
OIT_None,
OIT_Array,
OIT_Dictionary,
OIT_Singleton,
OIT_Init,
OIT_ReturnsSelf
670};

672enum ObjCStringFormatFamily {
SFF_None,
SFF_NSString,
SFF_CFString
676};

678/// Smart pointer class that efficiently represents Objective-C method
679/// names.
680///
681/// This class will either point to an IdentifierInfo or a
682/// MultiKeywordSelector (which is private). This enables us to optimize
683/// selectors that take no arguments and selectors that take 1 argument, which
684/// accounts for 78% of all selectors in Cocoa.h.
685class Selector {
friend class Diagnostic;
friend class SelectorTable; // only the SelectorTable can create these
friend class DeclarationName; // and the AST's DeclarationName.

enum IdentifierInfoFlag {
  // Empty selector = 0. Note that these enumeration values must
  // correspond to the enumeration values of DeclarationName::StoredNameKind
  ZeroArg  = 0x01,
  OneArg   = 0x02,
  MultiArg = 0x07,
  ArgFlags = 0x07
};

/// A pointer to the MultiKeywordSelector or IdentifierInfo. We use the low
/// three bits of InfoPtr to store an IdentifierInfoFlag. Note that in any
/// case IdentifierInfo and MultiKeywordSelector are already aligned to
/// 8 bytes even on 32 bits archs because of DeclarationName.
uintptr_t InfoPtr = 0;

Selector(IdentifierInfo *II, unsigned nArgs) {
  InfoPtr = reinterpret_cast<uintptr_t>(II);
  assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo")((void)0);
  assert(nArgs < 2 && "nArgs not equal to 0/1")((void)0);
  InfoPtr |= nArgs+1;
}

Selector(MultiKeywordSelector *SI) {
  InfoPtr = reinterpret_cast<uintptr_t>(SI);
  assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo")((void)0);
  InfoPtr |= MultiArg;
}

IdentifierInfo *getAsIdentifierInfo() const {
  if (getIdentifierInfoFlag() < MultiArg)
    return reinterpret_cast<IdentifierInfo *>(InfoPtr & ~ArgFlags);
  return nullptr;
}

MultiKeywordSelector *getMultiKeywordSelector() const {
  return reinterpret_cast<MultiKeywordSelector *>(InfoPtr & ~ArgFlags);
}

unsigned getIdentifierInfoFlag() const {
  return InfoPtr & ArgFlags;
}

static ObjCMethodFamily getMethodFamilyImpl(Selector sel);

static ObjCStringFormatFamily getStringFormatFamilyImpl(Selector sel);

736public:
/// The default ctor should only be used when creating data structures that
///  will contain selectors.
Selector() = default;
explicit Selector(uintptr_t V) : InfoPtr(V) {}

/// operator==/!= - Indicate whether the specified selectors are identical.
bool operator==(Selector RHS) const {
  return InfoPtr == RHS.InfoPtr;
}
bool operator!=(Selector RHS) const {
  return InfoPtr != RHS.InfoPtr;
}

void *getAsOpaquePtr() const {
  return reinterpret_cast<void*>(InfoPtr);
}

/// Determine whether this is the empty selector.
bool isNull() const { return InfoPtr == 0; }

// Predicates to identify the selector type.
bool isKeywordSelector() const {
  return getIdentifierInfoFlag() != ZeroArg;
}

bool isUnarySelector() const {
  return getIdentifierInfoFlag() == ZeroArg;
}

/// If this selector is the specific keyword selector described by Names.
bool isKeywordSelector(ArrayRef<StringRef> Names) const;

/// If this selector is the specific unary selector described by Name.
bool isUnarySelector(StringRef Name) const;

unsigned getNumArgs() const;

/// Retrieve the identifier at a given position in the selector.
///
/// Note that the identifier pointer returned may be NULL. Clients that only
/// care about the text of the identifier string, and not the specific,
/// uniqued identifier pointer, should use \c getNameForSlot(), which returns
/// an empty string when the identifier pointer would be NULL.
///
/// \param argIndex The index for which we want to retrieve the identifier.
/// This index shall be less than \c getNumArgs() unless this is a keyword
/// selector, in which case 0 is the only permissible value.
///
/// \returns the uniqued identifier for this slot, or NULL if this slot has
/// no corresponding identifier.
IdentifierInfo *getIdentifierInfoForSlot(unsigned argIndex) const;

/// Retrieve the name at a given position in the selector.
///
/// \param argIndex The index for which we want to retrieve the name.
/// This index shall be less than \c getNumArgs() unless this is a keyword
/// selector, in which case 0 is the only permissible value.
///
/// \returns the name for this slot, which may be the empty string if no
/// name was supplied.
StringRef getNameForSlot(unsigned argIndex) const;

/// Derive the full selector name (e.g. "foo:bar:") and return
/// it as an std::string.
std::string getAsString() const;

/// Prints the full selector name (e.g. "foo:bar:").
void print(llvm::raw_ostream &OS) const;

void dump() const;

/// Derive the conventional family of this method.
ObjCMethodFamily getMethodFamily() const {
  return getMethodFamilyImpl(*this);
}

ObjCStringFormatFamily getStringFormatFamily() const {
  return getStringFormatFamilyImpl(*this);
}

static Selector getEmptyMarker() {
  return Selector(uintptr_t(-1));
}

static Selector getTombstoneMarker() {
  return Selector(uintptr_t(-2));
}

static ObjCInstanceTypeFamily getInstTypeMethodFamily(Selector sel);
826};

828/// This table allows us to fully hide how we implement
829/// multi-keyword caching.
830class SelectorTable {
// Actually a SelectorTableImpl
void *Impl;

834public:
SelectorTable();
SelectorTable(const SelectorTable &) = delete;
SelectorTable &operator=(const SelectorTable &) = delete;
~SelectorTable();

/// Can create any sort of selector.
///
/// \p NumArgs indicates whether this is a no argument selector "foo", a
/// single argument selector "foo:" or multi-argument "foo:bar:".
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV);

Selector getUnarySelector(IdentifierInfo *ID) {
  return Selector(ID, 1);
}

Selector getNullarySelector(IdentifierInfo *ID) {
  return Selector(ID, 0);
}

/// Return the total amount of memory allocated for managing selectors.
size_t getTotalMemory() const;

/// Return the default setter name for the given identifier.
///
/// This is "set" + \p Name where the initial character of \p Name
/// has been capitalized.
static SmallString<64> constructSetterName(StringRef Name);

/// Return the default setter selector for the given identifier.
///
/// This is "set" + \p Name where the initial character of \p Name
/// has been capitalized.
static Selector constructSetterSelector(IdentifierTable &Idents,
                                        SelectorTable &SelTable,
                                        const IdentifierInfo *Name);

/// Return the property name for the given setter selector.
static std::string getPropertyNameFromSetterSelector(Selector Sel);
873};

875namespace detail {

877/// DeclarationNameExtra is used as a base of various uncommon special names.
878/// This class is needed since DeclarationName has not enough space to store
879/// the kind of every possible names. Therefore the kind of common names is
880/// stored directly in DeclarationName, and the kind of uncommon names is
881/// stored in DeclarationNameExtra. It is aligned to 8 bytes because
882/// DeclarationName needs the lower 3 bits to store the kind of common names.
883/// DeclarationNameExtra is tightly coupled to DeclarationName and any change
884/// here is very likely to require changes in DeclarationName(Table).
885class alignas(IdentifierInfoAlignment) DeclarationNameExtra {
friend class clang::DeclarationName;
friend class clang::DeclarationNameTable;

889protected:
/// The kind of "extra" information stored in the DeclarationName. See
/// @c ExtraKindOrNumArgs for an explanation of how these enumerator values
/// are used. Note that DeclarationName depends on the numerical values
/// of the enumerators in this enum. See DeclarationName::StoredNameKind
/// for more info.
enum ExtraKind {
  CXXDeductionGuideName,
  CXXLiteralOperatorName,
  CXXUsingDirective,
  ObjCMultiArgSelector
};

/// ExtraKindOrNumArgs has one of the following meaning:
///  * The kind of an uncommon C++ special name. This DeclarationNameExtra
///    is in this case in fact either a CXXDeductionGuideNameExtra or
///    a CXXLiteralOperatorIdName.
///
///  * It may be also name common to C++ using-directives (CXXUsingDirective),
///
///  * Otherwise it is ObjCMultiArgSelector+NumArgs, where NumArgs is
///    the number of arguments in the Objective-C selector, in which
///    case the DeclarationNameExtra is also a MultiKeywordSelector.
unsigned ExtraKindOrNumArgs;

DeclarationNameExtra(ExtraKind Kind) : ExtraKindOrNumArgs(Kind) {}
DeclarationNameExtra(unsigned NumArgs)
    : ExtraKindOrNumArgs(ObjCMultiArgSelector + NumArgs) {}

/// Return the corresponding ExtraKind.
ExtraKind getKind() const {
  return static_cast<ExtraKind>(ExtraKindOrNumArgs >
                                        (unsigned)ObjCMultiArgSelector
                                    ? (unsigned)ObjCMultiArgSelector
                                    : ExtraKindOrNumArgs);
}

/// Return the number of arguments in an ObjC selector. Only valid when this
/// is indeed an ObjCMultiArgSelector.
unsigned getNumArgs() const {
  assert(ExtraKindOrNumArgs >= (unsigned)ObjCMultiArgSelector &&((void)0)
         "getNumArgs called but this is not an ObjC selector!")((void)0);
  return ExtraKindOrNumArgs - (unsigned)ObjCMultiArgSelector;
}
933};

935} // namespace detail

937}  // namespace clang

939namespace llvm {

941/// Define DenseMapInfo so that Selectors can be used as keys in DenseMap and
942/// DenseSets.
943template <>
944struct DenseMapInfo<clang::Selector> {
static clang::Selector getEmptyKey() {
  return clang::Selector::getEmptyMarker();
}

static clang::Selector getTombstoneKey() {
  return clang::Selector::getTombstoneMarker();
}

static unsigned getHashValue(clang::Selector S);

static bool isEqual(clang::Selector LHS, clang::Selector RHS) {
  return LHS == RHS;
}
958};

960template<>
961struct PointerLikeTypeTraits<clang::Selector> {
static const void *getAsVoidPointer(clang::Selector P) {
  return P.getAsOpaquePtr();
}

static clang::Selector getFromVoidPointer(const void *P) {
  return clang::Selector(reinterpret_cast<uintptr_t>(P));
}

static constexpr int NumLowBitsAvailable = 0;
971};

973// Provide PointerLikeTypeTraits for IdentifierInfo pointers, which
974// are not guaranteed to be 8-byte aligned.
975template<>
976struct PointerLikeTypeTraits<clang::IdentifierInfo*> {
static void *getAsVoidPointer(clang::IdentifierInfo* P) {
  return P;
}

static clang::IdentifierInfo *getFromVoidPointer(void *P) {
  return static_cast<clang::IdentifierInfo*>(P);
}

static constexpr int NumLowBitsAvailable = 1;
986};

988template<>
989struct PointerLikeTypeTraits<const clang::IdentifierInfo*> {
static const void *getAsVoidPointer(const clang::IdentifierInfo* P) {
  return P;
}

static const clang::IdentifierInfo *getFromVoidPointer(const void *P) {
  return static_cast<const clang::IdentifierInfo*>(P);
}

static constexpr int NumLowBitsAvailable = 1;
999};

1001} // namespace llvm

1003#endif // LLVM_CLANG_BASIC_IDENTIFIERTABLE_H