clang  6.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 /// \brief 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 /// \brief 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 /// \brief 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 
879 /// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
880 /// If 'Namespace' is non-null, then it is a token required to exist on the
881 /// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
882 void Preprocessor::AddPragmaHandler(StringRef Namespace,
883  PragmaHandler *Handler) {
884  PragmaNamespace *InsertNS = PragmaHandlers.get();
885 
886  // If this is specified to be in a namespace, step down into it.
887  if (!Namespace.empty()) {
888  // If there is already a pragma handler with the name of this namespace,
889  // we either have an error (directive with the same name as a namespace) or
890  // we already have the namespace to insert into.
891  if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
892  InsertNS = Existing->getIfNamespace();
893  assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
894  " handler with the same name!");
895  } else {
896  // Otherwise, this namespace doesn't exist yet, create and insert the
897  // handler for it.
898  InsertNS = new PragmaNamespace(Namespace);
899  PragmaHandlers->AddPragma(InsertNS);
900  }
901  }
902 
903  // Check to make sure we don't already have a pragma for this identifier.
904  assert(!InsertNS->FindHandler(Handler->getName()) &&
905  "Pragma handler already exists for this identifier!");
906  InsertNS->AddPragma(Handler);
907 }
908 
909 /// RemovePragmaHandler - Remove the specific pragma handler from the
910 /// preprocessor. If \arg Namespace is non-null, then it should be the
911 /// namespace that \arg Handler was added to. It is an error to remove
912 /// a handler that has not been registered.
913 void Preprocessor::RemovePragmaHandler(StringRef Namespace,
914  PragmaHandler *Handler) {
915  PragmaNamespace *NS = PragmaHandlers.get();
916 
917  // If this is specified to be in a namespace, step down into it.
918  if (!Namespace.empty()) {
919  PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
920  assert(Existing && "Namespace containing handler does not exist!");
921 
922  NS = Existing->getIfNamespace();
923  assert(NS && "Invalid namespace, registered as a regular pragma handler!");
924  }
925 
926  NS->RemovePragmaHandler(Handler);
927 
928  // If this is a non-default namespace and it is now empty, remove it.
929  if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
930  PragmaHandlers->RemovePragmaHandler(NS);
931  delete NS;
932  }
933 }
934 
936  Token Tok;
937  LexUnexpandedToken(Tok);
938 
939  if (Tok.isNot(tok::identifier)) {
940  Diag(Tok, diag::ext_on_off_switch_syntax);
941  return true;
942  }
943  IdentifierInfo *II = Tok.getIdentifierInfo();
944  if (II->isStr("ON"))
945  Result = tok::OOS_ON;
946  else if (II->isStr("OFF"))
947  Result = tok::OOS_OFF;
948  else if (II->isStr("DEFAULT"))
949  Result = tok::OOS_DEFAULT;
950  else {
951  Diag(Tok, diag::ext_on_off_switch_syntax);
952  return true;
953  }
954 
955  // Verify that this is followed by EOD.
956  LexUnexpandedToken(Tok);
957  if (Tok.isNot(tok::eod))
958  Diag(Tok, diag::ext_pragma_syntax_eod);
959  return false;
960 }
961 
962 namespace {
963 
964 /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
965 struct PragmaOnceHandler : public PragmaHandler {
966  PragmaOnceHandler() : PragmaHandler("once") {}
967 
968  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
969  Token &OnceTok) override {
970  PP.CheckEndOfDirective("pragma once");
971  PP.HandlePragmaOnce(OnceTok);
972  }
973 };
974 
975 /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
976 /// rest of the line is not lexed.
977 struct PragmaMarkHandler : public PragmaHandler {
978  PragmaMarkHandler() : PragmaHandler("mark") {}
979 
980  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
981  Token &MarkTok) override {
982  PP.HandlePragmaMark();
983  }
984 };
985 
986 /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
987 struct PragmaPoisonHandler : public PragmaHandler {
988  PragmaPoisonHandler() : PragmaHandler("poison") {}
989 
990  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
991  Token &PoisonTok) override {
992  PP.HandlePragmaPoison();
993  }
994 };
995 
996 /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
997 /// as a system header, which silences warnings in it.
998 struct PragmaSystemHeaderHandler : public PragmaHandler {
999  PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}
1000 
1001  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1002  Token &SHToken) override {
1003  PP.HandlePragmaSystemHeader(SHToken);
1004  PP.CheckEndOfDirective("pragma");
1005  }
1006 };
1007 
1008 struct PragmaDependencyHandler : public PragmaHandler {
1009  PragmaDependencyHandler() : PragmaHandler("dependency") {}
1010 
1011  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1012  Token &DepToken) override {
1013  PP.HandlePragmaDependency(DepToken);
1014  }
1015 };
1016 
1017 struct PragmaDebugHandler : public PragmaHandler {
1018  PragmaDebugHandler() : PragmaHandler("__debug") {}
1019 
1020  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1021  Token &DepToken) override {
1022  Token Tok;
1023  PP.LexUnexpandedToken(Tok);
1024  if (Tok.isNot(tok::identifier)) {
1025  PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1026  return;
1027  }
1028  IdentifierInfo *II = Tok.getIdentifierInfo();
1029 
1030  if (II->isStr("assert")) {
1031  llvm_unreachable("This is an assertion!");
1032  } else if (II->isStr("crash")) {
1033  LLVM_BUILTIN_TRAP;
1034  } else if (II->isStr("parser_crash")) {
1035  Token Crasher;
1036  Crasher.startToken();
1037  Crasher.setKind(tok::annot_pragma_parser_crash);
1038  Crasher.setAnnotationRange(SourceRange(Tok.getLocation()));
1039  PP.EnterToken(Crasher);
1040  } else if (II->isStr("dump")) {
1041  Token Identifier;
1042  PP.LexUnexpandedToken(Identifier);
1043  if (auto *DumpII = Identifier.getIdentifierInfo()) {
1044  Token DumpAnnot;
1045  DumpAnnot.startToken();
1046  DumpAnnot.setKind(tok::annot_pragma_dump);
1047  DumpAnnot.setAnnotationRange(
1048  SourceRange(Tok.getLocation(), Identifier.getLocation()));
1049  DumpAnnot.setAnnotationValue(DumpII);
1051  PP.EnterToken(DumpAnnot);
1052  } else {
1053  PP.Diag(Identifier, diag::warn_pragma_debug_missing_argument)
1054  << II->getName();
1055  }
1056  } else if (II->isStr("llvm_fatal_error")) {
1057  llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
1058  } else if (II->isStr("llvm_unreachable")) {
1059  llvm_unreachable("#pragma clang __debug llvm_unreachable");
1060  } else if (II->isStr("macro")) {
1061  Token MacroName;
1062  PP.LexUnexpandedToken(MacroName);
1063  auto *MacroII = MacroName.getIdentifierInfo();
1064  if (MacroII)
1065  PP.dumpMacroInfo(MacroII);
1066  else
1067  PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
1068  << II->getName();
1069  } else if (II->isStr("overflow_stack")) {
1070  DebugOverflowStack();
1071  } else if (II->isStr("handle_crash")) {
1072  llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent();
1073  if (CRC)
1074  CRC->HandleCrash();
1075  } else if (II->isStr("captured")) {
1076  HandleCaptured(PP);
1077  } else {
1078  PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1079  << II->getName();
1080  }
1081 
1082  PPCallbacks *Callbacks = PP.getPPCallbacks();
1083  if (Callbacks)
1084  Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
1085  }
1086 
1087  void HandleCaptured(Preprocessor &PP) {
1088  // Skip if emitting preprocessed output.
1089  if (PP.isPreprocessedOutput())
1090  return;
1091 
1092  Token Tok;
1093  PP.LexUnexpandedToken(Tok);
1094 
1095  if (Tok.isNot(tok::eod)) {
1096  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
1097  << "pragma clang __debug captured";
1098  return;
1099  }
1100 
1101  SourceLocation NameLoc = Tok.getLocation();
1103  PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
1104  Toks[0].startToken();
1105  Toks[0].setKind(tok::annot_pragma_captured);
1106  Toks[0].setLocation(NameLoc);
1107 
1108  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
1109  }
1110 
1111 // Disable MSVC warning about runtime stack overflow.
1112 #ifdef _MSC_VER
1113  #pragma warning(disable : 4717)
1114 #endif
1115  static void DebugOverflowStack(void (*P)() = nullptr) {
1116  void (*volatile Self)(void(*P)()) = DebugOverflowStack;
1117  Self(reinterpret_cast<void(*)()>(Self));
1118  }
1119 #ifdef _MSC_VER
1120  #pragma warning(default : 4717)
1121 #endif
1122 };
1123 
1124 /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
1125 struct PragmaDiagnosticHandler : public PragmaHandler {
1126 private:
1127  const char *Namespace;
1128 
1129 public:
1130  explicit PragmaDiagnosticHandler(const char *NS)
1131  : PragmaHandler("diagnostic"), Namespace(NS) {}
1132 
1133  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1134  Token &DiagToken) override {
1135  SourceLocation DiagLoc = DiagToken.getLocation();
1136  Token Tok;
1137  PP.LexUnexpandedToken(Tok);
1138  if (Tok.isNot(tok::identifier)) {
1139  PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1140  return;
1141  }
1142  IdentifierInfo *II = Tok.getIdentifierInfo();
1143  PPCallbacks *Callbacks = PP.getPPCallbacks();
1144 
1145  if (II->isStr("pop")) {
1146  if (!PP.getDiagnostics().popMappings(DiagLoc))
1147  PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
1148  else if (Callbacks)
1149  Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
1150  return;
1151  } else if (II->isStr("push")) {
1152  PP.getDiagnostics().pushMappings(DiagLoc);
1153  if (Callbacks)
1154  Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
1155  return;
1156  }
1157 
1158  diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
1159  .Case("ignored", diag::Severity::Ignored)
1160  .Case("warning", diag::Severity::Warning)
1161  .Case("error", diag::Severity::Error)
1162  .Case("fatal", diag::Severity::Fatal)
1163  .Default(diag::Severity());
1164 
1165  if (SV == diag::Severity()) {
1166  PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1167  return;
1168  }
1169 
1170  PP.LexUnexpandedToken(Tok);
1171  SourceLocation StringLoc = Tok.getLocation();
1172 
1173  std::string WarningName;
1174  if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
1175  /*MacroExpansion=*/false))
1176  return;
1177 
1178  if (Tok.isNot(tok::eod)) {
1179  PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1180  return;
1181  }
1182 
1183  if (WarningName.size() < 3 || WarningName[0] != '-' ||
1184  (WarningName[1] != 'W' && WarningName[1] != 'R')) {
1185  PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
1186  return;
1187  }
1188 
1189  diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
1191  StringRef Group = StringRef(WarningName).substr(2);
1192  bool unknownDiag = false;
1193  if (Group == "everything") {
1194  // Special handling for pragma clang diagnostic ... "-Weverything".
1195  // There is no formal group named "everything", so there has to be a
1196  // special case for it.
1197  PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
1198  } else
1199  unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
1200  DiagLoc);
1201  if (unknownDiag)
1202  PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
1203  << WarningName;
1204  else if (Callbacks)
1205  Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
1206  }
1207 };
1208 
1209 /// "\#pragma warning(...)". MSVC's diagnostics do not map cleanly to clang's
1210 /// diagnostics, so we don't really implement this pragma. We parse it and
1211 /// ignore it to avoid -Wunknown-pragma warnings.
1212 struct PragmaWarningHandler : public PragmaHandler {
1213  PragmaWarningHandler() : PragmaHandler("warning") {}
1214 
1215  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1216  Token &Tok) override {
1217  // Parse things like:
1218  // warning(push, 1)
1219  // warning(pop)
1220  // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
1221  SourceLocation DiagLoc = Tok.getLocation();
1222  PPCallbacks *Callbacks = PP.getPPCallbacks();
1223 
1224  PP.Lex(Tok);
1225  if (Tok.isNot(tok::l_paren)) {
1226  PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
1227  return;
1228  }
1229 
1230  PP.Lex(Tok);
1231  IdentifierInfo *II = Tok.getIdentifierInfo();
1232 
1233  if (II && II->isStr("push")) {
1234  // #pragma warning( push[ ,n ] )
1235  int Level = -1;
1236  PP.Lex(Tok);
1237  if (Tok.is(tok::comma)) {
1238  PP.Lex(Tok);
1239  uint64_t Value;
1240  if (Tok.is(tok::numeric_constant) &&
1241  PP.parseSimpleIntegerLiteral(Tok, Value))
1242  Level = int(Value);
1243  if (Level < 0 || Level > 4) {
1244  PP.Diag(Tok, diag::warn_pragma_warning_push_level);
1245  return;
1246  }
1247  }
1248  if (Callbacks)
1249  Callbacks->PragmaWarningPush(DiagLoc, Level);
1250  } else if (II && II->isStr("pop")) {
1251  // #pragma warning( pop )
1252  PP.Lex(Tok);
1253  if (Callbacks)
1254  Callbacks->PragmaWarningPop(DiagLoc);
1255  } else {
1256  // #pragma warning( warning-specifier : warning-number-list
1257  // [; warning-specifier : warning-number-list...] )
1258  while (true) {
1259  II = Tok.getIdentifierInfo();
1260  if (!II && !Tok.is(tok::numeric_constant)) {
1261  PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1262  return;
1263  }
1264 
1265  // Figure out which warning specifier this is.
1266  bool SpecifierValid;
1267  StringRef Specifier;
1268  llvm::SmallString<1> SpecifierBuf;
1269  if (II) {
1270  Specifier = II->getName();
1271  SpecifierValid = llvm::StringSwitch<bool>(Specifier)
1272  .Cases("default", "disable", "error", "once",
1273  "suppress", true)
1274  .Default(false);
1275  // If we read a correct specifier, snatch next token (that should be
1276  // ":", checked later).
1277  if (SpecifierValid)
1278  PP.Lex(Tok);
1279  } else {
1280  // Token is a numeric constant. It should be either 1, 2, 3 or 4.
1281  uint64_t Value;
1282  Specifier = PP.getSpelling(Tok, SpecifierBuf);
1283  if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
1284  SpecifierValid = (Value >= 1) && (Value <= 4);
1285  } else
1286  SpecifierValid = false;
1287  // Next token already snatched by parseSimpleIntegerLiteral.
1288  }
1289 
1290  if (!SpecifierValid) {
1291  PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1292  return;
1293  }
1294  if (Tok.isNot(tok::colon)) {
1295  PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
1296  return;
1297  }
1298 
1299  // Collect the warning ids.
1300  SmallVector<int, 4> Ids;
1301  PP.Lex(Tok);
1302  while (Tok.is(tok::numeric_constant)) {
1303  uint64_t Value;
1304  if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
1305  Value > std::numeric_limits<int>::max()) {
1306  PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
1307  return;
1308  }
1309  Ids.push_back(int(Value));
1310  }
1311  if (Callbacks)
1312  Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
1313 
1314  // Parse the next specifier if there is a semicolon.
1315  if (Tok.isNot(tok::semi))
1316  break;
1317  PP.Lex(Tok);
1318  }
1319  }
1320 
1321  if (Tok.isNot(tok::r_paren)) {
1322  PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
1323  return;
1324  }
1325 
1326  PP.Lex(Tok);
1327  if (Tok.isNot(tok::eod))
1328  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
1329  }
1330 };
1331 
1332 /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1333 struct PragmaIncludeAliasHandler : public PragmaHandler {
1334  PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}
1335 
1336  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1337  Token &IncludeAliasTok) override {
1338  PP.HandlePragmaIncludeAlias(IncludeAliasTok);
1339  }
1340 };
1341 
1342 /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message
1343 /// extension. The syntax is:
1344 /// \code
1345 /// #pragma message(string)
1346 /// \endcode
1347 /// OR, in GCC mode:
1348 /// \code
1349 /// #pragma message string
1350 /// \endcode
1351 /// string is a string, which is fully macro expanded, and permits string
1352 /// concatenation, embedded escape characters, etc... See MSDN for more details.
1353 /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same
1354 /// form as \#pragma message.
1355 struct PragmaMessageHandler : public PragmaHandler {
1356 private:
1358  const StringRef Namespace;
1359 
1360  static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
1361  bool PragmaNameOnly = false) {
1362  switch (Kind) {
1364  return PragmaNameOnly ? "message" : "pragma message";
1366  return PragmaNameOnly ? "warning" : "pragma warning";
1368  return PragmaNameOnly ? "error" : "pragma error";
1369  }
1370  llvm_unreachable("Unknown PragmaMessageKind!");
1371  }
1372 
1373 public:
1374  PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
1375  StringRef Namespace = StringRef())
1376  : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind),
1377  Namespace(Namespace) {}
1378 
1379  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1380  Token &Tok) override {
1381  SourceLocation MessageLoc = Tok.getLocation();
1382  PP.Lex(Tok);
1383  bool ExpectClosingParen = false;
1384  switch (Tok.getKind()) {
1385  case tok::l_paren:
1386  // We have a MSVC style pragma message.
1387  ExpectClosingParen = true;
1388  // Read the string.
1389  PP.Lex(Tok);
1390  break;
1391  case tok::string_literal:
1392  // We have a GCC style pragma message, and we just read the string.
1393  break;
1394  default:
1395  PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
1396  return;
1397  }
1398 
1399  std::string MessageString;
1400  if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
1401  /*MacroExpansion=*/true))
1402  return;
1403 
1404  if (ExpectClosingParen) {
1405  if (Tok.isNot(tok::r_paren)) {
1406  PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1407  return;
1408  }
1409  PP.Lex(Tok); // eat the r_paren.
1410  }
1411 
1412  if (Tok.isNot(tok::eod)) {
1413  PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1414  return;
1415  }
1416 
1417  // Output the message.
1418  PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
1419  ? diag::err_pragma_message
1420  : diag::warn_pragma_message) << MessageString;
1421 
1422  // If the pragma is lexically sound, notify any interested PPCallbacks.
1423  if (PPCallbacks *Callbacks = PP.getPPCallbacks())
1424  Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
1425  }
1426 };
1427 
1428 /// Handle the clang \#pragma module import extension. The syntax is:
1429 /// \code
1430 /// #pragma clang module import some.module.name
1431 /// \endcode
1432 struct PragmaModuleImportHandler : public PragmaHandler {
1433  PragmaModuleImportHandler() : PragmaHandler("import") {}
1434 
1435  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1436  Token &Tok) override {
1437  SourceLocation ImportLoc = Tok.getLocation();
1438 
1439  // Read the module name.
1441  ModuleName;
1442  if (LexModuleName(PP, Tok, ModuleName))
1443  return;
1444 
1445  if (Tok.isNot(tok::eod))
1446  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1447 
1448  // If we have a non-empty module path, load the named module.
1449  Module *Imported =
1450  PP.getModuleLoader().loadModule(ImportLoc, ModuleName, Module::Hidden,
1451  /*IsIncludeDirective=*/false);
1452  if (!Imported)
1453  return;
1454 
1455  PP.makeModuleVisible(Imported, ImportLoc);
1456  PP.EnterAnnotationToken(SourceRange(ImportLoc, ModuleName.back().second),
1457  tok::annot_module_include, Imported);
1458  if (auto *CB = PP.getPPCallbacks())
1459  CB->moduleImport(ImportLoc, ModuleName, Imported);
1460  }
1461 };
1462 
1463 /// Handle the clang \#pragma module begin extension. The syntax is:
1464 /// \code
1465 /// #pragma clang module begin some.module.name
1466 /// ...
1467 /// #pragma clang module end
1468 /// \endcode
1469 struct PragmaModuleBeginHandler : public PragmaHandler {
1470  PragmaModuleBeginHandler() : PragmaHandler("begin") {}
1471 
1472  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1473  Token &Tok) override {
1474  SourceLocation BeginLoc = Tok.getLocation();
1475 
1476  // Read the module name.
1478  ModuleName;
1479  if (LexModuleName(PP, Tok, ModuleName))
1480  return;
1481 
1482  if (Tok.isNot(tok::eod))
1483  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1484 
1485  // We can only enter submodules of the current module.
1486  StringRef Current = PP.getLangOpts().CurrentModule;
1487  if (ModuleName.front().first->getName() != Current) {
1488  PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module)
1489  << ModuleName.front().first << (ModuleName.size() > 1)
1490  << Current.empty() << Current;
1491  return;
1492  }
1493 
1494  // Find the module we're entering. We require that a module map for it
1495  // be loaded or implicitly loadable.
1496  // FIXME: We could create the submodule here. We'd need to know whether
1497  // it's supposed to be explicit, but not much else.
1498  Module *M = PP.getHeaderSearchInfo().lookupModule(Current);
1499  if (!M) {
1500  PP.Diag(ModuleName.front().second,
1501  diag::err_pp_module_begin_no_module_map) << Current;
1502  return;
1503  }
1504  for (unsigned I = 1; I != ModuleName.size(); ++I) {
1505  auto *NewM = M->findSubmodule(ModuleName[I].first->getName());
1506  if (!NewM) {
1507  PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule)
1508  << M->getFullModuleName() << ModuleName[I].first;
1509  return;
1510  }
1511  M = NewM;
1512  }
1513 
1514  // If the module isn't available, it doesn't make sense to enter it.
1516  PP.getLangOpts(), PP.getTargetInfo(), PP.getDiagnostics(), M)) {
1517  PP.Diag(BeginLoc, diag::note_pp_module_begin_here)
1518  << M->getTopLevelModuleName();
1519  return;
1520  }
1521 
1522  // Enter the scope of the submodule.
1523  PP.EnterSubmodule(M, BeginLoc, /*ForPragma*/true);
1524  PP.EnterAnnotationToken(SourceRange(BeginLoc, ModuleName.back().second),
1525  tok::annot_module_begin, M);
1526  }
1527 };
1528 
1529 /// Handle the clang \#pragma module end extension.
1530 struct PragmaModuleEndHandler : public PragmaHandler {
1531  PragmaModuleEndHandler() : PragmaHandler("end") {}
1532 
1533  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1534  Token &Tok) override {
1535  SourceLocation Loc = Tok.getLocation();
1536 
1537  PP.LexUnexpandedToken(Tok);
1538  if (Tok.isNot(tok::eod))
1539  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1540 
1541  Module *M = PP.LeaveSubmodule(/*ForPragma*/true);
1542  if (M)
1543  PP.EnterAnnotationToken(SourceRange(Loc), tok::annot_module_end, M);
1544  else
1545  PP.Diag(Loc, diag::err_pp_module_end_without_module_begin);
1546  }
1547 };
1548 
1549 /// Handle the clang \#pragma module build extension.
1550 struct PragmaModuleBuildHandler : public PragmaHandler {
1551  PragmaModuleBuildHandler() : PragmaHandler("build") {}
1552 
1553  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1554  Token &Tok) override {
1555  PP.HandlePragmaModuleBuild(Tok);
1556  }
1557 };
1558 
1559 /// Handle the clang \#pragma module load extension.
1560 struct PragmaModuleLoadHandler : public PragmaHandler {
1561  PragmaModuleLoadHandler() : PragmaHandler("load") {}
1562 
1563  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1564  Token &Tok) override {
1565  SourceLocation Loc = Tok.getLocation();
1566 
1567  // Read the module name.
1569  ModuleName;
1570  if (LexModuleName(PP, Tok, ModuleName))
1571  return;
1572 
1573  if (Tok.isNot(tok::eod))
1574  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1575 
1576  // Load the module, don't make it visible.
1577  PP.getModuleLoader().loadModule(Loc, ModuleName, Module::Hidden,
1578  /*IsIncludeDirective=*/false);
1579  }
1580 };
1581 
1582 /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1583 /// macro on the top of the stack.
1584 struct PragmaPushMacroHandler : public PragmaHandler {
1585  PragmaPushMacroHandler() : PragmaHandler("push_macro") {}
1586 
1587  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1588  Token &PushMacroTok) override {
1589  PP.HandlePragmaPushMacro(PushMacroTok);
1590  }
1591 };
1592 
1593 /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the
1594 /// macro to the value on the top of the stack.
1595 struct PragmaPopMacroHandler : public PragmaHandler {
1596  PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}
1597 
1598  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1599  Token &PopMacroTok) override {
1600  PP.HandlePragmaPopMacro(PopMacroTok);
1601  }
1602 };
1603 
1604 // Pragma STDC implementations.
1605 
1606 /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...".
1607 struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler {
1608  PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {}
1609 
1610  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1611  Token &Tok) override {
1612  tok::OnOffSwitch OOS;
1613  if (PP.LexOnOffSwitch(OOS))
1614  return;
1615  if (OOS == tok::OOS_ON)
1616  PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported);
1617  }
1618 };
1619 
1620 /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...".
1621 struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler {
1622  PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {}
1623 
1624  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1625  Token &Tok) override {
1626  tok::OnOffSwitch OOS;
1627  PP.LexOnOffSwitch(OOS);
1628  }
1629 };
1630 
1631 /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...".
1632 struct PragmaSTDC_UnknownHandler : public PragmaHandler {
1633  PragmaSTDC_UnknownHandler() = default;
1634 
1635  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1636  Token &UnknownTok) override {
1637  // C99 6.10.6p2, unknown forms are not allowed.
1638  PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored);
1639  }
1640 };
1641 
1642 /// PragmaARCCFCodeAuditedHandler -
1643 /// \#pragma clang arc_cf_code_audited begin/end
1644 struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
1645  PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}
1646 
1647  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1648  Token &NameTok) override {
1649  SourceLocation Loc = NameTok.getLocation();
1650  bool IsBegin;
1651 
1652  Token Tok;
1653 
1654  // Lex the 'begin' or 'end'.
1655  PP.LexUnexpandedToken(Tok);
1656  const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1657  if (BeginEnd && BeginEnd->isStr("begin")) {
1658  IsBegin = true;
1659  } else if (BeginEnd && BeginEnd->isStr("end")) {
1660  IsBegin = false;
1661  } else {
1662  PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
1663  return;
1664  }
1665 
1666  // Verify that this is followed by EOD.
1667  PP.LexUnexpandedToken(Tok);
1668  if (Tok.isNot(tok::eod))
1669  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1670 
1671  // The start location of the active audit.
1673 
1674  // The start location we want after processing this.
1675  SourceLocation NewLoc;
1676 
1677  if (IsBegin) {
1678  // Complain about attempts to re-enter an audit.
1679  if (BeginLoc.isValid()) {
1680  PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
1681  PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1682  }
1683  NewLoc = Loc;
1684  } else {
1685  // Complain about attempts to leave an audit that doesn't exist.
1686  if (!BeginLoc.isValid()) {
1687  PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
1688  return;
1689  }
1690  NewLoc = SourceLocation();
1691  }
1692 
1693  PP.setPragmaARCCFCodeAuditedLoc(NewLoc);
1694  }
1695 };
1696 
1697 /// PragmaAssumeNonNullHandler -
1698 /// \#pragma clang assume_nonnull begin/end
1699 struct PragmaAssumeNonNullHandler : public PragmaHandler {
1700  PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}
1701 
1702  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1703  Token &NameTok) override {
1704  SourceLocation Loc = NameTok.getLocation();
1705  bool IsBegin;
1706 
1707  Token Tok;
1708 
1709  // Lex the 'begin' or 'end'.
1710  PP.LexUnexpandedToken(Tok);
1711  const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1712  if (BeginEnd && BeginEnd->isStr("begin")) {
1713  IsBegin = true;
1714  } else if (BeginEnd && BeginEnd->isStr("end")) {
1715  IsBegin = false;
1716  } else {
1717  PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
1718  return;
1719  }
1720 
1721  // Verify that this is followed by EOD.
1722  PP.LexUnexpandedToken(Tok);
1723  if (Tok.isNot(tok::eod))
1724  PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1725 
1726  // The start location of the active audit.
1727  SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc();
1728 
1729  // The start location we want after processing this.
1730  SourceLocation NewLoc;
1731  PPCallbacks *Callbacks = PP.getPPCallbacks();
1732 
1733  if (IsBegin) {
1734  // Complain about attempts to re-enter an audit.
1735  if (BeginLoc.isValid()) {
1736  PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
1737  PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1738  }
1739  NewLoc = Loc;
1740  if (Callbacks)
1741  Callbacks->PragmaAssumeNonNullBegin(NewLoc);
1742  } else {
1743  // Complain about attempts to leave an audit that doesn't exist.
1744  if (!BeginLoc.isValid()) {
1745  PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
1746  return;
1747  }
1748  NewLoc = SourceLocation();
1749  if (Callbacks)
1750  Callbacks->PragmaAssumeNonNullEnd(NewLoc);
1751  }
1752 
1753  PP.setPragmaAssumeNonNullLoc(NewLoc);
1754  }
1755 };
1756 
1757 /// \brief Handle "\#pragma region [...]"
1758 ///
1759 /// The syntax is
1760 /// \code
1761 /// #pragma region [optional name]
1762 /// #pragma endregion [optional comment]
1763 /// \endcode
1764 ///
1765 /// \note This is
1766 /// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a>
1767 /// pragma, just skipped by compiler.
1768 struct PragmaRegionHandler : public PragmaHandler {
1769  PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {}
1770 
1771  void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1772  Token &NameTok) override {
1773  // #pragma region: endregion matches can be verified
1774  // __pragma(region): no sense, but ignored by msvc
1775  // _Pragma is not valid for MSVC, but there isn't any point
1776  // to handle a _Pragma differently.
1777  }
1778 };
1779 
1780 } // namespace
1781 
1782 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
1783 /// \#pragma GCC poison/system_header/dependency and \#pragma once.
1784 void Preprocessor::RegisterBuiltinPragmas() {
1785  AddPragmaHandler(new PragmaOnceHandler());
1786  AddPragmaHandler(new PragmaMarkHandler());
1787  AddPragmaHandler(new PragmaPushMacroHandler());
1788  AddPragmaHandler(new PragmaPopMacroHandler());
1789  AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));
1790 
1791  // #pragma GCC ...
1792  AddPragmaHandler("GCC", new PragmaPoisonHandler());
1793  AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
1794  AddPragmaHandler("GCC", new PragmaDependencyHandler());
1795  AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
1796  AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
1797  "GCC"));
1798  AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
1799  "GCC"));
1800  // #pragma clang ...
1801  AddPragmaHandler("clang", new PragmaPoisonHandler());
1802  AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
1803  AddPragmaHandler("clang", new PragmaDebugHandler());
1804  AddPragmaHandler("clang", new PragmaDependencyHandler());
1805  AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
1806  AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
1807  AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
1808 
1809  // #pragma clang module ...
1810  auto *ModuleHandler = new PragmaNamespace("module");
1811  AddPragmaHandler("clang", ModuleHandler);
1812  ModuleHandler->AddPragma(new PragmaModuleImportHandler());
1813  ModuleHandler->AddPragma(new PragmaModuleBeginHandler());
1814  ModuleHandler->AddPragma(new PragmaModuleEndHandler());
1815  ModuleHandler->AddPragma(new PragmaModuleBuildHandler());
1816  ModuleHandler->AddPragma(new PragmaModuleLoadHandler());
1817 
1818  AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler());
1819  AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler());
1820  AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler());
1821 
1822  // MS extensions.
1823  if (LangOpts.MicrosoftExt) {
1824  AddPragmaHandler(new PragmaWarningHandler());
1825  AddPragmaHandler(new PragmaIncludeAliasHandler());
1826  AddPragmaHandler(new PragmaRegionHandler("region"));
1827  AddPragmaHandler(new PragmaRegionHandler("endregion"));
1828  }
1829 
1830  // Pragmas added by plugins
1831  for (PragmaHandlerRegistry::iterator it = PragmaHandlerRegistry::begin(),
1832  ie = PragmaHandlerRegistry::end();
1833  it != ie; ++it) {
1834  AddPragmaHandler(it->instantiate().release());
1835  }
1836 }
1837 
1838 /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
1839 /// warn about those pragmas being unknown.
1841  AddPragmaHandler(new EmptyPragmaHandler());
1842  // Also ignore all pragmas in all namespaces created
1843  // in Preprocessor::RegisterBuiltinPragmas().
1844  AddPragmaHandler("GCC", new EmptyPragmaHandler());
1845  AddPragmaHandler("clang", new EmptyPragmaHandler());
1846  if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) {
1847  // Preprocessor::RegisterBuiltinPragmas() already registers
1848  // PragmaSTDC_UnknownHandler as the empty handler, so remove it first,
1849  // otherwise there will be an assert about a duplicate handler.
1850  PragmaNamespace *STDCNamespace = NS->getIfNamespace();
1851  assert(STDCNamespace &&
1852  "Invalid namespace, registered as a regular pragma handler!");
1853  if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) {
1854  RemovePragmaHandler("STDC", Existing);
1855  delete Existing;
1856  }
1857  }
1858  AddPragmaHandler("STDC", new EmptyPragmaHandler());
1859 }
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:362
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:823
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:210
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:97
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:882
#pragma GCC error has been invoked.
Definition: PPCallbacks.h:190
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:247
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:231
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:235
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:1840
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:186
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:178
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override
Definition: Pragma.cpp:102
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:812
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:811
Describes a module or submodule.
Definition: Module.h:65
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:443
void CheckEndOfDirective(const char *Directive, bool EnableMacros=false)
Ensure that the next token is a tok::eod token.
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:169
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:817
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:286
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:182
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:131
Module * findSubmodule(StringRef Name) const
Find the submodule with the given name.
Definition: Module.cpp:272
virtual void PragmaAssumeNonNullBegin(SourceLocation Loc)
Callback invoked when a #pragma clang assume_nonnull begin directive is read.
Definition: PPCallbacks.h:240
StringRef Filename
Definition: Format.cpp:1345
#pragma GCC warning has been invoked.
Definition: PPCallbacks.h:187
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:226
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
bool LexOnOffSwitch(tok::OnOffSwitch &OOS)
Lex an on-off-switch (C99 6.10.6p2) and verify that it is followed by EOD.
Definition: Pragma.cpp:935
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:913
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
Accessors for preprocessor callbacks.
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:762
StringRef GetString() const
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true)
Lookup a module Search for a module with the given name.
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:184
All of the names in this module are hidden.
Definition: Module.h:262
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.
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 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:101
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:542
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer, Token &FirstToken) override
Definition: Pragma.cpp:67
Defines the PPCallbacks interface.
Defines the clang::TokenKind enum and support functions.
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
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:244
Defines the clang::SourceLocation class and associated facilities.
DiagnosticsEngine & getDiagnostics() const
Definition: Preprocessor.h:808
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:204
A diagnostic that indicates normal progress through compilation.
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:215
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:876
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:127