clang  8.0.0svn
Pragma.cpp
Go to the documentation of this file.
1 //===- Pragma.cpp - Pragma registration and handling ----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the PragmaHandler/PragmaTable interfaces and implements
11 // pragma related methods of the Preprocessor class.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/Lex/Pragma.h"
16 #include "clang/Basic/Diagnostic.h"
19 #include "clang/Basic/LLVM.h"
21 #include "clang/Basic/Module.h"
24 #include "clang/Basic/TokenKinds.h"
25 #include "clang/Lex/HeaderSearch.h"
27 #include "clang/Lex/Lexer.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"
34 #include "clang/Lex/PTHLexer.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/STLExtras.h"
40 #include "llvm/ADT/SmallString.h"
41 #include "llvm/ADT/SmallVector.h"
42 #include "llvm/ADT/StringSwitch.h"
43 #include "llvm/ADT/StringRef.h"
44 #include "llvm/Support/CrashRecoveryContext.h"
45 #include "llvm/Support/Compiler.h"
46 #include "llvm/Support/ErrorHandling.h"
47 #include <algorithm>
48 #include <cassert>
49 #include <cstddef>
50 #include <cstdint>
51 #include <limits>
52 #include <string>
53 #include <utility>
54 #include <vector>
55 
56 using namespace clang;
57 
58 // Out-of-line destructor to provide a home for the class.
60 
61 //===----------------------------------------------------------------------===//
62 // EmptyPragmaHandler Implementation.
63 //===----------------------------------------------------------------------===//
64 
66 
68  PragmaIntroducerKind Introducer,
69  Token &FirstToken) {}
70 
71 //===----------------------------------------------------------------------===//
72 // PragmaNamespace Implementation.
73 //===----------------------------------------------------------------------===//
74 
76  llvm::DeleteContainerSeconds(Handlers);
77 }
78 
79 /// FindHandler - Check to see if there is already a handler for the
80 /// specified name. If not, return the handler for the null identifier if it
81 /// exists, otherwise return null. If IgnoreNull is true (the default) then
82 /// the null handler isn't returned on failure to match.
84  bool IgnoreNull) const {
85  if (PragmaHandler *Handler = Handlers.lookup(Name))
86  return Handler;
87  return IgnoreNull ? nullptr : Handlers.lookup(StringRef());
88 }
89 
91  assert(!Handlers.lookup(Handler->getName()) &&
92  "A handler with this name is already registered in this namespace");
93  Handlers[Handler->getName()] = Handler;
94 }
95 
97  assert(Handlers.lookup(Handler->getName()) &&
98  "Handler not registered in this namespace");
99  Handlers.erase(Handler->getName());
100 }
101 
103  PragmaIntroducerKind Introducer,
104  Token &Tok) {
105  // Read the 'namespace' that the directive is in, e.g. STDC. Do not macro
106  // expand it, the user can have a STDC #define, that should not affect this.
107  PP.LexUnexpandedToken(Tok);
108 
109  // Get the handler for this token. If there is no handler, ignore the pragma.
110  PragmaHandler *Handler
111  = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName()
112  : StringRef(),
113  /*IgnoreNull=*/false);
114  if (!Handler) {
115  PP.Diag(Tok, diag::warn_pragma_ignored);
116  return;
117  }
118 
119  // Otherwise, pass it down.
120  Handler->HandlePragma(PP, Introducer, Tok);
121 }
122 
123 //===----------------------------------------------------------------------===//
124 // Preprocessor Pragma Directive Handling.
125 //===----------------------------------------------------------------------===//
126 
127 /// HandlePragmaDirective - The "\#pragma" directive has been parsed. Lex the
128 /// rest of the pragma, passing it to the registered pragma handlers.
129 void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc,
130  PragmaIntroducerKind Introducer) {
131  if (Callbacks)
132  Callbacks->PragmaDirective(IntroducerLoc, Introducer);
133 
134  if (!PragmasEnabled)
135  return;
136 
137  ++NumPragma;
138 
139  // Invoke the first level of pragma handlers which reads the namespace id.
140  Token Tok;
141  PragmaHandlers->HandlePragma(*this, Introducer, Tok);
142 
143  // If the pragma handler didn't read the rest of the line, consume it now.
144  if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())
145  || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
146  DiscardUntilEndOfDirective();
147 }
148 
149 namespace {
150 
151 /// Helper class for \see Preprocessor::Handle_Pragma.
152 class LexingFor_PragmaRAII {
153  Preprocessor &PP;
154  bool InMacroArgPreExpansion;
155  bool Failed = false;
156  Token &OutTok;
157  Token PragmaTok;
158 
159 public:
160  LexingFor_PragmaRAII(Preprocessor &PP, bool InMacroArgPreExpansion,
161  Token &Tok)
162  : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion), OutTok(Tok) {
163  if (InMacroArgPreExpansion) {
164  PragmaTok = OutTok;
166  }
167  }
168 
169  ~LexingFor_PragmaRAII() {
170  if (InMacroArgPreExpansion) {
171  // When committing/backtracking the cached pragma tokens in a macro
172  // argument pre-expansion we want to ensure that either the tokens which
173  // have been committed will be removed from the cache or that the tokens
174  // over which we just backtracked won't remain in the cache after they're
175  // consumed and that the caching will stop after consuming them.
176  // Otherwise the caching will interfere with the way macro expansion
177  // works, because we will continue to cache tokens after consuming the
178  // backtracked tokens, which shouldn't happen when we're dealing with
179  // macro argument pre-expansion.
180  auto CachedTokenRange = PP.LastCachedTokenRange();
181  if (Failed) {
183  } else {
184  PP.Backtrack();
185  OutTok = PragmaTok;
186  }
187  PP.EraseCachedTokens(CachedTokenRange);
188  }
189  }
190 
191  void failed() {
192  Failed = true;
193  }
194 };
195 
196 } // namespace
197 
198 /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then
199 /// return the first token after the directive. The _Pragma token has just
200 /// been read into 'Tok'.
201 void Preprocessor::Handle_Pragma(Token &Tok) {
202  // This works differently if we are pre-expanding a macro argument.
203  // In that case we don't actually "activate" the pragma now, we only lex it
204  // until we are sure it is lexically correct and then we backtrack so that
205  // we activate the pragma whenever we encounter the tokens again in the token
206  // stream. This ensures that we will activate it in the correct location
207  // or that we will ignore it if it never enters the token stream, e.g:
208  //
209  // #define EMPTY(x)
210  // #define INACTIVE(x) EMPTY(x)
211  // INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\""))
212 
213  LexingFor_PragmaRAII _PragmaLexing(*this, InMacroArgPreExpansion, Tok);
214 
215  // Remember the pragma token location.
216  SourceLocation PragmaLoc = Tok.getLocation();
217 
218  // Read the '('.
219  Lex(Tok);
220  if (Tok.isNot(tok::l_paren)) {
221  Diag(PragmaLoc, diag::err__Pragma_malformed);
222  return _PragmaLexing.failed();
223  }
224 
225  // Read the '"..."'.
226  Lex(Tok);
227  if (!tok::isStringLiteral(Tok.getKind())) {
228  Diag(PragmaLoc, diag::err__Pragma_malformed);
229  // Skip bad tokens, and the ')', if present.
230  if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof))
231  Lex(Tok);
232  while (Tok.isNot(tok::r_paren) &&
233  !Tok.isAtStartOfLine() &&
234  Tok.isNot(tok::eof))
235  Lex(Tok);
236  if (Tok.is(tok::r_paren))
237  Lex(Tok);
238  return _PragmaLexing.failed();
239  }
240 
241  if (Tok.hasUDSuffix()) {
242  Diag(Tok, diag::err_invalid_string_udl);
243  // Skip this token, and the ')', if present.
244  Lex(Tok);
245  if (Tok.is(tok::r_paren))
246  Lex(Tok);
247  return _PragmaLexing.failed();
248  }
249 
250  // Remember the string.
251  Token StrTok = Tok;
252 
253  // Read the ')'.
254  Lex(Tok);
255  if (Tok.isNot(tok::r_paren)) {
256  Diag(PragmaLoc, diag::err__Pragma_malformed);
257  return _PragmaLexing.failed();
258  }
259 
260  if (InMacroArgPreExpansion)
261  return;
262 
263  SourceLocation RParenLoc = Tok.getLocation();
264  std::string StrVal = getSpelling(StrTok);
265 
266  // The _Pragma is lexically sound. Destringize according to C11 6.10.9.1:
267  // "The string literal is destringized by deleting any encoding prefix,
268  // deleting the leading and trailing double-quotes, replacing each escape
269  // sequence \" by a double-quote, and replacing each escape sequence \\ by a
270  // single backslash."
271  if (StrVal[0] == 'L' || StrVal[0] == 'U' ||
272  (StrVal[0] == 'u' && StrVal[1] != '8'))
273  StrVal.erase(StrVal.begin());
274  else if (StrVal[0] == 'u')
275  StrVal.erase(StrVal.begin(), StrVal.begin() + 2);
276 
277  if (StrVal[0] == 'R') {
278  // FIXME: C++11 does not specify how to handle raw-string-literals here.
279  // We strip off the 'R', the quotes, the d-char-sequences, and the parens.
280  assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' &&
281  "Invalid raw string token!");
282 
283  // Measure the length of the d-char-sequence.
284  unsigned NumDChars = 0;
285  while (StrVal[2 + NumDChars] != '(') {
286  assert(NumDChars < (StrVal.size() - 5) / 2 &&
287  "Invalid raw string token!");
288  ++NumDChars;
289  }
290  assert(StrVal[StrVal.size() - 2 - NumDChars] == ')');
291 
292  // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the
293  // parens below.
294  StrVal.erase(0, 2 + NumDChars);
295  StrVal.erase(StrVal.size() - 1 - NumDChars);
296  } else {
297  assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
298  "Invalid string token!");
299 
300  // Remove escaped quotes and escapes.
301  unsigned ResultPos = 1;
302  for (size_t i = 1, e = StrVal.size() - 1; i != e; ++i) {
303  // Skip escapes. \\ -> '\' and \" -> '"'.
304  if (StrVal[i] == '\\' && i + 1 < e &&
305  (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"'))
306  ++i;
307  StrVal[ResultPos++] = StrVal[i];
308  }
309  StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);
310  }
311 
312  // Remove the front quote, replacing it with a space, so that the pragma
313  // contents appear to have a space before them.
314  StrVal[0] = ' ';
315 
316  // Replace the terminating quote with a \n.
317  StrVal[StrVal.size()-1] = '\n';
318 
319  // Plop the string (including the newline and trailing null) into a buffer
320  // where we can lex it.
321  Token TmpTok;
322  TmpTok.startToken();
323  CreateString(StrVal, TmpTok);
324  SourceLocation TokLoc = TmpTok.getLocation();
325 
326  // Make and enter a lexer object so that we lex and expand the tokens just
327  // like any others.
328  Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
329  StrVal.size(), *this);
330 
331  EnterSourceFileWithLexer(TL, nullptr);
332 
333  // With everything set up, lex this as a #pragma directive.
334  HandlePragmaDirective(PragmaLoc, PIK__Pragma);
335 
336  // Finally, return whatever came after the pragma directive.
337  return Lex(Tok);
338 }
339 
340 /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
341 /// is not enclosed within a string literal.
342 void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
343  // Remember the pragma token location.
344  SourceLocation PragmaLoc = Tok.getLocation();
345 
346  // Read the '('.
347  Lex(Tok);
348  if (Tok.isNot(tok::l_paren)) {
349  Diag(PragmaLoc, diag::err__Pragma_malformed);
350  return;
351  }
352 
353  // Get the tokens enclosed within the __pragma(), as well as the final ')'.
354  SmallVector<Token, 32> PragmaToks;
355  int NumParens = 0;
356  Lex(Tok);
357  while (Tok.isNot(tok::eof)) {
358  PragmaToks.push_back(Tok);
359  if (Tok.is(tok::l_paren))
360  NumParens++;
361  else if (Tok.is(tok::r_paren) && NumParens-- == 0)
362  break;
363  Lex(Tok);
364  }
365 
366  if (Tok.is(tok::eof)) {
367  Diag(PragmaLoc, diag::err_unterminated___pragma);
368  return;
369  }
370 
371  PragmaToks.front().setFlag(Token::LeadingSpace);
372 
373  // Replace the ')' with an EOD to mark the end of the pragma.
374  PragmaToks.back().setKind(tok::eod);
375 
376  Token *TokArray = new Token[PragmaToks.size()];
377  std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);
378 
379  // Push the tokens onto the stack.
380  EnterTokenStream(TokArray, PragmaToks.size(), true, true);
381 
382  // With everything set up, lex this as a #pragma directive.
383  HandlePragmaDirective(PragmaLoc, PIK___pragma);
384 
385  // Finally, return whatever came after the pragma directive.
386  return Lex(Tok);
387 }
388 
389 /// HandlePragmaOnce - Handle \#pragma once. OnceTok is the 'once'.
391  // Don't honor the 'once' when handling the primary source file, unless
392  // this is a prefix to a TU, which indicates we're generating a PCH file, or
393  // when the main file is a header (e.g. when -xc-header is provided on the
394  // commandline).
395  if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) {
396  Diag(OnceTok, diag::pp_pragma_once_in_main_file);
397  return;
398  }
399 
400  // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc.
401  // Mark the file as a once-only file now.
402  HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
403 }
404 
406  assert(CurPPLexer && "No current lexer?");
407  if (CurLexer)
408  CurLexer->ReadToEndOfLine();
409  else
410  CurPTHLexer->DiscardToEndOfLine();
411 }
412 
413 /// HandlePragmaPoison - Handle \#pragma GCC poison. PoisonTok is the 'poison'.
415  Token Tok;
416 
417  while (true) {
418  // Read the next token to poison. While doing this, pretend that we are
419  // skipping while reading the identifier to poison.
420  // This avoids errors on code like:
421  // #pragma GCC poison X
422  // #pragma GCC poison X
423  if (CurPPLexer) CurPPLexer->LexingRawMode = true;
424  LexUnexpandedToken(Tok);
425  if (CurPPLexer) CurPPLexer->LexingRawMode = false;
426 
427  // If we reached the end of line, we're done.
428  if (Tok.is(tok::eod)) return;
429 
430  // Can only poison identifiers.
431  if (Tok.isNot(tok::raw_identifier)) {
432  Diag(Tok, diag::err_pp_invalid_poison);
433  return;
434  }
435 
436  // Look up the identifier info for the token. We disabled identifier lookup
437  // by saying we're skipping contents, so we need to do this manually.
438  IdentifierInfo *II = LookUpIdentifierInfo(Tok);
439 
440  // Already poisoned.
441  if (II->isPoisoned()) continue;
442 
443  // If this is a macro identifier, emit a warning.
444  if (isMacroDefined(II))
445  Diag(Tok, diag::pp_poisoning_existing_macro);
446 
447  // Finally, poison it!
448  II->setIsPoisoned();
449  if (II->isFromAST())
451  }
452 }
453 
454 /// HandlePragmaSystemHeader - Implement \#pragma GCC system_header. We know
455 /// that the whole directive has been parsed.
457  if (isInPrimaryFile()) {
458  Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
459  return;
460  }
461 
462  // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc.
463  PreprocessorLexer *TheLexer = getCurrentFileLexer();
464 
465  // Mark the file as a system header.
466  HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry());
467 
468  PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
469  if (PLoc.isInvalid())
470  return;
471 
472  unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename());
473 
474  // Notify the client, if desired, that we are in a new source file.
475  if (Callbacks)
476  Callbacks->FileChanged(SysHeaderTok.getLocation(),
478 
479  // Emit a line marker. This will change any source locations from this point
480  // forward to realize they are in a system header.
481  // Create a line note with this information.
482  SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine() + 1,
483  FilenameID, /*IsEntry=*/false, /*IsExit=*/false,
485 }
486 
487 /// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah.
489  Token FilenameTok;
490  CurPPLexer->LexIncludeFilename(FilenameTok);
491 
492  // If the token kind is EOD, the error has already been diagnosed.
493  if (FilenameTok.is(tok::eod))
494  return;
495 
496  // Reserve a buffer to get the spelling.
497  SmallString<128> FilenameBuffer;
498  bool Invalid = false;
499  StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid);
500  if (Invalid)
501  return;
502 
503  bool isAngled =
504  GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
505  // If GetIncludeFilenameSpelling set the start ptr to null, there was an
506  // error.
507  if (Filename.empty())
508  return;
509 
510  // Search include directories for this file.
511  const DirectoryLookup *CurDir;
512  const FileEntry *File =
513  LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
514  nullptr, CurDir, nullptr, nullptr, nullptr, nullptr);
515  if (!File) {
516  if (!SuppressIncludeNotFoundError)
517  Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
518  return;
519  }
520 
521  const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();
522 
523  // If this file is older than the file it depends on, emit a diagnostic.
524  if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
525  // Lex tokens at the end of the message and include them in the message.
526  std::string Message;
527  Lex(DependencyTok);
528  while (DependencyTok.isNot(tok::eod)) {
529  Message += getSpelling(DependencyTok) + " ";
530  Lex(DependencyTok);
531  }
532 
533  // Remove the trailing ' ' if present.
534  if (!Message.empty())
535  Message.erase(Message.end()-1);
536  Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message;
537  }
538 }
539 
540 /// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
541 /// Return the IdentifierInfo* associated with the macro to push or pop.
543  // Remember the pragma token location.
544  Token PragmaTok = Tok;
545 
546  // Read the '('.
547  Lex(Tok);
548  if (Tok.isNot(tok::l_paren)) {
549  Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
550  << getSpelling(PragmaTok);
551  return nullptr;
552  }
553 
554  // Read the macro name string.
555  Lex(Tok);
556  if (Tok.isNot(tok::string_literal)) {
557  Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
558  << getSpelling(PragmaTok);
559  return nullptr;
560  }
561 
562  if (Tok.hasUDSuffix()) {
563  Diag(Tok, diag::err_invalid_string_udl);
564  return nullptr;
565  }
566 
567  // Remember the macro string.
568  std::string StrVal = getSpelling(Tok);
569 
570  // Read the ')'.
571  Lex(Tok);
572  if (Tok.isNot(tok::r_paren)) {
573  Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
574  << getSpelling(PragmaTok);
575  return nullptr;
576  }
577 
578  assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
579  "Invalid string token!");
580 
581  // Create a Token from the string.
582  Token MacroTok;
583  MacroTok.startToken();
584  MacroTok.setKind(tok::raw_identifier);
585  CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);
586 
587  // Get the IdentifierInfo of MacroToPushTok.
588  return LookUpIdentifierInfo(MacroTok);
589 }
590 
591 /// Handle \#pragma push_macro.
592 ///
593 /// The syntax is:
594 /// \code
595 /// #pragma push_macro("macro")
596 /// \endcode
598  // Parse the pragma directive and get the macro IdentifierInfo*.
599  IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok);
600  if (!IdentInfo) return;
601 
602  // Get the MacroInfo associated with IdentInfo.
603  MacroInfo *MI = getMacroInfo(IdentInfo);
604 
605  if (MI) {
606  // Allow the original MacroInfo to be redefined later.
608  }
609 
610  // Push the cloned MacroInfo so we can retrieve it later.
611  PragmaPushMacroInfo[IdentInfo].push_back(MI);
612 }
613 
614 /// Handle \#pragma pop_macro.
615 ///
616 /// The syntax is:
617 /// \code
618 /// #pragma pop_macro("macro")
619 /// \endcode
621  SourceLocation MessageLoc = PopMacroTok.getLocation();
622 
623  // Parse the pragma directive and get the macro IdentifierInfo*.
624  IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok);
625  if (!IdentInfo) return;
626 
627  // Find the vector<MacroInfo*> associated with the macro.
628  llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>::iterator iter =
629  PragmaPushMacroInfo.find(IdentInfo);
630  if (iter != PragmaPushMacroInfo.end()) {
631  // Forget the MacroInfo currently associated with IdentInfo.
632  if (MacroInfo *MI = getMacroInfo(IdentInfo)) {
633  if (MI->isWarnIfUnused())
634  WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
635  appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc));
636  }
637 
638  // Get the MacroInfo we want to reinstall.
639  MacroInfo *MacroToReInstall = iter->second.back();
640 
641  if (MacroToReInstall)
642  // Reinstall the previously pushed macro.
643  appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc);
644 
645  // Pop PragmaPushMacroInfo stack.
646  iter->second.pop_back();
647  if (iter->second.empty())
648  PragmaPushMacroInfo.erase(iter);
649  } else {
650  Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push)
651  << IdentInfo->getName();
652  }
653 }
654 
656  // We will either get a quoted filename or a bracketed filename, and we
657  // have to track which we got. The first filename is the source name,
658  // and the second name is the mapped filename. If the first is quoted,
659  // the second must be as well (cannot mix and match quotes and brackets).
660 
661  // Get the open paren
662  Lex(Tok);
663  if (Tok.isNot(tok::l_paren)) {
664  Diag(Tok, diag::warn_pragma_include_alias_expected) << "(";
665  return;
666  }
667 
668  // We expect either a quoted string literal, or a bracketed name
669  Token SourceFilenameTok;
670  CurPPLexer->LexIncludeFilename(SourceFilenameTok);
671  if (SourceFilenameTok.is(tok::eod)) {
672  // The diagnostic has already been handled
673  return;
674  }
675 
676  StringRef SourceFileName;
677  SmallString<128> FileNameBuffer;
678  if (SourceFilenameTok.is(tok::string_literal) ||
679  SourceFilenameTok.is(tok::angle_string_literal)) {
680  SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer);
681  } else if (SourceFilenameTok.is(tok::less)) {
682  // This could be a path instead of just a name
683  FileNameBuffer.push_back('<');
685  if (ConcatenateIncludeName(FileNameBuffer, End))
686  return; // Diagnostic already emitted
687  SourceFileName = FileNameBuffer;
688  } else {
689  Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
690  return;
691  }
692  FileNameBuffer.clear();
693 
694  // Now we expect a comma, followed by another include name
695  Lex(Tok);
696  if (Tok.isNot(tok::comma)) {
697  Diag(Tok, diag::warn_pragma_include_alias_expected) << ",";
698  return;
699  }
700 
701  Token ReplaceFilenameTok;
702  CurPPLexer->LexIncludeFilename(ReplaceFilenameTok);
703  if (ReplaceFilenameTok.is(tok::eod)) {
704  // The diagnostic has already been handled
705  return;
706  }
707 
708  StringRef ReplaceFileName;
709  if (ReplaceFilenameTok.is(tok::string_literal) ||
710  ReplaceFilenameTok.is(tok::angle_string_literal)) {
711  ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer);
712  } else if (ReplaceFilenameTok.is(tok::less)) {
713  // This could be a path instead of just a name
714  FileNameBuffer.push_back('<');
716  if (ConcatenateIncludeName(FileNameBuffer, End))
717  return; // Diagnostic already emitted
718  ReplaceFileName = FileNameBuffer;
719  } else {
720  Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
721  return;
722  }
723 
724  // Finally, we expect the closing paren
725  Lex(Tok);
726  if (Tok.isNot(tok::r_paren)) {
727  Diag(Tok, diag::warn_pragma_include_alias_expected) << ")";
728  return;
729  }
730 
731  // Now that we have the source and target filenames, we need to make sure
732  // they're both of the same type (angled vs non-angled)
733  StringRef OriginalSource = SourceFileName;
734 
735  bool SourceIsAngled =
736  GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(),
737  SourceFileName);
738  bool ReplaceIsAngled =
739  GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(),
740  ReplaceFileName);
741  if (!SourceFileName.empty() && !ReplaceFileName.empty() &&
742  (SourceIsAngled != ReplaceIsAngled)) {
743  unsigned int DiagID;
744  if (SourceIsAngled)
745  DiagID = diag::warn_pragma_include_alias_mismatch_angle;
746  else
747  DiagID = diag::warn_pragma_include_alias_mismatch_quote;
748 
749  Diag(SourceFilenameTok.getLocation(), DiagID)
750  << SourceFileName
751  << ReplaceFileName;
752 
753  return;
754  }
755 
756  // Now we can let the include handler know about this mapping
757  getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName);
758 }
759 
760 // Lex a component of a module name: either an identifier or a string literal;
761 // for components that can be expressed both ways, the two forms are equivalent.
763  Preprocessor &PP, Token &Tok,
764  std::pair<IdentifierInfo *, SourceLocation> &ModuleNameComponent,
765  bool First) {
766  PP.LexUnexpandedToken(Tok);
767  if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) {
768  StringLiteralParser Literal(Tok, PP);
769  if (Literal.hadError)
770  return true;
771  ModuleNameComponent = std::make_pair(
772  PP.getIdentifierInfo(Literal.GetString()), Tok.getLocation());
773  } else if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) {
774  ModuleNameComponent =
775  std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation());
776  } else {
777  PP.Diag(Tok.getLocation(), diag::err_pp_expected_module_name) << First;
778  return true;
779  }
780  return false;
781 }
782 
783 static bool LexModuleName(
784  Preprocessor &PP, Token &Tok,
785  llvm::SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>>
786  &ModuleName) {
787  while (true) {
788  std::pair<IdentifierInfo*, SourceLocation> NameComponent;
789  if (LexModuleNameComponent(PP, Tok, NameComponent, ModuleName.empty()))
790  return true;
791  ModuleName.push_back(NameComponent);
792 
793  PP.LexUnexpandedToken(Tok);
794  if (Tok.isNot(tok::period))
795  return false;
796  }
797 }
798 
800  SourceLocation Loc = Tok.getLocation();
801 
802  std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
803  if (LexModuleNameComponent(*this, Tok, ModuleNameLoc, true))
804  return;
805  IdentifierInfo *ModuleName = ModuleNameLoc.first;
806 
807  LexUnexpandedToken(Tok);
808  if (Tok.isNot(tok::eod)) {
809  Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
810  DiscardUntilEndOfDirective();
811  }
812 
813  if (CurPTHLexer) {
814  // FIXME: Support this somehow?
815  Diag(Loc, diag::err_pp_module_build_pth);
816  return;
817  }
818 
819  CurLexer->LexingRawMode = true;
820 
821  auto TryConsumeIdentifier = [&](StringRef Ident) -> bool {
822  if (Tok.getKind() != tok::raw_identifier ||
823  Tok.getRawIdentifier() != Ident)
824  return false;
825  CurLexer->Lex(Tok);
826  return true;
827  };
828 
829  // Scan forward looking for the end of the module.
830  const char *Start = CurLexer->getBufferLocation();
831  const char *End = nullptr;
832  unsigned NestingLevel = 1;
833  while (true) {
834  End = CurLexer->getBufferLocation();
835  CurLexer->Lex(Tok);
836 
837  if (Tok.is(tok::eof)) {
838  Diag(Loc, diag::err_pp_module_build_missing_end);
839  break;
840  }
841 
842  if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) {
843  // Token was part of module; keep going.
844  continue;
845  }
846 
847  // We hit something directive-shaped; check to see if this is the end
848  // of the module build.
849  CurLexer->ParsingPreprocessorDirective = true;
850  CurLexer->Lex(Tok);
851  if (TryConsumeIdentifier("pragma") && TryConsumeIdentifier("clang") &&
852  TryConsumeIdentifier("module")) {
853  if (TryConsumeIdentifier("build"))
854  // #pragma clang module build -> entering a nested module build.
855  ++NestingLevel;
856  else if (TryConsumeIdentifier("endbuild")) {
857  // #pragma clang module endbuild -> leaving a module build.
858  if (--NestingLevel == 0)
859  break;
860  }
861  // We should either be looking at the EOD or more of the current directive
862  // preceding the EOD. Either way we can ignore this token and keep going.
863  assert(Tok.getKind() != tok::eof && "missing EOD before EOF");
864  }
865  }
866 
867  CurLexer->LexingRawMode = false;
868 
869  // Load the extracted text as a preprocessed module.
870  assert(CurLexer->getBuffer().begin() <= Start &&
871  Start <= CurLexer->getBuffer().end() &&
872  CurLexer->getBuffer().begin() <= End &&
873  End <= CurLexer->getBuffer().end() &&
874  "module source range not contained within same file buffer");
875  TheModuleLoader.loadModuleFromSource(Loc, ModuleName->getName(),
876  StringRef(Start, End - Start));
877 }
878 
880  Lex(Tok);
881  if (Tok.is(tok::l_paren)) {
882  Diag(Tok.getLocation(), diag::warn_pp_hdrstop_filename_ignored);
883 
884  std::string FileName;
885  if (!LexStringLiteral(Tok, FileName, "pragma hdrstop", false))
886  return;
887 
888  if (Tok.isNot(tok::r_paren)) {
889  Diag(Tok, diag::err_expected) << tok::r_paren;
890  return;
891  }
892  Lex(Tok);
893  }
894  if (Tok.isNot(tok::eod))
895  Diag(Tok.getLocation(), diag::ext_pp_extra_tokens_at_eol)
896  << "pragma hdrstop";
897 
898  if (creatingPCHWithPragmaHdrStop() &&
899  SourceMgr.isInMainFile(Tok.getLocation())) {
900  assert(CurLexer && "no lexer for #pragma hdrstop processing");
901  Token &Result = Tok;
902  Result.startToken();
903  CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
904  CurLexer->cutOffLexing();
905  }
906  if (usingPCHWithPragmaHdrStop())
907  SkippingUntilPragmaHdrStop = false;
908 }
909 
910 /// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
911 /// If 'Namespace' is non-null, then it is a token required to exist on the
912 /// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
913 void Preprocessor::AddPragmaHandler(StringRef Namespace,
914  PragmaHandler *Handler) {
915  PragmaNamespace *InsertNS = PragmaHandlers.get();
916 
917  // If this is specified to be in a namespace, step down into it.
918  if (!Namespace.empty()) {
919  // If there is already a pragma handler with the name of this namespace,
920  // we either have an error (directive with the same name as a namespace) or
921  // we already have the namespace to insert into.
922  if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
923  InsertNS = Existing->getIfNamespace();
924  assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
925  " handler with the same name!");
926  } else {
927  // Otherwise, this namespace doesn't exist yet, create and insert the
928  // handler for it.
929  InsertNS = new PragmaNamespace(Namespace);
930  PragmaHandlers->AddPragma(InsertNS);
931  }
932  }
933 
934  // Check to make sure we don't already have a pragma for this identifier.
935  assert(!InsertNS->FindHandler(Handler->getName()) &&
936  "Pragma handler already exists for this identifier!");
937  InsertNS->AddPragma(Handler);
938 }
939 
940 /// RemovePragmaHandler - Remove the specific pragma handler from the
941 /// preprocessor. If \arg Namespace is non-null, then it should be the
942 /// namespace that \arg Handler was added to. It is an error to remove
943 /// a handler that has not been registered.
944 void Preprocessor::RemovePragmaHandler(StringRef Namespace,
945  PragmaHandler *Handler) {
946  PragmaNamespace *NS = PragmaHandlers.get();
947 
948  // If this is specified to be in a namespace, step down into it.
949  if (!Namespace.empty()) {
950  PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
951  assert(Existing && "Namespace containing handler does not exist!");
952 
953  NS = Existing->getIfNamespace();
954  assert(NS && "Invalid namespace, registered as a regular pragma handler!");
955  }
956 
957  NS->RemovePragmaHandler(Handler);
958 
959  // If this is a non-default namespace and it is now empty, remove it.
960  if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
961  PragmaHandlers->RemovePragmaHandler(NS);
962  delete NS;
963  }
964 }
965 
967  Token Tok;
968  LexUnexpandedToken(Tok);
969 
970  if (Tok.isNot(tok::identifier)) {
971  Diag(Tok, diag::ext_on_off_switch_syntax);
972  return true;
973  }
974  IdentifierInfo *II = Tok.getIdentifierInfo();
975  if (II->isStr("ON"))
976  Result = tok::OOS_ON;
977  else if (II->isStr("OFF"))
978  Result = tok::OOS_OFF;
979  else if (II->isStr("DEFAULT"))
980  Result = tok::OOS_DEFAULT;
981  else {
982  Diag(Tok, diag::ext_on_off_switch_syntax);
983  return true;
984  }
985 
986  // Verify that this is followed by EOD.
987  LexUnexpandedToken(Tok);
988  if (Tok.isNot(tok::eod))
989  Diag(Tok, diag::ext_pragma_syntax_eod);
990  return false;
991 }
992 
993 namespace {
994 
995 /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
996 struct PragmaOnceHandler : public PragmaHandler {
997  PragmaOnceHandler() : PragmaHandler("once") {}
998 
999  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1000  Token &OnceTok) override {
1001  PP.CheckEndOfDirective("pragma once");
1002  PP.HandlePragmaOnce(OnceTok);
1003  }
1004 };
1005 
1006 /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
1007 /// rest of the line is not lexed.
1008 struct PragmaMarkHandler : public PragmaHandler {
1009  PragmaMarkHandler() : PragmaHandler("mark") {}
1010 
1011  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1012  Token &MarkTok) override {
1013  PP.HandlePragmaMark();
1014  }
1015 };
1016 
1017 /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
1018 struct PragmaPoisonHandler : public PragmaHandler {
1019  PragmaPoisonHandler() : PragmaHandler("poison") {}
1020 
1021  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1022  Token &PoisonTok) override {
1023  PP.HandlePragmaPoison();
1024  }
1025 };
1026 
1027 /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
1028 /// as a system header, which silences warnings in it.
1029 struct PragmaSystemHeaderHandler : public PragmaHandler {
1030  PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}
1031 
1032  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1033  Token &SHToken) override {
1034  PP.HandlePragmaSystemHeader(SHToken);
1035  PP.CheckEndOfDirective("pragma");
1036  }
1037 };
1038 
1039 struct PragmaDependencyHandler : public PragmaHandler {
1040  PragmaDependencyHandler() : PragmaHandler("dependency") {}
1041 
1042  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1043  Token &DepToken) override {
1044  PP.HandlePragmaDependency(DepToken);
1045  }
1046 };
1047 
1048 struct PragmaDebugHandler : public PragmaHandler {
1049  PragmaDebugHandler() : PragmaHandler("__debug") {}
1050 
1051  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1052  Token &DepToken) override {
1053  Token Tok;
1054  PP.LexUnexpandedToken(Tok);
1055  if (Tok.isNot(tok::identifier)) {
1056  PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1057  return;
1058  }
1059  IdentifierInfo *II = Tok.getIdentifierInfo();
1060 
1061  if (II->isStr("assert")) {
1062  llvm_unreachable("This is an assertion!");
1063  } else if (II->isStr("crash")) {
1064  LLVM_BUILTIN_TRAP;
1065  } else if (II->isStr("parser_crash")) {
1066  Token Crasher;
1067  Crasher.startToken();
1068  Crasher.setKind(tok::annot_pragma_parser_crash);
1069  Crasher.setAnnotationRange(SourceRange(Tok.getLocation()));
1070  PP.EnterToken(Crasher);
1071  } else if (II->isStr("dump")) {
1072  Token Identifier;
1073  PP.LexUnexpandedToken(Identifier);
1074  if (auto *DumpII = Identifier.getIdentifierInfo()) {
1075  Token DumpAnnot;
1076  DumpAnnot.startToken();
1077  DumpAnnot.setKind(tok::annot_pragma_dump);
1078  DumpAnnot.setAnnotationRange(
1079  SourceRange(Tok.getLocation(), Identifier.getLocation()));
1080  DumpAnnot.setAnnotationValue(DumpII);
1082  PP.EnterToken(DumpAnnot);
1083  } else {
1084  PP.Diag(Identifier, diag::warn_pragma_debug_missing_argument)
1085  << II->getName();
1086  }
1087  } else if (II->isStr("diag_mapping")) {
1088  Token DiagName;
1089  PP.LexUnexpandedToken(DiagName);
1090  if (DiagName.is(tok::eod))
1091  PP.getDiagnostics().dump();
1092  else if (DiagName.is(tok::string_literal) && !DiagName.hasUDSuffix()) {
1093  StringLiteralParser Literal(DiagName, PP);
1094  if (Literal.hadError)
1095  return;
1096  PP.getDiagnostics().dump(Literal.GetString());
1097  } else {
1098  PP.Diag(DiagName, diag::warn_pragma_debug_missing_argument)
1099  << II->getName();
1100  }
1101  } else if (II->isStr("llvm_fatal_error")) {
1102  llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
1103  } else if (II->isStr("llvm_unreachable")) {
1104  llvm_unreachable("#pragma clang __debug llvm_unreachable");
1105  } else if (II->isStr("macro")) {
1106  Token MacroName;
1107  PP.LexUnexpandedToken(MacroName);
1108  auto *MacroII = MacroName.getIdentifierInfo();
1109  if (MacroII)
1110  PP.dumpMacroInfo(MacroII);
1111  else
1112  PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
1113  << II->getName();
1114  } else if (II->isStr("overflow_stack")) {
1115  DebugOverflowStack();
1116  } else if (II->isStr("handle_crash")) {
1117  llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent();
1118  if (CRC)
1119  CRC->HandleCrash();
1120  } else if (II->isStr("captured")) {
1121  HandleCaptured(PP);
1122  } else {
1123  PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1124  << II->getName();
1125  }
1126 
1127  PPCallbacks *Callbacks = PP.getPPCallbacks();
1128  if (Callbacks)
1129  Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
1130  }
1131 
1132  void HandleCaptured(Preprocessor &PP) {
1133  // Skip if emitting preprocessed output.
1134  if (PP.isPreprocessedOutput())
1135  return;
1136 
1137  Token Tok;
1138  PP.LexUnexpandedToken(Tok);
1139 
1140  if (Tok.isNot(tok::eod)) {
1141  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
1142  << "pragma clang __debug captured";
1143  return;
1144  }
1145 
1146  SourceLocation NameLoc = Tok.getLocation();
1148  PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
1149  Toks[0].startToken();
1150  Toks[0].setKind(tok::annot_pragma_captured);
1151  Toks[0].setLocation(NameLoc);
1152 
1153  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
1154  }
1155 
1156 // Disable MSVC warning about runtime stack overflow.
1157 #ifdef _MSC_VER
1158  #pragma warning(disable : 4717)
1159 #endif
1160  static void DebugOverflowStack(void (*P)() = nullptr) {
1161  void (*volatile Self)(void(*P)()) = DebugOverflowStack;
1162  Self(reinterpret_cast<void(*)()>(Self));
1163  }
1164 #ifdef _MSC_VER
1165  #pragma warning(default : 4717)
1166 #endif
1167 };
1168 
1169 /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
1170 struct PragmaDiagnosticHandler : public PragmaHandler {
1171 private:
1172  const char *Namespace;
1173 
1174 public:
1175  explicit PragmaDiagnosticHandler(const char *NS)
1176  : PragmaHandler("diagnostic"), Namespace(NS) {}
1177 
1178  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1179  Token &DiagToken) override {
1180  SourceLocation DiagLoc = DiagToken.getLocation();
1181  Token Tok;
1182  PP.LexUnexpandedToken(Tok);
1183  if (Tok.isNot(tok::identifier)) {
1184  PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1185  return;
1186  }
1187  IdentifierInfo *II = Tok.getIdentifierInfo();
1188  PPCallbacks *Callbacks = PP.getPPCallbacks();
1189 
1190  if (II->isStr("pop")) {
1191  if (!PP.getDiagnostics().popMappings(DiagLoc))
1192  PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
1193  else if (Callbacks)
1194  Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
1195  return;
1196  } else if (II->isStr("push")) {
1197  PP.getDiagnostics().pushMappings(DiagLoc);
1198  if (Callbacks)
1199  Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
1200  return;
1201  }
1202 
1203  diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
1204  .Case("ignored", diag::Severity::Ignored)
1205  .Case("warning", diag::Severity::Warning)
1206  .Case("error", diag::Severity::Error)
1207  .Case("fatal", diag::Severity::Fatal)
1208  .Default(diag::Severity());
1209 
1210  if (SV == diag::Severity()) {
1211  PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1212  return;
1213  }
1214 
1215  PP.LexUnexpandedToken(Tok);
1216  SourceLocation StringLoc = Tok.getLocation();
1217 
1218  std::string WarningName;
1219  if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
1220  /*MacroExpansion=*/false))
1221  return;
1222 
1223  if (Tok.isNot(tok::eod)) {
1224  PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1225  return;
1226  }
1227 
1228  if (WarningName.size() < 3 || WarningName[0] != '-' ||
1229  (WarningName[1] != 'W' && WarningName[1] != 'R')) {
1230  PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
1231  return;
1232  }
1233 
1234  diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
1236  StringRef Group = StringRef(WarningName).substr(2);
1237  bool unknownDiag = false;
1238  if (Group == "everything") {
1239  // Special handling for pragma clang diagnostic ... "-Weverything".
1240  // There is no formal group named "everything", so there has to be a
1241  // special case for it.
1242  PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
1243  } else
1244  unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
1245  DiagLoc);
1246  if (unknownDiag)
1247  PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
1248  << WarningName;
1249  else if (Callbacks)
1250  Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
1251  }
1252 };
1253 
1254 /// "\#pragma hdrstop [<header-name-string>]"
1255 struct PragmaHdrstopHandler : public PragmaHandler {
1256  PragmaHdrstopHandler() : PragmaHandler("hdrstop") {}
1257  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1258  Token &DepToken) override {
1259  PP.HandlePragmaHdrstop(DepToken);
1260  }
1261 };
1262 
1263 /// "\#pragma warning(...)". MSVC's diagnostics do not map cleanly to clang's
1264 /// diagnostics, so we don't really implement this pragma. We parse it and
1265 /// ignore it to avoid -Wunknown-pragma warnings.
1266 struct PragmaWarningHandler : public PragmaHandler {
1267  PragmaWarningHandler() : PragmaHandler("warning") {}
1268 
1269  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1270  Token &Tok) override {
1271  // Parse things like:
1272  // warning(push, 1)
1273  // warning(pop)
1274  // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
1275  SourceLocation DiagLoc = Tok.getLocation();
1276  PPCallbacks *Callbacks = PP.getPPCallbacks();
1277 
1278  PP.Lex(Tok);
1279  if (Tok.isNot(tok::l_paren)) {
1280  PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
1281  return;
1282  }
1283 
1284  PP.Lex(Tok);
1285  IdentifierInfo *II = Tok.getIdentifierInfo();
1286 
1287  if (II && II->isStr("push")) {
1288  // #pragma warning( push[ ,n ] )
1289  int Level = -1;
1290  PP.Lex(Tok);
1291  if (Tok.is(tok::comma)) {
1292  PP.Lex(Tok);
1293  uint64_t Value;
1294  if (Tok.is(tok::numeric_constant) &&
1295  PP.parseSimpleIntegerLiteral(Tok, Value))
1296  Level = int(Value);
1297  if (Level < 0 || Level > 4) {
1298  PP.Diag(Tok, diag::warn_pragma_warning_push_level);
1299  return;
1300  }
1301  }
1302  if (Callbacks)
1303  Callbacks->PragmaWarningPush(DiagLoc, Level);
1304  } else if (II && II->isStr("pop")) {
1305  // #pragma warning( pop )
1306  PP.Lex(Tok);
1307  if (Callbacks)
1308  Callbacks->PragmaWarningPop(DiagLoc);
1309  } else {
1310  // #pragma warning( warning-specifier : warning-number-list
1311  // [; warning-specifier : warning-number-list...] )
1312  while (true) {
1313  II = Tok.getIdentifierInfo();
1314  if (!II && !Tok.is(tok::numeric_constant)) {
1315  PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1316  return;
1317  }
1318 
1319  // Figure out which warning specifier this is.
1320  bool SpecifierValid;
1321  StringRef Specifier;
1322  llvm::SmallString<1> SpecifierBuf;
1323  if (II) {
1324  Specifier = II->getName();
1325  SpecifierValid = llvm::StringSwitch<bool>(Specifier)
1326  .Cases("default", "disable", "error", "once",
1327  "suppress", true)
1328  .Default(false);
1329  // If we read a correct specifier, snatch next token (that should be
1330  // ":", checked later).
1331  if (SpecifierValid)
1332  PP.Lex(Tok);
1333  } else {
1334  // Token is a numeric constant. It should be either 1, 2, 3 or 4.
1335  uint64_t Value;
1336  Specifier = PP.getSpelling(Tok, SpecifierBuf);
1337  if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
1338  SpecifierValid = (Value >= 1) && (Value <= 4);
1339  } else
1340  SpecifierValid = false;
1341  // Next token already snatched by parseSimpleIntegerLiteral.
1342  }
1343 
1344  if (!SpecifierValid) {
1345  PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1346  return;
1347  }
1348  if (Tok.isNot(tok::colon)) {
1349  PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
1350  return;
1351  }
1352 
1353  // Collect the warning ids.
1354  SmallVector<int, 4> Ids;
1355  PP.Lex(Tok);
1356  while (Tok.is(tok::numeric_constant)) {
1357  uint64_t Value;
1358  if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
1359  Value > std::numeric_limits<int>::max()) {
1360  PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
1361  return;
1362  }
1363  Ids.push_back(int(Value));
1364  }
1365  if (Callbacks)
1366  Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
1367 
1368  // Parse the next specifier if there is a semicolon.
1369  if (Tok.isNot(tok::semi))
1370  break;
1371  PP.Lex(Tok);
1372  }
1373  }
1374 
1375  if (Tok.isNot(tok::r_paren)) {
1376  PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
1377  return;
1378  }
1379 
1380  PP.Lex(Tok);
1381  if (Tok.isNot(tok::eod))
1382  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
1383  }
1384 };
1385 
1386 /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1387 struct PragmaIncludeAliasHandler : public PragmaHandler {
1388  PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}
1389 
1390  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1391  Token &IncludeAliasTok) override {
1392  PP.HandlePragmaIncludeAlias(IncludeAliasTok);
1393  }
1394 };
1395 
1396 /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message
1397 /// extension. The syntax is:
1398 /// \code
1399 /// #pragma message(string)
1400 /// \endcode
1401 /// OR, in GCC mode:
1402 /// \code
1403 /// #pragma message string
1404 /// \endcode
1405 /// string is a string, which is fully macro expanded, and permits string
1406 /// concatenation, embedded escape characters, etc... See MSDN for more details.
1407 /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same
1408 /// form as \#pragma message.
1409 struct PragmaMessageHandler : public PragmaHandler {
1410 private:
1412  const StringRef Namespace;
1413 
1414  static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
1415  bool PragmaNameOnly = false) {
1416  switch (Kind) {
1418  return PragmaNameOnly ? "message" : "pragma message";
1420  return PragmaNameOnly ? "warning" : "pragma warning";
1422  return PragmaNameOnly ? "error" : "pragma error";
1423  }
1424  llvm_unreachable("Unknown PragmaMessageKind!");
1425  }
1426 
1427 public:
1428  PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
1429  StringRef Namespace = StringRef())
1430  : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind),
1431  Namespace(Namespace) {}
1432 
1433  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1434  Token &Tok) override {
1435  SourceLocation MessageLoc = Tok.getLocation();
1436  PP.Lex(Tok);
1437  bool ExpectClosingParen = false;
1438  switch (Tok.getKind()) {
1439  case tok::l_paren:
1440  // We have a MSVC style pragma message.
1441  ExpectClosingParen = true;
1442  // Read the string.
1443  PP.Lex(Tok);
1444  break;
1445  case tok::string_literal:
1446  // We have a GCC style pragma message, and we just read the string.
1447  break;
1448  default:
1449  PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
1450  return;
1451  }
1452 
1453  std::string MessageString;
1454  if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
1455  /*MacroExpansion=*/true))
1456  return;
1457 
1458  if (ExpectClosingParen) {
1459  if (Tok.isNot(tok::r_paren)) {
1460  PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1461  return;
1462  }
1463  PP.Lex(Tok); // eat the r_paren.
1464  }
1465 
1466  if (Tok.isNot(tok::eod)) {
1467  PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1468  return;
1469  }
1470 
1471  // Output the message.
1472  PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
1473  ? diag::err_pragma_message
1474  : diag::warn_pragma_message) << MessageString;
1475 
1476  // If the pragma is lexically sound, notify any interested PPCallbacks.
1477  if (PPCallbacks *Callbacks = PP.getPPCallbacks())
1478  Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
1479  }
1480 };
1481 
1482 /// Handle the clang \#pragma module import extension. The syntax is:
1483 /// \code
1484 /// #pragma clang module import some.module.name
1485 /// \endcode
1486 struct PragmaModuleImportHandler : public PragmaHandler {
1487  PragmaModuleImportHandler() : PragmaHandler("import") {}
1488 
1489  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1490  Token &Tok) override {
1491  SourceLocation ImportLoc = Tok.getLocation();
1492 
1493  // Read the module name.
1495  ModuleName;
1496  if (LexModuleName(PP, Tok, ModuleName))
1497  return;
1498 
1499  if (Tok.isNot(tok::eod))
1500  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1501 
1502  // If we have a non-empty module path, load the named module.
1503  Module *Imported =
1504  PP.getModuleLoader().loadModule(ImportLoc, ModuleName, Module::Hidden,
1505  /*IsIncludeDirective=*/false);
1506  if (!Imported)
1507  return;
1508 
1509  PP.makeModuleVisible(Imported, ImportLoc);
1510  PP.EnterAnnotationToken(SourceRange(ImportLoc, ModuleName.back().second),
1511  tok::annot_module_include, Imported);
1512  if (auto *CB = PP.getPPCallbacks())
1513  CB->moduleImport(ImportLoc, ModuleName, Imported);
1514  }
1515 };
1516 
1517 /// Handle the clang \#pragma module begin extension. The syntax is:
1518 /// \code
1519 /// #pragma clang module begin some.module.name
1520 /// ...
1521 /// #pragma clang module end
1522 /// \endcode
1523 struct PragmaModuleBeginHandler : public PragmaHandler {
1524  PragmaModuleBeginHandler() : PragmaHandler("begin") {}
1525 
1526  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1527  Token &Tok) override {
1528  SourceLocation BeginLoc = Tok.getLocation();
1529 
1530  // Read the module name.
1532  ModuleName;
1533  if (LexModuleName(PP, Tok, ModuleName))
1534  return;
1535 
1536  if (Tok.isNot(tok::eod))
1537  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1538 
1539  // We can only enter submodules of the current module.
1540  StringRef Current = PP.getLangOpts().CurrentModule;
1541  if (ModuleName.front().first->getName() != Current) {
1542  PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module)
1543  << ModuleName.front().first << (ModuleName.size() > 1)
1544  << Current.empty() << Current;
1545  return;
1546  }
1547 
1548  // Find the module we're entering. We require that a module map for it
1549  // be loaded or implicitly loadable.
1550  // FIXME: We could create the submodule here. We'd need to know whether
1551  // it's supposed to be explicit, but not much else.
1552  Module *M = PP.getHeaderSearchInfo().lookupModule(Current);
1553  if (!M) {
1554  PP.Diag(ModuleName.front().second,
1555  diag::err_pp_module_begin_no_module_map) << Current;
1556  return;
1557  }
1558  for (unsigned I = 1; I != ModuleName.size(); ++I) {
1559  auto *NewM = M->findSubmodule(ModuleName[I].first->getName());
1560  if (!NewM) {
1561  PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule)
1562  << M->getFullModuleName() << ModuleName[I].first;
1563  return;
1564  }
1565  M = NewM;
1566  }
1567 
1568  // If the module isn't available, it doesn't make sense to enter it.
1570  PP.getLangOpts(), PP.getTargetInfo(), PP.getDiagnostics(), M)) {
1571  PP.Diag(BeginLoc, diag::note_pp_module_begin_here)
1572  << M->getTopLevelModuleName();
1573  return;
1574  }
1575 
1576  // Enter the scope of the submodule.
1577  PP.EnterSubmodule(M, BeginLoc, /*ForPragma*/true);
1578  PP.EnterAnnotationToken(SourceRange(BeginLoc, ModuleName.back().second),
1579  tok::annot_module_begin, M);
1580  }
1581 };
1582 
1583 /// Handle the clang \#pragma module end extension.
1584 struct PragmaModuleEndHandler : public PragmaHandler {
1585  PragmaModuleEndHandler() : PragmaHandler("end") {}
1586 
1587  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1588  Token &Tok) override {
1589  SourceLocation Loc = Tok.getLocation();
1590 
1591  PP.LexUnexpandedToken(Tok);
1592  if (Tok.isNot(tok::eod))
1593  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1594 
1595  Module *M = PP.LeaveSubmodule(/*ForPragma*/true);
1596  if (M)
1597  PP.EnterAnnotationToken(SourceRange(Loc), tok::annot_module_end, M);
1598  else
1599  PP.Diag(Loc, diag::err_pp_module_end_without_module_begin);
1600  }
1601 };
1602 
1603 /// Handle the clang \#pragma module build extension.
1604 struct PragmaModuleBuildHandler : public PragmaHandler {
1605  PragmaModuleBuildHandler() : PragmaHandler("build") {}
1606 
1607  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1608  Token &Tok) override {
1609  PP.HandlePragmaModuleBuild(Tok);
1610  }
1611 };
1612 
1613 /// Handle the clang \#pragma module load extension.
1614 struct PragmaModuleLoadHandler : public PragmaHandler {
1615  PragmaModuleLoadHandler() : PragmaHandler("load") {}
1616 
1617  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1618  Token &Tok) override {
1619  SourceLocation Loc = Tok.getLocation();
1620 
1621  // Read the module name.
1623  ModuleName;
1624  if (LexModuleName(PP, Tok, ModuleName))
1625  return;
1626 
1627  if (Tok.isNot(tok::eod))
1628  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1629 
1630  // Load the module, don't make it visible.
1631  PP.getModuleLoader().loadModule(Loc, ModuleName, Module::Hidden,
1632  /*IsIncludeDirective=*/false);
1633  }
1634 };
1635 
1636 /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1637 /// macro on the top of the stack.
1638 struct PragmaPushMacroHandler : public PragmaHandler {
1639  PragmaPushMacroHandler() : PragmaHandler("push_macro") {}
1640 
1641  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1642  Token &PushMacroTok) override {
1643  PP.HandlePragmaPushMacro(PushMacroTok);
1644  }
1645 };
1646 
1647 /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the
1648 /// macro to the value on the top of the stack.
1649 struct PragmaPopMacroHandler : public PragmaHandler {
1650  PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}
1651 
1652  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1653  Token &PopMacroTok) override {
1654  PP.HandlePragmaPopMacro(PopMacroTok);
1655  }
1656 };
1657 
1658 /// PragmaARCCFCodeAuditedHandler -
1659 /// \#pragma clang arc_cf_code_audited begin/end
1660 struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
1661  PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}
1662 
1663  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1664  Token &NameTok) override {
1665  SourceLocation Loc = NameTok.getLocation();
1666  bool IsBegin;
1667 
1668  Token Tok;
1669 
1670  // Lex the 'begin' or 'end'.
1671  PP.LexUnexpandedToken(Tok);
1672  const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1673  if (BeginEnd && BeginEnd->isStr("begin")) {
1674  IsBegin = true;
1675  } else if (BeginEnd && BeginEnd->isStr("end")) {
1676  IsBegin = false;
1677  } else {
1678  PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
1679  return;
1680  }
1681 
1682  // Verify that this is followed by EOD.
1683  PP.LexUnexpandedToken(Tok);
1684  if (Tok.isNot(tok::eod))
1685  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1686 
1687  // The start location of the active audit.
1689 
1690  // The start location we want after processing this.
1691  SourceLocation NewLoc;
1692 
1693  if (IsBegin) {
1694  // Complain about attempts to re-enter an audit.
1695  if (BeginLoc.isValid()) {
1696  PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
1697  PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1698  }
1699  NewLoc = Loc;
1700  } else {
1701  // Complain about attempts to leave an audit that doesn't exist.
1702  if (!BeginLoc.isValid()) {
1703  PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
1704  return;
1705  }
1706  NewLoc = SourceLocation();
1707  }
1708 
1709  PP.setPragmaARCCFCodeAuditedLoc(NewLoc);
1710  }
1711 };
1712 
1713 /// PragmaAssumeNonNullHandler -
1714 /// \#pragma clang assume_nonnull begin/end
1715 struct PragmaAssumeNonNullHandler : public PragmaHandler {
1716  PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}
1717 
1718  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1719  Token &NameTok) override {
1720  SourceLocation Loc = NameTok.getLocation();
1721  bool IsBegin;
1722 
1723  Token Tok;
1724 
1725  // Lex the 'begin' or 'end'.
1726  PP.LexUnexpandedToken(Tok);
1727  const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1728  if (BeginEnd && BeginEnd->isStr("begin")) {
1729  IsBegin = true;
1730  } else if (BeginEnd && BeginEnd->isStr("end")) {
1731  IsBegin = false;
1732  } else {
1733  PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
1734  return;
1735  }
1736 
1737  // Verify that this is followed by EOD.
1738  PP.LexUnexpandedToken(Tok);
1739  if (Tok.isNot(tok::eod))
1740  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1741 
1742  // The start location of the active audit.
1743  SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc();
1744 
1745  // The start location we want after processing this.
1746  SourceLocation NewLoc;
1747  PPCallbacks *Callbacks = PP.getPPCallbacks();
1748 
1749  if (IsBegin) {
1750  // Complain about attempts to re-enter an audit.
1751  if (BeginLoc.isValid()) {
1752  PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
1753  PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1754  }
1755  NewLoc = Loc;
1756  if (Callbacks)
1757  Callbacks->PragmaAssumeNonNullBegin(NewLoc);
1758  } else {
1759  // Complain about attempts to leave an audit that doesn't exist.
1760  if (!BeginLoc.isValid()) {
1761  PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
1762  return;
1763  }
1764  NewLoc = SourceLocation();
1765  if (Callbacks)
1766  Callbacks->PragmaAssumeNonNullEnd(NewLoc);
1767  }
1768 
1769  PP.setPragmaAssumeNonNullLoc(NewLoc);
1770  }
1771 };
1772 
1773 /// Handle "\#pragma region [...]"
1774 ///
1775 /// The syntax is
1776 /// \code
1777 /// #pragma region [optional name]
1778 /// #pragma endregion [optional comment]
1779 /// \endcode
1780 ///
1781 /// \note This is
1782 /// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a>
1783 /// pragma, just skipped by compiler.
1784 struct PragmaRegionHandler : public PragmaHandler {
1785  PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {}
1786 
1787  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1788  Token &NameTok) override {
1789  // #pragma region: endregion matches can be verified
1790  // __pragma(region): no sense, but ignored by msvc
1791  // _Pragma is not valid for MSVC, but there isn't any point
1792  // to handle a _Pragma differently.
1793  }
1794 };
1795 
1796 } // namespace
1797 
1798 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
1799 /// \#pragma GCC poison/system_header/dependency and \#pragma once.
1800 void Preprocessor::RegisterBuiltinPragmas() {
1801  AddPragmaHandler(new PragmaOnceHandler());
1802  AddPragmaHandler(new PragmaMarkHandler());
1803  AddPragmaHandler(new PragmaPushMacroHandler());
1804  AddPragmaHandler(new PragmaPopMacroHandler());
1805  AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));
1806 
1807  // #pragma GCC ...
1808  AddPragmaHandler("GCC", new PragmaPoisonHandler());
1809  AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
1810  AddPragmaHandler("GCC", new PragmaDependencyHandler());
1811  AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
1812  AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
1813  "GCC"));
1814  AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
1815  "GCC"));
1816  // #pragma clang ...
1817  AddPragmaHandler("clang", new PragmaPoisonHandler());
1818  AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
1819  AddPragmaHandler("clang", new PragmaDebugHandler());
1820  AddPragmaHandler("clang", new PragmaDependencyHandler());
1821  AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
1822  AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
1823  AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
1824 
1825  // #pragma clang module ...
1826  auto *ModuleHandler = new PragmaNamespace("module");
1827  AddPragmaHandler("clang", ModuleHandler);
1828  ModuleHandler->AddPragma(new PragmaModuleImportHandler());
1829  ModuleHandler->AddPragma(new PragmaModuleBeginHandler());
1830  ModuleHandler->AddPragma(new PragmaModuleEndHandler());
1831  ModuleHandler->AddPragma(new PragmaModuleBuildHandler());
1832  ModuleHandler->AddPragma(new PragmaModuleLoadHandler());
1833 
1834  // Add region pragmas.
1835  AddPragmaHandler(new PragmaRegionHandler("region"));
1836  AddPragmaHandler(new PragmaRegionHandler("endregion"));
1837 
1838  // MS extensions.
1839  if (LangOpts.MicrosoftExt) {
1840  AddPragmaHandler(new PragmaWarningHandler());
1841  AddPragmaHandler(new PragmaIncludeAliasHandler());
1842  AddPragmaHandler(new PragmaHdrstopHandler());
1843  }
1844 
1845  // Pragmas added by plugins
1846  for (PragmaHandlerRegistry::iterator it = PragmaHandlerRegistry::begin(),
1847  ie = PragmaHandlerRegistry::end();
1848  it != ie; ++it) {
1849  AddPragmaHandler(it->instantiate().release());
1850  }
1851 }
1852 
1853 /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
1854 /// warn about those pragmas being unknown.
1856  AddPragmaHandler(new EmptyPragmaHandler());
1857  // Also ignore all pragmas in all namespaces created
1858  // in Preprocessor::RegisterBuiltinPragmas().
1859  AddPragmaHandler("GCC", new EmptyPragmaHandler());
1860  AddPragmaHandler("clang", new EmptyPragmaHandler());
1861 }
A diagnostic that indicates a problem or potential problem.
void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map, SourceLocation Loc=SourceLocation())
Add the specified mapping to all diagnostics of the specified flavor.
Definition: Diagnostic.cpp:452
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::BumpPtrAllocator & getPreprocessorAllocator()
Definition: Preprocessor.h:839
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens...
Definition: Lexer.h:77
virtual void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace)
Callback invoked when a #pragma gcc diagnostic pop directive is read.
Definition: PPCallbacks.h:215
void setChangedSinceDeserialization()
Note that this identifier has changed since it was loaded from an AST file.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
void pushMappings(SourceLocation Loc)
Copies the current DiagMappings and pushes the new copy onto the top of the stack.
Definition: Diagnostic.cpp:98
Defines the clang::FileManager interface and associated types.
time_t getModificationTime() const
Definition: FileManager.h:91
void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler)
Add the specified pragma handler to this preprocessor.
Definition: Pragma.cpp:913
#pragma GCC error has been invoked.
Definition: PPCallbacks.h:195
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {...
Definition: Token.h:95
Defines the SourceManager interface.
virtual void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken)=0
Defines the clang::Module class, which describes a module in the source code.
void dumpMacroInfo(const IdentifierInfo *II)
SourceLocation getPragmaARCCFCodeAuditedLoc() const
The location of the currently-active #pragma clang arc_cf_code_audited begin.
StringRef P
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:335
Defines the clang::MacroInfo and clang::MacroDirective classes.
The pragma was introduced via the Microsoft __pragma(token-string).
Definition: Pragma.h:47
const NestedNameSpecifier * Specifier
virtual void PragmaWarningPush(SourceLocation Loc, int Level)
Callback invoked when a #pragma warning(push) directive is read.
Definition: PPCallbacks.h:236
bool isFromAST() const
Return true if the identifier in its current state was loaded from an AST file.
virtual void PragmaWarningPop(SourceLocation Loc)
Callback invoked when a #pragma warning(pop) directive is read.
Definition: PPCallbacks.h:240
bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value)
Parses a simple integer literal to get its numeric value.
void EnterToken(const Token &Tok)
Enters a token in the token stream to be lexed next.
void IgnorePragmas()
Install empty handlers for all pragmas (making them ignored).
Definition: Pragma.cpp:1855
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing)...
Definition: DiagnosticIDs.h:80
bool isStringLiteral(TokenKind K)
Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token...
Definition: TokenKinds.h:79
The pragma was introduced via the C99 _Pragma(string-literal).
Definition: Pragma.h:41
PragmaHandler * FindHandler(StringRef Name, bool IgnoreNull=true) const
FindHandler - Check to see if there is already a handler for the specified name.
Definition: Pragma.cpp:83
static Lexer * Create_PragmaLexer(SourceLocation SpellingLoc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned TokLen, Preprocessor &PP)
Create_PragmaLexer: Lexer constructor - Create a new lexer object for _Pragma expansion.
Definition: Lexer.cpp:187
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:36
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
Definition: Token.h:118
tok::TokenKind getKind() const
Definition: Token.h:90
One of these records is kept for each identifier that is lexed.
virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType)
Callback invoked when a #pragma clang __debug directive is read.
Definition: PPCallbacks.h:183
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
EmptyPragmaHandler(StringRef Name=StringRef())
Definition: Pragma.cpp:65
void EnterSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)
void AddPragma(PragmaHandler *Handler)
AddPragma - Add a pragma to this namespace.
Definition: Pragma.cpp:90
Module * LeaveSubmodule(bool ForPragma)
void HandlePragmaPushMacro(Token &Tok)
Handle #pragma push_macro.
Definition: Pragma.cpp:597
const TargetInfo & getTargetInfo() const
Definition: Preprocessor.h:828
Token - This structure provides full information about a lexed token.
Definition: Token.h:35
void setKind(tok::TokenKind K)
Definition: Token.h:91
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:827
Describes a module or submodule.
Definition: Module.h:65
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:461
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:214
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the &#39;spelling&#39; of the token at the given location; does not go up to the spelling location or ...
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:833
bool hasUDSuffix() const
Return true if this token is a string or character literal which has a ud-suffix. ...
Definition: Token.h:291
const FormatToken & Tok
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
void setIsAllowRedefinitionsWithoutWarning(bool Val)
Set the value of the IsAllowRedefinitionsWithoutWarning flag.
Definition: MacroInfo.h:156
bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group, diag::Severity Map, SourceLocation Loc=SourceLocation())
Change an entire diagnostic group (e.g.
Definition: Diagnostic.cpp:376
Defines the Diagnostic-related interfaces.
void CommitBacktrackedTokens()
Disable the last EnableBacktrackAtThisPos call.
Definition: PPCaching.cpp:32
Present this diagnostic as an error.
PragmaIntroducerKind
Describes how the pragma was introduced, e.g., with #pragma, _Pragma, or __pragma.
Definition: Pragma.h:32
void LexUnexpandedToken(Token &Result)
Just like Lex, but disables macro expansion of identifier tokens.
static bool LexModuleName(Preprocessor &PP, Token &Tok, llvm::SmallVectorImpl< std::pair< IdentifierInfo *, SourceLocation >> &ModuleName)
Definition: Pragma.cpp:783
void HandlePragmaPoison()
HandlePragmaPoison - Handle #pragma GCC poison. PoisonTok is the &#39;poison&#39;.
Definition: Pragma.cpp:414
PragmaMessageKind
Determines the kind of #pragma invoking a call to PragmaMessage.
Definition: PPCallbacks.h:187
void HandlePragmaIncludeAlias(Token &Tok)
Definition: Pragma.cpp:655
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:194
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
Definition: Module.cpp:317
virtual void PragmaAssumeNonNullBegin(SourceLocation Loc)
Callback invoked when a #pragma clang assume_nonnull begin directive is read.
Definition: PPCallbacks.h:245
StringRef Filename
Definition: Format.cpp:1602
#pragma GCC warning has been invoked.
Definition: PPCallbacks.h:192
static bool IsHeaderFile(const std::string &Filename)
void Backtrack()
Make Preprocessor re-lex the tokens that were lexed since EnableBacktrackAtThisPos() was previously c...
Definition: PPCaching.cpp:63
virtual void PragmaWarning(SourceLocation Loc, StringRef WarningSpec, ArrayRef< int > Ids)
Callback invoked when a #pragma warning directive is read.
Definition: PPCallbacks.h:231
void setAnnotationRange(SourceRange R)
Definition: Token.h:161
void HandlePragmaOnce(Token &OnceTok)
HandlePragmaOnce - Handle #pragma once. OnceTok is the &#39;once&#39;.
Definition: Pragma.cpp:390
void setAnnotationValue(void *val)
Definition: Token.h:228
Defines the clang::LangOptions interface.
SourceLocation End
bool isInvalid() const
Return true if this object is invalid or uninitialized.
void makeModuleVisible(Module *M, SourceLocation Loc)
PragmaNamespace * getIfNamespace() override
getIfNamespace - If this is a namespace, return it.
Definition: Pragma.h:118
void EnableBacktrackAtThisPos()
From the point that this method is called, and until CommitBacktrackedTokens() or Backtrack() is call...
Definition: PPCaching.cpp:26
unsigned getLine() const
Return the presumed line number of this location.
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file. ...
Definition: Token.h:124
Defines the clang::Preprocessor interface.
void setIsPoisoned(bool Value=true)
setIsPoisoned - Mark this identifier as poisoned.
void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler)
Remove the specific pragma handler from this preprocessor.
Definition: Pragma.cpp:944
static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, DiagnosticsEngine &Diags, Module *M)
Check that the given module is available, producing a diagnostic if not.
void setPragmaAssumeNonNullLoc(SourceLocation Loc)
Set the location of the currently-active #pragma clang assume_nonnull begin.
void HandlePragmaDependency(Token &DependencyTok)
HandlePragmaDependency - Handle #pragma GCC dependency "foo" blah.
Definition: Pragma.cpp:488
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
virtual ~PragmaHandler()
Represents an unpacked "presumed" location which can be presented to the user.
PPCallbacks * getPPCallbacks() const
Definition: Preprocessor.h:923
The result type of a method or function.
static bool LexModuleNameComponent(Preprocessor &PP, Token &Tok, std::pair< IdentifierInfo *, SourceLocation > &ModuleNameComponent, bool First)
Definition: Pragma.cpp:762
StringRef GetString() const
DirectoryLookup - This class represents one entry in the search list that specifies the search order ...
const char * getFilename() const
Return the presumed filename of this location.
Kind
Encodes a location in the source.
void setPragmaARCCFCodeAuditedLoc(SourceLocation Loc)
Set the location of the currently-active #pragma clang arc_cf_code_audited begin. ...
#pragma message has been invoked.
Definition: PPCallbacks.h:189
All of the names in this module are hidden.
Definition: Module.h:269
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:177
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
void Lex(Token &Result)
Lex the next token for this preprocessor.
bool isPoisoned() const
Return true if this token has been poisoned.
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:266
Flavor
Flavors of diagnostics we can emit.
Definition: DiagnosticIDs.h:91
SourceLocation getPragmaAssumeNonNullLoc() const
The location of the currently-active #pragma clang assume_nonnull begin.
void HandlePragmaHdrstop(Token &Tok)
Definition: Pragma.cpp:879
StringRef getName() const
Return the actual identifier string.
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
Dataflow Directional Tag Classes.
bool isValid() const
Return true if this is a valid SourceLocation object.
~PragmaNamespace() override
Definition: Pragma.cpp:75
const FileEntry * getFileEntry() const
getFileEntry - Return the FileEntry corresponding to this FileID.
void HandlePragmaPopMacro(Token &Tok)
Handle #pragma pop_macro.
Definition: Pragma.cpp:620
virtual PragmaNamespace * getIfNamespace()
getIfNamespace - If this is a namespace, return it.
Definition: Pragma.h:73
PragmaHandler - Instances of this interface defined to handle the various pragmas that the language f...
Definition: Pragma.h:59
virtual ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective)=0
Attempt to load the given module.
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) override
Definition: Pragma.cpp:102
void RemovePragmaHandler(PragmaHandler *Handler)
RemovePragmaHandler - Remove the given handler from the namespace.
Definition: Pragma.cpp:96
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
OnOffSwitch
Defines the possible values of an on-off-switch (C99 6.10.6p2).
Definition: TokenKinds.h:49
PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas, allowing hierarchical pragm...
Definition: Pragma.h:90
bool FinishLexStringLiteral(Token &Result, std::string &String, const char *DiagnosticTag, bool AllowMacroExpansion)
Complete the lexing of a string literal where the first token has already been lexed (see LexStringLi...
bool popMappings(SourceLocation Loc)
Pops the current DiagMappings off the top of the stack, causing the new top of the stack to be the ac...
Definition: Diagnostic.cpp:102
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true, bool AllowExtraModuleMapSearch=false)
Lookup a module Search for a module with the given name.
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with this preprocessor.
Definition: Preprocessor.h:854
bool IsEmpty() const
Definition: Pragma.h:113
IdentifierInfo * ParsePragmaPushOrPopMacro(Token &Tok)
ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
Definition: Pragma.cpp:542
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override
Definition: Pragma.cpp:67
void CheckEndOfDirective(const char *DirType, bool EnableMacros=false)
Ensure that the next token is a tok::eod token.
Defines the PPCallbacks interface.
Defines the clang::TokenKind enum and support functions.
void EraseCachedTokens(CachedTokensRange TokenRange)
Erase the range of cached tokens that were lexed since EnableBacktrackAtThisPos() was previously call...
Definition: PPCaching.cpp:44
virtual void PragmaAssumeNonNullEnd(SourceLocation Loc)
Callback invoked when a #pragma clang assume_nonnull end directive is read.
Definition: PPCallbacks.h:249
Defines the clang::SourceLocation class and associated facilities.
bool LexOnOffSwitch(tok::OnOffSwitch &Result)
Lex an on-off-switch (C99 6.10.6p2) and verify that it is followed by EOD.
Definition: Pragma.cpp:966
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:824
CachedTokensRange LastCachedTokenRange()
Returns the range of cached tokens that were lexed since EnableBacktrackAtThisPos() was previously ca...
Definition: PPCaching.cpp:38
StringRef getRawIdentifier() const
getRawIdentifier - For a raw identifier token (i.e., an identifier lexed in raw mode), returns a reference to the text substring in the buffer if known.
Definition: Token.h:203
static bool isMacroDefined(const Sema &S, SourceLocation Loc, StringRef Name)
Do not present this diagnostic, ignore it.
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
virtual void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace)
Callback invoked when a #pragma gcc diagnostic push directive is read.
Definition: PPCallbacks.h:209
A diagnostic that indicates normal progress through compilation.
__DEVICE__ int max(int __a, int __b)
void HandlePragmaModuleBuild(Token &Tok)
Definition: Pragma.cpp:799
void HandlePragmaSystemHeader(Token &SysHeaderTok)
HandlePragmaSystemHeader - Implement #pragma GCC system_header.
Definition: Pragma.cpp:456
void DiscardUntilEndOfDirective()
Read and discard all tokens remaining on the current line until the tok::eod token is found...
Present this diagnostic as a fatal error.
virtual void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace, diag::Severity mapping, StringRef Str)
Callback invoked when a #pragma gcc diagnostic directive is read.
Definition: PPCallbacks.h:220
A trivial tuple used to represent a source range.
void HandlePragmaMark()
Definition: Pragma.cpp:405
Present this diagnostic as a warning.
StringRef getName() const
Definition: Pragma.h:67
void EnterAnnotationToken(SourceRange Range, tok::TokenKind Kind, void *AnnotationVal)
Enter an annotation token into the token stream.
Defines the PreprocessorLexer interface.
bool isPreprocessedOutput() const
Returns true if the preprocessor is responsible for generating output, false if it is producing token...
Definition: Preprocessor.h:892
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
LLVM_DUMP_METHOD void dump() const
Definition: Diagnostic.h:489
void startToken()
Reset all flags to cleared.
Definition: Token.h:169
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127