Bug Summary

File:clang/lib/Lex/Pragma.cpp
Warning:line 1182, column 7
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -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 -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/build-llvm/tools/clang/lib/Lex -resource-dir /usr/lib/llvm-13/lib/clang/13.0.0 -D CLANG_ROUND_TRIP_CC1_ARGS=ON -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/build-llvm/tools/clang/lib/Lex -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/build-llvm/include -I /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/llvm/include -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-13/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/build-llvm/tools/clang/lib/Lex -fdebug-prefix-map=/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-07-26-235520-9401-1 -x c++ /build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp

/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/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//===----------------------------------------------------------------------===//
13
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>
56
57using namespace clang;
58
59// Out-of-line destructor to provide a home for the class.
60PragmaHandler::~PragmaHandler() = default;
61
62//===----------------------------------------------------------------------===//
63// EmptyPragmaHandler Implementation.
64//===----------------------------------------------------------------------===//
65
66EmptyPragmaHandler::EmptyPragmaHandler(StringRef Name) : PragmaHandler(Name) {}
67
68void EmptyPragmaHandler::HandlePragma(Preprocessor &PP,
69 PragmaIntroducer Introducer,
70 Token &FirstToken) {}
71
72//===----------------------------------------------------------------------===//
73// PragmaNamespace Implementation.
74//===----------------------------------------------------------------------===//
75
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,
81 bool IgnoreNull) const {
82 auto I = Handlers.find(Name);
83 if (I != Handlers.end())
84 return I->getValue().get();
85 if (IgnoreNull)
86 return nullptr;
87 I = Handlers.find(StringRef());
88 if (I != Handlers.end())
89 return I->getValue().get();
90 return nullptr;
91}
92
93void PragmaNamespace::AddPragma(PragmaHandler *Handler) {
94 assert(!Handlers.count(Handler->getName()) &&(static_cast <bool> (!Handlers.count(Handler->getName
()) && "A handler with this name is already registered in this namespace"
) ? void (0) : __assert_fail ("!Handlers.count(Handler->getName()) && \"A handler with this name is already registered in this namespace\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 95, __extension__ __PRETTY_FUNCTION__))
95 "A handler with this name is already registered in this namespace")(static_cast <bool> (!Handlers.count(Handler->getName
()) && "A handler with this name is already registered in this namespace"
) ? void (0) : __assert_fail ("!Handlers.count(Handler->getName()) && \"A handler with this name is already registered in this namespace\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 95, __extension__ __PRETTY_FUNCTION__))
;
96 Handlers[Handler->getName()].reset(Handler);
97}
98
99void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) {
100 auto I = Handlers.find(Handler->getName());
101 assert(I != Handlers.end() &&(static_cast <bool> (I != Handlers.end() && "Handler not registered in this namespace"
) ? void (0) : __assert_fail ("I != Handlers.end() && \"Handler not registered in this namespace\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 102, __extension__ __PRETTY_FUNCTION__))
102 "Handler not registered in this namespace")(static_cast <bool> (I != Handlers.end() && "Handler not registered in this namespace"
) ? void (0) : __assert_fail ("I != Handlers.end() && \"Handler not registered in this namespace\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 102, __extension__ __PRETTY_FUNCTION__))
;
103 // Release ownership back to the caller.
104 I->getValue().release();
105 Handlers.erase(I);
106}
107
108void PragmaNamespace::HandlePragma(Preprocessor &PP,
109 PragmaIntroducer Introducer, Token &Tok) {
110 // Read the 'namespace' that the directive is in, e.g. STDC. Do not macro
111 // expand it, the user can have a STDC #define, that should not affect this.
112 PP.LexUnexpandedToken(Tok);
113
114 // Get the handler for this token. If there is no handler, ignore the pragma.
115 PragmaHandler *Handler
116 = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName()
117 : StringRef(),
118 /*IgnoreNull=*/false);
119 if (!Handler) {
120 PP.Diag(Tok, diag::warn_pragma_ignored);
121 return;
122 }
123
124 // Otherwise, pass it down.
125 Handler->HandlePragma(PP, Introducer, Tok);
126}
127
128//===----------------------------------------------------------------------===//
129// Preprocessor Pragma Directive Handling.
130//===----------------------------------------------------------------------===//
131
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 {
137 Preprocessor &Self;
138 bool Collect;
139 SmallVector<Token, 3> Tokens;
140 Token &Tok;
141
142 void lex() {
143 if (Collect)
144 Tokens.push_back(Tok);
145 Self.Lex(Tok);
146 }
147
148 void revert() {
149 assert(Collect && "did not collect tokens")(static_cast <bool> (Collect && "did not collect tokens"
) ? void (0) : __assert_fail ("Collect && \"did not collect tokens\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 149, __extension__ __PRETTY_FUNCTION__))
;
150 assert(!Tokens.empty() && "collected unexpected number of tokens")(static_cast <bool> (!Tokens.empty() && "collected unexpected number of tokens"
) ? void (0) : __assert_fail ("!Tokens.empty() && \"collected unexpected number of tokens\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 150, __extension__ __PRETTY_FUNCTION__))
;
151
152 // Push the ( "string" ) tokens into the token stream.
153 auto Toks = std::make_unique<Token[]>(Tokens.size());
154 std::copy(Tokens.begin() + 1, Tokens.end(), Toks.get());
155 Toks[Tokens.size() - 1] = Tok;
156 Self.EnterTokenStream(std::move(Toks), Tokens.size(),
157 /*DisableMacroExpansion*/ true,
158 /*IsReinject*/ true);
159
160 // ... and return the pragma token unchanged.
161 Tok = *Tokens.begin();
162 }
163};
164} // namespace
165
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) {
169 if (Callbacks)
170 Callbacks->PragmaDirective(Introducer.Loc, Introducer.Kind);
171
172 if (!PragmasEnabled)
173 return;
174
175 ++NumPragma;
176
177 // Invoke the first level of pragma handlers which reads the namespace id.
178 Token Tok;
179 PragmaHandlers->HandlePragma(*this, Introducer, Tok);
180
181 // If the pragma handler didn't read the rest of the line, consume it now.
182 if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())
183 || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
184 DiscardUntilEndOfDirective();
185}
186
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) {
191 // C11 6.10.3.4/3:
192 // all pragma unary operator expressions within [a completely
193 // macro-replaced preprocessing token sequence] are [...] processed [after
194 // rescanning is complete]
195 //
196 // This means that we execute _Pragma operators in two cases:
197 //
198 // 1) on token sequences that would otherwise be produced as the output of
199 // phase 4 of preprocessing, and
200 // 2) on token sequences formed as the macro-replaced token sequence of a
201 // macro argument
202 //
203 // Case #2 appears to be a wording bug: only _Pragmas that would survive to
204 // the end of phase 4 should actually be executed. Discussion on the WG14
205 // mailing list suggests that a _Pragma operator is notionally checked early,
206 // but only pragmas that survive to the end of phase 4 should be executed.
207 //
208 // In Case #2, we check the syntax now, but then put the tokens back into the
209 // token stream for later consumption.
210
211 TokenCollector Toks = {*this, InMacroArgPreExpansion, {}, Tok};
212
213 // Remember the pragma token location.
214 SourceLocation PragmaLoc = Tok.getLocation();
215
216 // Read the '('.
217 Toks.lex();
218 if (Tok.isNot(tok::l_paren)) {
219 Diag(PragmaLoc, diag::err__Pragma_malformed);
220 return;
221 }
222
223 // Read the '"..."'.
224 Toks.lex();
225 if (!tok::isStringLiteral(Tok.getKind())) {
226 Diag(PragmaLoc, diag::err__Pragma_malformed);
227 // Skip bad tokens, and the ')', if present.
228 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof))
229 Lex(Tok);
230 while (Tok.isNot(tok::r_paren) &&
231 !Tok.isAtStartOfLine() &&
232 Tok.isNot(tok::eof))
233 Lex(Tok);
234 if (Tok.is(tok::r_paren))
235 Lex(Tok);
236 return;
237 }
238
239 if (Tok.hasUDSuffix()) {
240 Diag(Tok, diag::err_invalid_string_udl);
241 // Skip this token, and the ')', if present.
242 Lex(Tok);
243 if (Tok.is(tok::r_paren))
244 Lex(Tok);
245 return;
246 }
247
248 // Remember the string.
249 Token StrTok = Tok;
250
251 // Read the ')'.
252 Toks.lex();
253 if (Tok.isNot(tok::r_paren)) {
254 Diag(PragmaLoc, diag::err__Pragma_malformed);
255 return;
256 }
257
258 // If we're expanding a macro argument, put the tokens back.
259 if (InMacroArgPreExpansion) {
260 Toks.revert();
261 return;
262 }
263
264 SourceLocation RParenLoc = Tok.getLocation();
265 std::string StrVal = getSpelling(StrTok);
266
267 // The _Pragma is lexically sound. Destringize according to C11 6.10.9.1:
268 // "The string literal is destringized by deleting any encoding prefix,
269 // deleting the leading and trailing double-quotes, replacing each escape
270 // sequence \" by a double-quote, and replacing each escape sequence \\ by a
271 // single backslash."
272 if (StrVal[0] == 'L' || StrVal[0] == 'U' ||
273 (StrVal[0] == 'u' && StrVal[1] != '8'))
274 StrVal.erase(StrVal.begin());
275 else if (StrVal[0] == 'u')
276 StrVal.erase(StrVal.begin(), StrVal.begin() + 2);
277
278 if (StrVal[0] == 'R') {
279 // FIXME: C++11 does not specify how to handle raw-string-literals here.
280 // We strip off the 'R', the quotes, the d-char-sequences, and the parens.
281 assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' &&(static_cast <bool> (StrVal[1] == '"' && StrVal
[StrVal.size() - 1] == '"' && "Invalid raw string token!"
) ? void (0) : __assert_fail ("StrVal[1] == '\"' && StrVal[StrVal.size() - 1] == '\"' && \"Invalid raw string token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 282, __extension__ __PRETTY_FUNCTION__))
282 "Invalid raw string token!")(static_cast <bool> (StrVal[1] == '"' && StrVal
[StrVal.size() - 1] == '"' && "Invalid raw string token!"
) ? void (0) : __assert_fail ("StrVal[1] == '\"' && StrVal[StrVal.size() - 1] == '\"' && \"Invalid raw string token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 282, __extension__ __PRETTY_FUNCTION__))
;
283
284 // Measure the length of the d-char-sequence.
285 unsigned NumDChars = 0;
286 while (StrVal[2 + NumDChars] != '(') {
287 assert(NumDChars < (StrVal.size() - 5) / 2 &&(static_cast <bool> (NumDChars < (StrVal.size() - 5)
/ 2 && "Invalid raw string token!") ? void (0) : __assert_fail
("NumDChars < (StrVal.size() - 5) / 2 && \"Invalid raw string token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 288, __extension__ __PRETTY_FUNCTION__))
288 "Invalid raw string token!")(static_cast <bool> (NumDChars < (StrVal.size() - 5)
/ 2 && "Invalid raw string token!") ? void (0) : __assert_fail
("NumDChars < (StrVal.size() - 5) / 2 && \"Invalid raw string token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 288, __extension__ __PRETTY_FUNCTION__))
;
289 ++NumDChars;
290 }
291 assert(StrVal[StrVal.size() - 2 - NumDChars] == ')')(static_cast <bool> (StrVal[StrVal.size() - 2 - NumDChars
] == ')') ? void (0) : __assert_fail ("StrVal[StrVal.size() - 2 - NumDChars] == ')'"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 291, __extension__ __PRETTY_FUNCTION__))
;
292
293 // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the
294 // parens below.
295 StrVal.erase(0, 2 + NumDChars);
296 StrVal.erase(StrVal.size() - 1 - NumDChars);
297 } else {
298 assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&(static_cast <bool> (StrVal[0] == '"' && StrVal
[StrVal.size()-1] == '"' && "Invalid string token!") ?
void (0) : __assert_fail ("StrVal[0] == '\"' && StrVal[StrVal.size()-1] == '\"' && \"Invalid string token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 299, __extension__ __PRETTY_FUNCTION__))
299 "Invalid string token!")(static_cast <bool> (StrVal[0] == '"' && StrVal
[StrVal.size()-1] == '"' && "Invalid string token!") ?
void (0) : __assert_fail ("StrVal[0] == '\"' && StrVal[StrVal.size()-1] == '\"' && \"Invalid string token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 299, __extension__ __PRETTY_FUNCTION__))
;
300
301 // Remove escaped quotes and escapes.
302 unsigned ResultPos = 1;
303 for (size_t i = 1, e = StrVal.size() - 1; i != e; ++i) {
304 // Skip escapes. \\ -> '\' and \" -> '"'.
305 if (StrVal[i] == '\\' && i + 1 < e &&
306 (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"'))
307 ++i;
308 StrVal[ResultPos++] = StrVal[i];
309 }
310 StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);
311 }
312
313 // Remove the front quote, replacing it with a space, so that the pragma
314 // contents appear to have a space before them.
315 StrVal[0] = ' ';
316
317 // Replace the terminating quote with a \n.
318 StrVal[StrVal.size()-1] = '\n';
319
320 // Plop the string (including the newline and trailing null) into a buffer
321 // where we can lex it.
322 Token TmpTok;
323 TmpTok.startToken();
324 CreateString(StrVal, TmpTok);
325 SourceLocation TokLoc = TmpTok.getLocation();
326
327 // Make and enter a lexer object so that we lex and expand the tokens just
328 // like any others.
329 Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
330 StrVal.size(), *this);
331
332 EnterSourceFileWithLexer(TL, nullptr);
333
334 // With everything set up, lex this as a #pragma directive.
335 HandlePragmaDirective({PIK__Pragma, PragmaLoc});
336
337 // Finally, return whatever came after the pragma directive.
338 return Lex(Tok);
339}
340
341/// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
342/// is not enclosed within a string literal.
343void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
344 // During macro pre-expansion, check the syntax now but put the tokens back
345 // into the token stream for later consumption. Same as Handle_Pragma.
346 TokenCollector Toks = {*this, InMacroArgPreExpansion, {}, Tok};
347
348 // Remember the pragma token location.
349 SourceLocation PragmaLoc = Tok.getLocation();
350
351 // Read the '('.
352 Toks.lex();
353 if (Tok.isNot(tok::l_paren)) {
354 Diag(PragmaLoc, diag::err__Pragma_malformed);
355 return;
356 }
357
358 // Get the tokens enclosed within the __pragma(), as well as the final ')'.
359 SmallVector<Token, 32> PragmaToks;
360 int NumParens = 0;
361 Toks.lex();
362 while (Tok.isNot(tok::eof)) {
363 PragmaToks.push_back(Tok);
364 if (Tok.is(tok::l_paren))
365 NumParens++;
366 else if (Tok.is(tok::r_paren) && NumParens-- == 0)
367 break;
368 Toks.lex();
369 }
370
371 if (Tok.is(tok::eof)) {
372 Diag(PragmaLoc, diag::err_unterminated___pragma);
373 return;
374 }
375
376 // If we're expanding a macro argument, put the tokens back.
377 if (InMacroArgPreExpansion) {
378 Toks.revert();
379 return;
380 }
381
382 PragmaToks.front().setFlag(Token::LeadingSpace);
383
384 // Replace the ')' with an EOD to mark the end of the pragma.
385 PragmaToks.back().setKind(tok::eod);
386
387 Token *TokArray = new Token[PragmaToks.size()];
388 std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);
389
390 // Push the tokens onto the stack.
391 EnterTokenStream(TokArray, PragmaToks.size(), true, true,
392 /*IsReinject*/ false);
393
394 // With everything set up, lex this as a #pragma directive.
395 HandlePragmaDirective({PIK___pragma, PragmaLoc});
396
397 // Finally, return whatever came after the pragma directive.
398 return Lex(Tok);
399}
400
401/// HandlePragmaOnce - Handle \#pragma once. OnceTok is the 'once'.
402void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
403 // Don't honor the 'once' when handling the primary source file, unless
404 // this is a prefix to a TU, which indicates we're generating a PCH file, or
405 // when the main file is a header (e.g. when -xc-header is provided on the
406 // commandline).
407 if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) {
408 Diag(OnceTok, diag::pp_pragma_once_in_main_file);
409 return;
410 }
411
412 // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc.
413 // Mark the file as a once-only file now.
414 HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
415}
416
417void Preprocessor::HandlePragmaMark(Token &MarkTok) {
418 assert(CurPPLexer && "No current lexer?")(static_cast <bool> (CurPPLexer && "No current lexer?"
) ? void (0) : __assert_fail ("CurPPLexer && \"No current lexer?\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 418, __extension__ __PRETTY_FUNCTION__))
;
419
420 SmallString<64> Buffer;
421 CurLexer->ReadToEndOfLine(&Buffer);
422 if (Callbacks)
423 Callbacks->PragmaMark(MarkTok.getLocation(), Buffer);
424}
425
426/// HandlePragmaPoison - Handle \#pragma GCC poison. PoisonTok is the 'poison'.
427void Preprocessor::HandlePragmaPoison() {
428 Token Tok;
429
430 while (true) {
431 // Read the next token to poison. While doing this, pretend that we are
432 // skipping while reading the identifier to poison.
433 // This avoids errors on code like:
434 // #pragma GCC poison X
435 // #pragma GCC poison X
436 if (CurPPLexer) CurPPLexer->LexingRawMode = true;
437 LexUnexpandedToken(Tok);
438 if (CurPPLexer) CurPPLexer->LexingRawMode = false;
439
440 // If we reached the end of line, we're done.
441 if (Tok.is(tok::eod)) return;
442
443 // Can only poison identifiers.
444 if (Tok.isNot(tok::raw_identifier)) {
445 Diag(Tok, diag::err_pp_invalid_poison);
446 return;
447 }
448
449 // Look up the identifier info for the token. We disabled identifier lookup
450 // by saying we're skipping contents, so we need to do this manually.
451 IdentifierInfo *II = LookUpIdentifierInfo(Tok);
452
453 // Already poisoned.
454 if (II->isPoisoned()) continue;
455
456 // If this is a macro identifier, emit a warning.
457 if (isMacroDefined(II))
458 Diag(Tok, diag::pp_poisoning_existing_macro);
459
460 // Finally, poison it!
461 II->setIsPoisoned();
462 if (II->isFromAST())
463 II->setChangedSinceDeserialization();
464 }
465}
466
467/// HandlePragmaSystemHeader - Implement \#pragma GCC system_header. We know
468/// that the whole directive has been parsed.
469void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) {
470 if (isInPrimaryFile()) {
471 Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
472 return;
473 }
474
475 // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc.
476 PreprocessorLexer *TheLexer = getCurrentFileLexer();
477
478 // Mark the file as a system header.
479 HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry());
480
481 PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
482 if (PLoc.isInvalid())
483 return;
484
485 unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename());
486
487 // Notify the client, if desired, that we are in a new source file.
488 if (Callbacks)
489 Callbacks->FileChanged(SysHeaderTok.getLocation(),
490 PPCallbacks::SystemHeaderPragma, SrcMgr::C_System);
491
492 // Emit a line marker. This will change any source locations from this point
493 // forward to realize they are in a system header.
494 // Create a line note with this information.
495 SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine() + 1,
496 FilenameID, /*IsEntry=*/false, /*IsExit=*/false,
497 SrcMgr::C_System);
498}
499
500static llvm::Optional<Token> LexHeader(Preprocessor &PP,
501 Optional<FileEntryRef> &File,
502 bool SuppressIncludeNotFoundError) {
503 Token FilenameTok;
504 if (PP.LexHeaderName(FilenameTok, /*AllowConcatenation*/ false))
505 return llvm::None;
506
507 // If the next token wasn't a header-name, diagnose the error.
508 if (FilenameTok.isNot(tok::header_name)) {
509 PP.Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
510 return llvm::None;
511 }
512
513 // Reserve a buffer to get the spelling.
514 SmallString<128> FilenameBuffer;
515 bool Invalid = false;
516 StringRef Filename = PP.getSpelling(FilenameTok, FilenameBuffer, &Invalid);
517 if (Invalid)
518 return llvm::None;
519
520 bool isAngled =
521 PP.GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
522 // If GetIncludeFilenameSpelling set the start ptr to null, there was an
523 // error.
524 if (Filename.empty())
525 return llvm::None;
526
527 // Search include directories for this file.
528 const DirectoryLookup *CurDir;
529 File = PP.LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
530 nullptr, CurDir, nullptr, nullptr, nullptr, nullptr,
531 nullptr);
532 if (!File) {
533 if (!SuppressIncludeNotFoundError)
534 PP.Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
535 return llvm::None;
536 }
537
538 return FilenameTok;
539}
540
541/// HandlePragmaIncludeInstead - Handle \#pragma clang include_instead(header).
542void Preprocessor::HandlePragmaIncludeInstead(Token &Tok) {
543 // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc.
544 PreprocessorLexer *TheLexer = getCurrentFileLexer();
545
546 if (!SourceMgr.isInSystemHeader(Tok.getLocation())) {
547 Diag(Tok, diag::err_pragma_include_instead_not_sysheader);
548 return;
549 }
550
551 Lex(Tok);
552 if (Tok.isNot(tok::l_paren)) {
553 Diag(Tok, diag::err_expected) << "(";
554 return;
555 }
556
557 Optional<FileEntryRef> File;
558 llvm::Optional<Token> FilenameTok =
559 LexHeader(*this, File, SuppressIncludeNotFoundError);
560 if (!FilenameTok)
561 return;
562
563 Lex(Tok);
564 if (Tok.isNot(tok::r_paren)) {
565 Diag(Tok, diag::err_expected) << ")";
566 return;
567 }
568
569 HeaderInfo.AddFileAlias(
570 TheLexer->getFileEntry(),
571 {FilenameTok->getLiteralData(), FilenameTok->getLength()});
572}
573
574/// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah.
575void Preprocessor::HandlePragmaDependency(Token &DependencyTok) {
576 Optional<FileEntryRef> File;
577 llvm::Optional<Token> FilenameTok =
578 LexHeader(*this, File, SuppressIncludeNotFoundError);
579 if (!FilenameTok)
580 return;
581
582 const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();
583
584 // If this file is older than the file it depends on, emit a diagnostic.
585 if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
586 // Lex tokens at the end of the message and include them in the message.
587 std::string Message;
588 Lex(DependencyTok);
589 while (DependencyTok.isNot(tok::eod)) {
590 Message += getSpelling(DependencyTok) + " ";
591 Lex(DependencyTok);
592 }
593
594 // Remove the trailing ' ' if present.
595 if (!Message.empty())
596 Message.erase(Message.end()-1);
597 Diag(*FilenameTok, diag::pp_out_of_date_dependency) << Message;
598 }
599}
600
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) {
604 // Remember the pragma token location.
605 Token PragmaTok = Tok;
606
607 // Read the '('.
608 Lex(Tok);
609 if (Tok.isNot(tok::l_paren)) {
610 Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
611 << getSpelling(PragmaTok);
612 return nullptr;
613 }
614
615 // Read the macro name string.
616 Lex(Tok);
617 if (Tok.isNot(tok::string_literal)) {
618 Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
619 << getSpelling(PragmaTok);
620 return nullptr;
621 }
622
623 if (Tok.hasUDSuffix()) {
624 Diag(Tok, diag::err_invalid_string_udl);
625 return nullptr;
626 }
627
628 // Remember the macro string.
629 std::string StrVal = getSpelling(Tok);
630
631 // Read the ')'.
632 Lex(Tok);
633 if (Tok.isNot(tok::r_paren)) {
634 Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
635 << getSpelling(PragmaTok);
636 return nullptr;
637 }
638
639 assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&(static_cast <bool> (StrVal[0] == '"' && StrVal
[StrVal.size()-1] == '"' && "Invalid string token!") ?
void (0) : __assert_fail ("StrVal[0] == '\"' && StrVal[StrVal.size()-1] == '\"' && \"Invalid string token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 640, __extension__ __PRETTY_FUNCTION__))
640 "Invalid string token!")(static_cast <bool> (StrVal[0] == '"' && StrVal
[StrVal.size()-1] == '"' && "Invalid string token!") ?
void (0) : __assert_fail ("StrVal[0] == '\"' && StrVal[StrVal.size()-1] == '\"' && \"Invalid string token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 640, __extension__ __PRETTY_FUNCTION__))
;
641
642 // Create a Token from the string.
643 Token MacroTok;
644 MacroTok.startToken();
645 MacroTok.setKind(tok::raw_identifier);
646 CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);
647
648 // Get the IdentifierInfo of MacroToPushTok.
649 return LookUpIdentifierInfo(MacroTok);
650}
651
652/// Handle \#pragma push_macro.
653///
654/// The syntax is:
655/// \code
656/// #pragma push_macro("macro")
657/// \endcode
658void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) {
659 // Parse the pragma directive and get the macro IdentifierInfo*.
660 IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok);
661 if (!IdentInfo) return;
662
663 // Get the MacroInfo associated with IdentInfo.
664 MacroInfo *MI = getMacroInfo(IdentInfo);
665
666 if (MI) {
667 // Allow the original MacroInfo to be redefined later.
668 MI->setIsAllowRedefinitionsWithoutWarning(true);
669 }
670
671 // Push the cloned MacroInfo so we can retrieve it later.
672 PragmaPushMacroInfo[IdentInfo].push_back(MI);
673}
674
675/// Handle \#pragma pop_macro.
676///
677/// The syntax is:
678/// \code
679/// #pragma pop_macro("macro")
680/// \endcode
681void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) {
682 SourceLocation MessageLoc = PopMacroTok.getLocation();
683
684 // Parse the pragma directive and get the macro IdentifierInfo*.
685 IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok);
686 if (!IdentInfo) return;
687
688 // Find the vector<MacroInfo*> associated with the macro.
689 llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>::iterator iter =
690 PragmaPushMacroInfo.find(IdentInfo);
691 if (iter != PragmaPushMacroInfo.end()) {
692 // Forget the MacroInfo currently associated with IdentInfo.
693 if (MacroInfo *MI = getMacroInfo(IdentInfo)) {
694 if (MI->isWarnIfUnused())
695 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
696 appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc));
697 }
698
699 // Get the MacroInfo we want to reinstall.
700 MacroInfo *MacroToReInstall = iter->second.back();
701
702 if (MacroToReInstall)
703 // Reinstall the previously pushed macro.
704 appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc);
705
706 // Pop PragmaPushMacroInfo stack.
707 iter->second.pop_back();
708 if (iter->second.empty())
709 PragmaPushMacroInfo.erase(iter);
710 } else {
711 Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push)
712 << IdentInfo->getName();
713 }
714}
715
716void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) {
717 // We will either get a quoted filename or a bracketed filename, and we
718 // have to track which we got. The first filename is the source name,
719 // and the second name is the mapped filename. If the first is quoted,
720 // the second must be as well (cannot mix and match quotes and brackets).
721
722 // Get the open paren
723 Lex(Tok);
724 if (Tok.isNot(tok::l_paren)) {
725 Diag(Tok, diag::warn_pragma_include_alias_expected) << "(";
726 return;
727 }
728
729 // We expect either a quoted string literal, or a bracketed name
730 Token SourceFilenameTok;
731 if (LexHeaderName(SourceFilenameTok))
732 return;
733
734 StringRef SourceFileName;
735 SmallString<128> FileNameBuffer;
736 if (SourceFilenameTok.is(tok::header_name)) {
737 SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer);
738 } else {
739 Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
740 return;
741 }
742 FileNameBuffer.clear();
743
744 // Now we expect a comma, followed by another include name
745 Lex(Tok);
746 if (Tok.isNot(tok::comma)) {
747 Diag(Tok, diag::warn_pragma_include_alias_expected) << ",";
748 return;
749 }
750
751 Token ReplaceFilenameTok;
752 if (LexHeaderName(ReplaceFilenameTok))
753 return;
754
755 StringRef ReplaceFileName;
756 if (ReplaceFilenameTok.is(tok::header_name)) {
757 ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer);
758 } else {
759 Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
760 return;
761 }
762
763 // Finally, we expect the closing paren
764 Lex(Tok);
765 if (Tok.isNot(tok::r_paren)) {
766 Diag(Tok, diag::warn_pragma_include_alias_expected) << ")";
767 return;
768 }
769
770 // Now that we have the source and target filenames, we need to make sure
771 // they're both of the same type (angled vs non-angled)
772 StringRef OriginalSource = SourceFileName;
773
774 bool SourceIsAngled =
775 GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(),
776 SourceFileName);
777 bool ReplaceIsAngled =
778 GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(),
779 ReplaceFileName);
780 if (!SourceFileName.empty() && !ReplaceFileName.empty() &&
781 (SourceIsAngled != ReplaceIsAngled)) {
782 unsigned int DiagID;
783 if (SourceIsAngled)
784 DiagID = diag::warn_pragma_include_alias_mismatch_angle;
785 else
786 DiagID = diag::warn_pragma_include_alias_mismatch_quote;
787
788 Diag(SourceFilenameTok.getLocation(), DiagID)
789 << SourceFileName
790 << ReplaceFileName;
791
792 return;
793 }
794
795 // Now we can let the include handler know about this mapping
796 getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName);
797}
798
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(
802 Preprocessor &PP, Token &Tok,
803 std::pair<IdentifierInfo *, SourceLocation> &ModuleNameComponent,
804 bool First) {
805 PP.LexUnexpandedToken(Tok);
806 if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) {
807 StringLiteralParser Literal(Tok, PP);
808 if (Literal.hadError)
809 return true;
810 ModuleNameComponent = std::make_pair(
811 PP.getIdentifierInfo(Literal.GetString()), Tok.getLocation());
812 } else if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) {
813 ModuleNameComponent =
814 std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation());
815 } else {
816 PP.Diag(Tok.getLocation(), diag::err_pp_expected_module_name) << First;
817 return true;
818 }
819 return false;
820}
821
822static bool LexModuleName(
823 Preprocessor &PP, Token &Tok,
824 llvm::SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>>
825 &ModuleName) {
826 while (true) {
827 std::pair<IdentifierInfo*, SourceLocation> NameComponent;
828 if (LexModuleNameComponent(PP, Tok, NameComponent, ModuleName.empty()))
829 return true;
830 ModuleName.push_back(NameComponent);
831
832 PP.LexUnexpandedToken(Tok);
833 if (Tok.isNot(tok::period))
834 return false;
835 }
836}
837
838void Preprocessor::HandlePragmaModuleBuild(Token &Tok) {
839 SourceLocation Loc = Tok.getLocation();
840
841 std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
842 if (LexModuleNameComponent(*this, Tok, ModuleNameLoc, true))
843 return;
844 IdentifierInfo *ModuleName = ModuleNameLoc.first;
845
846 LexUnexpandedToken(Tok);
847 if (Tok.isNot(tok::eod)) {
848 Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
849 DiscardUntilEndOfDirective();
850 }
851
852 CurLexer->LexingRawMode = true;
853
854 auto TryConsumeIdentifier = [&](StringRef Ident) -> bool {
855 if (Tok.getKind() != tok::raw_identifier ||
856 Tok.getRawIdentifier() != Ident)
857 return false;
858 CurLexer->Lex(Tok);
859 return true;
860 };
861
862 // Scan forward looking for the end of the module.
863 const char *Start = CurLexer->getBufferLocation();
864 const char *End = nullptr;
865 unsigned NestingLevel = 1;
866 while (true) {
867 End = CurLexer->getBufferLocation();
868 CurLexer->Lex(Tok);
869
870 if (Tok.is(tok::eof)) {
871 Diag(Loc, diag::err_pp_module_build_missing_end);
872 break;
873 }
874
875 if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) {
876 // Token was part of module; keep going.
877 continue;
878 }
879
880 // We hit something directive-shaped; check to see if this is the end
881 // of the module build.
882 CurLexer->ParsingPreprocessorDirective = true;
883 CurLexer->Lex(Tok);
884 if (TryConsumeIdentifier("pragma") && TryConsumeIdentifier("clang") &&
885 TryConsumeIdentifier("module")) {
886 if (TryConsumeIdentifier("build"))
887 // #pragma clang module build -> entering a nested module build.
888 ++NestingLevel;
889 else if (TryConsumeIdentifier("endbuild")) {
890 // #pragma clang module endbuild -> leaving a module build.
891 if (--NestingLevel == 0)
892 break;
893 }
894 // We should either be looking at the EOD or more of the current directive
895 // preceding the EOD. Either way we can ignore this token and keep going.
896 assert(Tok.getKind() != tok::eof && "missing EOD before EOF")(static_cast <bool> (Tok.getKind() != tok::eof &&
"missing EOD before EOF") ? void (0) : __assert_fail ("Tok.getKind() != tok::eof && \"missing EOD before EOF\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 896, __extension__ __PRETTY_FUNCTION__))
;
897 }
898 }
899
900 CurLexer->LexingRawMode = false;
901
902 // Load the extracted text as a preprocessed module.
903 assert(CurLexer->getBuffer().begin() <= Start &&(static_cast <bool> (CurLexer->getBuffer().begin() <=
Start && Start <= CurLexer->getBuffer().end() &&
CurLexer->getBuffer().begin() <= End && End <=
CurLexer->getBuffer().end() && "module source range not contained within same file buffer"
) ? void (0) : __assert_fail ("CurLexer->getBuffer().begin() <= Start && Start <= CurLexer->getBuffer().end() && CurLexer->getBuffer().begin() <= End && End <= CurLexer->getBuffer().end() && \"module source range not contained within same file buffer\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 907, __extension__ __PRETTY_FUNCTION__))
904 Start <= CurLexer->getBuffer().end() &&(static_cast <bool> (CurLexer->getBuffer().begin() <=
Start && Start <= CurLexer->getBuffer().end() &&
CurLexer->getBuffer().begin() <= End && End <=
CurLexer->getBuffer().end() && "module source range not contained within same file buffer"
) ? void (0) : __assert_fail ("CurLexer->getBuffer().begin() <= Start && Start <= CurLexer->getBuffer().end() && CurLexer->getBuffer().begin() <= End && End <= CurLexer->getBuffer().end() && \"module source range not contained within same file buffer\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 907, __extension__ __PRETTY_FUNCTION__))
905 CurLexer->getBuffer().begin() <= End &&(static_cast <bool> (CurLexer->getBuffer().begin() <=
Start && Start <= CurLexer->getBuffer().end() &&
CurLexer->getBuffer().begin() <= End && End <=
CurLexer->getBuffer().end() && "module source range not contained within same file buffer"
) ? void (0) : __assert_fail ("CurLexer->getBuffer().begin() <= Start && Start <= CurLexer->getBuffer().end() && CurLexer->getBuffer().begin() <= End && End <= CurLexer->getBuffer().end() && \"module source range not contained within same file buffer\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 907, __extension__ __PRETTY_FUNCTION__))
906 End <= CurLexer->getBuffer().end() &&(static_cast <bool> (CurLexer->getBuffer().begin() <=
Start && Start <= CurLexer->getBuffer().end() &&
CurLexer->getBuffer().begin() <= End && End <=
CurLexer->getBuffer().end() && "module source range not contained within same file buffer"
) ? void (0) : __assert_fail ("CurLexer->getBuffer().begin() <= Start && Start <= CurLexer->getBuffer().end() && CurLexer->getBuffer().begin() <= End && End <= CurLexer->getBuffer().end() && \"module source range not contained within same file buffer\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 907, __extension__ __PRETTY_FUNCTION__))
907 "module source range not contained within same file buffer")(static_cast <bool> (CurLexer->getBuffer().begin() <=
Start && Start <= CurLexer->getBuffer().end() &&
CurLexer->getBuffer().begin() <= End && End <=
CurLexer->getBuffer().end() && "module source range not contained within same file buffer"
) ? void (0) : __assert_fail ("CurLexer->getBuffer().begin() <= Start && Start <= CurLexer->getBuffer().end() && CurLexer->getBuffer().begin() <= End && End <= CurLexer->getBuffer().end() && \"module source range not contained within same file buffer\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 907, __extension__ __PRETTY_FUNCTION__))
;
908 TheModuleLoader.createModuleFromSource(Loc, ModuleName->getName(),
909 StringRef(Start, End - Start));
910}
911
912void Preprocessor::HandlePragmaHdrstop(Token &Tok) {
913 Lex(Tok);
914 if (Tok.is(tok::l_paren)) {
915 Diag(Tok.getLocation(), diag::warn_pp_hdrstop_filename_ignored);
916
917 std::string FileName;
918 if (!LexStringLiteral(Tok, FileName, "pragma hdrstop", false))
919 return;
920
921 if (Tok.isNot(tok::r_paren)) {
922 Diag(Tok, diag::err_expected) << tok::r_paren;
923 return;
924 }
925 Lex(Tok);
926 }
927 if (Tok.isNot(tok::eod))
928 Diag(Tok.getLocation(), diag::ext_pp_extra_tokens_at_eol)
929 << "pragma hdrstop";
930
931 if (creatingPCHWithPragmaHdrStop() &&
932 SourceMgr.isInMainFile(Tok.getLocation())) {
933 assert(CurLexer && "no lexer for #pragma hdrstop processing")(static_cast <bool> (CurLexer && "no lexer for #pragma hdrstop processing"
) ? void (0) : __assert_fail ("CurLexer && \"no lexer for #pragma hdrstop processing\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 933, __extension__ __PRETTY_FUNCTION__))
;
934 Token &Result = Tok;
935 Result.startToken();
936 CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
937 CurLexer->cutOffLexing();
938 }
939 if (usingPCHWithPragmaHdrStop())
940 SkippingUntilPragmaHdrStop = false;
941}
942
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,
947 PragmaHandler *Handler) {
948 PragmaNamespace *InsertNS = PragmaHandlers.get();
949
950 // If this is specified to be in a namespace, step down into it.
951 if (!Namespace.empty()) {
952 // If there is already a pragma handler with the name of this namespace,
953 // we either have an error (directive with the same name as a namespace) or
954 // we already have the namespace to insert into.
955 if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
956 InsertNS = Existing->getIfNamespace();
957 assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"(static_cast <bool> (InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
" handler with the same name!") ? void (0) : __assert_fail (
"InsertNS != nullptr && \"Cannot have a pragma namespace and pragma\" \" handler with the same name!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 958, __extension__ __PRETTY_FUNCTION__))
958 " handler with the same name!")(static_cast <bool> (InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
" handler with the same name!") ? void (0) : __assert_fail (
"InsertNS != nullptr && \"Cannot have a pragma namespace and pragma\" \" handler with the same name!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 958, __extension__ __PRETTY_FUNCTION__))
;
959 } else {
960 // Otherwise, this namespace doesn't exist yet, create and insert the
961 // handler for it.
962 InsertNS = new PragmaNamespace(Namespace);
963 PragmaHandlers->AddPragma(InsertNS);
964 }
965 }
966
967 // Check to make sure we don't already have a pragma for this identifier.
968 assert(!InsertNS->FindHandler(Handler->getName()) &&(static_cast <bool> (!InsertNS->FindHandler(Handler->
getName()) && "Pragma handler already exists for this identifier!"
) ? void (0) : __assert_fail ("!InsertNS->FindHandler(Handler->getName()) && \"Pragma handler already exists for this identifier!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 969, __extension__ __PRETTY_FUNCTION__))
969 "Pragma handler already exists for this identifier!")(static_cast <bool> (!InsertNS->FindHandler(Handler->
getName()) && "Pragma handler already exists for this identifier!"
) ? void (0) : __assert_fail ("!InsertNS->FindHandler(Handler->getName()) && \"Pragma handler already exists for this identifier!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 969, __extension__ __PRETTY_FUNCTION__))
;
970 InsertNS->AddPragma(Handler);
971}
972
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,
978 PragmaHandler *Handler) {
979 PragmaNamespace *NS = PragmaHandlers.get();
980
981 // If this is specified to be in a namespace, step down into it.
982 if (!Namespace.empty()) {
983 PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
984 assert(Existing && "Namespace containing handler does not exist!")(static_cast <bool> (Existing && "Namespace containing handler does not exist!"
) ? void (0) : __assert_fail ("Existing && \"Namespace containing handler does not exist!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 984, __extension__ __PRETTY_FUNCTION__))
;
985
986 NS = Existing->getIfNamespace();
987 assert(NS && "Invalid namespace, registered as a regular pragma handler!")(static_cast <bool> (NS && "Invalid namespace, registered as a regular pragma handler!"
) ? void (0) : __assert_fail ("NS && \"Invalid namespace, registered as a regular pragma handler!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 987, __extension__ __PRETTY_FUNCTION__))
;
988 }
989
990 NS->RemovePragmaHandler(Handler);
991
992 // If this is a non-default namespace and it is now empty, remove it.
993 if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
994 PragmaHandlers->RemovePragmaHandler(NS);
995 delete NS;
996 }
997}
998
999bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) {
1000 Token Tok;
1001 LexUnexpandedToken(Tok);
1002
1003 if (Tok.isNot(tok::identifier)) {
1004 Diag(Tok, diag::ext_on_off_switch_syntax);
1005 return true;
1006 }
1007 IdentifierInfo *II = Tok.getIdentifierInfo();
1008 if (II->isStr("ON"))
1009 Result = tok::OOS_ON;
1010 else if (II->isStr("OFF"))
1011 Result = tok::OOS_OFF;
1012 else if (II->isStr("DEFAULT"))
1013 Result = tok::OOS_DEFAULT;
1014 else {
1015 Diag(Tok, diag::ext_on_off_switch_syntax);
1016 return true;
1017 }
1018
1019 // Verify that this is followed by EOD.
1020 LexUnexpandedToken(Tok);
1021 if (Tok.isNot(tok::eod))
1022 Diag(Tok, diag::ext_pragma_syntax_eod);
1023 return false;
1024}
1025
1026namespace {
1027
1028/// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
1029struct PragmaOnceHandler : public PragmaHandler {
1030 PragmaOnceHandler() : PragmaHandler("once") {}
1031
1032 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1033 Token &OnceTok) override {
1034 PP.CheckEndOfDirective("pragma once");
1035 PP.HandlePragmaOnce(OnceTok);
1036 }
1037};
1038
1039/// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
1040/// rest of the line is not lexed.
1041struct PragmaMarkHandler : public PragmaHandler {
1042 PragmaMarkHandler() : PragmaHandler("mark") {}
1043
1044 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1045 Token &MarkTok) override {
1046 PP.HandlePragmaMark(MarkTok);
1047 }
1048};
1049
1050/// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
1051struct PragmaPoisonHandler : public PragmaHandler {
1052 PragmaPoisonHandler() : PragmaHandler("poison") {}
1053
1054 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1055 Token &PoisonTok) override {
1056 PP.HandlePragmaPoison();
1057 }
1058};
1059
1060/// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
1061/// as a system header, which silences warnings in it.
1062struct PragmaSystemHeaderHandler : public PragmaHandler {
1063 PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}
1064
1065 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1066 Token &SHToken) override {
1067 PP.HandlePragmaSystemHeader(SHToken);
1068 PP.CheckEndOfDirective("pragma");
1069 }
1070};
1071
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 {
1076 PragmaIncludeInsteadHandler() : PragmaHandler("include_instead") {}
1077
1078 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1079 Token &IIToken) override {
1080 PP.HandlePragmaIncludeInstead(IIToken);
1081 }
1082};
1083
1084struct PragmaDependencyHandler : public PragmaHandler {
1085 PragmaDependencyHandler() : PragmaHandler("dependency") {}
1086
1087 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1088 Token &DepToken) override {
1089 PP.HandlePragmaDependency(DepToken);
1090 }
1091};
1092
1093struct PragmaDebugHandler : public PragmaHandler {
1094 PragmaDebugHandler() : PragmaHandler("__debug") {}
1095
1096 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1097 Token &DebugToken) override {
1098 Token Tok;
1099 PP.LexUnexpandedToken(Tok);
1100 if (Tok.isNot(tok::identifier)) {
1
Calling 'Token::isNot'
4
Returning from 'Token::isNot'
5
Taking false branch
1101 PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1102 return;
1103 }
1104 IdentifierInfo *II = Tok.getIdentifierInfo();
1105
1106 if (II->isStr("assert")) {
6
Calling 'IdentifierInfo::isStr'
9
Returning from 'IdentifierInfo::isStr'
10
Taking false branch
1107 if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1108 llvm_unreachable("This is an assertion!")::llvm::llvm_unreachable_internal("This is an assertion!", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 1108)
;
1109 } else if (II->isStr("crash")) {
11
Calling 'IdentifierInfo::isStr'
14
Returning from 'IdentifierInfo::isStr'
15
Taking false branch
1110 llvm::Timer T("crash", "pragma crash");
1111 llvm::TimeRegion R(&T);
1112 if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1113 LLVM_BUILTIN_TRAP__builtin_trap();
1114 } else if (II->isStr("parser_crash")) {
16
Calling 'IdentifierInfo::isStr'
19
Returning from 'IdentifierInfo::isStr'
20
Taking false branch
1115 if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash) {
1116 Token Crasher;
1117 Crasher.startToken();
1118 Crasher.setKind(tok::annot_pragma_parser_crash);
1119 Crasher.setAnnotationRange(SourceRange(Tok.getLocation()));
1120 PP.EnterToken(Crasher, /*IsReinject*/ false);
1121 }
1122 } else if (II->isStr("dump")) {
21
Calling 'IdentifierInfo::isStr'
24
Returning from 'IdentifierInfo::isStr'
25
Taking false branch
1123 Token Identifier;
1124 PP.LexUnexpandedToken(Identifier);
1125 if (auto *DumpII = Identifier.getIdentifierInfo()) {
1126 Token DumpAnnot;
1127 DumpAnnot.startToken();
1128 DumpAnnot.setKind(tok::annot_pragma_dump);
1129 DumpAnnot.setAnnotationRange(
1130 SourceRange(Tok.getLocation(), Identifier.getLocation()));
1131 DumpAnnot.setAnnotationValue(DumpII);
1132 PP.DiscardUntilEndOfDirective();
1133 PP.EnterToken(DumpAnnot, /*IsReinject*/false);
1134 } else {
1135 PP.Diag(Identifier, diag::warn_pragma_debug_missing_argument)
1136 << II->getName();
1137 }
1138 } else if (II->isStr("diag_mapping")) {
26
Calling 'IdentifierInfo::isStr'
28
Returning from 'IdentifierInfo::isStr'
29
Taking false branch
1139 Token DiagName;
1140 PP.LexUnexpandedToken(DiagName);
1141 if (DiagName.is(tok::eod))
1142 PP.getDiagnostics().dump();
1143 else if (DiagName.is(tok::string_literal) && !DiagName.hasUDSuffix()) {
1144 StringLiteralParser Literal(DiagName, PP);
1145 if (Literal.hadError)
1146 return;
1147 PP.getDiagnostics().dump(Literal.GetString());
1148 } else {
1149 PP.Diag(DiagName, diag::warn_pragma_debug_missing_argument)
1150 << II->getName();
1151 }
1152 } else if (II->isStr("llvm_fatal_error")) {
30
Calling 'IdentifierInfo::isStr'
33
Returning from 'IdentifierInfo::isStr'
34
Taking false branch
1153 if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1154 llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
1155 } else if (II->isStr("llvm_unreachable")) {
35
Calling 'IdentifierInfo::isStr'
37
Returning from 'IdentifierInfo::isStr'
38
Taking false branch
1156 if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1157 llvm_unreachable("#pragma clang __debug llvm_unreachable")::llvm::llvm_unreachable_internal("#pragma clang __debug llvm_unreachable"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 1157)
;
1158 } else if (II->isStr("macro")) {
39
Calling 'IdentifierInfo::isStr'
41
Returning from 'IdentifierInfo::isStr'
42
Taking false branch
1159 Token MacroName;
1160 PP.LexUnexpandedToken(MacroName);
1161 auto *MacroII = MacroName.getIdentifierInfo();
1162 if (MacroII)
1163 PP.dumpMacroInfo(MacroII);
1164 else
1165 PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
1166 << II->getName();
1167 } else if (II->isStr("module_map")) {
43
Calling 'IdentifierInfo::isStr'
47
Returning from 'IdentifierInfo::isStr'
48
Taking true branch
1168 llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1169 ModuleName;
1170 if (LexModuleName(PP, Tok, ModuleName))
49
Assuming the condition is false
50
Taking false branch
1171 return;
1172 ModuleMap &MM = PP.getHeaderSearchInfo().getModuleMap();
1173 Module *M = nullptr;
51
'M' initialized to a null pointer value
1174 for (auto IIAndLoc : ModuleName) {
52
Assuming '__begin11' is equal to '__end11'
1175 M = MM.lookupModuleQualified(IIAndLoc.first->getName(), M);
1176 if (!M) {
1177 PP.Diag(IIAndLoc.second, diag::warn_pragma_debug_unknown_module)
1178 << IIAndLoc.first;
1179 return;
1180 }
1181 }
1182 M->dump();
53
Called C++ object pointer is null
1183 } else if (II->isStr("overflow_stack")) {
1184 if (!PP.getPreprocessorOpts().DisablePragmaDebugCrash)
1185 DebugOverflowStack();
1186 } else if (II->isStr("captured")) {
1187 HandleCaptured(PP);
1188 } else if (II->isStr("modules")) {
1189 struct ModuleVisitor {
1190 Preprocessor &PP;
1191 void visit(Module *M, bool VisibleOnly) {
1192 SourceLocation ImportLoc = PP.getModuleImportLoc(M);
1193 if (!VisibleOnly || ImportLoc.isValid()) {
1194 llvm::errs() << M->getFullModuleName() << " ";
1195 if (ImportLoc.isValid()) {
1196 llvm::errs() << M << " visible ";
1197 ImportLoc.print(llvm::errs(), PP.getSourceManager());
1198 }
1199 llvm::errs() << "\n";
1200 }
1201 for (Module *Sub : M->submodules()) {
1202 if (!VisibleOnly || ImportLoc.isInvalid() || Sub->IsExplicit)
1203 visit(Sub, VisibleOnly);
1204 }
1205 }
1206 void visitAll(bool VisibleOnly) {
1207 for (auto &NameAndMod :
1208 PP.getHeaderSearchInfo().getModuleMap().modules())
1209 visit(NameAndMod.second, VisibleOnly);
1210 }
1211 } Visitor{PP};
1212
1213 Token Kind;
1214 PP.LexUnexpandedToken(Kind);
1215 auto *DumpII = Kind.getIdentifierInfo();
1216 if (!DumpII) {
1217 PP.Diag(Kind, diag::warn_pragma_debug_missing_argument)
1218 << II->getName();
1219 } else if (DumpII->isStr("all")) {
1220 Visitor.visitAll(false);
1221 } else if (DumpII->isStr("visible")) {
1222 Visitor.visitAll(true);
1223 } else if (DumpII->isStr("building")) {
1224 for (auto &Building : PP.getBuildingSubmodules()) {
1225 llvm::errs() << "in " << Building.M->getFullModuleName();
1226 if (Building.ImportLoc.isValid()) {
1227 llvm::errs() << " imported ";
1228 if (Building.IsPragma)
1229 llvm::errs() << "via pragma ";
1230 llvm::errs() << "at ";
1231 Building.ImportLoc.print(llvm::errs(), PP.getSourceManager());
1232 llvm::errs() << "\n";
1233 }
1234 }
1235 } else {
1236 PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1237 << DumpII->getName();
1238 }
1239 } else {
1240 PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1241 << II->getName();
1242 }
1243
1244 PPCallbacks *Callbacks = PP.getPPCallbacks();
1245 if (Callbacks)
1246 Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
1247 }
1248
1249 void HandleCaptured(Preprocessor &PP) {
1250 Token Tok;
1251 PP.LexUnexpandedToken(Tok);
1252
1253 if (Tok.isNot(tok::eod)) {
1254 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
1255 << "pragma clang __debug captured";
1256 return;
1257 }
1258
1259 SourceLocation NameLoc = Tok.getLocation();
1260 MutableArrayRef<Token> Toks(
1261 PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
1262 Toks[0].startToken();
1263 Toks[0].setKind(tok::annot_pragma_captured);
1264 Toks[0].setLocation(NameLoc);
1265
1266 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
1267 /*IsReinject=*/false);
1268 }
1269
1270// Disable MSVC warning about runtime stack overflow.
1271#ifdef _MSC_VER
1272 #pragma warning(disable : 4717)
1273#endif
1274 static void DebugOverflowStack(void (*P)() = nullptr) {
1275 void (*volatile Self)(void(*P)()) = DebugOverflowStack;
1276 Self(reinterpret_cast<void(*)()>(Self));
1277 }
1278#ifdef _MSC_VER
1279 #pragma warning(default : 4717)
1280#endif
1281};
1282
1283/// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
1284struct PragmaDiagnosticHandler : public PragmaHandler {
1285private:
1286 const char *Namespace;
1287
1288public:
1289 explicit PragmaDiagnosticHandler(const char *NS)
1290 : PragmaHandler("diagnostic"), Namespace(NS) {}
1291
1292 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1293 Token &DiagToken) override {
1294 SourceLocation DiagLoc = DiagToken.getLocation();
1295 Token Tok;
1296 PP.LexUnexpandedToken(Tok);
1297 if (Tok.isNot(tok::identifier)) {
1298 PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1299 return;
1300 }
1301 IdentifierInfo *II = Tok.getIdentifierInfo();
1302 PPCallbacks *Callbacks = PP.getPPCallbacks();
1303
1304 if (II->isStr("pop")) {
1305 if (!PP.getDiagnostics().popMappings(DiagLoc))
1306 PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
1307 else if (Callbacks)
1308 Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
1309 return;
1310 } else if (II->isStr("push")) {
1311 PP.getDiagnostics().pushMappings(DiagLoc);
1312 if (Callbacks)
1313 Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
1314 return;
1315 }
1316
1317 diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
1318 .Case("ignored", diag::Severity::Ignored)
1319 .Case("warning", diag::Severity::Warning)
1320 .Case("error", diag::Severity::Error)
1321 .Case("fatal", diag::Severity::Fatal)
1322 .Default(diag::Severity());
1323
1324 if (SV == diag::Severity()) {
1325 PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1326 return;
1327 }
1328
1329 PP.LexUnexpandedToken(Tok);
1330 SourceLocation StringLoc = Tok.getLocation();
1331
1332 std::string WarningName;
1333 if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
1334 /*AllowMacroExpansion=*/false))
1335 return;
1336
1337 if (Tok.isNot(tok::eod)) {
1338 PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1339 return;
1340 }
1341
1342 if (WarningName.size() < 3 || WarningName[0] != '-' ||
1343 (WarningName[1] != 'W' && WarningName[1] != 'R')) {
1344 PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
1345 return;
1346 }
1347
1348 diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
1349 : diag::Flavor::Remark;
1350 StringRef Group = StringRef(WarningName).substr(2);
1351 bool unknownDiag = false;
1352 if (Group == "everything") {
1353 // Special handling for pragma clang diagnostic ... "-Weverything".
1354 // There is no formal group named "everything", so there has to be a
1355 // special case for it.
1356 PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
1357 } else
1358 unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
1359 DiagLoc);
1360 if (unknownDiag)
1361 PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
1362 << WarningName;
1363 else if (Callbacks)
1364 Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
1365 }
1366};
1367
1368/// "\#pragma hdrstop [<header-name-string>]"
1369struct PragmaHdrstopHandler : public PragmaHandler {
1370 PragmaHdrstopHandler() : PragmaHandler("hdrstop") {}
1371 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1372 Token &DepToken) override {
1373 PP.HandlePragmaHdrstop(DepToken);
1374 }
1375};
1376
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 {
1381 PragmaWarningHandler() : PragmaHandler("warning") {}
1382
1383 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1384 Token &Tok) override {
1385 // Parse things like:
1386 // warning(push, 1)
1387 // warning(pop)
1388 // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
1389 SourceLocation DiagLoc = Tok.getLocation();
1390 PPCallbacks *Callbacks = PP.getPPCallbacks();
1391
1392 PP.Lex(Tok);
1393 if (Tok.isNot(tok::l_paren)) {
1394 PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
1395 return;
1396 }
1397
1398 PP.Lex(Tok);
1399 IdentifierInfo *II = Tok.getIdentifierInfo();
1400
1401 if (II && II->isStr("push")) {
1402 // #pragma warning( push[ ,n ] )
1403 int Level = -1;
1404 PP.Lex(Tok);
1405 if (Tok.is(tok::comma)) {
1406 PP.Lex(Tok);
1407 uint64_t Value;
1408 if (Tok.is(tok::numeric_constant) &&
1409 PP.parseSimpleIntegerLiteral(Tok, Value))
1410 Level = int(Value);
1411 if (Level < 0 || Level > 4) {
1412 PP.Diag(Tok, diag::warn_pragma_warning_push_level);
1413 return;
1414 }
1415 }
1416 if (Callbacks)
1417 Callbacks->PragmaWarningPush(DiagLoc, Level);
1418 } else if (II && II->isStr("pop")) {
1419 // #pragma warning( pop )
1420 PP.Lex(Tok);
1421 if (Callbacks)
1422 Callbacks->PragmaWarningPop(DiagLoc);
1423 } else {
1424 // #pragma warning( warning-specifier : warning-number-list
1425 // [; warning-specifier : warning-number-list...] )
1426 while (true) {
1427 II = Tok.getIdentifierInfo();
1428 if (!II && !Tok.is(tok::numeric_constant)) {
1429 PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1430 return;
1431 }
1432
1433 // Figure out which warning specifier this is.
1434 bool SpecifierValid;
1435 StringRef Specifier;
1436 llvm::SmallString<1> SpecifierBuf;
1437 if (II) {
1438 Specifier = II->getName();
1439 SpecifierValid = llvm::StringSwitch<bool>(Specifier)
1440 .Cases("default", "disable", "error", "once",
1441 "suppress", true)
1442 .Default(false);
1443 // If we read a correct specifier, snatch next token (that should be
1444 // ":", checked later).
1445 if (SpecifierValid)
1446 PP.Lex(Tok);
1447 } else {
1448 // Token is a numeric constant. It should be either 1, 2, 3 or 4.
1449 uint64_t Value;
1450 Specifier = PP.getSpelling(Tok, SpecifierBuf);
1451 if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
1452 SpecifierValid = (Value >= 1) && (Value <= 4);
1453 } else
1454 SpecifierValid = false;
1455 // Next token already snatched by parseSimpleIntegerLiteral.
1456 }
1457
1458 if (!SpecifierValid) {
1459 PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1460 return;
1461 }
1462 if (Tok.isNot(tok::colon)) {
1463 PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
1464 return;
1465 }
1466
1467 // Collect the warning ids.
1468 SmallVector<int, 4> Ids;
1469 PP.Lex(Tok);
1470 while (Tok.is(tok::numeric_constant)) {
1471 uint64_t Value;
1472 if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
1473 Value > INT_MAX2147483647) {
1474 PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
1475 return;
1476 }
1477 Ids.push_back(int(Value));
1478 }
1479 if (Callbacks)
1480 Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
1481
1482 // Parse the next specifier if there is a semicolon.
1483 if (Tok.isNot(tok::semi))
1484 break;
1485 PP.Lex(Tok);
1486 }
1487 }
1488
1489 if (Tok.isNot(tok::r_paren)) {
1490 PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
1491 return;
1492 }
1493
1494 PP.Lex(Tok);
1495 if (Tok.isNot(tok::eod))
1496 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
1497 }
1498};
1499
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 {
1504 PragmaExecCharsetHandler() : PragmaHandler("execution_character_set") {}
1505
1506 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1507 Token &Tok) override {
1508 // Parse things like:
1509 // execution_character_set(push, "UTF-8")
1510 // execution_character_set(pop)
1511 SourceLocation DiagLoc = Tok.getLocation();
1512 PPCallbacks *Callbacks = PP.getPPCallbacks();
1513
1514 PP.Lex(Tok);
1515 if (Tok.isNot(tok::l_paren)) {
1516 PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << "(";
1517 return;
1518 }
1519
1520 PP.Lex(Tok);
1521 IdentifierInfo *II = Tok.getIdentifierInfo();
1522
1523 if (II && II->isStr("push")) {
1524 // #pragma execution_character_set( push[ , string ] )
1525 PP.Lex(Tok);
1526 if (Tok.is(tok::comma)) {
1527 PP.Lex(Tok);
1528
1529 std::string ExecCharset;
1530 if (!PP.FinishLexStringLiteral(Tok, ExecCharset,
1531 "pragma execution_character_set",
1532 /*AllowMacroExpansion=*/false))
1533 return;
1534
1535 // MSVC supports either of these, but nothing else.
1536 if (ExecCharset != "UTF-8" && ExecCharset != "utf-8") {
1537 PP.Diag(Tok, diag::warn_pragma_exec_charset_push_invalid) << ExecCharset;
1538 return;
1539 }
1540 }
1541 if (Callbacks)
1542 Callbacks->PragmaExecCharsetPush(DiagLoc, "UTF-8");
1543 } else if (II && II->isStr("pop")) {
1544 // #pragma execution_character_set( pop )
1545 PP.Lex(Tok);
1546 if (Callbacks)
1547 Callbacks->PragmaExecCharsetPop(DiagLoc);
1548 } else {
1549 PP.Diag(Tok, diag::warn_pragma_exec_charset_spec_invalid);
1550 return;
1551 }
1552
1553 if (Tok.isNot(tok::r_paren)) {
1554 PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << ")";
1555 return;
1556 }
1557
1558 PP.Lex(Tok);
1559 if (Tok.isNot(tok::eod))
1560 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma execution_character_set";
1561 }
1562};
1563
1564/// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1565struct PragmaIncludeAliasHandler : public PragmaHandler {
1566 PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}
1567
1568 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1569 Token &IncludeAliasTok) override {
1570 PP.HandlePragmaIncludeAlias(IncludeAliasTok);
1571 }
1572};
1573
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:
1589 const PPCallbacks::PragmaMessageKind Kind;
1590 const StringRef Namespace;
1591
1592 static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
1593 bool PragmaNameOnly = false) {
1594 switch (Kind) {
1595 case PPCallbacks::PMK_Message:
1596 return PragmaNameOnly ? "message" : "pragma message";
1597 case PPCallbacks::PMK_Warning:
1598 return PragmaNameOnly ? "warning" : "pragma warning";
1599 case PPCallbacks::PMK_Error:
1600 return PragmaNameOnly ? "error" : "pragma error";
1601 }
1602 llvm_unreachable("Unknown PragmaMessageKind!")::llvm::llvm_unreachable_internal("Unknown PragmaMessageKind!"
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/lib/Lex/Pragma.cpp"
, 1602)
;
1603 }
1604
1605public:
1606 PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
1607 StringRef Namespace = StringRef())
1608 : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind),
1609 Namespace(Namespace) {}
1610
1611 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1612 Token &Tok) override {
1613 SourceLocation MessageLoc = Tok.getLocation();
1614 PP.Lex(Tok);
1615 bool ExpectClosingParen = false;
1616 switch (Tok.getKind()) {
1617 case tok::l_paren:
1618 // We have a MSVC style pragma message.
1619 ExpectClosingParen = true;
1620 // Read the string.
1621 PP.Lex(Tok);
1622 break;
1623 case tok::string_literal:
1624 // We have a GCC style pragma message, and we just read the string.
1625 break;
1626 default:
1627 PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
1628 return;
1629 }
1630
1631 std::string MessageString;
1632 if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
1633 /*AllowMacroExpansion=*/true))
1634 return;
1635
1636 if (ExpectClosingParen) {
1637 if (Tok.isNot(tok::r_paren)) {
1638 PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1639 return;
1640 }
1641 PP.Lex(Tok); // eat the r_paren.
1642 }
1643
1644 if (Tok.isNot(tok::eod)) {
1645 PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1646 return;
1647 }
1648
1649 // Output the message.
1650 PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
1651 ? diag::err_pragma_message
1652 : diag::warn_pragma_message) << MessageString;
1653
1654 // If the pragma is lexically sound, notify any interested PPCallbacks.
1655 if (PPCallbacks *Callbacks = PP.getPPCallbacks())
1656 Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
1657 }
1658};
1659
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 {
1665 PragmaModuleImportHandler() : PragmaHandler("import") {}
1666
1667 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1668 Token &Tok) override {
1669 SourceLocation ImportLoc = Tok.getLocation();
1670
1671 // Read the module name.
1672 llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1673 ModuleName;
1674 if (LexModuleName(PP, Tok, ModuleName))
1675 return;
1676
1677 if (Tok.isNot(tok::eod))
1678 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1679
1680 // If we have a non-empty module path, load the named module.
1681 Module *Imported =
1682 PP.getModuleLoader().loadModule(ImportLoc, ModuleName, Module::Hidden,
1683 /*IsInclusionDirective=*/false);
1684 if (!Imported)
1685 return;
1686
1687 PP.makeModuleVisible(Imported, ImportLoc);
1688 PP.EnterAnnotationToken(SourceRange(ImportLoc, ModuleName.back().second),
1689 tok::annot_module_include, Imported);
1690 if (auto *CB = PP.getPPCallbacks())
1691 CB->moduleImport(ImportLoc, ModuleName, Imported);
1692 }
1693};
1694
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 {
1702 PragmaModuleBeginHandler() : PragmaHandler("begin") {}
1703
1704 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1705 Token &Tok) override {
1706 SourceLocation BeginLoc = Tok.getLocation();
1707
1708 // Read the module name.
1709 llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1710 ModuleName;
1711 if (LexModuleName(PP, Tok, ModuleName))
1712 return;
1713
1714 if (Tok.isNot(tok::eod))
1715 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1716
1717 // We can only enter submodules of the current module.
1718 StringRef Current = PP.getLangOpts().CurrentModule;
1719 if (ModuleName.front().first->getName() != Current) {
1720 PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module)
1721 << ModuleName.front().first << (ModuleName.size() > 1)
1722 << Current.empty() << Current;
1723 return;
1724 }
1725
1726 // Find the module we're entering. We require that a module map for it
1727 // be loaded or implicitly loadable.
1728 auto &HSI = PP.getHeaderSearchInfo();
1729 Module *M = HSI.lookupModule(Current);
1730 if (!M) {
1731 PP.Diag(ModuleName.front().second,
1732 diag::err_pp_module_begin_no_module_map) << Current;
1733 return;
1734 }
1735 for (unsigned I = 1; I != ModuleName.size(); ++I) {
1736 auto *NewM = M->findOrInferSubmodule(ModuleName[I].first->getName());
1737 if (!NewM) {
1738 PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule)
1739 << M->getFullModuleName() << ModuleName[I].first;
1740 return;
1741 }
1742 M = NewM;
1743 }
1744
1745 // If the module isn't available, it doesn't make sense to enter it.
1746 if (Preprocessor::checkModuleIsAvailable(
1747 PP.getLangOpts(), PP.getTargetInfo(), PP.getDiagnostics(), M)) {
1748 PP.Diag(BeginLoc, diag::note_pp_module_begin_here)
1749 << M->getTopLevelModuleName();
1750 return;
1751 }
1752
1753 // Enter the scope of the submodule.
1754 PP.EnterSubmodule(M, BeginLoc, /*ForPragma*/true);
1755 PP.EnterAnnotationToken(SourceRange(BeginLoc, ModuleName.back().second),
1756 tok::annot_module_begin, M);
1757 }
1758};
1759
1760/// Handle the clang \#pragma module end extension.
1761struct PragmaModuleEndHandler : public PragmaHandler {
1762 PragmaModuleEndHandler() : PragmaHandler("end") {}
1763
1764 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1765 Token &Tok) override {
1766 SourceLocation Loc = Tok.getLocation();
1767
1768 PP.LexUnexpandedToken(Tok);
1769 if (Tok.isNot(tok::eod))
1770 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1771
1772 Module *M = PP.LeaveSubmodule(/*ForPragma*/true);
1773 if (M)
1774 PP.EnterAnnotationToken(SourceRange(Loc), tok::annot_module_end, M);
1775 else
1776 PP.Diag(Loc, diag::err_pp_module_end_without_module_begin);
1777 }
1778};
1779
1780/// Handle the clang \#pragma module build extension.
1781struct PragmaModuleBuildHandler : public PragmaHandler {
1782 PragmaModuleBuildHandler() : PragmaHandler("build") {}
1783
1784 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1785 Token &Tok) override {
1786 PP.HandlePragmaModuleBuild(Tok);
1787 }
1788};
1789
1790/// Handle the clang \#pragma module load extension.
1791struct PragmaModuleLoadHandler : public PragmaHandler {
1792 PragmaModuleLoadHandler() : PragmaHandler("load") {}
1793
1794 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1795 Token &Tok) override {
1796 SourceLocation Loc = Tok.getLocation();
1797
1798 // Read the module name.
1799 llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 8>
1800 ModuleName;
1801 if (LexModuleName(PP, Tok, ModuleName))
1802 return;
1803
1804 if (Tok.isNot(tok::eod))
1805 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1806
1807 // Load the module, don't make it visible.
1808 PP.getModuleLoader().loadModule(Loc, ModuleName, Module::Hidden,
1809 /*IsInclusionDirective=*/false);
1810 }
1811};
1812
1813/// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1814/// macro on the top of the stack.
1815struct PragmaPushMacroHandler : public PragmaHandler {
1816 PragmaPushMacroHandler() : PragmaHandler("push_macro") {}
1817
1818 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1819 Token &PushMacroTok) override {
1820 PP.HandlePragmaPushMacro(PushMacroTok);
1821 }
1822};
1823
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 {
1827 PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}
1828
1829 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1830 Token &PopMacroTok) override {
1831 PP.HandlePragmaPopMacro(PopMacroTok);
1832 }
1833};
1834
1835/// PragmaARCCFCodeAuditedHandler -
1836/// \#pragma clang arc_cf_code_audited begin/end
1837struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
1838 PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}
1839
1840 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1841 Token &NameTok) override {
1842 SourceLocation Loc = NameTok.getLocation();
1843 bool IsBegin;
1844
1845 Token Tok;
1846
1847 // Lex the 'begin' or 'end'.
1848 PP.LexUnexpandedToken(Tok);
1849 const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1850 if (BeginEnd && BeginEnd->isStr("begin")) {
1851 IsBegin = true;
1852 } else if (BeginEnd && BeginEnd->isStr("end")) {
1853 IsBegin = false;
1854 } else {
1855 PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
1856 return;
1857 }
1858
1859 // Verify that this is followed by EOD.
1860 PP.LexUnexpandedToken(Tok);
1861 if (Tok.isNot(tok::eod))
1862 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1863
1864 // The start location of the active audit.
1865 SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedInfo().second;
1866
1867 // The start location we want after processing this.
1868 SourceLocation NewLoc;
1869
1870 if (IsBegin) {
1871 // Complain about attempts to re-enter an audit.
1872 if (BeginLoc.isValid()) {
1873 PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
1874 PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1875 }
1876 NewLoc = Loc;
1877 } else {
1878 // Complain about attempts to leave an audit that doesn't exist.
1879 if (!BeginLoc.isValid()) {
1880 PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
1881 return;
1882 }
1883 NewLoc = SourceLocation();
1884 }
1885
1886 PP.setPragmaARCCFCodeAuditedInfo(NameTok.getIdentifierInfo(), NewLoc);
1887 }
1888};
1889
1890/// PragmaAssumeNonNullHandler -
1891/// \#pragma clang assume_nonnull begin/end
1892struct PragmaAssumeNonNullHandler : public PragmaHandler {
1893 PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}
1894
1895 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1896 Token &NameTok) override {
1897 SourceLocation Loc = NameTok.getLocation();
1898 bool IsBegin;
1899
1900 Token Tok;
1901
1902 // Lex the 'begin' or 'end'.
1903 PP.LexUnexpandedToken(Tok);
1904 const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1905 if (BeginEnd && BeginEnd->isStr("begin")) {
1906 IsBegin = true;
1907 } else if (BeginEnd && BeginEnd->isStr("end")) {
1908 IsBegin = false;
1909 } else {
1910 PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
1911 return;
1912 }
1913
1914 // Verify that this is followed by EOD.
1915 PP.LexUnexpandedToken(Tok);
1916 if (Tok.isNot(tok::eod))
1917 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1918
1919 // The start location of the active audit.
1920 SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc();
1921
1922 // The start location we want after processing this.
1923 SourceLocation NewLoc;
1924 PPCallbacks *Callbacks = PP.getPPCallbacks();
1925
1926 if (IsBegin) {
1927 // Complain about attempts to re-enter an audit.
1928 if (BeginLoc.isValid()) {
1929 PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
1930 PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1931 }
1932 NewLoc = Loc;
1933 if (Callbacks)
1934 Callbacks->PragmaAssumeNonNullBegin(NewLoc);
1935 } else {
1936 // Complain about attempts to leave an audit that doesn't exist.
1937 if (!BeginLoc.isValid()) {
1938 PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
1939 return;
1940 }
1941 NewLoc = SourceLocation();
1942 if (Callbacks)
1943 Callbacks->PragmaAssumeNonNullEnd(NewLoc);
1944 }
1945
1946 PP.setPragmaAssumeNonNullLoc(NewLoc);
1947 }
1948};
1949
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 {
1962 PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {}
1963
1964 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1965 Token &NameTok) override {
1966 // #pragma region: endregion matches can be verified
1967 // __pragma(region): no sense, but ignored by msvc
1968 // _Pragma is not valid for MSVC, but there isn't any point
1969 // to handle a _Pragma differently.
1970 }
1971};
1972
1973} // namespace
1974
1975/// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
1976/// \#pragma GCC poison/system_header/dependency and \#pragma once.
1977void Preprocessor::RegisterBuiltinPragmas() {
1978 AddPragmaHandler(new PragmaOnceHandler());
1979 AddPragmaHandler(new PragmaMarkHandler());
1980 AddPragmaHandler(new PragmaPushMacroHandler());
1981 AddPragmaHandler(new PragmaPopMacroHandler());
1982 AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));
1983
1984 // #pragma GCC ...
1985 AddPragmaHandler("GCC", new PragmaPoisonHandler());
1986 AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
1987 AddPragmaHandler("GCC", new PragmaDependencyHandler());
1988 AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
1989 AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
1990 "GCC"));
1991 AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
1992 "GCC"));
1993 // #pragma clang ...
1994 AddPragmaHandler("clang", new PragmaPoisonHandler());
1995 AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
1996 AddPragmaHandler("clang", new PragmaIncludeInsteadHandler());
1997 AddPragmaHandler("clang", new PragmaDebugHandler());
1998 AddPragmaHandler("clang", new PragmaDependencyHandler());
1999 AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
2000 AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
2001 AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
2002
2003 // #pragma clang module ...
2004 auto *ModuleHandler = new PragmaNamespace("module");
2005 AddPragmaHandler("clang", ModuleHandler);
2006 ModuleHandler->AddPragma(new PragmaModuleImportHandler());
2007 ModuleHandler->AddPragma(new PragmaModuleBeginHandler());
2008 ModuleHandler->AddPragma(new PragmaModuleEndHandler());
2009 ModuleHandler->AddPragma(new PragmaModuleBuildHandler());
2010 ModuleHandler->AddPragma(new PragmaModuleLoadHandler());
2011
2012 // Add region pragmas.
2013 AddPragmaHandler(new PragmaRegionHandler("region"));
2014 AddPragmaHandler(new PragmaRegionHandler("endregion"));
2015
2016 // MS extensions.
2017 if (LangOpts.MicrosoftExt) {
2018 AddPragmaHandler(new PragmaWarningHandler());
2019 AddPragmaHandler(new PragmaExecCharsetHandler());
2020 AddPragmaHandler(new PragmaIncludeAliasHandler());
2021 AddPragmaHandler(new PragmaHdrstopHandler());
2022 AddPragmaHandler(new PragmaSystemHeaderHandler());
2023 }
2024
2025 // Pragmas added by plugins
2026 for (const PragmaHandlerRegistry::entry &handler :
2027 PragmaHandlerRegistry::entries()) {
2028 AddPragmaHandler(handler.instantiate().release());
2029 }
2030}
2031
2032/// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
2033/// warn about those pragmas being unknown.
2034void Preprocessor::IgnorePragmas() {
2035 AddPragmaHandler(new EmptyPragmaHandler());
2036 // Also ignore all pragmas in all namespaces created
2037 // in Preprocessor::RegisterBuiltinPragmas().
2038 AddPragmaHandler("GCC", new EmptyPragmaHandler());
2039 AddPragmaHandler("clang", new EmptyPragmaHandler());
2040}

