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