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