/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/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//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_LEX_TOKEN_H
14#define LLVM_CLANG_LEX_TOKEN_H
15
16#include "clang/Basic/SourceLocation.h"
17#include "clang/Basic/TokenKinds.h"
18#include "llvm/ADT/StringRef.h"
19#include <cassert>
20
21namespace clang {
22
23class IdentifierInfo;
24
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 {
35 /// The location of the token. This is actually a SourceLocation.
36 SourceLocation::UIntTy Loc;
37
38 // Conceptually these next two fields could be in a union. However, this
39 // causes gcc 4.2 to pessimize LexTokenInternal, a very performance critical
40 // routine. Keeping as separate members with casts until a more beautiful fix
41 // presents itself.
42
43 /// UintData - This holds either the length of the token text, when
44 /// a normal token, or the end of the SourceRange when an annotation
45 /// token.
46 SourceLocation::UIntTy UintData;
47
48 /// PtrData - This is a union of four different pointer types, which depends
49 /// on what type of token this is:
50 /// Identifiers, keywords, etc:
51 /// This is an IdentifierInfo*, which contains the uniqued identifier
52 /// spelling.
53 /// Literals: isLiteral() returns true.
54 /// This is a pointer to the start of the token in a text buffer, which
55 /// may be dirty (have trigraphs / escaped newlines).
56 /// Annotations (resolved type names, C++ scopes, etc): isAnnotation().
57 /// This is a pointer to sema-specific data for the annotation token.
58 /// Eof:
59 // This is a pointer to a Decl.
60 /// Other:
61 /// This is null.
62 void *PtrData;
63
64 /// Kind - The actual flavor of token this is.
65 tok::TokenKind Kind;
66
67 /// Flags - Bits we track about this token, members of the TokenFlags enum.
68 unsigned short Flags;
69
70public:
71 // Various flags set per token:
72 enum TokenFlags {
73 StartOfLine = 0x01, // At start of line or only after whitespace
74 // (considering the line after macro expansion).
75 LeadingSpace = 0x02, // Whitespace exists before this token (considering
76 // whitespace after macro expansion).
77 DisableExpand = 0x04, // This identifier may never be macro expanded.
78 NeedsCleaning = 0x08, // Contained an escaped newline or trigraph.
79 LeadingEmptyMacro = 0x10, // Empty macro exists before this token.
80 HasUDSuffix = 0x20, // This string or character literal has a ud-suffix.
81 HasUCN = 0x40, // This identifier contains a UCN.
82 IgnoredComma = 0x80, // This comma is not a macro argument separator (MS).
83 StringifiedInMacro = 0x100, // This string or character literal is formed by
84 // macro stringizing or charizing operator.
85 CommaAfterElided = 0x200, // The comma following this token was elided (MS).
86 IsEditorPlaceholder = 0x400, // This identifier is a placeholder.
87 IsReinjected = 0x800, // A phase 4 token that was produced before and
88 // re-added, e.g. via EnterTokenStream. Annotation
89 // tokens are *not* reinjected.
90 };
91
92 tok::TokenKind getKind() const { return Kind; }
93 void setKind(tok::TokenKind K) { Kind = K; }
94
95 /// is/isNot - Predicates to check if this token is a specific kind, as in
96 /// "if (Tok.is(tok::l_brace)) {...}".
97 bool is(tok::TokenKind K) const { return Kind == K; }
98 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
99 bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const {
100 return is(K1) || is(K2);
101 }
102 template <typename... Ts>
103 bool isOneOf(tok::TokenKind K1, tok::TokenKind K2, Ts... Ks) const {
104 return is(K1) || isOneOf(K2, Ks...);
105 }
106
107 /// Return true if this is a raw identifier (when lexing
108 /// in raw mode) or a non-keyword identifier (when lexing in non-raw mode).
109 bool isAnyIdentifier() const {
110 return tok::isAnyIdentifier(getKind());
111 }
112
113 /// Return true if this is a "literal", like a numeric
114 /// constant, string, etc.
115 bool isLiteral() const {
116 return tok::isLiteral(getKind());
117 }
118
119 /// Return true if this is any of tok::annot_* kind tokens.
120 bool isAnnotation() const {
121 return tok::isAnnotation(getKind());
122 }
123
124 /// Return a source location identifier for the specified
125 /// offset in the current file.
126 SourceLocation getLocation() const {
127 return SourceLocation::getFromRawEncoding(Loc);
128 }
129 unsigned getLength() const {
130 assert(!isAnnotation() && "Annotation tokens have no length field")(static_cast <bool> (!isAnnotation() && "Annotation tokens have no length field"
) ? void (0) : __assert_fail ("!isAnnotation() && \"Annotation tokens have no length field\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 130, __extension__ __PRETTY_FUNCTION__))
;
131 return UintData;
132 }
133
134 void setLocation(SourceLocation L) { Loc = L.getRawEncoding(); }
135 void setLength(unsigned Len) {
136 assert(!isAnnotation() && "Annotation tokens have no length field")(static_cast <bool> (!isAnnotation() && "Annotation tokens have no length field"
) ? void (0) : __assert_fail ("!isAnnotation() && \"Annotation tokens have no length field\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 136, __extension__ __PRETTY_FUNCTION__))
;
137 UintData = Len;
138 }
139
140 SourceLocation getAnnotationEndLoc() const {
141 assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")(static_cast <bool> (isAnnotation() && "Used AnnotEndLocID on non-annotation token"
) ? void (0) : __assert_fail ("isAnnotation() && \"Used AnnotEndLocID on non-annotation token\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 141, __extension__ __PRETTY_FUNCTION__))
;
142 return SourceLocation::getFromRawEncoding(UintData ? UintData : Loc);
143 }
144 void setAnnotationEndLoc(SourceLocation L) {
145 assert(isAnnotation() && "Used AnnotEndLocID on non-annotation token")(static_cast <bool> (isAnnotation() && "Used AnnotEndLocID on non-annotation token"
) ? void (0) : __assert_fail ("isAnnotation() && \"Used AnnotEndLocID on non-annotation token\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 145, __extension__ __PRETTY_FUNCTION__))
;
146 UintData = L.getRawEncoding();
147 }
148
149 SourceLocation getLastLoc() const {
150 return isAnnotation() ? getAnnotationEndLoc() : getLocation();
151 }
152
153 SourceLocation getEndLoc() const {
154 return isAnnotation() ? getAnnotationEndLoc()
155 : getLocation().getLocWithOffset(getLength());
156 }
157
158 /// SourceRange of the group of tokens that this annotation token
159 /// represents.
160 SourceRange getAnnotationRange() const {
161 return SourceRange(getLocation(), getAnnotationEndLoc());
162 }
163 void setAnnotationRange(SourceRange R) {
164 setLocation(R.getBegin());
165 setAnnotationEndLoc(R.getEnd());
166 }
167
168 const char *getName() const { return tok::getTokenName(Kind); }
169
170 /// Reset all flags to cleared.
171 void startToken() {
172 Kind = tok::unknown;
173 Flags = 0;
174 PtrData = nullptr;
175 UintData = 0;
176 Loc = SourceLocation().getRawEncoding();
177 }
178
179 IdentifierInfo *getIdentifierInfo() const {
180 assert(isNot(tok::raw_identifier) &&(static_cast <bool> (isNot(tok::raw_identifier) &&
"getIdentifierInfo() on a tok::raw_identifier token!") ? void
(0) : __assert_fail ("isNot(tok::raw_identifier) && \"getIdentifierInfo() on a tok::raw_identifier token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 181, __extension__ __PRETTY_FUNCTION__))
181 "getIdentifierInfo() on a tok::raw_identifier token!")(static_cast <bool> (isNot(tok::raw_identifier) &&
"getIdentifierInfo() on a tok::raw_identifier token!") ? void
(0) : __assert_fail ("isNot(tok::raw_identifier) && \"getIdentifierInfo() on a tok::raw_identifier token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 181, __extension__ __PRETTY_FUNCTION__))
;
182 assert(!isAnnotation() &&(static_cast <bool> (!isAnnotation() && "getIdentifierInfo() on an annotation token!"
) ? void (0) : __assert_fail ("!isAnnotation() && \"getIdentifierInfo() on an annotation token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 183, __extension__ __PRETTY_FUNCTION__))
183 "getIdentifierInfo() on an annotation token!")(static_cast <bool> (!isAnnotation() && "getIdentifierInfo() on an annotation token!"
) ? void (0) : __assert_fail ("!isAnnotation() && \"getIdentifierInfo() on an annotation token!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 183, __extension__ __PRETTY_FUNCTION__))
;
184 if (isLiteral()) return nullptr;
185 if (is(tok::eof)) return nullptr;
186 return (IdentifierInfo*) PtrData;
187 }
188 void setIdentifierInfo(IdentifierInfo *II) {
189 PtrData = (void*) II;
190 }
191
192 const void *getEofData() const {
193 assert(is(tok::eof))(static_cast <bool> (is(tok::eof)) ? void (0) : __assert_fail
("is(tok::eof)", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 193, __extension__ __PRETTY_FUNCTION__))
;
194 return reinterpret_cast<const void *>(PtrData);
195 }
196 void setEofData(const void *D) {
197 assert(is(tok::eof))(static_cast <bool> (is(tok::eof)) ? void (0) : __assert_fail
("is(tok::eof)", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 197, __extension__ __PRETTY_FUNCTION__))
;
198 assert(!PtrData)(static_cast <bool> (!PtrData) ? void (0) : __assert_fail
("!PtrData", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 198, __extension__ __PRETTY_FUNCTION__))
;
199 PtrData = const_cast<void *>(D);
200 }
201
202 /// getRawIdentifier - For a raw identifier token (i.e., an identifier
203 /// lexed in raw mode), returns a reference to the text substring in the
204 /// buffer if known.
205 StringRef getRawIdentifier() const {
206 assert(is(tok::raw_identifier))(static_cast <bool> (is(tok::raw_identifier)) ? void (0
) : __assert_fail ("is(tok::raw_identifier)", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 206, __extension__ __PRETTY_FUNCTION__))
;
207 return StringRef(reinterpret_cast<const char *>(PtrData), getLength());
208 }
209 void setRawIdentifierData(const char *Ptr) {
210 assert(is(tok::raw_identifier))(static_cast <bool> (is(tok::raw_identifier)) ? void (0
) : __assert_fail ("is(tok::raw_identifier)", "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 210, __extension__ __PRETTY_FUNCTION__))
;
211 PtrData = const_cast<char*>(Ptr);
212 }
213
214 /// getLiteralData - For a literal token (numeric constant, string, etc), this
215 /// returns a pointer to the start of it in the text buffer if known, null
216 /// otherwise.
217 const char *getLiteralData() const {
218 assert(isLiteral() && "Cannot get literal data of non-literal")(static_cast <bool> (isLiteral() && "Cannot get literal data of non-literal"
) ? void (0) : __assert_fail ("isLiteral() && \"Cannot get literal data of non-literal\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 218, __extension__ __PRETTY_FUNCTION__))
;
219 return reinterpret_cast<const char*>(PtrData);
220 }
221 void setLiteralData(const char *Ptr) {
222 assert(isLiteral() && "Cannot set literal data of non-literal")(static_cast <bool> (isLiteral() && "Cannot set literal data of non-literal"
) ? void (0) : __assert_fail ("isLiteral() && \"Cannot set literal data of non-literal\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 222, __extension__ __PRETTY_FUNCTION__))
;
223 PtrData = const_cast<char*>(Ptr);
224 }
225
226 void *getAnnotationValue() const {
227 assert(isAnnotation() && "Used AnnotVal on non-annotation token")(static_cast <bool> (isAnnotation() && "Used AnnotVal on non-annotation token"
) ? void (0) : __assert_fail ("isAnnotation() && \"Used AnnotVal on non-annotation token\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 227, __extension__ __PRETTY_FUNCTION__))
;
228 return PtrData;
229 }
230 void setAnnotationValue(void *val) {
231 assert(isAnnotation() && "Used AnnotVal on non-annotation token")(static_cast <bool> (isAnnotation() && "Used AnnotVal on non-annotation token"
) ? void (0) : __assert_fail ("isAnnotation() && \"Used AnnotVal on non-annotation token\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Lex/Token.h"
, 231, __extension__ __PRETTY_FUNCTION__))
;
232 PtrData = val;
233 }
234
235 /// Set the specified flag.
236 void setFlag(TokenFlags Flag) {
237 Flags |= Flag;
238 }
239
240 /// Get the specified flag.
241 bool getFlag(TokenFlags Flag) const {
242 return (Flags & Flag) != 0;
243 }
244
245 /// Unset the specified flag.
246 void clearFlag(TokenFlags Flag) {
247 Flags &= ~Flag;
248 }
249
250 /// Return the internal represtation of the flags.
251 ///
252 /// This is only intended for low-level operations such as writing tokens to
253 /// disk.
254 unsigned getFlags() const {
255 return Flags;
256 }
257
258 /// Set a flag to either true or false.
259 void setFlagValue(TokenFlags Flag, bool Val) {
260 if (Val)
261 setFlag(Flag);
262 else
263 clearFlag(Flag);
264 }
265
266 /// isAtStartOfLine - Return true if this token is at the start of a line.
267 ///
268 bool isAtStartOfLine() const { return getFlag(StartOfLine); }
269
270 /// Return true if this token has whitespace before it.
271 ///
272 bool hasLeadingSpace() const { return getFlag(LeadingSpace); }
273
274 /// Return true if this identifier token should never
275 /// be expanded in the future, due to C99 6.10.3.4p2.
276 bool isExpandDisabled() const { return getFlag(DisableExpand); }
277
278 /// Return true if we have an ObjC keyword identifier.
279 bool isObjCAtKeyword(tok::ObjCKeywordKind objcKey) const;
280
281 /// Return the ObjC keyword kind.
282 tok::ObjCKeywordKind getObjCKeywordID() const;
283
284 /// Return true if this token has trigraphs or escaped newlines in it.
285 bool needsCleaning() const { return getFlag(NeedsCleaning); }
286
287 /// Return true if this token has an empty macro before it.
288 ///
289 bool hasLeadingEmptyMacro() const { return getFlag(LeadingEmptyMacro); }
290
291 /// Return true if this token is a string or character literal which
292 /// has a ud-suffix.
293 bool hasUDSuffix() const { return getFlag(HasUDSuffix); }
294
295 /// Returns true if this token contains a universal character name.
296 bool hasUCN() const { return getFlag(HasUCN); }
297
298 /// Returns true if this token is formed by macro by stringizing or charizing
299 /// operator.
300 bool stringifiedInMacro() const { return getFlag(StringifiedInMacro); }
301
302 /// Returns true if the comma after this token was elided.
303 bool commaAfterElided() const { return getFlag(CommaAfterElided); }
304
305 /// Returns true if this token is an editor placeholder.
306 ///
307 /// Editor placeholders are produced by the code-completion engine and are
308 /// represented as characters between '<#' and '#>' in the source code. The
309 /// lexer uses identifier tokens to represent placeholders.
310 bool isEditorPlaceholder() const { return getFlag(IsEditorPlaceholder); }
311};
312
313/// Information about the conditional stack (\#if directives)
314/// currently active.
315struct PPConditionalInfo {
316 /// Location where the conditional started.
317 SourceLocation IfLoc;
318
319 /// True if this was contained in a skipping directive, e.g.,
320 /// in a "\#if 0" block.
321 bool WasSkipping;
322
323 /// True if we have emitted tokens already, and now we're in
324 /// an \#else block or something. Only useful in Skipping blocks.
325 bool FoundNonSkip;
326
327 /// True if we've seen a \#else in this block. If so,
328 /// \#elif/\#else directives are not allowed.
329 bool FoundElse;
330};
331
332} // end namespace clang
333
334#endif // LLVM_CLANG_LEX_TOKEN_H

/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/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//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
16#define LLVM_CLANG_BASIC_IDENTIFIERTABLE_H
17
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>
33
34namespace clang {
35
36class DeclarationName;
37class DeclarationNameTable;
38class IdentifierInfo;
39class LangOptions;
40class MultiKeywordSelector;
41class SourceLocation;
42
43enum class ReservedIdentifierStatus {
44 NotReserved = 0,
45 StartsWithUnderscoreAtGlobalScope,
46 StartsWithDoubleUnderscore,
47 StartsWithUnderscoreFollowedByCapitalLetter,
48 ContainsDoubleUnderscore,
49};
50
51/// A simple pair of identifier info and location.
52using IdentifierLocPair = std::pair<IdentifierInfo *, SourceLocation>;
53
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 };
58
59static constexpr int ObjCOrBuiltinIDBits = 16;
60
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 {
68 friend class IdentifierTable;
69
70 // Front-end token ID or tok::identifier.
71 unsigned TokenID : 9;
72
73 // ObjC keyword ('protocol' in '@protocol') or builtin (__builtin_inf).
74 // First NUM_OBJC_KEYWORDS values are for Objective-C,
75 // the remaining values are for builtins.
76 unsigned ObjCOrBuiltinID : ObjCOrBuiltinIDBits;
77
78 // True if there is a #define for this.
79 unsigned HasMacro : 1;
80
81 // True if there was a #define for this.
82 unsigned HadMacro : 1;
83
84 // True if the identifier is a language extension.
85 unsigned IsExtension : 1;
86
87 // True if the identifier is a keyword in a newer or proposed Standard.
88 unsigned IsFutureCompatKeyword : 1;
89
90 // True if the identifier is poisoned.
91 unsigned IsPoisoned : 1;
92
93 // True if the identifier is a C++ operator keyword.
94 unsigned IsCPPOperatorKeyword : 1;
95
96 // Internal bit set by the member function RecomputeNeedsHandleIdentifier.
97 // See comment about RecomputeNeedsHandleIdentifier for more info.
98 unsigned NeedsHandleIdentifier : 1;
99
100 // True if the identifier was loaded (at least partially) from an AST file.
101 unsigned IsFromAST : 1;
102
103 // True if the identifier has changed from the definition
104 // loaded from an AST file.
105 unsigned ChangedAfterLoad : 1;
106
107 // True if the identifier's frontend information has changed from the
108 // definition loaded from an AST file.
109 unsigned FEChangedAfterLoad : 1;
110
111 // True if revertTokenIDToIdentifier was called.
112 unsigned RevertedTokenID : 1;
113
114 // True if there may be additional information about
115 // this identifier stored externally.
116 unsigned OutOfDate : 1;
117
118 // True if this is the 'import' contextual keyword.
119 unsigned IsModulesImport : 1;
120
121 // True if this is a mangled OpenMP variant name.
122 unsigned IsMangledOpenMPVariantName : 1;
123
124 // 28 bits left in a 64-bit word.
125
126 // Managed by the language front-end.
127 void *FETokenInfo = nullptr;
128
129 llvm::StringMapEntry<IdentifierInfo *> *Entry = nullptr;
130
131 IdentifierInfo()
132 : TokenID(tok::identifier), ObjCOrBuiltinID(0), HasMacro(false),
133 HadMacro(false), IsExtension(false), IsFutureCompatKeyword(false),
134 IsPoisoned(false), IsCPPOperatorKeyword(false),
135 NeedsHandleIdentifier(false), IsFromAST(false), ChangedAfterLoad(false),
136 FEChangedAfterLoad(false), RevertedTokenID(false), OutOfDate(false),
137 IsModulesImport(false), IsMangledOpenMPVariantName(false) {}
138
139public:
140 IdentifierInfo(const IdentifierInfo &) = delete;
141 IdentifierInfo &operator=(const IdentifierInfo &) = delete;
142 IdentifierInfo(IdentifierInfo &&) = delete;
143 IdentifierInfo &operator=(IdentifierInfo &&) = delete;
144
145 /// Return true if this is the identifier for the specified string.
146 ///
147 /// This is intended to be used for string literals only: II->isStr("foo").
148 template <std::size_t StrLen>
149 bool isStr(const char (&Str)[StrLen]) const {
150 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
151 memcmp(getNameStart(), Str, StrLen-1) == 0;
45
Assuming the condition is true
152 }
153
154 /// Return true if this is the identifier for the specified StringRef.
155 bool isStr(llvm::StringRef Str) const {
156 llvm::StringRef ThisStr(getNameStart(), getLength());
157 return ThisStr == Str;
158 }
159
160 /// Return the beginning of the actual null-terminated string for this
161 /// identifier.
162 const char *getNameStart() const { return Entry->getKeyData(); }
163
164 /// Efficiently return the length of this identifier info.
165 unsigned getLength() const { return Entry->getKeyLength(); }
166
167 /// Return the actual identifier string.
168 StringRef getName() const {
169 return StringRef(getNameStart(), getLength());
170 }
171
172 /// Return true if this identifier is \#defined to some other value.
173 /// \note The current definition may be in a module and not currently visible.
174 bool hasMacroDefinition() const {
175 return HasMacro;
176 }
177 void setHasMacroDefinition(bool Val) {
178 if (HasMacro == Val) return;
179
180 HasMacro = Val;
181 if (Val) {
182 NeedsHandleIdentifier = true;
183 HadMacro = true;
184 } else {
185 RecomputeNeedsHandleIdentifier();
186 }
187 }
188 /// Returns true if this identifier was \#defined to some value at any
189 /// moment. In this case there should be an entry for the identifier in the
190 /// macro history table in Preprocessor.
191 bool hadMacroDefinition() const {
192 return HadMacro;
193 }
194
195 /// If this is a source-language token (e.g. 'for'), this API
196 /// can be used to cause the lexer to map identifiers to source-language
197 /// tokens.
198 tok::TokenKind getTokenID() const { return (tok::TokenKind)TokenID; }
199
200 /// True if revertTokenIDToIdentifier() was called.
201 bool hasRevertedTokenIDToIdentifier() const { return RevertedTokenID; }
202
203 /// Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2
204 /// compatibility.
205 ///
206 /// TokenID is normally read-only but there are 2 instances where we revert it
207 /// to tok::identifier for libstdc++ 4.2. Keep track of when this happens
208 /// using this method so we can inform serialization about it.
209 void revertTokenIDToIdentifier() {
210 assert(TokenID != tok::identifier && "Already at tok::identifier")(static_cast <bool> (TokenID != tok::identifier &&
"Already at tok::identifier") ? void (0) : __assert_fail ("TokenID != tok::identifier && \"Already at tok::identifier\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 210, __extension__ __PRETTY_FUNCTION__))
;
211 TokenID = tok::identifier;
212 RevertedTokenID = true;
213 }
214 void revertIdentifierToTokenID(tok::TokenKind TK) {
215 assert(TokenID == tok::identifier && "Should be at tok::identifier")(static_cast <bool> (TokenID == tok::identifier &&
"Should be at tok::identifier") ? void (0) : __assert_fail (
"TokenID == tok::identifier && \"Should be at tok::identifier\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 215, __extension__ __PRETTY_FUNCTION__))
;
216 TokenID = TK;
217 RevertedTokenID = false;
218 }
219
220 /// Return the preprocessor keyword ID for this identifier.
221 ///
222 /// For example, "define" will return tok::pp_define.
223 tok::PPKeywordKind getPPKeywordID() const;
224
225 /// Return the Objective-C keyword ID for the this identifier.
226 ///
227 /// For example, 'class' will return tok::objc_class if ObjC is enabled.
228 tok::ObjCKeywordKind getObjCKeywordID() const {
229 if (ObjCOrBuiltinID < tok::NUM_OBJC_KEYWORDS)
230 return tok::ObjCKeywordKind(ObjCOrBuiltinID);
231 else
232 return tok::objc_not_keyword;
233 }
234 void setObjCKeywordID(tok::ObjCKeywordKind ID) { ObjCOrBuiltinID = ID; }
235
236 /// Return a value indicating whether this is a builtin function.
237 ///
238 /// 0 is not-built-in. 1+ are specific builtin functions.
239 unsigned getBuiltinID() const {
240 if (ObjCOrBuiltinID >= tok::NUM_OBJC_KEYWORDS)
241 return ObjCOrBuiltinID - tok::NUM_OBJC_KEYWORDS;
242 else
243 return 0;
244 }
245 void setBuiltinID(unsigned ID) {
246 ObjCOrBuiltinID = ID + tok::NUM_OBJC_KEYWORDS;
247 assert(ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS) == ID(static_cast <bool> (ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS
) == ID && "ID too large for field!") ? void (0) : __assert_fail
("ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS) == ID && \"ID too large for field!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 248, __extension__ __PRETTY_FUNCTION__))
248 && "ID too large for field!")(static_cast <bool> (ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS
) == ID && "ID too large for field!") ? void (0) : __assert_fail
("ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS) == ID && \"ID too large for field!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 248, __extension__ __PRETTY_FUNCTION__))
;
249 }
250
251 unsigned getObjCOrBuiltinID() const { return ObjCOrBuiltinID; }
252 void setObjCOrBuiltinID(unsigned ID) { ObjCOrBuiltinID = ID; }
253
254 /// get/setExtension - Initialize information about whether or not this
255 /// language token is an extension. This controls extension warnings, and is
256 /// only valid if a custom token ID is set.
257 bool isExtensionToken() const { return IsExtension; }
258 void setIsExtensionToken(bool Val) {
259 IsExtension = Val;
260 if (Val)
261 NeedsHandleIdentifier = true;
262 else
263 RecomputeNeedsHandleIdentifier();
264 }
265
266 /// is/setIsFutureCompatKeyword - Initialize information about whether or not
267 /// this language token is a keyword in a newer or proposed Standard. This
268 /// controls compatibility warnings, and is only true when not parsing the
269 /// corresponding Standard. Once a compatibility problem has been diagnosed
270 /// with this keyword, the flag will be cleared.
271 bool isFutureCompatKeyword() const { return IsFutureCompatKeyword; }
272 void setIsFutureCompatKeyword(bool Val) {
273 IsFutureCompatKeyword = Val;
274 if (Val)
275 NeedsHandleIdentifier = true;
276 else
277 RecomputeNeedsHandleIdentifier();
278 }
279
280 /// setIsPoisoned - Mark this identifier as poisoned. After poisoning, the
281 /// Preprocessor will emit an error every time this token is used.
282 void setIsPoisoned(bool Value = true) {
283 IsPoisoned = Value;
284 if (Value)
285 NeedsHandleIdentifier = true;
286 else
287 RecomputeNeedsHandleIdentifier();
288 }
289
290 /// Return true if this token has been poisoned.
291 bool isPoisoned() const { return IsPoisoned; }
292
293 /// isCPlusPlusOperatorKeyword/setIsCPlusPlusOperatorKeyword controls whether
294 /// this identifier is a C++ alternate representation of an operator.
295 void setIsCPlusPlusOperatorKeyword(bool Val = true) {
296 IsCPPOperatorKeyword = Val;
297 }
298 bool isCPlusPlusOperatorKeyword() const { return IsCPPOperatorKeyword; }
299
300 /// Return true if this token is a keyword in the specified language.
301 bool isKeyword(const LangOptions &LangOpts) const;
302
303 /// Return true if this token is a C++ keyword in the specified
304 /// language.
305 bool isCPlusPlusKeyword(const LangOptions &LangOpts) const;
306
307 /// Get and set FETokenInfo. The language front-end is allowed to associate
308 /// arbitrary metadata with this token.
309 void *getFETokenInfo() const { return FETokenInfo; }
310 void setFETokenInfo(void *T) { FETokenInfo = T; }
311
312 /// Return true if the Preprocessor::HandleIdentifier must be called
313 /// on a token of this identifier.
314 ///
315 /// If this returns false, we know that HandleIdentifier will not affect
316 /// the token.
317 bool isHandleIdentifierCase() const { return NeedsHandleIdentifier; }
318
319 /// Return true if the identifier in its current state was loaded
320 /// from an AST file.
321 bool isFromAST() const { return IsFromAST; }
322
323 void setIsFromAST() { IsFromAST = true; }
324
325 /// Determine whether this identifier has changed since it was loaded
326 /// from an AST file.
327 bool hasChangedSinceDeserialization() const {
328 return ChangedAfterLoad;
329 }
330
331 /// Note that this identifier has changed since it was loaded from
332 /// an AST file.
333 void setChangedSinceDeserialization() {
334 ChangedAfterLoad = true;
335 }
336
337 /// Determine whether the frontend token information for this
338 /// identifier has changed since it was loaded from an AST file.
339 bool hasFETokenInfoChangedSinceDeserialization() const {
340 return FEChangedAfterLoad;
341 }
342
343 /// Note that the frontend token information for this identifier has
344 /// changed since it was loaded from an AST file.
345 void setFETokenInfoChangedSinceDeserialization() {
346 FEChangedAfterLoad = true;
347 }
348
349 /// Determine whether the information for this identifier is out of
350 /// date with respect to the external source.
351 bool isOutOfDate() const { return OutOfDate; }
352
353 /// Set whether the information for this identifier is out of
354 /// date with respect to the external source.
355 void setOutOfDate(bool OOD) {
356 OutOfDate = OOD;
357 if (OOD)
358 NeedsHandleIdentifier = true;
359 else
360 RecomputeNeedsHandleIdentifier();
361 }
362
363 /// Determine whether this is the contextual keyword \c import.
364 bool isModulesImport() const { return IsModulesImport; }
365
366 /// Set whether this identifier is the contextual keyword \c import.
367 void setModulesImport(bool I) {
368 IsModulesImport = I;
369 if (I)
370 NeedsHandleIdentifier = true;
371 else
372 RecomputeNeedsHandleIdentifier();
373 }
374
375 /// Determine whether this is the mangled name of an OpenMP variant.
376 bool isMangledOpenMPVariantName() const { return IsMangledOpenMPVariantName; }
377
378 /// Set whether this is the mangled name of an OpenMP variant.
379 void setMangledOpenMPVariantName(bool I) { IsMangledOpenMPVariantName = I; }
380
381 /// Return true if this identifier is an editor placeholder.
382 ///
383 /// Editor placeholders are produced by the code-completion engine and are
384 /// represented as characters between '<#' and '#>' in the source code. An
385 /// example of auto-completed call with a placeholder parameter is shown
386 /// below:
387 /// \code
388 /// function(<#int x#>);
389 /// \endcode
390 bool isEditorPlaceholder() const {
391 return getName().startswith("<#") && getName().endswith("#>");
392 }
393
394 /// Determine whether \p this is a name reserved for the implementation (C99
395 /// 7.1.3, C++ [lib.global.names]).
396 ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;
397
398 /// Provide less than operator for lexicographical sorting.
399 bool operator<(const IdentifierInfo &RHS) const {
400 return getName() < RHS.getName();
401 }
402
403private:
404 /// The Preprocessor::HandleIdentifier does several special (but rare)
405 /// things to identifiers of various sorts. For example, it changes the
406 /// \c for keyword token from tok::identifier to tok::for.
407 ///
408 /// This method is very tied to the definition of HandleIdentifier. Any
409 /// change to it should be reflected here.
410 void RecomputeNeedsHandleIdentifier() {
411 NeedsHandleIdentifier = isPoisoned() || hasMacroDefinition() ||
412 isExtensionToken() || isFutureCompatKeyword() ||
413 isOutOfDate() || isModulesImport();
414 }
415};
416
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 {
422 IdentifierInfo *const II;
423 const bool OldValue;
424
425public:
426 PoisonIdentifierRAIIObject(IdentifierInfo *II, bool NewValue)
427 : II(II), OldValue(II ? II->isPoisoned() : false) {
428 if(II)
429 II->setIsPoisoned(NewValue);
430 }
431
432 ~PoisonIdentifierRAIIObject() {
433 if(II)
434 II->setIsPoisoned(OldValue);
435 }
436};
437
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:
450 IdentifierIterator() = default;
451
452public:
453 IdentifierIterator(const IdentifierIterator &) = delete;
454 IdentifierIterator &operator=(const IdentifierIterator &) = delete;
455
456 virtual ~IdentifierIterator();
457
458 /// Retrieve the next string in the identifier table and
459 /// advances the iterator for the following string.
460 ///
461 /// \returns The next string in the identifier table. If there is
462 /// no such string, returns an empty \c StringRef.
463 virtual StringRef Next() = 0;
464};
465
466/// Provides lookups to, and iteration over, IdentiferInfo objects.
467class IdentifierInfoLookup {
468public:
469 virtual ~IdentifierInfoLookup();
470
471 /// Return the IdentifierInfo for the specified named identifier.
472 ///
473 /// Unlike the version in IdentifierTable, this returns a pointer instead
474 /// of a reference. If the pointer is null then the IdentifierInfo cannot
475 /// be found.
476 virtual IdentifierInfo* get(StringRef Name) = 0;
477
478 /// Retrieve an iterator into the set of all identifiers
479 /// known to this identifier lookup source.
480 ///
481 /// This routine provides access to all of the identifiers known to
482 /// the identifier lookup, allowing access to the contents of the
483 /// identifiers without introducing the overhead of constructing
484 /// IdentifierInfo objects for each.
485 ///
486 /// \returns A new iterator into the set of known identifiers. The
487 /// caller is responsible for deleting this iterator.
488 virtual IdentifierIterator *getIdentifiers();
489};
490
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 {
497 // Shark shows that using MallocAllocator is *much* slower than using this
498 // BumpPtrAllocator!
499 using HashTableTy = llvm::StringMap<IdentifierInfo *, llvm::BumpPtrAllocator>;
500 HashTableTy HashTable;
501
502 IdentifierInfoLookup* ExternalLookup;
503
504public:
505 /// Create the identifier table.
506 explicit IdentifierTable(IdentifierInfoLookup *ExternalLookup = nullptr);
507
508 /// Create the identifier table, populating it with info about the
509 /// language keywords for the language specified by \p LangOpts.
510 explicit IdentifierTable(const LangOptions &LangOpts,
511 IdentifierInfoLookup *ExternalLookup = nullptr);
512
513 /// Set the external identifier lookup mechanism.
514 void setExternalIdentifierLookup(IdentifierInfoLookup *IILookup) {
515 ExternalLookup = IILookup;
516 }
517
518 /// Retrieve the external identifier lookup object, if any.
519 IdentifierInfoLookup *getExternalIdentifierLookup() const {
520 return ExternalLookup;
521 }
522
523 llvm::BumpPtrAllocator& getAllocator() {
524 return HashTable.getAllocator();
525 }
526
527 /// Return the identifier token info for the specified named
528 /// identifier.
529 IdentifierInfo &get(StringRef Name) {
530 auto &Entry = *HashTable.insert(std::make_pair(Name, nullptr)).first;
531
532 IdentifierInfo *&II = Entry.second;
533 if (II) return *II;
534
535 // No entry; if we have an external lookup, look there first.
536 if (ExternalLookup) {
537 II = ExternalLookup->get(Name);
538 if (II)
539 return *II;
540 }
541
542 // Lookups failed, make a new IdentifierInfo.
543 void *Mem = getAllocator().Allocate<IdentifierInfo>();
544 II = new (Mem) IdentifierInfo();
545
546 // Make sure getName() knows how to find the IdentifierInfo
547 // contents.
548 II->Entry = &Entry;
549
550 return *II;
551 }
552
553 IdentifierInfo &get(StringRef Name, tok::TokenKind TokenCode) {
554 IdentifierInfo &II = get(Name);
555 II.TokenID = TokenCode;
556 assert(II.TokenID == (unsigned) TokenCode && "TokenCode too large")(static_cast <bool> (II.TokenID == (unsigned) TokenCode
&& "TokenCode too large") ? void (0) : __assert_fail
("II.TokenID == (unsigned) TokenCode && \"TokenCode too large\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 556, __extension__ __PRETTY_FUNCTION__))
;
557 return II;
558 }
559
560 /// Gets an IdentifierInfo for the given name without consulting
561 /// external sources.
562 ///
563 /// This is a version of get() meant for external sources that want to
564 /// introduce or modify an identifier. If they called get(), they would
565 /// likely end up in a recursion.
566 IdentifierInfo &getOwn(StringRef Name) {
567 auto &Entry = *HashTable.insert(std::make_pair(Name, nullptr)).first;
568
569 IdentifierInfo *&II = Entry.second;
570 if (II)
571 return *II;
572
573 // Lookups failed, make a new IdentifierInfo.
574 void *Mem = getAllocator().Allocate<IdentifierInfo>();
575 II = new (Mem) IdentifierInfo();
576
577 // Make sure getName() knows how to find the IdentifierInfo
578 // contents.
579 II->Entry = &Entry;
580
581 // If this is the 'import' contextual keyword, mark it as such.
582 if (Name.equals("import"))
583 II->setModulesImport(true);
584
585 return *II;
586 }
587
588 using iterator = HashTableTy::const_iterator;
589 using const_iterator = HashTableTy::const_iterator;
590
591 iterator begin() const { return HashTable.begin(); }
592 iterator end() const { return HashTable.end(); }
593 unsigned size() const { return HashTable.size(); }
594
595 iterator find(StringRef Name) const { return HashTable.find(Name); }
596
597 /// Print some statistics to stderr that indicate how well the
598 /// hashing is doing.
599 void PrintStats() const;
600
601 /// Populate the identifier table with info about the language keywords
602 /// for the language specified by \p LangOpts.
603 void AddKeywords(const LangOptions &LangOpts);
604};
605
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 {
624 /// No particular method family.
625 OMF_None,
626
627 // Selectors in these families may have arbitrary arity, may be
628 // written with arbitrary leading underscores, and may have
629 // additional CamelCase "words" in their first selector chunk
630 // following the family name.
631 OMF_alloc,
632 OMF_copy,
633 OMF_init,
634 OMF_mutableCopy,
635 OMF_new,
636
637 // These families are singletons consisting only of the nullary
638 // selector with the given name.
639 OMF_autorelease,
640 OMF_dealloc,
641 OMF_finalize,
642 OMF_release,
643 OMF_retain,
644 OMF_retainCount,
645 OMF_self,
646 OMF_initialize,
647
648 // performSelector families
649 OMF_performSelector
650};
651
652/// Enough bits to store any enumerator in ObjCMethodFamily or
653/// InvalidObjCMethodFamily.
654enum { ObjCMethodFamilyBitWidth = 4 };
655
656/// An invalid value of ObjCMethodFamily.
657enum { InvalidObjCMethodFamily = (1 << ObjCMethodFamilyBitWidth) - 1 };
658
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 {
664 OIT_None,
665 OIT_Array,
666 OIT_Dictionary,
667 OIT_Singleton,
668 OIT_Init,
669 OIT_ReturnsSelf
670};
671
672enum ObjCStringFormatFamily {
673 SFF_None,
674 SFF_NSString,
675 SFF_CFString
676};
677
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 {
686 friend class Diagnostic;
687 friend class SelectorTable; // only the SelectorTable can create these
688 friend class DeclarationName; // and the AST's DeclarationName.
689
690 enum IdentifierInfoFlag {
691 // Empty selector = 0. Note that these enumeration values must
692 // correspond to the enumeration values of DeclarationName::StoredNameKind
693 ZeroArg = 0x01,
694 OneArg = 0x02,
695 MultiArg = 0x07,
696 ArgFlags = 0x07
697 };
698
699 /// A pointer to the MultiKeywordSelector or IdentifierInfo. We use the low
700 /// three bits of InfoPtr to store an IdentifierInfoFlag. Note that in any
701 /// case IdentifierInfo and MultiKeywordSelector are already aligned to
702 /// 8 bytes even on 32 bits archs because of DeclarationName.
703 uintptr_t InfoPtr = 0;
704
705 Selector(IdentifierInfo *II, unsigned nArgs) {
706 InfoPtr = reinterpret_cast<uintptr_t>(II);
707 assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo")(static_cast <bool> ((InfoPtr & ArgFlags) == 0 &&
"Insufficiently aligned IdentifierInfo") ? void (0) : __assert_fail
("(InfoPtr & ArgFlags) == 0 &&\"Insufficiently aligned IdentifierInfo\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 707, __extension__ __PRETTY_FUNCTION__))
;
708 assert(nArgs < 2 && "nArgs not equal to 0/1")(static_cast <bool> (nArgs < 2 && "nArgs not equal to 0/1"
) ? void (0) : __assert_fail ("nArgs < 2 && \"nArgs not equal to 0/1\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 708, __extension__ __PRETTY_FUNCTION__))
;
709 InfoPtr |= nArgs+1;
710 }
711
712 Selector(MultiKeywordSelector *SI) {
713 InfoPtr = reinterpret_cast<uintptr_t>(SI);
714 assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo")(static_cast <bool> ((InfoPtr & ArgFlags) == 0 &&
"Insufficiently aligned IdentifierInfo") ? void (0) : __assert_fail
("(InfoPtr & ArgFlags) == 0 &&\"Insufficiently aligned IdentifierInfo\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 714, __extension__ __PRETTY_FUNCTION__))
;
715 InfoPtr |= MultiArg;
716 }
717
718 IdentifierInfo *getAsIdentifierInfo() const {
719 if (getIdentifierInfoFlag() < MultiArg)
720 return reinterpret_cast<IdentifierInfo *>(InfoPtr & ~ArgFlags);
721 return nullptr;
722 }
723
724 MultiKeywordSelector *getMultiKeywordSelector() const {
725 return reinterpret_cast<MultiKeywordSelector *>(InfoPtr & ~ArgFlags);
726 }
727
728 unsigned getIdentifierInfoFlag() const {
729 return InfoPtr & ArgFlags;
730 }
731
732 static ObjCMethodFamily getMethodFamilyImpl(Selector sel);
733
734 static ObjCStringFormatFamily getStringFormatFamilyImpl(Selector sel);
735
736public:
737 /// The default ctor should only be used when creating data structures that
738 /// will contain selectors.
739 Selector() = default;
740 explicit Selector(uintptr_t V) : InfoPtr(V) {}
741
742 /// operator==/!= - Indicate whether the specified selectors are identical.
743 bool operator==(Selector RHS) const {
744 return InfoPtr == RHS.InfoPtr;
745 }
746 bool operator!=(Selector RHS) const {
747 return InfoPtr != RHS.InfoPtr;
748 }
749
750 void *getAsOpaquePtr() const {
751 return reinterpret_cast<void*>(InfoPtr);
752 }
753
754 /// Determine whether this is the empty selector.
755 bool isNull() const { return InfoPtr == 0; }
756
757 // Predicates to identify the selector type.
758 bool isKeywordSelector() const {
759 return getIdentifierInfoFlag() != ZeroArg;
760 }
761
762 bool isUnarySelector() const {
763 return getIdentifierInfoFlag() == ZeroArg;
764 }
765
766 /// If this selector is the specific keyword selector described by Names.
767 bool isKeywordSelector(ArrayRef<StringRef> Names) const;
768
769 /// If this selector is the specific unary selector described by Name.
770 bool isUnarySelector(StringRef Name) const;
771
772 unsigned getNumArgs() const;
773
774 /// Retrieve the identifier at a given position in the selector.
775 ///
776 /// Note that the identifier pointer returned may be NULL. Clients that only
777 /// care about the text of the identifier string, and not the specific,
778 /// uniqued identifier pointer, should use \c getNameForSlot(), which returns
779 /// an empty string when the identifier pointer would be NULL.
780 ///
781 /// \param argIndex The index for which we want to retrieve the identifier.
782 /// This index shall be less than \c getNumArgs() unless this is a keyword
783 /// selector, in which case 0 is the only permissible value.
784 ///
785 /// \returns the uniqued identifier for this slot, or NULL if this slot has
786 /// no corresponding identifier.
787 IdentifierInfo *getIdentifierInfoForSlot(unsigned argIndex) const;
788
789 /// Retrieve the name at a given position in the selector.
790 ///
791 /// \param argIndex The index for which we want to retrieve the name.
792 /// This index shall be less than \c getNumArgs() unless this is a keyword
793 /// selector, in which case 0 is the only permissible value.
794 ///
795 /// \returns the name for this slot, which may be the empty string if no
796 /// name was supplied.
797 StringRef getNameForSlot(unsigned argIndex) const;
798
799 /// Derive the full selector name (e.g. "foo:bar:") and return
800 /// it as an std::string.
801 std::string getAsString() const;
802
803 /// Prints the full selector name (e.g. "foo:bar:").
804 void print(llvm::raw_ostream &OS) const;
805
806 void dump() const;
807
808 /// Derive the conventional family of this method.
809 ObjCMethodFamily getMethodFamily() const {
810 return getMethodFamilyImpl(*this);
811 }
812
813 ObjCStringFormatFamily getStringFormatFamily() const {
814 return getStringFormatFamilyImpl(*this);
815 }
816
817 static Selector getEmptyMarker() {
818 return Selector(uintptr_t(-1));
819 }
820
821 static Selector getTombstoneMarker() {
822 return Selector(uintptr_t(-2));
823 }
824
825 static ObjCInstanceTypeFamily getInstTypeMethodFamily(Selector sel);
826};
827
828/// This table allows us to fully hide how we implement
829/// multi-keyword caching.
830class SelectorTable {
831 // Actually a SelectorTableImpl
832 void *Impl;
833
834public:
835 SelectorTable();
836 SelectorTable(const SelectorTable &) = delete;
837 SelectorTable &operator=(const SelectorTable &) = delete;
838 ~SelectorTable();
839
840 /// Can create any sort of selector.
841 ///
842 /// \p NumArgs indicates whether this is a no argument selector "foo", a
843 /// single argument selector "foo:" or multi-argument "foo:bar:".
844 Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV);
845
846 Selector getUnarySelector(IdentifierInfo *ID) {
847 return Selector(ID, 1);
848 }
849
850 Selector getNullarySelector(IdentifierInfo *ID) {
851 return Selector(ID, 0);
852 }
853
854 /// Return the total amount of memory allocated for managing selectors.
855 size_t getTotalMemory() const;
856
857 /// Return the default setter name for the given identifier.
858 ///
859 /// This is "set" + \p Name where the initial character of \p Name
860 /// has been capitalized.
861 static SmallString<64> constructSetterName(StringRef Name);
862
863 /// Return the default setter selector for the given identifier.
864 ///
865 /// This is "set" + \p Name where the initial character of \p Name
866 /// has been capitalized.
867 static Selector constructSetterSelector(IdentifierTable &Idents,
868 SelectorTable &SelTable,
869 const IdentifierInfo *Name);
870
871 /// Return the property name for the given setter selector.
872 static std::string getPropertyNameFromSetterSelector(Selector Sel);
873};
874
875namespace detail {
876
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 {
886 friend class clang::DeclarationName;
887 friend class clang::DeclarationNameTable;
888
889protected:
890 /// The kind of "extra" information stored in the DeclarationName. See
891 /// @c ExtraKindOrNumArgs for an explanation of how these enumerator values
892 /// are used. Note that DeclarationName depends on the numerical values
893 /// of the enumerators in this enum. See DeclarationName::StoredNameKind
894 /// for more info.
895 enum ExtraKind {
896 CXXDeductionGuideName,
897 CXXLiteralOperatorName,
898 CXXUsingDirective,
899 ObjCMultiArgSelector
900 };
901
902 /// ExtraKindOrNumArgs has one of the following meaning:
903 /// * The kind of an uncommon C++ special name. This DeclarationNameExtra
904 /// is in this case in fact either a CXXDeductionGuideNameExtra or
905 /// a CXXLiteralOperatorIdName.
906 ///
907 /// * It may be also name common to C++ using-directives (CXXUsingDirective),
908 ///
909 /// * Otherwise it is ObjCMultiArgSelector+NumArgs, where NumArgs is
910 /// the number of arguments in the Objective-C selector, in which
911 /// case the DeclarationNameExtra is also a MultiKeywordSelector.
912 unsigned ExtraKindOrNumArgs;
913
914 DeclarationNameExtra(ExtraKind Kind) : ExtraKindOrNumArgs(Kind) {}
915 DeclarationNameExtra(unsigned NumArgs)
916 : ExtraKindOrNumArgs(ObjCMultiArgSelector + NumArgs) {}
917
918 /// Return the corresponding ExtraKind.
919 ExtraKind getKind() const {
920 return static_cast<ExtraKind>(ExtraKindOrNumArgs >
921 (unsigned)ObjCMultiArgSelector
922 ? (unsigned)ObjCMultiArgSelector
923 : ExtraKindOrNumArgs);
924 }
925
926 /// Return the number of arguments in an ObjC selector. Only valid when this
927 /// is indeed an ObjCMultiArgSelector.
928 unsigned getNumArgs() const {
929 assert(ExtraKindOrNumArgs >= (unsigned)ObjCMultiArgSelector &&(static_cast <bool> (ExtraKindOrNumArgs >= (unsigned
)ObjCMultiArgSelector && "getNumArgs called but this is not an ObjC selector!"
) ? void (0) : __assert_fail ("ExtraKindOrNumArgs >= (unsigned)ObjCMultiArgSelector && \"getNumArgs called but this is not an ObjC selector!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 930, __extension__ __PRETTY_FUNCTION__))
930 "getNumArgs called but this is not an ObjC selector!")(static_cast <bool> (ExtraKindOrNumArgs >= (unsigned
)ObjCMultiArgSelector && "getNumArgs called but this is not an ObjC selector!"
) ? void (0) : __assert_fail ("ExtraKindOrNumArgs >= (unsigned)ObjCMultiArgSelector && \"getNumArgs called but this is not an ObjC selector!\""
, "/build/llvm-toolchain-snapshot-13~++20210726100616+dead50d4427c/clang/include/clang/Basic/IdentifierTable.h"
, 930, __extension__ __PRETTY_FUNCTION__))
;
931 return ExtraKindOrNumArgs - (unsigned)ObjCMultiArgSelector;
932 }
933};
934
935} // namespace detail
936
937} // namespace clang
938
939namespace llvm {
940
941/// Define DenseMapInfo so that Selectors can be used as keys in DenseMap and
942/// DenseSets.
943template <>
944struct DenseMapInfo<clang::Selector> {
945 static clang::Selector getEmptyKey() {
946 return clang::Selector::getEmptyMarker();
947 }
948
949 static clang::Selector getTombstoneKey() {
950 return clang::Selector::getTombstoneMarker();
951 }
952
953 static unsigned getHashValue(clang::Selector S);
954
955 static bool isEqual(clang::Selector LHS, clang::Selector RHS) {
956 return LHS == RHS;
957 }
958};
959
960template<>
961struct PointerLikeTypeTraits<clang::Selector> {
962 static const void *getAsVoidPointer(clang::Selector P) {
963 return P.getAsOpaquePtr();
964 }
965
966 static clang::Selector getFromVoidPointer(const void *P) {
967 return clang::Selector(reinterpret_cast<uintptr_t>(P));
968 }
969
970 static constexpr int NumLowBitsAvailable = 0;
971};
972
973// Provide PointerLikeTypeTraits for IdentifierInfo pointers, which
974// are not guaranteed to be 8-byte aligned.
975template<>
976struct PointerLikeTypeTraits<clang::IdentifierInfo*> {
977 static void *getAsVoidPointer(clang::IdentifierInfo* P) {
978 return P;
979 }
980
981 static clang::IdentifierInfo *getFromVoidPointer(void *P) {
982 return static_cast<clang::IdentifierInfo*>(P);
983 }
984
985 static constexpr int NumLowBitsAvailable = 1;
986};
987
988template<>
989struct PointerLikeTypeTraits<const clang::IdentifierInfo*> {
990 static const void *getAsVoidPointer(const clang::IdentifierInfo* P) {
991 return P;
992 }
993
994 static const clang::IdentifierInfo *getFromVoidPointer(const void *P) {
995 return static_cast<const clang::IdentifierInfo*>(P);
996 }
997
998 static constexpr int NumLowBitsAvailable = 1;
999};
1000
1001} // namespace llvm
1002
1003#endif // LLVM_CLANG_BASIC_IDENTIFIERTABLE_H