• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/FileManager.h"
17 #include "clang/Basic/SourceManager.h"
18 #include "clang/Lex/HeaderSearch.h"
19 #include "clang/Lex/LexDiagnostic.h"
20 #include "clang/Lex/LiteralSupport.h"
21 #include "clang/Lex/MacroInfo.h"
22 #include "clang/Lex/Preprocessor.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/StringSwitch.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/Support/CrashRecoveryContext.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include <algorithm>
29 using namespace clang;
30 
31 #include "llvm/Support/raw_ostream.h"
32 
33 // Out-of-line destructor to provide a home for the class.
~PragmaHandler()34 PragmaHandler::~PragmaHandler() {
35 }
36 
37 //===----------------------------------------------------------------------===//
38 // EmptyPragmaHandler Implementation.
39 //===----------------------------------------------------------------------===//
40 
EmptyPragmaHandler(StringRef Name)41 EmptyPragmaHandler::EmptyPragmaHandler(StringRef Name) : PragmaHandler(Name) {}
42 
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & FirstToken)43 void EmptyPragmaHandler::HandlePragma(Preprocessor &PP,
44                                       PragmaIntroducerKind Introducer,
45                                       Token &FirstToken) {}
46 
47 //===----------------------------------------------------------------------===//
48 // PragmaNamespace Implementation.
49 //===----------------------------------------------------------------------===//
50 
~PragmaNamespace()51 PragmaNamespace::~PragmaNamespace() {
52   llvm::DeleteContainerSeconds(Handlers);
53 }
54 
55 /// FindHandler - Check to see if there is already a handler for the
56 /// specified name.  If not, return the handler for the null identifier if it
57 /// exists, otherwise return null.  If IgnoreNull is true (the default) then
58 /// the null handler isn't returned on failure to match.
FindHandler(StringRef Name,bool IgnoreNull) const59 PragmaHandler *PragmaNamespace::FindHandler(StringRef Name,
60                                             bool IgnoreNull) const {
61   if (PragmaHandler *Handler = Handlers.lookup(Name))
62     return Handler;
63   return IgnoreNull ? nullptr : Handlers.lookup(StringRef());
64 }
65 
AddPragma(PragmaHandler * Handler)66 void PragmaNamespace::AddPragma(PragmaHandler *Handler) {
67   assert(!Handlers.lookup(Handler->getName()) &&
68          "A handler with this name is already registered in this namespace");
69   Handlers[Handler->getName()] = Handler;
70 }
71 
RemovePragmaHandler(PragmaHandler * Handler)72 void PragmaNamespace::RemovePragmaHandler(PragmaHandler *Handler) {
73   assert(Handlers.lookup(Handler->getName()) &&
74          "Handler not registered in this namespace");
75   Handlers.erase(Handler->getName());
76 }
77 
HandlePragma(Preprocessor & PP,PragmaIntroducerKind Introducer,Token & Tok)78 void PragmaNamespace::HandlePragma(Preprocessor &PP,
79                                    PragmaIntroducerKind Introducer,
80                                    Token &Tok) {
81   // Read the 'namespace' that the directive is in, e.g. STDC.  Do not macro
82   // expand it, the user can have a STDC #define, that should not affect this.
83   PP.LexUnexpandedToken(Tok);
84 
85   // Get the handler for this token.  If there is no handler, ignore the pragma.
86   PragmaHandler *Handler
87     = FindHandler(Tok.getIdentifierInfo() ? Tok.getIdentifierInfo()->getName()
88                                           : StringRef(),
89                   /*IgnoreNull=*/false);
90   if (!Handler) {
91     PP.Diag(Tok, diag::warn_pragma_ignored);
92     return;
93   }
94 
95   // Otherwise, pass it down.
96   Handler->HandlePragma(PP, Introducer, Tok);
97 }
98 
99 //===----------------------------------------------------------------------===//
100 // Preprocessor Pragma Directive Handling.
101 //===----------------------------------------------------------------------===//
102 
103 /// HandlePragmaDirective - The "\#pragma" directive has been parsed.  Lex the
104 /// rest of the pragma, passing it to the registered pragma handlers.
HandlePragmaDirective(SourceLocation IntroducerLoc,PragmaIntroducerKind Introducer)105 void Preprocessor::HandlePragmaDirective(SourceLocation IntroducerLoc,
106                                          PragmaIntroducerKind Introducer) {
107   if (Callbacks)
108     Callbacks->PragmaDirective(IntroducerLoc, Introducer);
109 
110   if (!PragmasEnabled)
111     return;
112 
113   ++NumPragma;
114 
115   // Invoke the first level of pragma handlers which reads the namespace id.
116   Token Tok;
117   PragmaHandlers->HandlePragma(*this, Introducer, Tok);
118 
119   // If the pragma handler didn't read the rest of the line, consume it now.
120   if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())
121    || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
122     DiscardUntilEndOfDirective();
123 }
124 
125 namespace {
126 /// \brief Helper class for \see Preprocessor::Handle_Pragma.
127 class LexingFor_PragmaRAII {
128   Preprocessor &PP;
129   bool InMacroArgPreExpansion;
130   bool Failed;
131   Token &OutTok;
132   Token PragmaTok;
133 
134 public:
LexingFor_PragmaRAII(Preprocessor & PP,bool InMacroArgPreExpansion,Token & Tok)135   LexingFor_PragmaRAII(Preprocessor &PP, bool InMacroArgPreExpansion,
136                        Token &Tok)
137     : PP(PP), InMacroArgPreExpansion(InMacroArgPreExpansion),
138       Failed(false), OutTok(Tok) {
139     if (InMacroArgPreExpansion) {
140       PragmaTok = OutTok;
141       PP.EnableBacktrackAtThisPos();
142     }
143   }
144 
~LexingFor_PragmaRAII()145   ~LexingFor_PragmaRAII() {
146     if (InMacroArgPreExpansion) {
147       if (Failed) {
148         PP.CommitBacktrackedTokens();
149       } else {
150         PP.Backtrack();
151         OutTok = PragmaTok;
152       }
153     }
154   }
155 
failed()156   void failed() {
157     Failed = true;
158   }
159 };
160 }
161 
162 /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then
163 /// return the first token after the directive.  The _Pragma token has just
164 /// been read into 'Tok'.
Handle_Pragma(Token & Tok)165 void Preprocessor::Handle_Pragma(Token &Tok) {
166 
167   // This works differently if we are pre-expanding a macro argument.
168   // In that case we don't actually "activate" the pragma now, we only lex it
169   // until we are sure it is lexically correct and then we backtrack so that
170   // we activate the pragma whenever we encounter the tokens again in the token
171   // stream. This ensures that we will activate it in the correct location
172   // or that we will ignore it if it never enters the token stream, e.g:
173   //
174   //     #define EMPTY(x)
175   //     #define INACTIVE(x) EMPTY(x)
176   //     INACTIVE(_Pragma("clang diagnostic ignored \"-Wconversion\""))
177 
178   LexingFor_PragmaRAII _PragmaLexing(*this, InMacroArgPreExpansion, Tok);
179 
180   // Remember the pragma token location.
181   SourceLocation PragmaLoc = Tok.getLocation();
182 
183   // Read the '('.
184   Lex(Tok);
185   if (Tok.isNot(tok::l_paren)) {
186     Diag(PragmaLoc, diag::err__Pragma_malformed);
187     return _PragmaLexing.failed();
188   }
189 
190   // Read the '"..."'.
191   Lex(Tok);
192   if (!tok::isStringLiteral(Tok.getKind())) {
193     Diag(PragmaLoc, diag::err__Pragma_malformed);
194     // Skip bad tokens, and the ')', if present.
195     if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof))
196       Lex(Tok);
197     while (Tok.isNot(tok::r_paren) &&
198            !Tok.isAtStartOfLine() &&
199            Tok.isNot(tok::eof))
200       Lex(Tok);
201     if (Tok.is(tok::r_paren))
202       Lex(Tok);
203     return _PragmaLexing.failed();
204   }
205 
206   if (Tok.hasUDSuffix()) {
207     Diag(Tok, diag::err_invalid_string_udl);
208     // Skip this token, and the ')', if present.
209     Lex(Tok);
210     if (Tok.is(tok::r_paren))
211       Lex(Tok);
212     return _PragmaLexing.failed();
213   }
214 
215   // Remember the string.
216   Token StrTok = Tok;
217 
218   // Read the ')'.
219   Lex(Tok);
220   if (Tok.isNot(tok::r_paren)) {
221     Diag(PragmaLoc, diag::err__Pragma_malformed);
222     return _PragmaLexing.failed();
223   }
224 
225   if (InMacroArgPreExpansion)
226     return;
227 
228   SourceLocation RParenLoc = Tok.getLocation();
229   std::string StrVal = getSpelling(StrTok);
230 
231   // The _Pragma is lexically sound.  Destringize according to C11 6.10.9.1:
232   // "The string literal is destringized by deleting any encoding prefix,
233   // deleting the leading and trailing double-quotes, replacing each escape
234   // sequence \" by a double-quote, and replacing each escape sequence \\ by a
235   // single backslash."
236   if (StrVal[0] == 'L' || StrVal[0] == 'U' ||
237       (StrVal[0] == 'u' && StrVal[1] != '8'))
238     StrVal.erase(StrVal.begin());
239   else if (StrVal[0] == 'u')
240     StrVal.erase(StrVal.begin(), StrVal.begin() + 2);
241 
242   if (StrVal[0] == 'R') {
243     // FIXME: C++11 does not specify how to handle raw-string-literals here.
244     // We strip off the 'R', the quotes, the d-char-sequences, and the parens.
245     assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' &&
246            "Invalid raw string token!");
247 
248     // Measure the length of the d-char-sequence.
249     unsigned NumDChars = 0;
250     while (StrVal[2 + NumDChars] != '(') {
251       assert(NumDChars < (StrVal.size() - 5) / 2 &&
252              "Invalid raw string token!");
253       ++NumDChars;
254     }
255     assert(StrVal[StrVal.size() - 2 - NumDChars] == ')');
256 
257     // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the
258     // parens below.
259     StrVal.erase(0, 2 + NumDChars);
260     StrVal.erase(StrVal.size() - 1 - NumDChars);
261   } else {
262     assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
263            "Invalid string token!");
264 
265     // Remove escaped quotes and escapes.
266     unsigned ResultPos = 1;
267     for (unsigned i = 1, e = StrVal.size() - 1; i != e; ++i) {
268       // Skip escapes.  \\ -> '\' and \" -> '"'.
269       if (StrVal[i] == '\\' && i + 1 < e &&
270           (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"'))
271         ++i;
272       StrVal[ResultPos++] = StrVal[i];
273     }
274     StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);
275   }
276 
277   // Remove the front quote, replacing it with a space, so that the pragma
278   // contents appear to have a space before them.
279   StrVal[0] = ' ';
280 
281   // Replace the terminating quote with a \n.
282   StrVal[StrVal.size()-1] = '\n';
283 
284   // Plop the string (including the newline and trailing null) into a buffer
285   // where we can lex it.
286   Token TmpTok;
287   TmpTok.startToken();
288   CreateString(StrVal, TmpTok);
289   SourceLocation TokLoc = TmpTok.getLocation();
290 
291   // Make and enter a lexer object so that we lex and expand the tokens just
292   // like any others.
293   Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
294                                         StrVal.size(), *this);
295 
296   EnterSourceFileWithLexer(TL, nullptr);
297 
298   // With everything set up, lex this as a #pragma directive.
299   HandlePragmaDirective(PragmaLoc, PIK__Pragma);
300 
301   // Finally, return whatever came after the pragma directive.
302   return Lex(Tok);
303 }
304 
305 /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
306 /// is not enclosed within a string literal.
HandleMicrosoft__pragma(Token & Tok)307 void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
308   // Remember the pragma token location.
309   SourceLocation PragmaLoc = Tok.getLocation();
310 
311   // Read the '('.
312   Lex(Tok);
313   if (Tok.isNot(tok::l_paren)) {
314     Diag(PragmaLoc, diag::err__Pragma_malformed);
315     return;
316   }
317 
318   // Get the tokens enclosed within the __pragma(), as well as the final ')'.
319   SmallVector<Token, 32> PragmaToks;
320   int NumParens = 0;
321   Lex(Tok);
322   while (Tok.isNot(tok::eof)) {
323     PragmaToks.push_back(Tok);
324     if (Tok.is(tok::l_paren))
325       NumParens++;
326     else if (Tok.is(tok::r_paren) && NumParens-- == 0)
327       break;
328     Lex(Tok);
329   }
330 
331   if (Tok.is(tok::eof)) {
332     Diag(PragmaLoc, diag::err_unterminated___pragma);
333     return;
334   }
335 
336   PragmaToks.front().setFlag(Token::LeadingSpace);
337 
338   // Replace the ')' with an EOD to mark the end of the pragma.
339   PragmaToks.back().setKind(tok::eod);
340 
341   Token *TokArray = new Token[PragmaToks.size()];
342   std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);
343 
344   // Push the tokens onto the stack.
345   EnterTokenStream(TokArray, PragmaToks.size(), true, true);
346 
347   // With everything set up, lex this as a #pragma directive.
348   HandlePragmaDirective(PragmaLoc, PIK___pragma);
349 
350   // Finally, return whatever came after the pragma directive.
351   return Lex(Tok);
352 }
353 
354 /// HandlePragmaOnce - Handle \#pragma once.  OnceTok is the 'once'.
355 ///
HandlePragmaOnce(Token & OnceTok)356 void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
357   if (isInPrimaryFile()) {
358     Diag(OnceTok, diag::pp_pragma_once_in_main_file);
359     return;
360   }
361 
362   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
363   // Mark the file as a once-only file now.
364   HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
365 }
366 
HandlePragmaMark()367 void Preprocessor::HandlePragmaMark() {
368   assert(CurPPLexer && "No current lexer?");
369   if (CurLexer)
370     CurLexer->ReadToEndOfLine();
371   else
372     CurPTHLexer->DiscardToEndOfLine();
373 }
374 
375 
376 /// HandlePragmaPoison - Handle \#pragma GCC poison.  PoisonTok is the 'poison'.
377 ///
HandlePragmaPoison(Token & PoisonTok)378 void Preprocessor::HandlePragmaPoison(Token &PoisonTok) {
379   Token Tok;
380 
381   while (1) {
382     // Read the next token to poison.  While doing this, pretend that we are
383     // skipping while reading the identifier to poison.
384     // This avoids errors on code like:
385     //   #pragma GCC poison X
386     //   #pragma GCC poison X
387     if (CurPPLexer) CurPPLexer->LexingRawMode = true;
388     LexUnexpandedToken(Tok);
389     if (CurPPLexer) CurPPLexer->LexingRawMode = false;
390 
391     // If we reached the end of line, we're done.
392     if (Tok.is(tok::eod)) return;
393 
394     // Can only poison identifiers.
395     if (Tok.isNot(tok::raw_identifier)) {
396       Diag(Tok, diag::err_pp_invalid_poison);
397       return;
398     }
399 
400     // Look up the identifier info for the token.  We disabled identifier lookup
401     // by saying we're skipping contents, so we need to do this manually.
402     IdentifierInfo *II = LookUpIdentifierInfo(Tok);
403 
404     // Already poisoned.
405     if (II->isPoisoned()) continue;
406 
407     // If this is a macro identifier, emit a warning.
408     if (isMacroDefined(II))
409       Diag(Tok, diag::pp_poisoning_existing_macro);
410 
411     // Finally, poison it!
412     II->setIsPoisoned();
413     if (II->isFromAST())
414       II->setChangedSinceDeserialization();
415   }
416 }
417 
418 /// HandlePragmaSystemHeader - Implement \#pragma GCC system_header.  We know
419 /// that the whole directive has been parsed.
HandlePragmaSystemHeader(Token & SysHeaderTok)420 void Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) {
421   if (isInPrimaryFile()) {
422     Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
423     return;
424   }
425 
426   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
427   PreprocessorLexer *TheLexer = getCurrentFileLexer();
428 
429   // Mark the file as a system header.
430   HeaderInfo.MarkFileSystemHeader(TheLexer->getFileEntry());
431 
432 
433   PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
434   if (PLoc.isInvalid())
435     return;
436 
437   unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename());
438 
439   // Notify the client, if desired, that we are in a new source file.
440   if (Callbacks)
441     Callbacks->FileChanged(SysHeaderTok.getLocation(),
442                            PPCallbacks::SystemHeaderPragma, SrcMgr::C_System);
443 
444   // Emit a line marker.  This will change any source locations from this point
445   // forward to realize they are in a system header.
446   // Create a line note with this information.
447   SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine()+1,
448                         FilenameID, /*IsEntry=*/false, /*IsExit=*/false,
449                         /*IsSystem=*/true, /*IsExternC=*/false);
450 }
451 
452 /// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah.
453 ///
HandlePragmaDependency(Token & DependencyTok)454 void Preprocessor::HandlePragmaDependency(Token &DependencyTok) {
455   Token FilenameTok;
456   CurPPLexer->LexIncludeFilename(FilenameTok);
457 
458   // If the token kind is EOD, the error has already been diagnosed.
459   if (FilenameTok.is(tok::eod))
460     return;
461 
462   // Reserve a buffer to get the spelling.
463   SmallString<128> FilenameBuffer;
464   bool Invalid = false;
465   StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid);
466   if (Invalid)
467     return;
468 
469   bool isAngled =
470     GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
471   // If GetIncludeFilenameSpelling set the start ptr to null, there was an
472   // error.
473   if (Filename.empty())
474     return;
475 
476   // Search include directories for this file.
477   const DirectoryLookup *CurDir;
478   const FileEntry *File =
479       LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
480                  nullptr, CurDir, nullptr, nullptr, nullptr);
481   if (!File) {
482     if (!SuppressIncludeNotFoundError)
483       Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
484     return;
485   }
486 
487   const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();
488 
489   // If this file is older than the file it depends on, emit a diagnostic.
490   if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
491     // Lex tokens at the end of the message and include them in the message.
492     std::string Message;
493     Lex(DependencyTok);
494     while (DependencyTok.isNot(tok::eod)) {
495       Message += getSpelling(DependencyTok) + " ";
496       Lex(DependencyTok);
497     }
498 
499     // Remove the trailing ' ' if present.
500     if (!Message.empty())
501       Message.erase(Message.end()-1);
502     Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message;
503   }
504 }
505 
506 /// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
507 /// Return the IdentifierInfo* associated with the macro to push or pop.
ParsePragmaPushOrPopMacro(Token & Tok)508 IdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) {
509   // Remember the pragma token location.
510   Token PragmaTok = Tok;
511 
512   // Read the '('.
513   Lex(Tok);
514   if (Tok.isNot(tok::l_paren)) {
515     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
516       << getSpelling(PragmaTok);
517     return nullptr;
518   }
519 
520   // Read the macro name string.
521   Lex(Tok);
522   if (Tok.isNot(tok::string_literal)) {
523     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
524       << getSpelling(PragmaTok);
525     return nullptr;
526   }
527 
528   if (Tok.hasUDSuffix()) {
529     Diag(Tok, diag::err_invalid_string_udl);
530     return nullptr;
531   }
532 
533   // Remember the macro string.
534   std::string StrVal = getSpelling(Tok);
535 
536   // Read the ')'.
537   Lex(Tok);
538   if (Tok.isNot(tok::r_paren)) {
539     Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
540       << getSpelling(PragmaTok);
541     return nullptr;
542   }
543 
544   assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
545          "Invalid string token!");
546 
547   // Create a Token from the string.
548   Token MacroTok;
549   MacroTok.startToken();
550   MacroTok.setKind(tok::raw_identifier);
551   CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);
552 
553   // Get the IdentifierInfo of MacroToPushTok.
554   return LookUpIdentifierInfo(MacroTok);
555 }
556 
557 /// \brief Handle \#pragma push_macro.
558 ///
559 /// The syntax is:
560 /// \code
561 ///   #pragma push_macro("macro")
562 /// \endcode
HandlePragmaPushMacro(Token & PushMacroTok)563 void Preprocessor::HandlePragmaPushMacro(Token &PushMacroTok) {
564   // Parse the pragma directive and get the macro IdentifierInfo*.
565   IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok);
566   if (!IdentInfo) return;
567 
568   // Get the MacroInfo associated with IdentInfo.
569   MacroInfo *MI = getMacroInfo(IdentInfo);
570 
571   if (MI) {
572     // Allow the original MacroInfo to be redefined later.
573     MI->setIsAllowRedefinitionsWithoutWarning(true);
574   }
575 
576   // Push the cloned MacroInfo so we can retrieve it later.
577   PragmaPushMacroInfo[IdentInfo].push_back(MI);
578 }
579 
580 /// \brief Handle \#pragma pop_macro.
581 ///
582 /// The syntax is:
583 /// \code
584 ///   #pragma pop_macro("macro")
585 /// \endcode
HandlePragmaPopMacro(Token & PopMacroTok)586 void Preprocessor::HandlePragmaPopMacro(Token &PopMacroTok) {
587   SourceLocation MessageLoc = PopMacroTok.getLocation();
588 
589   // Parse the pragma directive and get the macro IdentifierInfo*.
590   IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok);
591   if (!IdentInfo) return;
592 
593   // Find the vector<MacroInfo*> associated with the macro.
594   llvm::DenseMap<IdentifierInfo*, std::vector<MacroInfo*> >::iterator iter =
595     PragmaPushMacroInfo.find(IdentInfo);
596   if (iter != PragmaPushMacroInfo.end()) {
597     // Forget the MacroInfo currently associated with IdentInfo.
598     if (MacroInfo *MI = getMacroInfo(IdentInfo)) {
599       if (MI->isWarnIfUnused())
600         WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
601       appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc));
602     }
603 
604     // Get the MacroInfo we want to reinstall.
605     MacroInfo *MacroToReInstall = iter->second.back();
606 
607     if (MacroToReInstall)
608       // Reinstall the previously pushed macro.
609       appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc);
610 
611     // Pop PragmaPushMacroInfo stack.
612     iter->second.pop_back();
613     if (iter->second.size() == 0)
614       PragmaPushMacroInfo.erase(iter);
615   } else {
616     Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push)
617       << IdentInfo->getName();
618   }
619 }
620 
HandlePragmaIncludeAlias(Token & Tok)621 void Preprocessor::HandlePragmaIncludeAlias(Token &Tok) {
622   // We will either get a quoted filename or a bracketed filename, and we
623   // have to track which we got.  The first filename is the source name,
624   // and the second name is the mapped filename.  If the first is quoted,
625   // the second must be as well (cannot mix and match quotes and brackets).
626 
627   // Get the open paren
628   Lex(Tok);
629   if (Tok.isNot(tok::l_paren)) {
630     Diag(Tok, diag::warn_pragma_include_alias_expected) << "(";
631     return;
632   }
633 
634   // We expect either a quoted string literal, or a bracketed name
635   Token SourceFilenameTok;
636   CurPPLexer->LexIncludeFilename(SourceFilenameTok);
637   if (SourceFilenameTok.is(tok::eod)) {
638     // The diagnostic has already been handled
639     return;
640   }
641 
642   StringRef SourceFileName;
643   SmallString<128> FileNameBuffer;
644   if (SourceFilenameTok.is(tok::string_literal) ||
645       SourceFilenameTok.is(tok::angle_string_literal)) {
646     SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer);
647   } else if (SourceFilenameTok.is(tok::less)) {
648     // This could be a path instead of just a name
649     FileNameBuffer.push_back('<');
650     SourceLocation End;
651     if (ConcatenateIncludeName(FileNameBuffer, End))
652       return; // Diagnostic already emitted
653     SourceFileName = FileNameBuffer;
654   } else {
655     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
656     return;
657   }
658   FileNameBuffer.clear();
659 
660   // Now we expect a comma, followed by another include name
661   Lex(Tok);
662   if (Tok.isNot(tok::comma)) {
663     Diag(Tok, diag::warn_pragma_include_alias_expected) << ",";
664     return;
665   }
666 
667   Token ReplaceFilenameTok;
668   CurPPLexer->LexIncludeFilename(ReplaceFilenameTok);
669   if (ReplaceFilenameTok.is(tok::eod)) {
670     // The diagnostic has already been handled
671     return;
672   }
673 
674   StringRef ReplaceFileName;
675   if (ReplaceFilenameTok.is(tok::string_literal) ||
676       ReplaceFilenameTok.is(tok::angle_string_literal)) {
677     ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer);
678   } else if (ReplaceFilenameTok.is(tok::less)) {
679     // This could be a path instead of just a name
680     FileNameBuffer.push_back('<');
681     SourceLocation End;
682     if (ConcatenateIncludeName(FileNameBuffer, End))
683       return; // Diagnostic already emitted
684     ReplaceFileName = FileNameBuffer;
685   } else {
686     Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
687     return;
688   }
689 
690   // Finally, we expect the closing paren
691   Lex(Tok);
692   if (Tok.isNot(tok::r_paren)) {
693     Diag(Tok, diag::warn_pragma_include_alias_expected) << ")";
694     return;
695   }
696 
697   // Now that we have the source and target filenames, we need to make sure
698   // they're both of the same type (angled vs non-angled)
699   StringRef OriginalSource = SourceFileName;
700 
701   bool SourceIsAngled =
702     GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(),
703                                 SourceFileName);
704   bool ReplaceIsAngled =
705     GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(),
706                                 ReplaceFileName);
707   if (!SourceFileName.empty() && !ReplaceFileName.empty() &&
708       (SourceIsAngled != ReplaceIsAngled)) {
709     unsigned int DiagID;
710     if (SourceIsAngled)
711       DiagID = diag::warn_pragma_include_alias_mismatch_angle;
712     else
713       DiagID = diag::warn_pragma_include_alias_mismatch_quote;
714 
715     Diag(SourceFilenameTok.getLocation(), DiagID)
716       << SourceFileName
717       << ReplaceFileName;
718 
719     return;
720   }
721 
722   // Now we can let the include handler know about this mapping
723   getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName);
724 }
725 
726 /// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
727 /// If 'Namespace' is non-null, then it is a token required to exist on the
728 /// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
AddPragmaHandler(StringRef Namespace,PragmaHandler * Handler)729 void Preprocessor::AddPragmaHandler(StringRef Namespace,
730                                     PragmaHandler *Handler) {
731   PragmaNamespace *InsertNS = PragmaHandlers.get();
732 
733   // If this is specified to be in a namespace, step down into it.
734   if (!Namespace.empty()) {
735     // If there is already a pragma handler with the name of this namespace,
736     // we either have an error (directive with the same name as a namespace) or
737     // we already have the namespace to insert into.
738     if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
739       InsertNS = Existing->getIfNamespace();
740       assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
741              " handler with the same name!");
742     } else {
743       // Otherwise, this namespace doesn't exist yet, create and insert the
744       // handler for it.
745       InsertNS = new PragmaNamespace(Namespace);
746       PragmaHandlers->AddPragma(InsertNS);
747     }
748   }
749 
750   // Check to make sure we don't already have a pragma for this identifier.
751   assert(!InsertNS->FindHandler(Handler->getName()) &&
752          "Pragma handler already exists for this identifier!");
753   InsertNS->AddPragma(Handler);
754 }
755 
756 /// RemovePragmaHandler - Remove the specific pragma handler from the
757 /// preprocessor. If \arg Namespace is non-null, then it should be the
758 /// namespace that \arg Handler was added to. It is an error to remove
759 /// a handler that has not been registered.
RemovePragmaHandler(StringRef Namespace,PragmaHandler * Handler)760 void Preprocessor::RemovePragmaHandler(StringRef Namespace,
761                                        PragmaHandler *Handler) {
762   PragmaNamespace *NS = PragmaHandlers.get();
763 
764   // If this is specified to be in a namespace, step down into it.
765   if (!Namespace.empty()) {
766     PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
767     assert(Existing && "Namespace containing handler does not exist!");
768 
769     NS = Existing->getIfNamespace();
770     assert(NS && "Invalid namespace, registered as a regular pragma handler!");
771   }
772 
773   NS->RemovePragmaHandler(Handler);
774 
775   // If this is a non-default namespace and it is now empty, remove it.
776   if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
777     PragmaHandlers->RemovePragmaHandler(NS);
778     delete NS;
779   }
780 }
781 
LexOnOffSwitch(tok::OnOffSwitch & Result)782 bool Preprocessor::LexOnOffSwitch(tok::OnOffSwitch &Result) {
783   Token Tok;
784   LexUnexpandedToken(Tok);
785 
786   if (Tok.isNot(tok::identifier)) {
787     Diag(Tok, diag::ext_on_off_switch_syntax);
788     return true;
789   }
790   IdentifierInfo *II = Tok.getIdentifierInfo();
791   if (II->isStr("ON"))
792     Result = tok::OOS_ON;
793   else if (II->isStr("OFF"))
794     Result = tok::OOS_OFF;
795   else if (II->isStr("DEFAULT"))
796     Result = tok::OOS_DEFAULT;
797   else {
798     Diag(Tok, diag::ext_on_off_switch_syntax);
799     return true;
800   }
801 
802   // Verify that this is followed by EOD.
803   LexUnexpandedToken(Tok);
804   if (Tok.isNot(tok::eod))
805     Diag(Tok, diag::ext_pragma_syntax_eod);
806   return false;
807 }
808 
809 namespace {
810 /// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
811 struct PragmaOnceHandler : public PragmaHandler {
PragmaOnceHandler__anonfbb82d950211::PragmaOnceHandler812   PragmaOnceHandler() : PragmaHandler("once") {}
HandlePragma__anonfbb82d950211::PragmaOnceHandler813   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
814                     Token &OnceTok) override {
815     PP.CheckEndOfDirective("pragma once");
816     PP.HandlePragmaOnce(OnceTok);
817   }
818 };
819 
820 /// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
821 /// rest of the line is not lexed.
822 struct PragmaMarkHandler : public PragmaHandler {
PragmaMarkHandler__anonfbb82d950211::PragmaMarkHandler823   PragmaMarkHandler() : PragmaHandler("mark") {}
HandlePragma__anonfbb82d950211::PragmaMarkHandler824   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
825                     Token &MarkTok) override {
826     PP.HandlePragmaMark();
827   }
828 };
829 
830 /// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
831 struct PragmaPoisonHandler : public PragmaHandler {
PragmaPoisonHandler__anonfbb82d950211::PragmaPoisonHandler832   PragmaPoisonHandler() : PragmaHandler("poison") {}
HandlePragma__anonfbb82d950211::PragmaPoisonHandler833   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
834                     Token &PoisonTok) override {
835     PP.HandlePragmaPoison(PoisonTok);
836   }
837 };
838 
839 /// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
840 /// as a system header, which silences warnings in it.
841 struct PragmaSystemHeaderHandler : public PragmaHandler {
PragmaSystemHeaderHandler__anonfbb82d950211::PragmaSystemHeaderHandler842   PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}
HandlePragma__anonfbb82d950211::PragmaSystemHeaderHandler843   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
844                     Token &SHToken) override {
845     PP.HandlePragmaSystemHeader(SHToken);
846     PP.CheckEndOfDirective("pragma");
847   }
848 };
849 struct PragmaDependencyHandler : public PragmaHandler {
PragmaDependencyHandler__anonfbb82d950211::PragmaDependencyHandler850   PragmaDependencyHandler() : PragmaHandler("dependency") {}
HandlePragma__anonfbb82d950211::PragmaDependencyHandler851   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
852                     Token &DepToken) override {
853     PP.HandlePragmaDependency(DepToken);
854   }
855 };
856 
857 struct PragmaDebugHandler : public PragmaHandler {
PragmaDebugHandler__anonfbb82d950211::PragmaDebugHandler858   PragmaDebugHandler() : PragmaHandler("__debug") {}
HandlePragma__anonfbb82d950211::PragmaDebugHandler859   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
860                     Token &DepToken) override {
861     Token Tok;
862     PP.LexUnexpandedToken(Tok);
863     if (Tok.isNot(tok::identifier)) {
864       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
865       return;
866     }
867     IdentifierInfo *II = Tok.getIdentifierInfo();
868 
869     if (II->isStr("assert")) {
870       llvm_unreachable("This is an assertion!");
871     } else if (II->isStr("crash")) {
872       LLVM_BUILTIN_TRAP;
873     } else if (II->isStr("parser_crash")) {
874       Token Crasher;
875       Crasher.startToken();
876       Crasher.setKind(tok::annot_pragma_parser_crash);
877       Crasher.setAnnotationRange(SourceRange(Tok.getLocation()));
878       PP.EnterToken(Crasher);
879     } else if (II->isStr("dump")) {
880       Token Identifier;
881       PP.LexUnexpandedToken(Identifier);
882       if (auto *DumpII = Identifier.getIdentifierInfo()) {
883         Token DumpAnnot;
884         DumpAnnot.startToken();
885         DumpAnnot.setKind(tok::annot_pragma_dump);
886         DumpAnnot.setAnnotationRange(
887             SourceRange(Tok.getLocation(), Identifier.getLocation()));
888         DumpAnnot.setAnnotationValue(DumpII);
889         PP.DiscardUntilEndOfDirective();
890         PP.EnterToken(DumpAnnot);
891       } else {
892         PP.Diag(Identifier, diag::warn_pragma_debug_missing_argument)
893             << II->getName();
894       }
895     } else if (II->isStr("llvm_fatal_error")) {
896       llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
897     } else if (II->isStr("llvm_unreachable")) {
898       llvm_unreachable("#pragma clang __debug llvm_unreachable");
899     } else if (II->isStr("macro")) {
900       Token MacroName;
901       PP.LexUnexpandedToken(MacroName);
902       auto *MacroII = MacroName.getIdentifierInfo();
903       if (MacroII)
904         PP.dumpMacroInfo(MacroII);
905       else
906         PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
907             << II->getName();
908     } else if (II->isStr("overflow_stack")) {
909       DebugOverflowStack();
910     } else if (II->isStr("handle_crash")) {
911       llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent();
912       if (CRC)
913         CRC->HandleCrash();
914     } else if (II->isStr("captured")) {
915       HandleCaptured(PP);
916     } else {
917       PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
918         << II->getName();
919     }
920 
921     PPCallbacks *Callbacks = PP.getPPCallbacks();
922     if (Callbacks)
923       Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
924   }
925 
HandleCaptured__anonfbb82d950211::PragmaDebugHandler926   void HandleCaptured(Preprocessor &PP) {
927     // Skip if emitting preprocessed output.
928     if (PP.isPreprocessedOutput())
929       return;
930 
931     Token Tok;
932     PP.LexUnexpandedToken(Tok);
933 
934     if (Tok.isNot(tok::eod)) {
935       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
936         << "pragma clang __debug captured";
937       return;
938     }
939 
940     SourceLocation NameLoc = Tok.getLocation();
941     MutableArrayRef<Token> Toks(
942         PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
943     Toks[0].startToken();
944     Toks[0].setKind(tok::annot_pragma_captured);
945     Toks[0].setLocation(NameLoc);
946 
947     PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
948   }
949 
950 // Disable MSVC warning about runtime stack overflow.
951 #ifdef _MSC_VER
952     #pragma warning(disable : 4717)
953 #endif
DebugOverflowStack__anonfbb82d950211::PragmaDebugHandler954   static void DebugOverflowStack() {
955     void (*volatile Self)() = DebugOverflowStack;
956     Self();
957   }
958 #ifdef _MSC_VER
959     #pragma warning(default : 4717)
960 #endif
961 
962 };
963 
964 /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
965 struct PragmaDiagnosticHandler : public PragmaHandler {
966 private:
967   const char *Namespace;
968 public:
PragmaDiagnosticHandler__anonfbb82d950211::PragmaDiagnosticHandler969   explicit PragmaDiagnosticHandler(const char *NS) :
970     PragmaHandler("diagnostic"), Namespace(NS) {}
HandlePragma__anonfbb82d950211::PragmaDiagnosticHandler971   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
972                     Token &DiagToken) override {
973     SourceLocation DiagLoc = DiagToken.getLocation();
974     Token Tok;
975     PP.LexUnexpandedToken(Tok);
976     if (Tok.isNot(tok::identifier)) {
977       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
978       return;
979     }
980     IdentifierInfo *II = Tok.getIdentifierInfo();
981     PPCallbacks *Callbacks = PP.getPPCallbacks();
982 
983     if (II->isStr("pop")) {
984       if (!PP.getDiagnostics().popMappings(DiagLoc))
985         PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
986       else if (Callbacks)
987         Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
988       return;
989     } else if (II->isStr("push")) {
990       PP.getDiagnostics().pushMappings(DiagLoc);
991       if (Callbacks)
992         Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
993       return;
994     }
995 
996     diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
997                             .Case("ignored", diag::Severity::Ignored)
998                             .Case("warning", diag::Severity::Warning)
999                             .Case("error", diag::Severity::Error)
1000                             .Case("fatal", diag::Severity::Fatal)
1001                             .Default(diag::Severity());
1002 
1003     if (SV == diag::Severity()) {
1004       PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1005       return;
1006     }
1007 
1008     PP.LexUnexpandedToken(Tok);
1009     SourceLocation StringLoc = Tok.getLocation();
1010 
1011     std::string WarningName;
1012     if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
1013                                    /*MacroExpansion=*/false))
1014       return;
1015 
1016     if (Tok.isNot(tok::eod)) {
1017       PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1018       return;
1019     }
1020 
1021     if (WarningName.size() < 3 || WarningName[0] != '-' ||
1022         (WarningName[1] != 'W' && WarningName[1] != 'R')) {
1023       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
1024       return;
1025     }
1026 
1027     diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
1028                                                 : diag::Flavor::Remark;
1029     StringRef Group = StringRef(WarningName).substr(2);
1030     bool unknownDiag = false;
1031     if (Group == "everything") {
1032       // Special handling for pragma clang diagnostic ... "-Weverything".
1033       // There is no formal group named "everything", so there has to be a
1034       // special case for it.
1035       PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
1036     } else
1037       unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
1038                                                             DiagLoc);
1039     if (unknownDiag)
1040       PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
1041         << WarningName;
1042     else if (Callbacks)
1043       Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
1044   }
1045 };
1046 
1047 /// "\#pragma warning(...)".  MSVC's diagnostics do not map cleanly to clang's
1048 /// diagnostics, so we don't really implement this pragma.  We parse it and
1049 /// ignore it to avoid -Wunknown-pragma warnings.
1050 struct PragmaWarningHandler : public PragmaHandler {
PragmaWarningHandler__anonfbb82d950211::PragmaWarningHandler1051   PragmaWarningHandler() : PragmaHandler("warning") {}
1052 
HandlePragma__anonfbb82d950211::PragmaWarningHandler1053   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1054                     Token &Tok) override {
1055     // Parse things like:
1056     // warning(push, 1)
1057     // warning(pop)
1058     // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
1059     SourceLocation DiagLoc = Tok.getLocation();
1060     PPCallbacks *Callbacks = PP.getPPCallbacks();
1061 
1062     PP.Lex(Tok);
1063     if (Tok.isNot(tok::l_paren)) {
1064       PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
1065       return;
1066     }
1067 
1068     PP.Lex(Tok);
1069     IdentifierInfo *II = Tok.getIdentifierInfo();
1070 
1071     if (II && II->isStr("push")) {
1072       // #pragma warning( push[ ,n ] )
1073       int Level = -1;
1074       PP.Lex(Tok);
1075       if (Tok.is(tok::comma)) {
1076         PP.Lex(Tok);
1077         uint64_t Value;
1078         if (Tok.is(tok::numeric_constant) &&
1079             PP.parseSimpleIntegerLiteral(Tok, Value))
1080           Level = int(Value);
1081         if (Level < 0 || Level > 4) {
1082           PP.Diag(Tok, diag::warn_pragma_warning_push_level);
1083           return;
1084         }
1085       }
1086       if (Callbacks)
1087         Callbacks->PragmaWarningPush(DiagLoc, Level);
1088     } else if (II && II->isStr("pop")) {
1089       // #pragma warning( pop )
1090       PP.Lex(Tok);
1091       if (Callbacks)
1092         Callbacks->PragmaWarningPop(DiagLoc);
1093     } else {
1094       // #pragma warning( warning-specifier : warning-number-list
1095       //                  [; warning-specifier : warning-number-list...] )
1096       while (true) {
1097         II = Tok.getIdentifierInfo();
1098         if (!II && !Tok.is(tok::numeric_constant)) {
1099           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1100           return;
1101         }
1102 
1103         // Figure out which warning specifier this is.
1104         bool SpecifierValid;
1105         StringRef Specifier;
1106         llvm::SmallString<1> SpecifierBuf;
1107         if (II) {
1108           Specifier = II->getName();
1109           SpecifierValid = llvm::StringSwitch<bool>(Specifier)
1110                                .Cases("default", "disable", "error", "once",
1111                                       "suppress", true)
1112                                .Default(false);
1113           // If we read a correct specifier, snatch next token (that should be
1114           // ":", checked later).
1115           if (SpecifierValid)
1116             PP.Lex(Tok);
1117         } else {
1118           // Token is a numeric constant. It should be either 1, 2, 3 or 4.
1119           uint64_t Value;
1120           Specifier = PP.getSpelling(Tok, SpecifierBuf);
1121           if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
1122             SpecifierValid = (Value >= 1) && (Value <= 4);
1123           } else
1124             SpecifierValid = false;
1125           // Next token already snatched by parseSimpleIntegerLiteral.
1126         }
1127 
1128         if (!SpecifierValid) {
1129           PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1130           return;
1131         }
1132         if (Tok.isNot(tok::colon)) {
1133           PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
1134           return;
1135         }
1136 
1137         // Collect the warning ids.
1138         SmallVector<int, 4> Ids;
1139         PP.Lex(Tok);
1140         while (Tok.is(tok::numeric_constant)) {
1141           uint64_t Value;
1142           if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
1143               Value > INT_MAX) {
1144             PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
1145             return;
1146           }
1147           Ids.push_back(int(Value));
1148         }
1149         if (Callbacks)
1150           Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
1151 
1152         // Parse the next specifier if there is a semicolon.
1153         if (Tok.isNot(tok::semi))
1154           break;
1155         PP.Lex(Tok);
1156       }
1157     }
1158 
1159     if (Tok.isNot(tok::r_paren)) {
1160       PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
1161       return;
1162     }
1163 
1164     PP.Lex(Tok);
1165     if (Tok.isNot(tok::eod))
1166       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
1167   }
1168 };
1169 
1170 /// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1171 struct PragmaIncludeAliasHandler : public PragmaHandler {
PragmaIncludeAliasHandler__anonfbb82d950211::PragmaIncludeAliasHandler1172   PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}
HandlePragma__anonfbb82d950211::PragmaIncludeAliasHandler1173   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1174                     Token &IncludeAliasTok) override {
1175     PP.HandlePragmaIncludeAlias(IncludeAliasTok);
1176   }
1177 };
1178 
1179 /// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message
1180 /// extension.  The syntax is:
1181 /// \code
1182 ///   #pragma message(string)
1183 /// \endcode
1184 /// OR, in GCC mode:
1185 /// \code
1186 ///   #pragma message string
1187 /// \endcode
1188 /// string is a string, which is fully macro expanded, and permits string
1189 /// concatenation, embedded escape characters, etc... See MSDN for more details.
1190 /// Also handles \#pragma GCC warning and \#pragma GCC error which take the same
1191 /// form as \#pragma message.
1192 struct PragmaMessageHandler : public PragmaHandler {
1193 private:
1194   const PPCallbacks::PragmaMessageKind Kind;
1195   const StringRef Namespace;
1196 
PragmaKind__anonfbb82d950211::PragmaMessageHandler1197   static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
1198                                 bool PragmaNameOnly = false) {
1199     switch (Kind) {
1200       case PPCallbacks::PMK_Message:
1201         return PragmaNameOnly ? "message" : "pragma message";
1202       case PPCallbacks::PMK_Warning:
1203         return PragmaNameOnly ? "warning" : "pragma warning";
1204       case PPCallbacks::PMK_Error:
1205         return PragmaNameOnly ? "error" : "pragma error";
1206     }
1207     llvm_unreachable("Unknown PragmaMessageKind!");
1208   }
1209 
1210 public:
PragmaMessageHandler__anonfbb82d950211::PragmaMessageHandler1211   PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
1212                        StringRef Namespace = StringRef())
1213     : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind), Namespace(Namespace) {}
1214 
HandlePragma__anonfbb82d950211::PragmaMessageHandler1215   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1216                     Token &Tok) override {
1217     SourceLocation MessageLoc = Tok.getLocation();
1218     PP.Lex(Tok);
1219     bool ExpectClosingParen = false;
1220     switch (Tok.getKind()) {
1221     case tok::l_paren:
1222       // We have a MSVC style pragma message.
1223       ExpectClosingParen = true;
1224       // Read the string.
1225       PP.Lex(Tok);
1226       break;
1227     case tok::string_literal:
1228       // We have a GCC style pragma message, and we just read the string.
1229       break;
1230     default:
1231       PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
1232       return;
1233     }
1234 
1235     std::string MessageString;
1236     if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
1237                                    /*MacroExpansion=*/true))
1238       return;
1239 
1240     if (ExpectClosingParen) {
1241       if (Tok.isNot(tok::r_paren)) {
1242         PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1243         return;
1244       }
1245       PP.Lex(Tok);  // eat the r_paren.
1246     }
1247 
1248     if (Tok.isNot(tok::eod)) {
1249       PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1250       return;
1251     }
1252 
1253     // Output the message.
1254     PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
1255                           ? diag::err_pragma_message
1256                           : diag::warn_pragma_message) << MessageString;
1257 
1258     // If the pragma is lexically sound, notify any interested PPCallbacks.
1259     if (PPCallbacks *Callbacks = PP.getPPCallbacks())
1260       Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
1261   }
1262 };
1263 
1264 /// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1265 /// macro on the top of the stack.
1266 struct PragmaPushMacroHandler : public PragmaHandler {
PragmaPushMacroHandler__anonfbb82d950211::PragmaPushMacroHandler1267   PragmaPushMacroHandler() : PragmaHandler("push_macro") {}
HandlePragma__anonfbb82d950211::PragmaPushMacroHandler1268   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1269                     Token &PushMacroTok) override {
1270     PP.HandlePragmaPushMacro(PushMacroTok);
1271   }
1272 };
1273 
1274 
1275 /// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the
1276 /// macro to the value on the top of the stack.
1277 struct PragmaPopMacroHandler : public PragmaHandler {
PragmaPopMacroHandler__anonfbb82d950211::PragmaPopMacroHandler1278   PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}
HandlePragma__anonfbb82d950211::PragmaPopMacroHandler1279   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1280                     Token &PopMacroTok) override {
1281     PP.HandlePragmaPopMacro(PopMacroTok);
1282   }
1283 };
1284 
1285 // Pragma STDC implementations.
1286 
1287 /// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...".
1288 struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler {
PragmaSTDC_FENV_ACCESSHandler__anonfbb82d950211::PragmaSTDC_FENV_ACCESSHandler1289   PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {}
HandlePragma__anonfbb82d950211::PragmaSTDC_FENV_ACCESSHandler1290   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1291                     Token &Tok) override {
1292     tok::OnOffSwitch OOS;
1293     if (PP.LexOnOffSwitch(OOS))
1294      return;
1295     if (OOS == tok::OOS_ON)
1296       PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported);
1297   }
1298 };
1299 
1300 /// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...".
1301 struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler {
PragmaSTDC_CX_LIMITED_RANGEHandler__anonfbb82d950211::PragmaSTDC_CX_LIMITED_RANGEHandler1302   PragmaSTDC_CX_LIMITED_RANGEHandler()
1303     : PragmaHandler("CX_LIMITED_RANGE") {}
HandlePragma__anonfbb82d950211::PragmaSTDC_CX_LIMITED_RANGEHandler1304   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1305                     Token &Tok) override {
1306     tok::OnOffSwitch OOS;
1307     PP.LexOnOffSwitch(OOS);
1308   }
1309 };
1310 
1311 /// PragmaSTDC_UnknownHandler - "\#pragma STDC ...".
1312 struct PragmaSTDC_UnknownHandler : public PragmaHandler {
PragmaSTDC_UnknownHandler__anonfbb82d950211::PragmaSTDC_UnknownHandler1313   PragmaSTDC_UnknownHandler() {}
HandlePragma__anonfbb82d950211::PragmaSTDC_UnknownHandler1314   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1315                     Token &UnknownTok) override {
1316     // C99 6.10.6p2, unknown forms are not allowed.
1317     PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored);
1318   }
1319 };
1320 
1321 /// PragmaARCCFCodeAuditedHandler -
1322 ///   \#pragma clang arc_cf_code_audited begin/end
1323 struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
PragmaARCCFCodeAuditedHandler__anonfbb82d950211::PragmaARCCFCodeAuditedHandler1324   PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}
HandlePragma__anonfbb82d950211::PragmaARCCFCodeAuditedHandler1325   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1326                     Token &NameTok) override {
1327     SourceLocation Loc = NameTok.getLocation();
1328     bool IsBegin;
1329 
1330     Token Tok;
1331 
1332     // Lex the 'begin' or 'end'.
1333     PP.LexUnexpandedToken(Tok);
1334     const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1335     if (BeginEnd && BeginEnd->isStr("begin")) {
1336       IsBegin = true;
1337     } else if (BeginEnd && BeginEnd->isStr("end")) {
1338       IsBegin = false;
1339     } else {
1340       PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
1341       return;
1342     }
1343 
1344     // Verify that this is followed by EOD.
1345     PP.LexUnexpandedToken(Tok);
1346     if (Tok.isNot(tok::eod))
1347       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1348 
1349     // The start location of the active audit.
1350     SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedLoc();
1351 
1352     // The start location we want after processing this.
1353     SourceLocation NewLoc;
1354 
1355     if (IsBegin) {
1356       // Complain about attempts to re-enter an audit.
1357       if (BeginLoc.isValid()) {
1358         PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
1359         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1360       }
1361       NewLoc = Loc;
1362     } else {
1363       // Complain about attempts to leave an audit that doesn't exist.
1364       if (!BeginLoc.isValid()) {
1365         PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
1366         return;
1367       }
1368       NewLoc = SourceLocation();
1369     }
1370 
1371     PP.setPragmaARCCFCodeAuditedLoc(NewLoc);
1372   }
1373 };
1374 
1375 /// PragmaAssumeNonNullHandler -
1376 ///   \#pragma clang assume_nonnull begin/end
1377 struct PragmaAssumeNonNullHandler : public PragmaHandler {
PragmaAssumeNonNullHandler__anonfbb82d950211::PragmaAssumeNonNullHandler1378   PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}
HandlePragma__anonfbb82d950211::PragmaAssumeNonNullHandler1379   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1380                     Token &NameTok) override {
1381     SourceLocation Loc = NameTok.getLocation();
1382     bool IsBegin;
1383 
1384     Token Tok;
1385 
1386     // Lex the 'begin' or 'end'.
1387     PP.LexUnexpandedToken(Tok);
1388     const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1389     if (BeginEnd && BeginEnd->isStr("begin")) {
1390       IsBegin = true;
1391     } else if (BeginEnd && BeginEnd->isStr("end")) {
1392       IsBegin = false;
1393     } else {
1394       PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
1395       return;
1396     }
1397 
1398     // Verify that this is followed by EOD.
1399     PP.LexUnexpandedToken(Tok);
1400     if (Tok.isNot(tok::eod))
1401       PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1402 
1403     // The start location of the active audit.
1404     SourceLocation BeginLoc = PP.getPragmaAssumeNonNullLoc();
1405 
1406     // The start location we want after processing this.
1407     SourceLocation NewLoc;
1408 
1409     if (IsBegin) {
1410       // Complain about attempts to re-enter an audit.
1411       if (BeginLoc.isValid()) {
1412         PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
1413         PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1414       }
1415       NewLoc = Loc;
1416     } else {
1417       // Complain about attempts to leave an audit that doesn't exist.
1418       if (!BeginLoc.isValid()) {
1419         PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
1420         return;
1421       }
1422       NewLoc = SourceLocation();
1423     }
1424 
1425     PP.setPragmaAssumeNonNullLoc(NewLoc);
1426   }
1427 };
1428 
1429 /// \brief Handle "\#pragma region [...]"
1430 ///
1431 /// The syntax is
1432 /// \code
1433 ///   #pragma region [optional name]
1434 ///   #pragma endregion [optional comment]
1435 /// \endcode
1436 ///
1437 /// \note This is
1438 /// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a>
1439 /// pragma, just skipped by compiler.
1440 struct PragmaRegionHandler : public PragmaHandler {
PragmaRegionHandler__anonfbb82d950211::PragmaRegionHandler1441   PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) { }
1442 
HandlePragma__anonfbb82d950211::PragmaRegionHandler1443   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
1444                     Token &NameTok) override {
1445     // #pragma region: endregion matches can be verified
1446     // __pragma(region): no sense, but ignored by msvc
1447     // _Pragma is not valid for MSVC, but there isn't any point
1448     // to handle a _Pragma differently.
1449   }
1450 };
1451 
1452 }  // end anonymous namespace
1453 
1454 
1455 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
1456 /// \#pragma GCC poison/system_header/dependency and \#pragma once.
RegisterBuiltinPragmas()1457 void Preprocessor::RegisterBuiltinPragmas() {
1458   AddPragmaHandler(new PragmaOnceHandler());
1459   AddPragmaHandler(new PragmaMarkHandler());
1460   AddPragmaHandler(new PragmaPushMacroHandler());
1461   AddPragmaHandler(new PragmaPopMacroHandler());
1462   AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));
1463 
1464   // #pragma GCC ...
1465   AddPragmaHandler("GCC", new PragmaPoisonHandler());
1466   AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
1467   AddPragmaHandler("GCC", new PragmaDependencyHandler());
1468   AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
1469   AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
1470                                                    "GCC"));
1471   AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
1472                                                    "GCC"));
1473   // #pragma clang ...
1474   AddPragmaHandler("clang", new PragmaPoisonHandler());
1475   AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
1476   AddPragmaHandler("clang", new PragmaDebugHandler());
1477   AddPragmaHandler("clang", new PragmaDependencyHandler());
1478   AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
1479   AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
1480   AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
1481 
1482   AddPragmaHandler("STDC", new PragmaSTDC_FENV_ACCESSHandler());
1483   AddPragmaHandler("STDC", new PragmaSTDC_CX_LIMITED_RANGEHandler());
1484   AddPragmaHandler("STDC", new PragmaSTDC_UnknownHandler());
1485 
1486   // MS extensions.
1487   if (LangOpts.MicrosoftExt) {
1488     AddPragmaHandler(new PragmaWarningHandler());
1489     AddPragmaHandler(new PragmaIncludeAliasHandler());
1490     AddPragmaHandler(new PragmaRegionHandler("region"));
1491     AddPragmaHandler(new PragmaRegionHandler("endregion"));
1492   }
1493 
1494   // Pragmas added by plugins
1495   for (PragmaHandlerRegistry::iterator it = PragmaHandlerRegistry::begin(),
1496                                        ie = PragmaHandlerRegistry::end();
1497        it != ie; ++it) {
1498     AddPragmaHandler(it->instantiate().release());
1499   }
1500 }
1501 
1502 /// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
1503 /// warn about those pragmas being unknown.
IgnorePragmas()1504 void Preprocessor::IgnorePragmas() {
1505   AddPragmaHandler(new EmptyPragmaHandler());
1506   // Also ignore all pragmas in all namespaces created
1507   // in Preprocessor::RegisterBuiltinPragmas().
1508   AddPragmaHandler("GCC", new EmptyPragmaHandler());
1509   AddPragmaHandler("clang", new EmptyPragmaHandler());
1510   if (PragmaHandler *NS = PragmaHandlers->FindHandler("STDC")) {
1511     // Preprocessor::RegisterBuiltinPragmas() already registers
1512     // PragmaSTDC_UnknownHandler as the empty handler, so remove it first,
1513     // otherwise there will be an assert about a duplicate handler.
1514     PragmaNamespace *STDCNamespace = NS->getIfNamespace();
1515     assert(STDCNamespace &&
1516            "Invalid namespace, registered as a regular pragma handler!");
1517     if (PragmaHandler *Existing = STDCNamespace->FindHandler("", false)) {
1518       RemovePragmaHandler("STDC", Existing);
1519       delete Existing;
1520     }
1521   }
1522   AddPragmaHandler("STDC", new EmptyPragmaHandler());
1523 }
1524